| # |
| # Copyright 2018 - The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| from acts import asserts |
| from acts import base_test |
| from acts.test_decorators import test_tracker_info |
| from acts_contrib.test_utils.net.net_test_utils import start_tcpdump |
| from acts_contrib.test_utils.net.net_test_utils import stop_tcpdump |
| from acts_contrib.test_utils.wifi import wifi_test_utils as wutils |
| |
| |
| from scapy.all import IP |
| from scapy.all import TCP |
| from scapy.all import UDP |
| from scapy.all import Raw |
| from scapy.all import rdpcap |
| from scapy.all import Scapy_Exception |
| |
| |
| class ProxyTest(base_test.BaseTestClass): |
| """ Network proxy tests """ |
| |
| def setup_class(self): |
| """ Setup devices for tests and unpack params """ |
| self.dut = self.android_devices[0] |
| req_params = ("proxy_pac", "proxy_server", |
| "proxy_port", "bypass_host", "non_bypass_host", |
| "wifi_network") |
| self.unpack_userparams(req_param_names=req_params,) |
| wutils.wifi_test_device_init(self.dut) |
| wutils.wifi_toggle_state(self.dut, True) |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, self.wifi_network["SSID"]) |
| wutils.wifi_connect(self.dut, self.wifi_network) |
| self.tcpdump_pid = None |
| self.proxy_port = int(self.proxy_port) |
| |
| def teardown_test(self): |
| self.dut.droid.connectivityResetGlobalProxy() |
| global_proxy = self.dut.droid.connectivityGetGlobalProxy() |
| if global_proxy: |
| self.log.error("Failed to reset global proxy settings") |
| |
| def teardown_class(self): |
| wutils.reset_wifi(self.dut) |
| |
| def on_fail(self, test_name, begin_time): |
| self.dut.take_bug_report(test_name, begin_time) |
| |
| """ Helper methods """ |
| |
| def _verify_http_request(self, ad): |
| """ Send http requests to hosts |
| |
| Steps: |
| 1. Send http requests to hosts |
| a. Host that is bypassed by proxy server |
| b. Host that goes through proxy server |
| 2. Verify that both return valid responses |
| |
| Args: |
| 1. ad: dut to run http requests |
| """ |
| for host in [self.bypass_host, self.non_bypass_host]: |
| host = "https://%s" % host |
| result = ad.droid.httpRequestString(host) |
| asserts.assert_true(result, "Http request failed for %s" % host) |
| |
| def _verify_proxy_server(self, pcap_file, bypass_host, hostname): |
| """ Verify that http requests are going through proxy server |
| |
| Args: |
| 1. tcpdump: pcap file |
| 2. bypass_host: boolean value if the request goes through proxy |
| 3. hostname: hostname requested |
| |
| Returns: |
| True/False if the bypass condition met |
| """ |
| self.log.info("Checking proxy server for query to: %s" % hostname) |
| try: |
| packets = rdpcap(pcap_file) |
| except Scapy_Exception: |
| asserts.fail("Not a valid pcap file") |
| |
| dns_query = False |
| http_query = False |
| for pkt in packets: |
| summary = "%s" % pkt.summary() |
| if UDP in pkt and pkt[UDP].dport == 53 and hostname in summary: |
| dns_query = True |
| break |
| if TCP in pkt and pkt[TCP].dport == self.proxy_port and Raw in pkt\ |
| and hostname in str(pkt[Raw]): |
| http_query = True |
| |
| self.log.info("Bypass hostname set to: %s" % bypass_host) |
| self.log.info("Found DNS query for host: %s" % dns_query) |
| self.log.info("Found HTTP query for host: %s" % http_query) |
| if bypass_host and http_query and not dns_query or \ |
| not bypass_host and not http_query and dns_query: |
| return False |
| return True |
| |
| def _test_proxy(self): |
| """ Test pac piroxy and manual proxy settings |
| |
| Steps: |
| 1. Start tcpdump |
| 2. Run http requests |
| 3. Stop tcpdump |
| 4. Verify the packets from tcpdump have valid queries |
| """ |
| |
| # start tcpdump on the device |
| self.tcpdump_pid = start_tcpdump(self.dut, self.test_name) |
| |
| # verify http requests |
| self._verify_http_request(self.dut) |
| |
| # stop tcpdump on the device |
| pcap_file = stop_tcpdump(self.dut, self.tcpdump_pid, self.test_name) |
| |
| # verify proxy server |
| result = self._verify_proxy_server(pcap_file, True, self.bypass_host) |
| asserts.assert_true(result, "Proxy failed for %s" % self.bypass_host) |
| result = self._verify_proxy_server(pcap_file, False, self.non_bypass_host) |
| asserts.assert_true(result, "Proxy failed for %s" % self.non_bypass_host) |
| |
| """ Test Cases """ |
| |
| @test_tracker_info(uuid="16881315-1a50-48ce-bd36-7b0d2f21b734") |
| def test_pac_proxy_over_wifi(self): |
| """ Test proxy with auto config over wifi |
| |
| Steps: |
| 1. Connect to a wifi network |
| 2. Set a global proxy with auto config |
| 3. Do a http request on the hostnames |
| 4. Verify that no DNS packets seen for non bypassed hostnames |
| 5. Verify that DNS packets seen for bypassed hostnames |
| """ |
| # set global pac proxy |
| self.log.info("Setting global proxy to: %s" % self.proxy_pac) |
| self.dut.droid.connectivitySetGlobalPacProxy(self.proxy_pac) |
| global_proxy = self.dut.droid.connectivityGetGlobalProxy() |
| asserts.assert_true(global_proxy['PacUrl'] == self.proxy_pac, |
| "Failed to set pac proxy") |
| |
| # test proxy |
| self._test_proxy() |
| |
| @test_tracker_info(uuid="4d3361f6-866d-423c-9ed7-5a6943575fe9") |
| def test_manual_proxy_over_wifi(self): |
| """ Test manual proxy over wifi |
| |
| Steps: |
| 1. Connect to a wifi network |
| 2. Set a global manual proxy with proxy server, port & bypass URLs |
| 3. Do a http request on the hostnames |
| 4. Verify that no DNS packets are seen for non bypassed hostnames |
| 5. Verify that DNS packets seen for bypassed hostnames |
| """ |
| # set global manual proxy |
| self.log.info("Setting global proxy to: %s %s %s" % |
| (self.proxy_server, self.proxy_port, self.bypass_host)) |
| self.dut.droid.connectivitySetGlobalProxy(self.proxy_server, |
| self.proxy_port, |
| self.bypass_host) |
| global_proxy = self.dut.droid.connectivityGetGlobalProxy() |
| asserts.assert_true(global_proxy['Hostname'] == self.proxy_server, |
| "Failed to set manual proxy") |
| |
| # test proxy |
| self._test_proxy() |
