#
#   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.controllers import adb
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.net import connectivity_const as cconst
from acts_contrib.test_utils.net import ipsec_test_utils as iutils
from acts_contrib.test_utils.net import socket_test_utils as sutils
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

import random
import time

WLAN = "wlan0"
WAIT_FOR_IP = 15


class IpSecTest(base_test.BaseTestClass):
    """ Tests for UID networking """

    def setup_class(self):
        """ Setup devices for tests and unpack params """
        self.dut_a = self.android_devices[0]
        self.dut_b = self.android_devices[1]

        req_params = ("wifi_network",)
        self.unpack_userparams(req_params)
        wutils.connect_to_wifi_network(self.dut_a, self.wifi_network)
        wutils.connect_to_wifi_network(self.dut_b, self.wifi_network)
        time.sleep(WAIT_FOR_IP)

        try:
            self.ipv4_dut_a = self.dut_a.droid.connectivityGetIPv4Addresses(
                WLAN)[0]
            self.ipv4_dut_b = self.dut_b.droid.connectivityGetIPv4Addresses(
                WLAN)[0]
            self.ipv6_dut_a = self.dut_a.droid.connectivityGetIPv6Addresses(
                WLAN)[0]
            self.ipv6_dut_b = self.dut_b.droid.connectivityGetIPv6Addresses(
                WLAN)[0]
        except Exception as e:
            asserts.abort_class("Failed to get IPv4/IPv6 address: %s" % e)

        self.crypt_auth_combos = iutils.generate_random_crypt_auth_combo()

        self.tcpdump_pid_a = None
        self.tcpdump_pid_b = None

    def teardown_class(self):
        for ad in self.android_devices:
            wutils.reset_wifi(ad)

    def setup_test(self):
        self.tcpdump_pid_a = start_tcpdump(self.dut_a, self.test_name)
        self.tcpdump_pid_b = start_tcpdump(self.dut_b, self.test_name)

    def teardown_test(self):
        stop_tcpdump(self.dut_a, self.tcpdump_pid_a, self.test_name)
        stop_tcpdump(self.dut_b, self.tcpdump_pid_b, self.test_name)

    def on_fail(self, test_name, begin_time):
        self.dut_a.take_bug_report(test_name, begin_time)
        self.dut_b.take_bug_report(test_name, begin_time)

    """ Helper functions begin """

    def _test_spi_allocate_release_req_spi(self, dut, ip):
        req_spi = random.randint(1, 999999999)
        self.log.info("IP addr: %s" % ip)
        self.log.info("Request SPI: %s" % req_spi)
        key = dut.droid.ipSecAllocateSecurityParameterIndex(ip, req_spi)
        spi = dut.droid.ipSecGetSecurityParameterIndex(key)
        self.log.info("Got: %s" % spi)
        dut.droid.ipSecReleaseSecurityParameterIndex(key)
        asserts.assert_true(req_spi == spi, "Incorrect SPI")
        spi = dut.droid.ipSecGetSecurityParameterIndex(key)
        self.log.info("SPI after release: %s" % spi)
        asserts.assert_true(spi == 0, "Release SPI failed")

    def _test_spi_allocate_release_random_spi(self, dut, ip):
        self.log.info("IP addr: %s" % ip)
        key = dut.droid.ipSecAllocateSecurityParameterIndex(ip)
        spi = dut.droid.ipSecGetSecurityParameterIndex(key)
        self.log.info("Got: %s" % spi)
        dut.droid.ipSecReleaseSecurityParameterIndex(key)
        spi = dut.droid.ipSecGetSecurityParameterIndex(key)
        self.log.info("SPI after release: %s" % spi)
        asserts.assert_true(spi == 0, "Release SPI failed")

    def _test_transport_mode_transform_file_descriptors(self,
                                                        domain,
                                                        sock_type,
                                                        udp_encap = False):
        """Test transport mode tranform with android.system.Os sockets"""

        # dut objects & ip addrs
        dut_a = self.dut_a
        dut_b = self.dut_b
        port = random.randint(5000, 6000)
        udp_encap_port = 4500
        ip_a = self.ipv4_dut_a
        ip_b = self.ipv4_dut_b
        if domain == cconst.AF_INET6:
            ip_a = self.ipv6_dut_a
            ip_b = self.ipv6_dut_b
        self.log.info("DUT_A IP addr: %s" % ip_a)
        self.log.info("DUT_B IP addr: %s" % ip_b)
        self.log.info("Port: %s" % port)

        # create crypt and auth keys
        cl, auth_algo, al, trunc_bits = random.choice(self.crypt_auth_combos)
        crypt_key = iutils.make_key(cl)
        auth_key = iutils.make_key(al)
        crypt_algo = cconst.CRYPT_AES_CBC

        # open sockets
        fd_a = sutils.open_android_socket(dut_a, domain, sock_type, ip_a, port)
        fd_b = sutils.open_android_socket(dut_b, domain, sock_type, ip_b, port)

        # allocate SPIs
        spi_keys_a = iutils.allocate_spis(dut_a, ip_a, ip_b)
        in_spi = dut_a.droid.ipSecGetSecurityParameterIndex(spi_keys_a[0])
        out_spi = dut_a.droid.ipSecGetSecurityParameterIndex(spi_keys_a[1])
        spi_keys_b = iutils.allocate_spis(dut_b, ip_b, ip_a, out_spi, in_spi)

        # open udp encap sockets
        udp_encap_a = None
        udp_encap_b = None
        if udp_encap:
            udp_encap_a = dut_a.droid.ipSecOpenUdpEncapsulationSocket(
                udp_encap_port)
            udp_encap_b = dut_b.droid.ipSecOpenUdpEncapsulationSocket(
                udp_encap_port)
        self.log.info("UDP Encap: %s" % udp_encap_a)
        self.log.info("UDP Encap: %s" % udp_encap_b)

        # create transforms
        transforms_a = iutils.create_transport_mode_transforms(
            dut_a, spi_keys_a, ip_a, ip_b, crypt_algo, crypt_key, auth_algo,
            auth_key, trunc_bits, udp_encap_a)
        transforms_b = iutils.create_transport_mode_transforms(
            dut_b, spi_keys_b, ip_b, ip_a, crypt_algo, crypt_key, auth_algo,
            auth_key, trunc_bits, udp_encap_b)

        # apply transforms to socket
        iutils.apply_transport_mode_transforms_file_descriptors(
            dut_a, fd_a, transforms_a)
        iutils.apply_transport_mode_transforms_file_descriptors(
            dut_b, fd_b, transforms_b)

        # listen, connect, accept if TCP socket
        if sock_type == cconst.SOCK_STREAM:
            server_fd = fd_b
            self.log.info("Setup TCP connection")
            dut_b.droid.listenSocket(fd_b)
            dut_a.droid.connectSocket(fd_a, ip_b, port)
            fd_b = dut_b.droid.acceptSocket(fd_b)
            asserts.assert_true(fd_b, "accept() failed")

        # Send message from one dut to another
        sutils.send_recv_data_android_sockets(
            dut_a, dut_b, fd_a, fd_b, ip_b, port)

        # verify ESP packets
        iutils.verify_esp_packets([dut_a, dut_b])

        # remove transforms from socket
        iutils.remove_transport_mode_transforms_file_descriptors(dut_a, fd_a)
        iutils.remove_transport_mode_transforms_file_descriptors(dut_b, fd_b)

        # destroy transforms
        iutils.destroy_transport_mode_transforms(dut_a, transforms_a)
        iutils.destroy_transport_mode_transforms(dut_b, transforms_b)

        # close udp encap sockets
        if udp_encap:
            dut_a.droid.ipSecCloseUdpEncapsulationSocket(udp_encap_a)
            dut_b.droid.ipSecCloseUdpEncapsulationSocket(udp_encap_b)

        # release SPIs
        iutils.release_spis(dut_a, spi_keys_a)
        iutils.release_spis(dut_b, spi_keys_b)

        # Send message from one dut to another
        sutils.send_recv_data_android_sockets(
            dut_a, dut_b, fd_a, fd_b, ip_b, port)

        # close sockets
        sutils.close_android_socket(dut_a, fd_a)
        sutils.close_android_socket(dut_b, fd_b)
        if sock_type == cconst.SOCK_STREAM:
            sutils.close_android_socket(dut_b, server_fd)

    def _test_transport_mode_transform_datagram_sockets(self,
                                                        domain,
                                                        udp_encap = False):
        """ Test transport mode transform datagram sockets """

        # dut objects and ip addrs
        dut_a = self.dut_a
        dut_b = self.dut_b
        udp_encap_port = 4500
        ip_a = self.ipv4_dut_a
        ip_b = self.ipv4_dut_b
        if domain == cconst.AF_INET6:
            ip_a = self.ipv6_dut_a
            ip_b = self.ipv6_dut_b
        self.log.info("DUT_A IP addr: %s" % ip_a)
        self.log.info("DUT_B IP addr: %s" % ip_b)

        # create crypt and auth keys
        cl, auth_algo, al, trunc_bits = random.choice(self.crypt_auth_combos)
        crypt_key = iutils.make_key(cl)
        auth_key = iutils.make_key(al)
        crypt_algo = cconst.CRYPT_AES_CBC

        # open sockets
        socket_a = sutils.open_datagram_socket(dut_a, ip_a, 0)
        socket_b = sutils.open_datagram_socket(dut_b, ip_b, 0)
        port = dut_b.droid.getPortOfDatagramSocket(socket_b)

        # allocate SPIs
        spi_keys_a = iutils.allocate_spis(dut_a, ip_a, ip_b)
        in_spi = dut_a.droid.ipSecGetSecurityParameterIndex(spi_keys_a[0])
        out_spi = dut_a.droid.ipSecGetSecurityParameterIndex(spi_keys_a[1])
        spi_keys_b = iutils.allocate_spis(dut_b, ip_b, ip_a, out_spi, in_spi)

        # open udp encap sockets
        udp_encap_a = None
        udp_encap_b = None
        if udp_encap:
            udp_encap_a = dut_a.droid.ipSecOpenUdpEncapsulationSocket(
                udp_encap_port)
            udp_encap_b = dut_b.droid.ipSecOpenUdpEncapsulationSocket(
                udp_encap_port)
        self.log.info("UDP Encap: %s" % udp_encap_a)
        self.log.info("UDP Encap: %s" % udp_encap_b)

        # create transforms
        transforms_a = iutils.create_transport_mode_transforms(
            dut_a, spi_keys_a, ip_a, ip_b, crypt_algo, crypt_key, auth_algo,
            auth_key, trunc_bits, udp_encap_a)
        transforms_b = iutils.create_transport_mode_transforms(
            dut_b, spi_keys_b, ip_b, ip_a, crypt_algo, crypt_key, auth_algo,
            auth_key, trunc_bits, udp_encap_b)

        # apply transforms
        iutils.apply_transport_mode_transforms_datagram_socket(
            dut_a, socket_a, transforms_a)
        iutils.apply_transport_mode_transforms_datagram_socket(
            dut_b, socket_b, transforms_b)

        # send and verify message from one dut to another
        sutils.send_recv_data_datagram_sockets(
            dut_a, dut_b, socket_a, socket_b, ip_b, port)

        # verify ESP packets
        iutils.verify_esp_packets([dut_a, dut_b])

        # remove transforms
        iutils.remove_transport_mode_transforms_datagram_socket(dut_a, socket_a)
        iutils.remove_transport_mode_transforms_datagram_socket(dut_b, socket_b)

        # destroy transforms
        iutils.destroy_transport_mode_transforms(dut_a, transforms_a)
        iutils.destroy_transport_mode_transforms(dut_b, transforms_b)

        # close udp encap sockets
        if udp_encap:
            dut_a.droid.ipSecCloseUdpEncapsulationSocket(udp_encap_a)
            dut_b.droid.ipSecCloseUdpEncapsulationSocket(udp_encap_b)

        # release SPIs
        iutils.release_spis(dut_a, spi_keys_a)
        iutils.release_spis(dut_b, spi_keys_b)

        # Send and verify message from one dut to another
        sutils.send_recv_data_datagram_sockets(
            dut_a, dut_b, socket_a, socket_b, ip_b, port)

        # close sockets
        sutils.close_datagram_socket(dut_a, socket_a)
        sutils.close_datagram_socket(dut_b, socket_b)

    def _test_transport_mode_transform_sockets(self, domain, udp_encap = False):

        # dut objects and ip addrs
        dut_a = self.dut_a
        dut_b = self.dut_b
        ip_a = self.ipv4_dut_a
        ip_b = self.ipv4_dut_b
        if domain == cconst.AF_INET6:
            ip_a = self.ipv6_dut_a
            ip_b = self.ipv6_dut_b
        self.log.info("DUT_A IP addr: %s" % ip_a)
        self.log.info("DUT_B IP addr: %s" % ip_b)
        udp_encap_port = 4500

        # open sockets
        server_sock = sutils.open_server_socket(dut_b, ip_b, 0)
        port = dut_b.droid.getPortOfServerSocket(server_sock)
        sock_a, sock_b = sutils.open_connect_socket(
            dut_a, dut_b, ip_a, ip_b, 0, port, server_sock)

        # create crypt and auth keys
        cl, auth_algo, al, trunc_bits = random.choice(self.crypt_auth_combos)
        crypt_key = iutils.make_key(cl)
        auth_key = iutils.make_key(al)
        crypt_algo = cconst.CRYPT_AES_CBC

        # allocate SPIs
        spi_keys_a = iutils.allocate_spis(dut_a, ip_a, ip_b)
        in_spi = dut_a.droid.ipSecGetSecurityParameterIndex(spi_keys_a[0])
        out_spi = dut_a.droid.ipSecGetSecurityParameterIndex(spi_keys_a[1])
        spi_keys_b = iutils.allocate_spis(dut_b, ip_b, ip_a, out_spi, in_spi)

        # open udp encap sockets
        udp_encap_a = None
        udp_encap_b = None
        if udp_encap:
            udp_encap_a = dut_a.droid.ipSecOpenUdpEncapsulationSocket(
                udp_encap_port)
            udp_encap_b = dut_b.droid.ipSecOpenUdpEncapsulationSocket(
                udp_encap_port)
        self.log.info("UDP Encap: %s" % udp_encap_a)
        self.log.info("UDP Encap: %s" % udp_encap_b)

        # create transforms
        transforms_a = iutils.create_transport_mode_transforms(
            dut_a, spi_keys_a, ip_a, ip_b, crypt_algo, crypt_key, auth_algo,
            auth_key, trunc_bits, udp_encap_a)
        transforms_b = iutils.create_transport_mode_transforms(
            dut_b, spi_keys_b, ip_b, ip_a, crypt_algo, crypt_key, auth_algo,
            auth_key, trunc_bits, udp_encap_b)

        # apply transform to sockets
        iutils.apply_transport_mode_transforms_socket(dut_a, sock_a, transforms_a)
        iutils.apply_transport_mode_transforms_socket(dut_b, sock_b, transforms_b)

        # send message from one dut to another
        sutils.send_recv_data_sockets(dut_a, dut_b, sock_a, sock_b)

        # verify esp packets
        iutils.verify_esp_packets([dut_a, dut_b])

        # remove transforms from socket
        iutils.remove_transport_mode_transforms_socket(dut_a, sock_a)
        iutils.remove_transport_mode_transforms_socket(dut_b, sock_b)

        # destroy transforms
        iutils.destroy_transport_mode_transforms(dut_a, transforms_a)
        iutils.destroy_transport_mode_transforms(dut_b, transforms_b)

        # close udp encap sockets
        if udp_encap:
            dut_a.droid.ipSecCloseUdpEncapsulationSocket(udp_encap_a)
            dut_b.droid.ipSecCloseUdpEncapsulationSocket(udp_encap_b)

        # release SPIs
        iutils.release_spis(dut_a, spi_keys_a)
        iutils.release_spis(dut_b, spi_keys_b)

        # send message from one dut to another
        sutils.send_recv_data_sockets(dut_a, dut_b, sock_a, sock_b)

        # close sockets
        sutils.close_socket(dut_a, sock_a)
        sutils.close_socket(dut_b, sock_b)
        sutils.close_server_socket(dut_b, server_sock)

    """ Helper functions end """

    """ Tests begin """

    @test_tracker_info(uuid="877577e2-94e8-46d3-8fee-330327adba1e")
    def test_spi_allocate_release_requested_spi_ipv4(self):
        """
        Steps:
          1. Request SPI for IPv4 dest addr
          2. SPI should be generated with the requested value
          3. Close SPI
        """
        self._test_spi_allocate_release_req_spi(self.dut_a, self.ipv4_dut_b)
        self._test_spi_allocate_release_req_spi(self.dut_b, self.ipv4_dut_a)

    @test_tracker_info(uuid="0be4c204-0e63-43fd-a7ff-8647eef21066")
    def test_spi_allocate_release_requested_spi_ipv6(self):
        """
        Steps:
          1. Request SPI for IPv6 dest addr
          2. SPI should be generated with the requested value
          3. Close SPI
        """
        self._test_spi_allocate_release_req_spi(self.dut_a, self.ipv6_dut_b)
        self._test_spi_allocate_release_req_spi(self.dut_b, self.ipv6_dut_a)

    @test_tracker_info(uuid="75eea49c-5621-4410-839f-f6e7bdd792a0")
    def test_spi_allocate_release_random_spi_ipv4(self):
        """
        Steps:
          1. Request SPI for IPv4 dest addr
          2. A random SPI should be generated
          3. Close SPI
        """
        self._test_spi_allocate_release_random_spi(self.dut_a, self.ipv4_dut_b)
        self._test_spi_allocate_release_random_spi(self.dut_b, self.ipv4_dut_a)

    @test_tracker_info(uuid="afad9e48-5573-4b3f-8dfd-c7a77eda4e1e")
    def test_spi_allocate_release_random_spi_ipv6(self):
        """
        Steps:
          1. Request SPI for IPv6 dest addr
          2. A random SPI should be generated
          3. Close SPI
        """
        self._test_spi_allocate_release_random_spi(self.dut_a, self.ipv6_dut_b)
        self._test_spi_allocate_release_random_spi(self.dut_b, self.ipv6_dut_a)

    @test_tracker_info(uuid="97817f4d-159a-4692-93f7-a38b162a565e")
    def test_allocate_release_multiple_random_spis_ipv4(self):
        """
        Steps:
          1. Request 10 SPIs at a time
          2. After 8, the remaining should return 0
        """
        res = True
        spi_key_list = []
        spi_list = []
        for i in range(10):
            spi_key = self.dut_a.droid.ipSecAllocateSecurityParameterIndex(
                self.ipv4_dut_a)
            spi_key_list.append(spi_key)
            spi = self.dut_a.droid.ipSecGetSecurityParameterIndex(spi_key)
            spi_list.append(spi)
        if spi_list.count(0) > 2:
            self.log.error("Valid SPIs is less than 8: %s" % spi_list)
            res = False

        spi_list = []
        for key in spi_key_list:
            self.dut_a.droid.ipSecReleaseSecurityParameterIndex(key)
            spi = self.dut_a.droid.ipSecGetSecurityParameterIndex(key)
            spi_list.append(spi)
        if spi_list.count(0) != 10:
            self.log.error("Could not release all SPIs")
            res = False

        return res

    @test_tracker_info(uuid="efb22e2a-1c2f-43fc-85fa-5d9a5b8e2705")
    def test_spi_allocate_release_requested_spi_ipv4_stress(self):
        """
        Steps:
          1. Request and release requested SPIs for IPv4
        """
        for i in range(15):
            self._test_spi_allocate_release_req_spi(self.dut_a, self.ipv4_dut_b)
            self._test_spi_allocate_release_req_spi(self.dut_b, self.ipv4_dut_a)

    @test_tracker_info(uuid="589749b7-3e6c-4a19-8404-d4a725d63dfd")
    def test_spi_allocate_release_requested_spi_ipv6_stress(self):
        """
        Steps:
          1. Request and release requested SPIs for IPv6
        """
        for i in range(15):
            self._test_spi_allocate_release_req_spi(self.dut_a, self.ipv6_dut_b)
            self._test_spi_allocate_release_req_spi(self.dut_b, self.ipv6_dut_a)

    @test_tracker_info(uuid="4a48130a-3f69-4390-a587-20848dee4777")
    def test_spi_allocate_release_random_spi_ipv4_stress(self):
        """
        Steps:
          1. Request and release random SPIs for IPv4
        """
        for i in range(15):
            self._test_spi_allocate_release_random_spi(
                self.dut_a, self.ipv4_dut_b)
            self._test_spi_allocate_release_random_spi(
                self.dut_b, self.ipv4_dut_a)

    @test_tracker_info(uuid="b56f6b65-cd71-4462-a739-e29d60e90ae8")
    def test_spi_allocate_release_random_spi_ipv6_stress(self):
        """
        Steps:
          1. Request and release random SPIs for IPv6
        """
        for i in range(15):
            self._test_spi_allocate_release_random_spi(
                self.dut_a, self.ipv6_dut_b)
            self._test_spi_allocate_release_random_spi(
                self.dut_b, self.ipv6_dut_a)

    """ android.system.Os sockets """

    @test_tracker_info(uuid="65c9ab9a-1128-4ba0-a1a1-a9feb99ce712")
    def test_transport_mode_udp_ipv4_file_descriptors_no_nat_no_encap(self):
        """
        Steps:
          1. Encrypt a android.system.Os IPv4 UDP socket with transport mode
             transform with UDP encap on a non-NAT network
          2. Verify encyption and decryption of packets
          3. Remove transform and verify that packets are unencrypted
        """
        self._test_transport_mode_transform_file_descriptors(cconst.AF_INET,
                                                             cconst.SOCK_DGRAM)

    @test_tracker_info(uuid="66956266-f18b-490c-b859-08530c6745c9")
    def test_transport_mode_udp_ipv4_file_descriptors_no_nat_with_encap(self):
        """
        Steps:
          1. Encrypt a android.system.Os IPv4 UDP socket with transport mode
             transform with UDP encap on a non-NAT network
          2. Verify encyption and decryption of packets
          3. Remove transform and verify that packets are unencrypted
        """
        self._test_transport_mode_transform_file_descriptors(cconst.AF_INET,
                                                             cconst.SOCK_DGRAM,
                                                             True)

    @test_tracker_info(uuid="467a1e7b-e508-439f-be24-a213bec4a9f0")
    def test_transport_mode_tcp_ipv4_file_descriptors_no_nat_no_encap(self):
        """
        Steps:
          1. Encrypt a android.system.Os IPv4 TCP socket with transport mode
             transform without UDP encap on a non-NAT network
          2. Verify encyption and decryption of packets
          3. Remove transform and verify that packets are unencrypted
        """
        self._test_transport_mode_transform_file_descriptors(cconst.AF_INET,
                                                             cconst.SOCK_STREAM)

    @test_tracker_info(uuid="877a9516-2b1c-4b52-8931-3a9a55d57875")
    def test_transport_mode_tcp_ipv4_file_descriptors_no_nat_with_encap(self):
        """
        Steps:
          1. Encrypt a android.system.Os IPv4 TCP socket with transport mode
             transform with UDP encap on a non-NAT network
          2. Verify encyption and decryption of packets
          3. Remove transform and verify that packets are unencrypted
        """
        self._test_transport_mode_transform_file_descriptors(cconst.AF_INET,
                                                             cconst.SOCK_STREAM,
                                                             True)

    @test_tracker_info(uuid="a2dd8dc7-99c8-4420-b586-b4cd68f4197e")
    def test_transport_mode_udp_ipv6_file_descriptors(self):
        """ Verify transport mode transform on android.Os datagram sockets ipv4

        Steps:
          1. Encrypt a android.system.Os IPv6 UDP socket with transport mode
             transform
          2. Verify that packets are encrypted and decrypted at the other end
          3. Remove tranform and verify that unencrypted packets are sent
        """
        self._test_transport_mode_transform_file_descriptors(cconst.AF_INET6,
                                                             cconst.SOCK_DGRAM)

    @test_tracker_info(uuid="7bc49d79-ffa8-4946-a25f-11daed4061cc")
    def test_transport_mode_tcp_ipv6_file_descriptors(self):
        """ Verify transport mode on android.system.Os stream sockets ipv6

        Steps:
          1. Encrypt a android.system.Os IPv6 TCP socket with transport mode
             transform
          2. Verify that packets are encrypted and decrypted at the other end
          3. Remove tranform and verify that unencrypted packets are sent
        """
        self._test_transport_mode_transform_file_descriptors(cconst.AF_INET6,
                                                             cconst.SOCK_STREAM)

    """ Datagram socket tests """

    @test_tracker_info(uuid="7ff29fc9-41fd-44f4-81e9-ce8c3afd9304")
    def test_transport_mode_udp_ipv4_datagram_sockets_no_nat_no_encap(self):
        """ Verify transport mode transform on datagram sockets ipv6 - UDP

        Steps:
          1. Encypt a DatagramSocket IPv6 socket with transport mode transform
             without UDP encap on a non-NAT network
          2. Verify that packets are encrypted and decrypted at the other end
          3. Remove tranform and verify that unencrypted packets are sent
        """
        self._test_transport_mode_transform_datagram_sockets(cconst.AF_INET)

    @test_tracker_info(uuid="552af945-a23a-49f2-9ceb-b0d1e7c1d50b")
    def test_transport_mode_udp_ipv4_datagram_sockets_no_nat_with_encap(self):
        """ Verify transport mode transform on datagram sockets ipv6 - UDP

        Steps:
          1. Encypt a DatagramSocket IPv6 socket with transport mode transform
             with UDP encap on a non-NAT network
          2. Verify that packets are encrypted and decrypted at the other end
          3. Remove tranform and verify that unencrypted packets are sent
        """
        self._test_transport_mode_transform_datagram_sockets(cconst.AF_INET, True)

    @test_tracker_info(uuid="dd3a08c4-d393-46c4-b550-bc551ceb15f7")
    def test_transport_mode_udp_ipv6_datagram_sockets(self):
        """ Verify transport mode transform on datagram sockets ipv6 - UDP

        Steps:
          1. Encypt a DatagramSocket IPv6 socket with transport mode transform
          2. Verify that packets are encrypted and decrypted at the other end
          3. Remove tranform and verify that unencrypted packets are sent
        """
        self._test_transport_mode_transform_datagram_sockets(cconst.AF_INET6)

    """ Socket & server socket tests """

    @test_tracker_info(uuid="f851b5da-790a-45c6-8968-1a347ef30cf2")
    def test_transport_mode_tcp_ipv4_sockets_no_nat_no_encap(self):
        """ Verify transport mode transform on sockets ipv4 - TCP

        Steps:
          1. Encypt a Socket IPv4 socket with transport mode transform without
             UDP encap on a non-NAT network
          2. Verify that packets are encrypted and decrypted at the other end
          3. Remove tranform and verify that unencrypted packets are sent
        """
        self._test_transport_mode_transform_sockets(cconst.AF_INET)

    @test_tracker_info(uuid="11982874-8625-40c1-aae5-8327217bb3c4")
    def test_transport_mode_tcp_ipv4_sockets_no_nat_with_encap(self):
        """ Verify transport mode transform on sockets ipv4 - TCP

        Steps:
          1. Encypt a Socket IPv4 socket with transport mode transform with
             UDP encap on a non-NAT network
          2. Verify that packets are encrypted and decrypted at the other end
          3. Remove tranform and verify that unencrypted packets are sent
        """
        self._test_transport_mode_transform_sockets(cconst.AF_INET, True)

    @test_tracker_info(uuid="ba8f98c7-2123-4082-935f-a5fd5e6fb461")
    def test_transport_mode_tcp_ipv6_sockets(self):
        """ Verify transport mode transform on sockets ipv6 - TCP

        Steps:
          1. Encypt a Socket IPv6 socket with transport mode transform
          2. Verify that packets are encrypted and decrypted at the other end
          3. Remove tranform and verify that unencrypted packets are sent
        """
        self._test_transport_mode_transform_sockets(cconst.AF_INET6)

    """ Tests end """