File size: 142,700 Bytes
{"repo": "secdev/scapy", "pull_number": 371, "instance_id": "secdev__scapy-371", "issue_numbers": "", "base_commit": "94bab875acdf3947f691c5fae819b8dc22289e3a", "patch": "diff --git a/scapy/layers/dot11.py b/scapy/layers/dot11.py\n--- a/scapy/layers/dot11.py\n+++ b/scapy/layers/dot11.py\n@@ -21,9 +21,13 @@\n \n \n try:\n-    from Crypto.Cipher import ARC4\n+    from cryptography.hazmat.backends import default_backend\n+    from cryptography.hazmat.primitives.ciphers import (\n+        Cipher,\n+        algorithms,\n+    )\n except ImportError:\n-    log_loading.info(\"Can't import python Crypto lib. Won't be able to decrypt WEP.\")\n+    log_loading.info(\"Can't import python cryptography lib. Won't be able to decrypt WEP.\")\n \n \n ### Fields\n@@ -339,8 +343,12 @@ def post_build(self, p, pay):\n                     icv = \"\"\n                 else:\n                     icv = p[4:8]\n-                c = ARC4.new(self.iv+key)\n-                p = p[:4]+c.encrypt(pay)+icv\n+                e = Cipher(\n+                    algorithms.ARC4(self.iv+key),\n+                    None,\n+                    default_backend(),\n+                ).encryptor()\n+                p = p[:4]+e.update(pay)+e.finalize()+icv\n             else:\n                 warning(\"No WEP key set (conf.wepkey).. strange results expected..\")\n         return p\n@@ -350,9 +358,13 @@ def decrypt(self,key=None):\n         if key is None:\n             key = conf.wepkey\n         if key:\n-            c = ARC4.new(self.iv+key)\n-            self.add_payload(LLC(c.decrypt(self.wepdata)))\n-                    \n+            d = Cipher(\n+                algorithms.ARC4(self.iv+key),\n+                None,\n+                default_backend(),\n+            ).decryptor()\n+            self.add_payload(LLC(d.update(self.wepdata)+d.finalize()))\n+\n \n bind_layers( PrismHeader,   Dot11,         )\n bind_layers( RadioTap,      Dot11,         )\ndiff --git a/scapy/layers/ipsec.py b/scapy/layers/ipsec.py\n--- a/scapy/layers/ipsec.py\n+++ b/scapy/layers/ipsec.py\n@@ -39,17 +39,15 @@\n True\n \"\"\"\n \n+from fractions import gcd\n+import os\n import socket\n import struct\n-from scapy.error import warning\n-\n-try:\n-    from Crypto.Util.number import GCD as gcd\n-except ImportError:\n-    from fractions import gcd\n \n+from scapy.error import warning\n \n from scapy.data import IP_PROTOS\n+from scapy.error import log_loading\n \n from scapy.fields import ByteEnumField, ByteField, StrField, XIntField, IntField, \\\n     ShortField, PacketField\n@@ -145,22 +143,19 @@ def data_for_encryption(self):\n \n #------------------------------------------------------------------------------\n try:\n-    from Crypto.Cipher import AES\n-    from Crypto.Cipher import DES\n-    from Crypto.Cipher import DES3\n-    from Crypto.Cipher import CAST\n-    from Crypto.Cipher import Blowfish\n-    from Crypto.Util import Counter\n-    from Crypto import Random\n+    from cryptography.exceptions import InvalidTag\n+    from cryptography.hazmat.backends import default_backend\n+    from cryptography.hazmat.primitives.ciphers import (\n+        Cipher,\n+        algorithms,\n+        modes,\n+    )\n except ImportError:\n-    # no error if pycrypto is not available but encryption won't be supported\n-    warning(\"IPsec encryption not supported (pycrypto required).\")\n-    AES = None\n-    DES = None\n-    DES3 = None\n-    CAST = None\n-    Blowfish = None\n-    Random = None\n+    log_loading.info(\"Can't import python cryptography lib. \"\n+                     \"Disabled IPsec encryption/authentication.\")\n+    algorithms = None\n+    Cipher = None\n+    modes = None\n \n try:\n     from Crypto.Cipher.AES import MODE_GCM\n@@ -183,7 +178,8 @@ class CryptAlgo(object):\n     IPsec encryption algorithm\n     \"\"\"\n \n-    def __init__(self, name, cipher, mode, block_size=None, iv_size=None, key_size=None, icv_size=None):\n+    def __init__(self, name, cipher, mode, block_size=None, iv_size=None,\n+                 key_size=None, icv_size=None, salt_size=None):\n         \"\"\"\n         @param name: the name of this encryption algorithm\n         @param cipher: a Cipher module\n@@ -195,24 +191,25 @@ def __init__(self, name, cipher, mode, block_size=None, iv_size=None, key_size=N\n         @param key_size: an integer or list/tuple of integers. If specified,\n                          force the secret keys length to one of the values.\n                          Defaults to the `key_size` of the cipher.\n-        @param icv_size: the length of the integrity check value of this algo.\n-                         Only used in this class for AEAD algorithms.\n+        @param icv_size: the length of the Integrity Check Value of this algo.\n+                         Used by Combined Mode Algorithms e.g. GCM\n+        @param salt_size: the length of the salt to use as the IV prefix.\n+                          Usually used by Counter modes e.g. CTR\n         \"\"\"\n         self.name = name\n         self.cipher = cipher\n         self.mode = mode\n-        self.is_aead = (hasattr(self.cipher, 'MODE_GCM') and\n-                        self.mode == self.cipher.MODE_GCM) or \\\n-                        (hasattr(self.cipher, 'MODE_CCM') and\n-                        self.mode == self.cipher.MODE_CCM)\n+        self.icv_size = icv_size\n \n-        if icv_size is not None:\n-            self.icv_size = icv_size\n+        if self.mode is not None:\n+            self.is_aead = issubclass(self.mode, modes.ModeWithAuthenticationTag)\n+        else:\n+            self.is_aead = False\n \n         if block_size is not None:\n             self.block_size = block_size\n         elif cipher is not None:\n-            self.block_size = cipher.block_size\n+            self.block_size = cipher.block_size // 8\n         else:\n             self.block_size = 1\n \n@@ -224,10 +221,15 @@ def __init__(self, name, cipher, mode, block_size=None, iv_size=None, key_size=N\n         if key_size is not None:\n             self.key_size = key_size\n         elif cipher is not None:\n-            self.key_size = cipher.key_size\n+            self.key_size = tuple(i // 8 for i in cipher.key_sizes)\n         else:\n             self.key_size = None\n \n+        if salt_size is None:\n+            self.salt_size = 0\n+        else:\n+            self.salt_size = salt_size\n+\n     def check_key(self, key):\n         \"\"\"\n         Check that the key length is valid.\n@@ -240,58 +242,48 @@ def check_key(self, key):\n \n     def generate_iv(self):\n         \"\"\"\n-        Generate a random initialization vector. If pycrypto is not available,\n-        return a buffer of the correct length filled with only '\\x00'.\n+        Generate a random initialization vector.\n         \"\"\"\n-        if Random:\n-            return Random.get_random_bytes(self.iv_size)\n-        else:\n-            return chr(0) * self.iv_size\n+        # XXX: Handle counter modes with real counters? RFCs allow the use of\n+        # XXX: random bytes for counters, so it is not wrong to do it that way\n+        return os.urandom(self.iv_size - self.salt_size)\n \n-    def new_cipher(self, key, iv):\n+    def new_cipher(self, key, iv, digest=None):\n         \"\"\"\n         @param key:    the secret key, a byte string\n-        @param iv:     the initialization vector, a byte string\n+        @param iv:     the initialization vector, a byte string. Used as the\n+                       initial nonce in counter mode\n+        @param digest: also known as tag or icv. A byte string containing the\n+                       digest of the encrypted data. Only use this during\n+                       decryption!\n+\n         @return:    an initialized cipher object for this algo\n         \"\"\"\n-        if (hasattr(self.cipher, 'MODE_CTR') and self.mode == self.cipher.MODE_CTR\n-            or self.is_aead):\n-            # in counter mode, the \"iv\" must be incremented for each block\n-            # it is calculated like this:\n-            # +---------+------------------+---------+\n-            # |  nonce  |        IV        | counter |\n-            # +---------+------------------+---------+\n-            #   m bytes       n bytes        4 bytes\n-            # <-------------------------------------->\n-            #               block_size\n-            nonce_size = self.cipher.block_size - self.iv_size - 4\n-\n-            # instead of asking for an extra parameter, we extract the last\n-            # nonce_size bytes of the key and use them as the nonce.\n-            # +----------------------------+---------+\n-            # |        cipher key          |  nonce  |\n-            # +----------------------------+---------+\n-            #                              <--------->\n-            #                               nonce_size\n-            cipher_key, nonce = key[:-nonce_size], key[-nonce_size:]\n-            if self.is_aead:\n-                return self.cipher.new(cipher_key, self.mode, nonce + iv,\n-                                       counter=Counter.new(4 * 8, prefix=nonce + iv))\n-\n-            return self.cipher.new(cipher_key, self.mode,\n-                                   counter=Counter.new(4 * 8, prefix=nonce + iv))\n+        if self.is_aead and digest is not None:\n+            # With AEAD, the mode needs the digest during decryption.\n+            return Cipher(\n+                self.cipher(key),\n+                self.mode(iv, digest, len(digest)),\n+                default_backend(),\n+            )\n         else:\n-            return self.cipher.new(key, self.mode, iv)\n+            return Cipher(\n+                self.cipher(key),\n+                self.mode(iv),\n+                default_backend(),\n+            )\n \n     def pad(self, esp):\n         \"\"\"\n         Add the correct amount of padding so that the data to encrypt is\n         exactly a multiple of the algorithm's block size.\n \n-        Also, make sure that the total ESP packet length is a multiple of 4 or\n-        8 bytes with IP or IPv6 respectively.\n+        Also, make sure that the total ESP packet length is a multiple of 4\n+        bytes.\n \n         @param esp:    an unencrypted _ESPPlain packet\n+\n+        @return:    an unencrypted _ESPPlain packet with valid padding\n         \"\"\"\n         # 2 extra bytes for padlen and nh\n         data_len = len(esp.data) + 2\n@@ -303,7 +295,9 @@ def pad(self, esp):\n         # pad for block size\n         esp.padlen = -data_len % align\n \n-        # padding must be an array of bytes starting from 1 to padlen\n+        # Still according to the RFC, the default value for padding *MUST* be an\n+        # array of bytes starting from 1 to padlen\n+        # TODO: Handle padding function according to the encryption algo\n         esp.padding = ''.join(chr(b) for b in xrange(1, esp.padlen + 1))\n \n         # If the following test fails, it means that this algo does not comply\n@@ -326,19 +320,20 @@ def encrypt(self, esp, key):\n         data = esp.data_for_encryption()\n \n         if self.cipher:\n-            self.check_key(key)\n             cipher = self.new_cipher(key, esp.iv)\n+            encryptor = cipher.encryptor()\n \n             if self.is_aead:\n-                cipher.update(struct.pack('!LL', esp.spi, esp.seq))\n-                data = cipher.encrypt(data)\n-                data += cipher.digest()[:self.icv_size]\n+                aad = struct.pack('!LL', esp.spi, esp.seq)\n+                encryptor.authenticate_additional_data(aad)\n+                data = encryptor.update(data) + encryptor.finalize()\n+                data += encryptor.tag[:self.icv_size]\n             else:\n-                data = cipher.encrypt(data)\n+                data = encryptor.update(data) + encryptor.finalize()\n \n         return ESP(spi=esp.spi, seq=esp.seq, data=esp.iv + data)\n \n-    def decrypt(self, esp, key, icv_size=0):\n+    def decrypt(self, esp, key, icv_size=None):\n         \"\"\"\n         Decrypt an ESP packet\n \n@@ -347,23 +342,30 @@ def decrypt(self, esp, key, icv_size=0):\n         @param icv_size:   the length of the icv used for integrity check\n \n         @return:    a valid ESP packet encrypted with this algorithm\n+        @raise IPSecIntegrityError: if the integrity check fails with an AEAD\n+                                    algorithm\n         \"\"\"\n-        self.check_key(key)\n-\n-        if self.cipher and self.is_aead:\n-            icv_size = self.icv_size\n+        if icv_size is None:\n+            icv_size = self.icv_size if self.is_aead else 0\n \n         iv = esp.data[:self.iv_size]\n         data = esp.data[self.iv_size:len(esp.data) - icv_size]\n         icv = esp.data[len(esp.data) - icv_size:]\n \n         if self.cipher:\n-            cipher = self.new_cipher(key, iv)\n+            cipher = self.new_cipher(key, iv, icv)\n+            decryptor = cipher.decryptor()\n \n             if self.is_aead:\n-                cipher.update(struct.pack('!LL', esp.spi, esp.seq))\n+                # Tag value check is done during the finalize method\n+                decryptor.authenticate_additional_data(\n+                    struct.pack('!LL', esp.spi, esp.seq)\n+                )\n \n-            data = cipher.decrypt(data)\n+            try:\n+                data = decryptor.update(data) + decryptor.finalize()\n+            except InvalidTag as err:\n+                raise IPSecIntegrityError(err)\n \n         # extract padlen and nh\n         padlen = ord(data[-2])\n@@ -390,72 +392,53 @@ def decrypt(self, esp, key, icv_size=0):\n     'NULL': CryptAlgo('NULL', cipher=None, mode=None, iv_size=0),\n }\n \n-if AES:\n+if algorithms:\n     CRYPT_ALGOS['AES-CBC'] = CryptAlgo('AES-CBC',\n-                                       cipher=AES,\n-                                       mode=AES.MODE_CBC)\n-    # specific case for counter mode:\n-    # the last 4 bytes of the key are used to carry the nonce of the counter\n+                                       cipher=algorithms.AES,\n+                                       mode=modes.CBC)\n     CRYPT_ALGOS['AES-CTR'] = CryptAlgo('AES-CTR',\n-                                       cipher=AES,\n-                                       mode=AES.MODE_CTR,\n-                                       block_size=1,\n-                                       iv_size=8,\n-                                       key_size=(16 + 4, 24 + 4, 32 + 4))\n-\n-    # AEAD algorithms are only supported in pycrypto 2.7a1+\n-    # they also have an additional field icv_size, which is usually\n-    # populated by an auth algo when signing and verifying signatures.\n-    if hasattr(AES, \"MODE_GCM\"):\n-        CRYPT_ALGOS['AES-GCM'] = CryptAlgo('AES-GCM',\n-                                           cipher=AES,\n-                                           mode=AES.MODE_GCM,\n-                                           iv_size=8,\n-                                           icv_size=16,\n-                                           key_size=(16 + 4, 24 + 4, 32 + 4))\n-    if hasattr(AES, \"MODE_CCM\"):\n+                                       cipher=algorithms.AES,\n+                                       mode=modes.CTR,\n+                                       salt_size=4)\n+    CRYPT_ALGOS['AES-GCM'] = CryptAlgo('AES-GCM',\n+                                       cipher=algorithms.AES,\n+                                       mode=modes.GCM,\n+                                       salt_size=4,\n+                                       icv_size=16)\n+    if hasattr(modes, 'CCM'):\n         CRYPT_ALGOS['AES-CCM'] = CryptAlgo('AES-CCM',\n-                                           cipher=AES,\n-                                           mode=AES.MODE_CCM,\n-                                           iv_size=8,\n-                                           icv_size=16,\n-                                           key_size=(16 + 4, 24 + 4, 32 + 4))\n-if DES:\n-    CRYPT_ALGOS['DES'] = CryptAlgo('DES',\n-                                   cipher=DES,\n-                                   mode=DES.MODE_CBC)\n-if Blowfish:\n+                                           cipher=algorithms.AES,\n+                                           mode=modes.CCM,\n+                                           icv_size=16)\n+    # XXX: Flagged as weak by 'cryptography'. Kept for backward compatibility\n     CRYPT_ALGOS['Blowfish'] = CryptAlgo('Blowfish',\n-                                        cipher=Blowfish,\n-                                        mode=Blowfish.MODE_CBC)\n-if DES3:\n+                                        cipher=algorithms.Blowfish,\n+                                        mode=modes.CBC)\n+    # XXX: RFC7321 states that DES *MUST NOT* be implemented.\n+    # XXX: Keep for backward compatibility?\n+    # Using a TripleDES cipher algorithm for DES is done by using the same 64\n+    # bits key 3 times (done by cryptography when given a 64 bits key)\n+    CRYPT_ALGOS['DES'] = CryptAlgo('DES',\n+                                   cipher=algorithms.TripleDES,\n+                                   mode=modes.CBC,\n+                                   key_size=(8,))\n     CRYPT_ALGOS['3DES'] = CryptAlgo('3DES',\n-                                    cipher=DES3,\n-                                    mode=DES3.MODE_CBC)\n-if CAST:\n+                                    cipher=algorithms.TripleDES,\n+                                    mode=modes.CBC)\n     CRYPT_ALGOS['CAST'] = CryptAlgo('CAST',\n-                                    cipher=CAST,\n-                                    mode=CAST.MODE_CBC)\n+                                    cipher=algorithms.CAST5,\n+                                    mode=modes.CBC)\n \n #------------------------------------------------------------------------------\n try:\n-    from Crypto.Hash import HMAC\n-    from Crypto.Hash import SHA\n-    from Crypto.Hash import MD5\n-    from Crypto.Hash import SHA256\n-    from Crypto.Hash import SHA384\n-    from Crypto.Hash import SHA512\n+    from cryptography.hazmat.primitives.hmac import HMAC\n+    from cryptography.hazmat.primitives.cmac import CMAC\n+    from cryptography.hazmat.primitives import hashes\n except ImportError:\n-    # no error if pycrypto is not available but authentication won't be supported\n+    # no error if cryptography is not available but authentication won't be supported\n     HMAC = None\n-    SHA = None\n-    MD5 = None\n-    SHA256 = None\n-    SHA384 = None\n-try:\n-    from Crypto.Hash import XCBCMAC\n-except ImportError:\n-    XCBCMAC = None\n+    CMAC = None\n+    hashes = None\n \n #------------------------------------------------------------------------------\n class IPSecIntegrityError(Exception):\n@@ -500,11 +483,10 @@ def new_mac(self, key):\n         @param key:    a byte string\n         @return:       an initialized mac object for this algo\n         \"\"\"\n-        if self.mac is XCBCMAC:\n-            # specific case here, ciphermod instead of digestmod\n-            return self.mac.new(key, ciphermod=self.digestmod)\n+        if self.mac is CMAC:\n+            return self.mac(self.digestmod(key), default_backend())\n         else:\n-            return self.mac.new(key, digestmod=self.digestmod)\n+            return self.mac(key, self.digestmod(), default_backend())\n \n     def sign(self, pkt, key):\n         \"\"\"\n@@ -518,18 +500,16 @@ def sign(self, pkt, key):\n         if not self.mac:\n             return pkt\n \n-        self.check_key(key)\n-\n         mac = self.new_mac(key)\n \n         if pkt.haslayer(ESP):\n             mac.update(str(pkt[ESP]))\n-            pkt[ESP].data += mac.digest()[:self.icv_size]\n+            pkt[ESP].data += mac.finalize()[:self.icv_size]\n \n         elif pkt.haslayer(AH):\n             clone = zero_mutable_fields(pkt.copy(), sending=True)\n             mac.update(str(clone))\n-            pkt[AH].icv = mac.digest()[:self.icv_size]\n+            pkt[AH].icv = mac.finalize()[:self.icv_size]\n \n         return pkt\n \n@@ -545,8 +525,6 @@ def verify(self, pkt, key):\n         if not self.mac or self.icv_size == 0:\n             return\n \n-        self.check_key(key)\n-\n         mac = self.new_mac(key)\n \n         pkt_icv = 'not found'\n@@ -554,19 +532,17 @@ def verify(self, pkt, key):\n \n         if isinstance(pkt, ESP):\n             pkt_icv = pkt.data[len(pkt.data) - self.icv_size:]\n-\n-            pkt = pkt.copy()\n-            pkt.data = pkt.data[:len(pkt.data) - self.icv_size]\n-            mac.update(str(pkt))\n-            computed_icv = mac.digest()[:self.icv_size]\n+            clone = pkt.copy()\n+            clone.data = clone.data[:len(clone.data) - self.icv_size]\n \n         elif pkt.haslayer(AH):\n             pkt_icv = pkt[AH].icv[:self.icv_size]\n-\n             clone = zero_mutable_fields(pkt.copy(), sending=False)\n-            mac.update(str(clone))\n-            computed_icv = mac.digest()[:self.icv_size]\n \n+        mac.update(str(clone))\n+        computed_icv = mac.finalize()[:self.icv_size]\n+\n+        # XXX: Cannot use mac.verify because the ICV can be truncated\n         if pkt_icv != computed_icv:\n             raise IPSecIntegrityError('pkt_icv=%r, computed_icv=%r' %\n                                       (pkt_icv, computed_icv))\n@@ -579,38 +555,35 @@ def verify(self, pkt, key):\n     'NULL': AuthAlgo('NULL', mac=None, digestmod=None, icv_size=0),\n }\n \n-if HMAC:\n-    if SHA:\n-        AUTH_ALGOS['HMAC-SHA1-96'] = AuthAlgo('HMAC-SHA1-96',\n-                                              mac=HMAC,\n-                                              digestmod=SHA,\n-                                              icv_size=12)\n-    if SHA256:\n-        AUTH_ALGOS['SHA2-256-128'] = AuthAlgo('SHA2-256-128',\n-                                              mac=HMAC,\n-                                              digestmod=SHA256,\n-                                              icv_size=16)\n-    if SHA384:\n-        AUTH_ALGOS['SHA2-384-192'] = AuthAlgo('SHA2-384-192',\n-                                              mac=HMAC,\n-                                              digestmod=SHA384,\n-                                              icv_size=24)\n-    if SHA512:\n-        AUTH_ALGOS['SHA2-512-256'] = AuthAlgo('SHA2-512-256',\n-                                              mac=HMAC,\n-                                              digestmod=SHA512,\n-                                              icv_size=32)\n-    if MD5:\n-        AUTH_ALGOS['HMAC-MD5-96'] = AuthAlgo('HMAC-MD5-96',\n-                                             mac=HMAC,\n-                                             digestmod=MD5,\n-                                             icv_size=12)\n-if AES and XCBCMAC:\n-    AUTH_ALGOS['AES-XCBC-96'] = AuthAlgo('AES-XCBC-96',\n-                                         mac=XCBCMAC,\n-                                         digestmod=AES,\n-                                         icv_size=12,\n-                                         key_size=(16,))\n+if HMAC and hashes:\n+    # XXX: NIST has deprecated SHA1 but is required by RFC7321\n+    AUTH_ALGOS['HMAC-SHA1-96'] = AuthAlgo('HMAC-SHA1-96',\n+                                          mac=HMAC,\n+                                          digestmod=hashes.SHA1,\n+                                          icv_size=12)\n+    AUTH_ALGOS['SHA2-256-128'] = AuthAlgo('SHA2-256-128',\n+                                          mac=HMAC,\n+                                          digestmod=hashes.SHA256,\n+                                          icv_size=16)\n+    AUTH_ALGOS['SHA2-384-192'] = AuthAlgo('SHA2-384-192',\n+                                          mac=HMAC,\n+                                          digestmod=hashes.SHA384,\n+                                          icv_size=24)\n+    AUTH_ALGOS['SHA2-512-256'] = AuthAlgo('SHA2-512-256',\n+                                          mac=HMAC,\n+                                          digestmod=hashes.SHA512,\n+                                          icv_size=32)\n+    # XXX:Flagged as deprecated by 'cryptography'. Kept for backward compat\n+    AUTH_ALGOS['HMAC-MD5-96'] = AuthAlgo('HMAC-MD5-96',\n+                                         mac=HMAC,\n+                                         digestmod=hashes.MD5,\n+                                         icv_size=12)\n+if CMAC and algorithms:\n+    AUTH_ALGOS['AES-CMAC-96'] = AuthAlgo('AES-CMAC-96',\n+                                      mac=CMAC,\n+                                      digestmod=algorithms.AES,\n+                                      icv_size=12,\n+                                      key_size=(16,))\n \n #------------------------------------------------------------------------------\n def split_for_transport(orig_pkt, transport_proto):\n@@ -781,8 +754,15 @@ def __init__(self, proto, spi, seq_num=1, crypt_algo=None, crypt_key=None,\n                 raise TypeError('unsupported encryption algo %r, try %r' %\n                                 (crypt_algo, CRYPT_ALGOS.keys()))\n             self.crypt_algo = CRYPT_ALGOS[crypt_algo]\n-            self.crypt_algo.check_key(crypt_key)\n-            self.crypt_key = crypt_key\n+\n+            if crypt_key:\n+                salt_size = self.crypt_algo.salt_size\n+                self.crypt_key = crypt_key[:len(crypt_key) - salt_size]\n+                self.crypt_salt = crypt_key[len(crypt_key) - salt_size:]\n+            else:\n+                self.crypt_key = None\n+                self.crypt_salt = None\n+\n         else:\n             self.crypt_algo = CRYPT_ALGOS['NULL']\n             self.crypt_key = None\n@@ -792,7 +772,6 @@ def __init__(self, proto, spi, seq_num=1, crypt_algo=None, crypt_key=None,\n                 raise TypeError('unsupported integrity algo %r, try %r' %\n                                 (auth_algo, AUTH_ALGOS.keys()))\n             self.auth_algo = AUTH_ALGOS[auth_algo]\n-            self.auth_algo.check_key(auth_key)\n             self.auth_key = auth_key\n         else:\n             self.auth_algo = AUTH_ALGOS['NULL']\n@@ -818,6 +797,8 @@ def _encrypt_esp(self, pkt, seq_num=None, iv=None):\n \n         if iv is None:\n             iv = self.crypt_algo.generate_iv()\n+            if self.crypt_salt:\n+                iv = self.crypt_salt + iv\n         else:\n             if len(iv) != self.crypt_algo.iv_size:\n                 raise TypeError('iv length must be %s' % self.crypt_algo.iv_size)\n@@ -949,6 +930,7 @@ def _decrypt_esp(self, pkt, verify=True):\n             self.auth_algo.verify(encrypted, self.auth_key)\n \n         esp = self.crypt_algo.decrypt(encrypted, self.crypt_key,\n+                                      self.crypt_algo.icv_size or\n                                       self.auth_algo.icv_size)\n \n         if self.tunnel_header:\ndiff --git a/scapy/layers/tls/__init__.py b/scapy/layers/tls/__init__.py\n--- a/scapy/layers/tls/__init__.py\n+++ b/scapy/layers/tls/__init__.py\n@@ -8,11 +8,11 @@\n \"\"\"\n \n try:\n-    import Crypto\n+    import cryptography\n except ImportError:\n     import logging\n     log_loading = logging.getLogger(\"scapy.loading\")\n-    log_loading.info(\"Can't import python Crypto lib. Disabled certificate manipulation tools\")\n+    log_loading.info(\"Can't import python cryptography lib. Disabled certificate manipulation tools\")\n \n try:\n     import ecdsa\ndiff --git a/scapy/layers/tls/cert.py b/scapy/layers/tls/cert.py\n--- a/scapy/layers/tls/cert.py\n+++ b/scapy/layers/tls/cert.py\n@@ -29,7 +29,9 @@\n import base64, os, time\n \n import ecdsa\n-from Crypto.PublicKey import RSA\n+from cryptography.hazmat.backends import default_backend\n+from cryptography.hazmat.primitives.asymmetric import rsa\n+from cryptography.hazmat.primitives import hashes\n \n from scapy.layers.tls.crypto.curves import import_curve\n from scapy.layers.tls.crypto.pkcs1 import pkcs_os2ip, pkcs_i2osp, mapHashFunc\n@@ -243,7 +245,10 @@ def updateWith(self, pubkey):\n         self.modulus    = pubkey.modulus.val\n         self.modulusLen = len(binrepr(pubkey.modulus.val))\n         self.pubExp     = pubkey.publicExponent.val\n-        self.key = RSA.construct((self.modulus, self.pubExp, ))\n+        self.key = rsa.RSAPublicNumbers(\n+            n=self.modulus,\n+            e=self.pubExp\n+        ).public_key(default_backend())\n     def encrypt(self, msg, t=None, h=None, mgf=None, L=None):\n         # no ECDSA encryption support, hence no ECDSA specific keywords here\n         return _EncryptAndVerifyRSA.encrypt(self, msg, t=t, h=h, mgf=mgf, L=L)\n@@ -396,7 +401,11 @@ def updateWith(self, privkey):\n         self.exponent1   = privkey.exponent1.val\n         self.exponent2   = privkey.exponent2.val\n         self.coefficient = privkey.coefficient.val\n-        self.key = RSA.construct((self.modulus, self.pubExp, self.privExp))\n+        self.key = rsa.RSAPrivateNumbers(\n+            p=self.prime1, q=self.prime2, d=self.privExp, dmp1=self.exponent1,\n+            dmq1=self.exponent2, iqmp=self.coefficient,\n+            public_numbers=rsa.RSAPublicNumbers(n=self.modulus, e=self.pubExp),\n+        ).private_key(default_backend())\n     def verify(self, msg, sig, h=None,\n                t=None, mgf=None, sLen=None,\n                sigdecode=None):\ndiff --git a/scapy/layers/tls/crypto/pkcs1.py b/scapy/layers/tls/crypto/pkcs1.py\n--- a/scapy/layers/tls/crypto/pkcs1.py\n+++ b/scapy/layers/tls/crypto/pkcs1.py\n@@ -9,8 +9,11 @@\n \n import os, popen2, tempfile\n import math, random, struct\n-from hashlib import md5, sha1, sha224, sha256, sha384, sha512\n-from Crypto.Hash import MD2, MD4\n+\n+from cryptography.exceptions import InvalidSignature\n+from cryptography.hazmat.backends import default_backend\n+from cryptography.hazmat.primitives import hashes\n+from cryptography.hazmat.primitives.asymmetric import padding\n \n \n #####################################################################\n@@ -105,42 +108,38 @@ def pkcs_ilen(n):\n #   PKCS#1 v2.1, MD4 should not be used.\n # - 'tls' one is the concatenation of both md5 and sha1 hashes used\n #   by SSL/TLS when signing/verifying things\n+def _hashWrapper(hash_algo, message, backend=default_backend()):\n+    digest = hashes.Hash(hash_algo, backend).update(message)\n+    return digest.finalize()\n+\n _hashFuncParams = {\n-    \"md2\"    : (16,\n-                MD2.new,\n-                lambda x: MD2.new(x).digest(),\n-                '\\x30\\x20\\x30\\x0c\\x06\\x08\\x2a\\x86\\x48\\x86\\xf7\\x0d\\x02\\x02\\x05\\x00\\x04\\x10'),\n-    \"md4\"    : (16,\n-                MD4.new,\n-                lambda x: MD4.new(x).digest(),\n-                '\\x30\\x20\\x30\\x0c\\x06\\x08\\x2a\\x86\\x48\\x86\\xf7\\x0d\\x02\\x04\\x05\\x00\\x04\\x10'),\n     \"md5\"    : (16,\n-                md5,\n-                lambda x: md5(x).digest(),\n+                hashes.MD5,\n+                lambda x: _hashWrapper(hashes.MD5, x),\n                 '\\x30\\x20\\x30\\x0c\\x06\\x08\\x2a\\x86\\x48\\x86\\xf7\\x0d\\x02\\x05\\x05\\x00\\x04\\x10'),\n     \"sha1\"   : (20,\n-                sha1,\n-                lambda x: sha1(x).digest(),\n+                hashes.SHA1,\n+                lambda x: _hashWrapper(hashes.SHA1, x),\n                 '\\x30\\x21\\x30\\x09\\x06\\x05\\x2b\\x0e\\x03\\x02\\x1a\\x05\\x00\\x04\\x14'),\n     \"sha224\" : (28,\n-                sha224,\n-                lambda x: sha224(x).digest(),\n+                hashes.SHA224,\n+                lambda x: _hashWrapper(hashes.SHA224, x),\n                 '\\x30\\x2d\\x30\\x0d\\x06\\x09\\x60\\x86\\x48\\x01\\x65\\x03\\x04\\x02\\x04\\x05\\x00\\x04\\x1c'),\n     \"sha256\" : (32,\n-                sha256,\n-                lambda x: sha256(x).digest(),\n+                hashes.SHA256,\n+                lambda x: _hashWrapper(hashes.SHA256, x),\n                 '\\x30\\x31\\x30\\x0d\\x06\\x09\\x60\\x86\\x48\\x01\\x65\\x03\\x04\\x02\\x01\\x05\\x00\\x04\\x20'),\n     \"sha384\" : (48,\n-                sha384,\n-                lambda x: sha384(x).digest(),\n+                hashes.SHA384,\n+                lambda x: _hashWrapper(hashes.SHA384, x),\n                 '\\x30\\x41\\x30\\x0d\\x06\\x09\\x60\\x86\\x48\\x01\\x65\\x03\\x04\\x02\\x02\\x05\\x00\\x04\\x30'),\n     \"sha512\" : (64,\n-                sha512,\n-                lambda x: sha512(x).digest(),\n+                hashes.SHA512,\n+                lambda x: _hashWrapper(hashes.SHA512, x),\n                 '\\x30\\x51\\x30\\x0d\\x06\\x09\\x60\\x86\\x48\\x01\\x65\\x03\\x04\\x02\\x03\\x05\\x00\\x04\\x40'),\n     \"tls\"    : (36,\n                 None,\n-                lambda x: md5(x).digest() + sha1(x).digest(),\n+                lambda x: _hashWrapper(hashes.MD5, x) + _hashWrapper(hashes.SHA1, x),\n                 '')\n     }\n \n@@ -425,135 +424,6 @@ def create_temporary_ca_path(anchor_list, folder):\n #####################################################################\n \n class _EncryptAndVerifyRSA(object):\n-    ### Below are encryption methods\n-\n-    def _rsaep(self, m):\n-        \"\"\"\n-        Internal method providing raw RSA encryption, i.e. simple modular\n-        exponentiation of the given message representative 'm', a long\n-        between 0 and n-1.\n-\n-        This is the encryption primitive RSAEP described in PKCS#1 v2.1,\n-        i.e. RFC 3447 Sect. 5.1.1.\n-\n-        Input:\n-           m: message representative, a long between 0 and n-1, where\n-              n is the key modulus.\n-\n-        Output:\n-           ciphertext representative, a long between 0 and n-1\n-\n-        Not intended to be used directly. Please, see encrypt() method.\n-        \"\"\"\n-\n-        n = self.modulus\n-        if isinstance(m, int):\n-            m = long(m)\n-        if (not isinstance(m, long)) or m > n-1:\n-            _warning(\"Key._rsaep() expects a long between 0 and n-1\")\n-            return None\n-\n-        return self.key.encrypt(m, \"\")[0]\n-\n-\n-    def _rsaes_pkcs1_v1_5_encrypt(self, M):\n-        \"\"\"\n-        Implements RSAES-PKCS1-V1_5-ENCRYPT() function described in section\n-        7.2.1 of RFC 3447.\n-\n-        Input:\n-           M: message to be encrypted, an octet string of length mLen, where\n-              mLen <= k-11 (k denotes the length in octets of the key modulus)\n-\n-        Output:\n-           ciphertext, an octet string of length k\n-\n-        On error, None is returned.\n-        \"\"\"\n-\n-        # 1) Length checking\n-        mLen = len(M)\n-        k = self.modulusLen / 8\n-        if mLen > k - 11:\n-            _warning(\"Key._rsaes_pkcs1_v1_5_encrypt(): message too \"\n-                    \"long (%d > %d - 11)\" % (mLen, k))\n-            return None\n-\n-        # 2) EME-PKCS1-v1_5 encoding\n-        PS = zerofree_randstring(k - mLen - 3)      # 2.a)\n-        EM = '\\x00' + '\\x02' + PS + '\\x00' + M      # 2.b)\n-\n-        # 3) RSA encryption\n-        m = pkcs_os2ip(EM)                          # 3.a)\n-        c = self._rsaep(m)                          # 3.b)\n-        C = pkcs_i2osp(c, k)                        # 3.c)\n-\n-        return C                                    # 4)\n-\n-\n-    def _rsaes_oaep_encrypt(self, M, h=None, mgf=None, L=None):\n-        \"\"\"\n-        Internal method providing RSAES-OAEP-ENCRYPT as defined in Sect.\n-        7.1.1 of RFC 3447. Not intended to be used directly. Please, see\n-        encrypt() method for type \"OAEP\".\n-\n-        Input:\n-           M  : message to be encrypted, an octet string of length mLen\n-                where mLen <= k - 2*hLen - 2 (k denotes the length in octets\n-                of the RSA modulus and hLen the length in octets of the hash\n-                function output)\n-           h  : hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls',\n-                'sha256', 'sha384'). hLen denotes the length in octets of\n-                the hash function output. 'sha1' is used by default if not\n-                provided.\n-           mgf: the mask generation function f : seed, maskLen -> mask\n-           L  : optional label to be associated with the message; the default\n-                value for L, if not provided is the empty string\n-\n-        Output:\n-           ciphertext, an octet string of length k\n-\n-        On error, None is returned.\n-        \"\"\"\n-        # The steps below are the one described in Sect. 7.1.1 of RFC 3447.\n-        # 1) Length Checking\n-                                                    # 1.a) is not done\n-        mLen = len(M)\n-        if h is None:\n-            h = \"sha1\"\n-        if not _hashFuncParams.has_key(h):\n-            _warning(\"Key._rsaes_oaep_encrypt(): unknown hash function %s.\" % h)\n-            return None\n-        hLen = _hashFuncParams[h][0]\n-        hFun = _hashFuncParams[h][2]\n-        k = self.modulusLen / 8\n-        if mLen > k - 2*hLen - 2:                   # 1.b)\n-            _warning(\"Key._rsaes_oaep_encrypt(): message too long.\")\n-            return None\n-\n-        # 2) EME-OAEP encoding\n-        if L is None:                               # 2.a)\n-            L = \"\"\n-        lHash = hFun(L)\n-        PS = '\\x00'*(k - mLen - 2*hLen - 2)         # 2.b)\n-        DB = lHash + PS + '\\x01' + M                # 2.c)\n-        seed = randstring(hLen)                     # 2.d)\n-        if mgf is None:                             # 2.e)\n-            mgf = lambda x,y: pkcs_mgf1(x,y,h)\n-        dbMask = mgf(seed, k - hLen - 1)\n-        maskedDB = strxor(DB, dbMask)               # 2.f)\n-        seedMask = mgf(maskedDB, hLen)              # 2.g)\n-        maskedSeed = strxor(seed, seedMask)         # 2.h)\n-        EM = '\\x00' + maskedSeed + maskedDB         # 2.i)\n-\n-        # 3) RSA Encryption\n-        m = pkcs_os2ip(EM)                          # 3.a)\n-        c = self._rsaep(m)                          # 3.b)\n-        C = pkcs_i2osp(c, k)                        # 3.c)\n-\n-        return C                                    # 4)\n-\n-\n     def encrypt(self, m, t=None, h=None, mgf=None, L=None):\n         \"\"\"\n         Encrypt message 'm' using 't' encryption scheme where 't' can be:\n@@ -587,126 +457,33 @@ def encrypt(self, m, t=None, h=None, mgf=None, L=None):\n                   function regarding the size of 'L' (for instance, 2^61 - 1\n                   for SHA-1). You have been warned.\n         \"\"\"\n-\n+        if h is not None:\n+            h = mapHashFunc(h)\n         if t is None: # Raw encryption\n-            m = pkcs_os2ip(m)\n-            c = self._rsaep(m)\n-            return pkcs_i2osp(c, self.modulusLen/8)\n-\n+            return self.key.encrypt(\n+                m,\n+                padding.AsymmetricPadding(),\n+            )\n         elif t == \"pkcs\":\n-            return self._rsaes_pkcs1_v1_5_encrypt(m)\n+            return self.key.encrypt(\n+                m,\n+                padding.PKCS1v15(),\n+            )\n \n         elif t == \"oaep\":\n-            return self._rsaes_oaep_encrypt(m, h, mgf, L)\n+            return self.key.encrypt(\n+                m,\n+                padding.OAEP(\n+                    mgf=mgf(h()),\n+                    algorithm=h(),\n+                    label=L,\n+                ),\n+            )\n \n         else:\n             _warning(\"Key.encrypt(): Unknown encryption type (%s) provided\" % t)\n             return None\n \n-    ### Below are verification related methods\n-\n-    def _rsavp1(self, s):\n-        \"\"\"\n-        Internal method providing raw RSA verification, i.e. simple modular\n-        exponentiation of the given signature representative 'c', an integer\n-        between 0 and n-1.\n-\n-        This is the signature verification primitive RSAVP1 described in\n-        PKCS#1 v2.1, i.e. RFC 3447 Sect. 5.2.2.\n-\n-        Input:\n-          s: signature representative, an integer between 0 and n-1,\n-             where n is the key modulus.\n-\n-        Output:\n-           message representative, an integer between 0 and n-1\n-\n-        Not intended to be used directly. Please, see verify() method.\n-        \"\"\"\n-        return self._rsaep(s)\n-\n-    def _rsassa_pss_verify(self, M, S, h=None, mgf=None, sLen=None):\n-        \"\"\"\n-        Implements RSASSA-PSS-VERIFY() function described in Sect 8.1.2\n-        of RFC 3447\n-\n-        Input:\n-           M: message whose signature is to be verified\n-           S: signature to be verified, an octet string of length k, where k\n-              is the length in octets of the RSA modulus n.\n-\n-        Output:\n-           True is the signature is valid. False otherwise.\n-        \"\"\"\n-\n-        # Set default parameters if not provided\n-        if h is None: # By default, sha1\n-            h = \"sha1\"\n-        if not _hashFuncParams.has_key(h):\n-            _warning(\"Key._rsassa_pss_verify(): unknown hash function \"\n-                    \"provided (%s)\" % h)\n-            return False\n-        if mgf is None: # use mgf1 with underlying hash function\n-            mgf = lambda x,y: pkcs_mgf1(x, y, h)\n-        if sLen is None: # use Hash output length (A.2.3 of RFC 3447)\n-            hLen = _hashFuncParams[h][0]\n-            sLen = hLen\n-\n-        # 1) Length checking\n-        modBits = self.modulusLen\n-        k = modBits / 8\n-        if len(S) != k:\n-            return False\n-\n-        # 2) RSA verification\n-        s = pkcs_os2ip(S)                           # 2.a)\n-        m = self._rsavp1(s)                         # 2.b)\n-        emLen = math.ceil((modBits - 1) / 8.)       # 2.c)\n-        EM = pkcs_i2osp(m, emLen)\n-\n-        # 3) EMSA-PSS verification\n-        Result = pkcs_emsa_pss_verify(M, EM, modBits - 1, h, mgf, sLen)\n-\n-        return Result                               # 4)\n-\n-\n-    def _rsassa_pkcs1_v1_5_verify(self, M, S, h):\n-        \"\"\"\n-        Implements RSASSA-PKCS1-v1_5-VERIFY() function as described in\n-        Sect. 8.2.2 of RFC 3447.\n-\n-        Input:\n-           M: message whose signature is to be verified, an octet string\n-           S: signature to be verified, an octet string of length k, where\n-              k is the length in octets of the RSA modulus n\n-           h: hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls',\n-                'sha256', 'sha384').\n-\n-        Output:\n-           True if the signature is valid. False otherwise.\n-        \"\"\"\n-\n-        # 1) Length checking\n-        k = self.modulusLen / 8\n-        if len(S) != k:\n-            _warning(\"invalid signature (len(S) != k)\")\n-            return False\n-\n-        # 2) RSA verification\n-        s = pkcs_os2ip(S)                           # 2.a)\n-        m = self._rsavp1(s)                         # 2.b)\n-        EM = pkcs_i2osp(m, k)                       # 2.c)\n-\n-        # 3) EMSA-PKCS1-v1_5 encoding\n-        EMPrime = pkcs_emsa_pkcs1_v1_5_encode(M, k, h)\n-        if EMPrime is None:\n-            _warning(\"Key._rsassa_pkcs1_v1_5_verify(): unable to encode.\")\n-            return False\n-\n-        # 4) Comparison\n-        return EM == EMPrime\n-\n-\n     def verify(self, M, S, t=None, h=None, mgf=None, sLen=None):\n         \"\"\"\n         Verify alleged signature 'S' is indeed the signature of message 'M'\n@@ -744,31 +521,33 @@ def verify(self, M, S, t=None, h=None, mgf=None, sLen=None):\n                   default value (the byte length of the hash value for provided\n                   algorithm) by providing another one with that parameter.\n         \"\"\"\n-        if t is None: # RSAVP1\n-            S = pkcs_os2ip(S)\n-            n = self.modulus\n-            if S > n-1:\n-                _warning(\"Signature to be verified is too long for key modulus\")\n-                return False\n-            m = self._rsavp1(S)\n-            if m is None:\n-                return False\n-            l = int(math.ceil(math.log(m, 2) / 8.)) # Hack\n-            m = pkcs_i2osp(m, l)\n-            return M == m\n+        if h is not None:\n+            h = mapHashFunc(h)\n \n+        if t is None: # RSAVP1\n+            pad_inst = padding.AsymmetricPadding()\n         elif t == \"pkcs\": # RSASSA-PKCS1-v1_5-VERIFY\n             if h is None:\n-                h = \"sha1\"\n-            return self._rsassa_pkcs1_v1_5_verify(M, S, h)\n-\n+                h = hashes.SHA1\n+            pad_inst = padding.PKCS1v15()\n         elif t == \"pss\": # RSASSA-PSS-VERIFY\n-            return self._rsassa_pss_verify(M, S, h, mgf, sLen)\n+            pad_inst = padding.PSS(mgf=mgf, salt_length=sLen)\n \n         else:\n             _warning(\"Key.verify(): Unknown signature type (%s) provided\" % t)\n             return None\n \n+        try:\n+            self.key.verify(\n+                signature=S,\n+                data=M,\n+                padding=pad_inst,\n+                algorithm=h(),\n+            )\n+            return True\n+        except InvalidSignature:\n+            return False\n+\n class _DecryptAndSignRSA(object):\n     ### Below are decryption related methods. Encryption ones are inherited\n     ### from PubKey\ndiff --git a/scapy/tools/UTscapy.py b/scapy/tools/UTscapy.py\n--- a/scapy/tools/UTscapy.py\n+++ b/scapy/tools/UTscapy.py\n@@ -112,11 +112,17 @@ class Format(EnumClass):\n class TestClass:\n     def __getitem__(self, item):\n         return getattr(self, item)\n-    def add_keywords(self, kw):\n-        if kw is str:\n-            self.keywords.append(kw)\n-        else:\n-            self.keywords += kw\n+    def add_keywords(self, kws):\n+        if isinstance(kws, basestring):\n+            kws = [kws]\n+        for kwd in kws:\n+            if kwd.startswith('-'):\n+                try:\n+                    self.keywords.remove(kwd[1:])\n+                except KeyError:\n+                    pass\n+            else:\n+                self.keywords.add(kwd)\n \n class TestCampaign(TestClass):\n     def __init__(self, title):\n@@ -124,13 +130,14 @@ def __init__(self, title):\n         self.filename = None\n         self.headcomments = \"\"\n         self.campaign = []\n-        self.keywords = []\n+        self.keywords = set()\n         self.crc = None\n         self.sha = None\n         self.preexec = None\n         self.preexec_output = None\n     def add_testset(self, testset):\n         self.campaign.append(testset)\n+        testset.keywords.update(self.keywords)\n     def __iter__(self):\n         return self.campaign.__iter__()\n     def all_tests(self):\n@@ -143,11 +150,12 @@ def __init__(self, name):\n         self.name = name\n         self.tests = []\n         self.comments = \"\"\n-        self.keywords = []\n+        self.keywords = set()\n         self.crc = None\n         self.expand = 1\n     def add_test(self, test):\n         self.tests.append(test)\n+        test.keywords.update(self.keywords)\n     def __iter__(self):\n         return self.tests.__iter__()\n \n@@ -160,7 +168,7 @@ def __init__(self, name):\n         self.res = True  # must be True at init to have a different truth value than None\n         self.output = \"\"\n         self.num = -1\n-        self.keywords = []\n+        self.keywords = set()\n         self.crc = None\n         self.expand = 1\n     def __nonzero__(self):\n@@ -180,7 +188,7 @@ def parse_campaign_file(campaign_file):\n         if l[0] == '#':\n             continue\n         if l[0] == \"~\":\n-            (test or testset or campaign_file).add_keywords(l[1:].split())\n+            (test or testset or test_campaign).add_keywords(l[1:].split())\n         elif l[0] == \"%\":\n             test_campaign.title = l[1:].strip()\n         elif l[0] == \"+\":\n", "test_patch": "diff --git a/.travis/test.sh b/.travis/test.sh\n--- a/.travis/test.sh\n+++ b/.travis/test.sh\n@@ -12,10 +12,16 @@ then\n   SCAPY_SUDO=\"\"\n fi\n \n-# Test AEAD modes in IPsec if available\n-if [ \"$TEST_COMBINED_MODES\" != \"yes\" ]\n+# AES-CCM not implemented yet in Cryptography\n+# See\n+#  - https://github.com/pyca/cryptography/issues/2968\n+#  - https://github.com/pyca/cryptography/issues/1141\n+UT_FLAGS+=\" -K combined_modes_ccm\"\n+\n+if python --version 2>&1 | grep -q PyPy\n then\n-  UT_FLAGS+=\" -K combined_modes\"\n+  # cryptography requires PyPy >= 2.6, Travis CI uses 2.5.0\n+  UT_FLAGS+=\" -K crypto \"\n fi\n \n # Set PATH\ndiff --git a/test/cert.uts b/test/cert.uts\n--- a/test/cert.uts\n+++ b/test/cert.uts\n@@ -3,6 +3,7 @@\n # Try me with:\n # bash test/run_tests -t test/cert.uts -F\n \n+~ crypto\n \n ########### PKCS helpers ###############################################\n \ndiff --git a/test/ipsec.uts b/test/ipsec.uts\n--- a/test/ipsec.uts\n+++ b/test/ipsec.uts\n@@ -2,11 +2,14 @@\n % IPSec layer regression tests\n ##############################\n \n+~ crypto\n+\n ###############################################################################\n-+ IPv4 / ESP\n++ IPv4 / ESP - Transport - Encryption Algorithms\n \n #######################################\n-= IPv4 / ESP - Transport - AES-CBC - NULL\n+= IPv4 / ESP - Transport - NULL - NULL\n+~ -crypto\n \n import socket\n \n@@ -17,7 +20,38 @@ p = IP(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='NULL', auth_key=None)\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Transport - DES - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='DES', crypt_key='8bytekey',\n                          auth_algo='NULL', auth_key=None)\n \n e = sa.encrypt(p)\n@@ -26,6 +60,7 @@ e\n assert(isinstance(e, IP))\n assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n assert(e.chksum != p.chksum)\n+* the encrypted packet should have an ESP layer\n assert(e.proto == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n@@ -40,7 +75,7 @@ d\n assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv4 / ESP - Transport - NULL - HMAC-SHA1-96\n+= IPv4 / ESP - Transport - 3DES - NULL\n \n p = IP(src='1.1.1.1', dst='2.2.2.2')\n p /= TCP(sport=45012, dport=80)\n@@ -49,8 +84,8 @@ p = IP(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='NULL', crypt_key=None,\n-                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n+                         crypt_algo='3DES', crypt_key='threedifferent8byteskeys',\n+                         auth_algo='NULL', auth_key=None)\n \n e = sa.encrypt(p)\n e\n@@ -58,20 +93,22 @@ e\n assert(isinstance(e, IP))\n assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n assert(e.chksum != p.chksum)\n+* the encrypted packet should have an ESP layer\n assert(e.proto == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n assert(e[ESP].spi == sa.spi)\n-assert('testdata' in e[ESP].data)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n-* integrity verification should pass\n d = sa.decrypt(e)\n+d\n \n * after decryption the original packet payload should be unaltered\n assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv4 / ESP - Transport - NULL - HMAC-SHA1-96 - altered packet\n+= IPv4 / ESP - Transport - AES-CBC - NULL\n \n p = IP(src='1.1.1.1', dst='2.2.2.2')\n p /= TCP(sport=45012, dport=80)\n@@ -80,8 +117,8 @@ p = IP(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='NULL', crypt_key=None,\n-                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='NULL', auth_key=None)\n \n e = sa.encrypt(p)\n e\n@@ -93,20 +130,17 @@ assert(e.proto == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n assert(e[ESP].spi == sa.spi)\n-assert('testdata' in e[ESP].data)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n-* simulate the alteration of the packet before decryption\n-e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+d = sa.decrypt(e)\n+d\n \n-* integrity verification should fail\n-try:\n-    d = sa.decrypt(e)\n-    assert(False)\n-except IPSecIntegrityError, err:\n-    err\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv4 / ESP - Tunnel - AES-CTR - NULL\n+= IPv4 / ESP - Transport - AES-CTR - NULL\n \n p = IP(src='1.1.1.1', dst='2.2.2.2')\n p /= TCP(sport=45012, dport=80)\n@@ -116,6 +150,139 @@ p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n                          crypt_algo='AES-CTR', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None)\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Transport - Blowfish - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='Blowfish', crypt_key='sixteenbytes key',\n+                         auth_algo='NULL', auth_key=None)\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Transport - CAST - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='CAST', crypt_key='sixteenbytes key',\n+                         auth_algo='NULL', auth_key=None)\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n+\n+###############################################################################\n++ IPv4 / ESP - Tunnel - Encryption Algorithms\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - NULL\n+~ -crypto\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - DES - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='DES', crypt_key='8bytekey',\n                          auth_algo='NULL', auth_key=None,\n                          tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n \n@@ -126,6 +293,7 @@ assert(isinstance(e, IP))\n * after encryption packet should be encapsulated with the given ip tunnel header\n assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n assert(e.chksum != p.chksum)\n+* the encrypted packet should have an ESP layer\n assert(e.proto == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n@@ -136,12 +304,11 @@ assert('testdata' not in e[ESP].data)\n d = sa.decrypt(e)\n d\n \n-* after decryption original packet should be preserved\n-assert(d == p)\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv4 / ESP - Tunnel - AES-GCM - NULL\n-~ combined_modes\n+= IPv4 / ESP - Tunnel - 3DES - NULL\n \n p = IP(src='1.1.1.1', dst='2.2.2.2')\n p /= TCP(sport=45012, dport=80)\n@@ -150,7 +317,7 @@ p = IP(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         crypt_algo='3DES', crypt_key='threedifferent8byteskeys',\n                          auth_algo='NULL', auth_key=None,\n                          tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n \n@@ -161,6 +328,7 @@ assert(isinstance(e, IP))\n * after encryption packet should be encapsulated with the given ip tunnel header\n assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n assert(e.chksum != p.chksum)\n+* the encrypted packet should have an ESP layer\n assert(e.proto == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n@@ -171,12 +339,11 @@ assert('testdata' not in e[ESP].data)\n d = sa.decrypt(e)\n d\n \n-* after decryption original packet should be preserved\n-assert(d == p)\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv4 / ESP - Tunnel - AES-CCM - NULL\n-~ combined_modes\n+= IPv4 / ESP - Tunnel - AES-CBC - NULL\n \n p = IP(src='1.1.1.1', dst='2.2.2.2')\n p /= TCP(sport=45012, dport=80)\n@@ -185,7 +352,41 @@ p = IP(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='AES-CCM', crypt_key='16bytekey+4bytenonce',\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - AES-CTR - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CTR', crypt_key='16bytekey+4bytenonce',\n                          auth_algo='NULL', auth_key=None,\n                          tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n \n@@ -203,76 +404,2283 @@ assert(e[ESP].spi == sa.spi)\n * after encryption the original packet payload should NOT be readable\n assert('testdata' not in e[ESP].data)\n \n-d = sa.decrypt(e)\n-d\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - Blowfish - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='Blowfish', crypt_key='sixteenbytes key',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - CAST - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='CAST', crypt_key='sixteenbytes key',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n+\n+###############################################################################\n++ IPv4 / ESP - Transport - Authentication Algorithms\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - HMAC-SHA1-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - HMAC-SHA1-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - SHA2-256-128\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-256-128', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - SHA2-256-128 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-256-128', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - SHA2-384-192\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-384-192', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - SHA2-384-192 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-384-192', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - SHA2-512-256\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-512-256', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - SHA2-512-256 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-512-256', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - HMAC-MD5-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-MD5-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - HMAC-MD5-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-MD5-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - AES-CMAC-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='AES-CMAC-96', auth_key='sixteenbytes key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Transport - NULL - AES-CMAC-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='AES-CMAC-96', auth_key='sixteenbytes key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+###############################################################################\n++ IPv4 / ESP - Tunnel - Authentication Algorithms\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - HMAC-SHA1-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - HMAC-SHA1-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - SHA2-256-128\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-256-128', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - SHA2-256-128 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-256-128', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - SHA2-384-192\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-384-192', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - SHA2-384-192 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-384-192', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - SHA2-512-256\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-512-256', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - SHA2-512-256 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='SHA2-512-256', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - HMAC-MD5-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-MD5-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - HMAC-MD5-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-MD5-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - AES-CMAC-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='AES-CMAC-96', auth_key='sixteenbytes key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - NULL - AES-CMAC-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='AES-CMAC-96', auth_key='sixteenbytes key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should be readable\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+###############################################################################\n++ IPv4 / ESP - Encryption + Authentication\n+\n+#######################################\n+= IPv4 / ESP - Transport - AES-CBC - HMAC-SHA1-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Transport - AES-CBC - HMAC-SHA1-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].seq += 1\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Transport - AES-GCM - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None)\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Transport - AES-GCM - NULL - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None)\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].seq += 1\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+#######################################\n+= IPv4 / ESP - Tunnel - AES-CBC - HMAC-SHA1-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - AES-CBC - HMAC-SHA1-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].seq += 1\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - AES-GCM - NULL\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - AES-GCM - NULL - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].seq += 1\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+###############################################################################\n++ IPv4 / AH - Transport\n+\n+#######################################\n+= IPv4 / AH - Transport - HMAC-SHA1-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='HMAC-SHA1-96', auth_key='sixteenbytes key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / AH - Transport - HMAC-SHA1-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='HMAC-SHA1-96', auth_key='sixteenbytes key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before decryption\n+e[TCP].sport = 5\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Transport - SHA2-256-128\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-256-128', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / AH - Transport - SHA2-256-128 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-256-128', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e[TCP].dport = 46\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Transport - SHA2-384-192\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-384-192', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / AH - Transport - SHA2-384-192 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-384-192', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e[TCP].dport = 46\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Transport - SHA2-512-256\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-512-256', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / AH - Transport - SHA2-512-256 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-512-256', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e[TCP].dport = 46\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Transport - HMAC-MD5-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='HMAC-MD5-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / AH - Transport - HMAC-MD5-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='HMAC-MD5-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e[TCP].dport = 46\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Transport - AES-CMAC-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='AES-CMAC-96', auth_key='sixteenbytes key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / AH - Transport - AES-CMAC-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='AES-CMAC-96', auth_key='sixteenbytes key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n+assert(e.chksum != p.chksum)\n+* the encrypted packet should have an AH layer\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e[TCP].dport = 46\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+###############################################################################\n++ IPv4 / AH - Tunnel\n+\n+#######################################\n+= IPv4 / AH - Tunnel - HMAC-SHA1-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / AH - Tunnel - HMAC-SHA1-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e.dst = '4.4.4.4'\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Tunnel - SHA2-256-128\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-256-128', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / AH - Tunnel - SHA2-256-128 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-256-128', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e.dst = '4.4.4.4'\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Tunnel - SHA2-384-192\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-384-192', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / AH - Tunnel - SHA2-384-192 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-384-192', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e.dst = '4.4.4.4'\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Tunnel - SHA2-512-256\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-512-256', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / AH - Tunnel - SHA2-512-256 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='SHA2-512-256', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e.dst = '4.4.4.4'\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Tunnel - HMAC-MD5-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='HMAC-MD5-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / AH - Tunnel - HMAC-MD5-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='HMAC-MD5-96', auth_key='secret key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e.dst = '4.4.4.4'\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+#######################################\n+= IPv4 / AH - Tunnel - AES-CMAC-96\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='AES-CMAC-96', auth_key='sixteenbytes key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* alter mutable fields in the packet\n+e.ttl = 2\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet should be unaltered\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / AH - Tunnel - AES-CMAC-96 - altered packet\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(AH, spi=0x222,\n+                         auth_algo='AES-CMAC-96', auth_key='sixteenbytes key',\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_AH)\n+assert(e.haslayer(AH))\n+assert(e.haslayer(TCP))\n+assert(e[AH].spi == sa.spi)\n+\n+* simulate the alteration of the packet before verification\n+e.dst = '4.4.4.4'\n+\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n+\n+###############################################################################\n++ IPv6 / ESP\n+\n+#######################################\n+= IPv6 / ESP - Transport - NULL - NULL\n+~ -crypto\n+\n+p = IPv6(src='11::22', dst='22::11')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IPv6(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='NULL', auth_key=None)\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IPv6))\n+assert(e.src == '11::22' and e.dst == '22::11')\n+assert(e.nh == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv6 / ESP - Transport - AES-CBC - NULL\n+\n+p = IPv6(src='11::22', dst='22::11')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IPv6(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='NULL', auth_key=None)\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IPv6))\n+assert(e.src == '11::22' and e.dst == '22::11')\n+assert(e.nh == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - AES-GCM - NULL\n+~ combined_modes\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv4 / ESP - Tunnel - AES-CCM - NULL\n+~ combined_modes combined_modes_ccm\n+\n+p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IP(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IP))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n+assert(e.chksum != p.chksum)\n+assert(e.proto == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n+\n+d = sa.decrypt(e)\n+d\n+\n+* after decryption original packet should be preserved\n+assert(d == p)\n+\n+#######################################\n+= IPv6 / ESP - Transport - NULL - HMAC-SHA1-96\n+\n+p = IPv6(src='11::22', dst='22::11')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IPv6(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IPv6))\n+assert(e.src == '11::22' and e.dst == '22::11')\n+assert(e.nh == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+* integrity verification should pass\n+d = sa.decrypt(e)\n+\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n+\n+#######################################\n+= IPv6 / ESP - Transport - NULL - HMAC-SHA1-96 - altered packet\n+\n+p = IPv6(src='11::22', dst='22::11')\n+p /= TCP(sport=45012, dport=80)\n+p /= Raw('testdata')\n+p = IPv6(str(p))\n+p\n+\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='NULL', crypt_key=None,\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n+\n+e = sa.encrypt(p)\n+e\n+\n+assert(isinstance(e, IPv6))\n+assert(e.src == '11::22' and e.dst == '22::11')\n+assert(e.nh == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+assert('testdata' in e[ESP].data)\n+\n+* simulate the alteration of the packet before decryption\n+e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n \n-* after decryption original packet should be preserved\n-assert(d == p)\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n \n #######################################\n-= IPv4 / ESP - Tunnel - NULL - SHA2-256-128\n+= IPv6 / ESP - Transport - AES-CBC - HMAC-SHA1-96\n \n-p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n p /= Raw('testdata')\n-p = IP(str(p))\n+p = IPv6(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='NULL', crypt_key=None,\n-                         auth_algo='SHA2-256-128', auth_key='secret key',\n-                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n \n e = sa.encrypt(p)\n e\n \n-assert(isinstance(e, IP))\n-* after encryption packet should be encapsulated with the given ip tunnel header\n-assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n-assert(e.chksum != p.chksum)\n-assert(e.proto == socket.IPPROTO_ESP)\n+assert(isinstance(e, IPv6))\n+assert(e.src == '11::22' and e.dst == '22::11')\n+assert(e.nh == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n assert(e[ESP].spi == sa.spi)\n-* after encryption the original packet payload should be readable\n-assert('testdata' in e[ESP].data)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n-* integrity verification should pass\n d = sa.decrypt(e)\n+d\n \n-* after decryption the original packet should be preserved\n-assert(d == p)\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv4 / ESP - Tunnel - NULL - SHA2-256-128 - altered packet\n+= IPv6 / ESP - Transport - AES-CBC - HMAC-SHA1-96 - altered packet\n \n-p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n p /= Raw('testdata')\n-p = IP(str(p))\n+p = IPv6(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='NULL', crypt_key=None,\n-                         auth_algo='SHA2-256-128', auth_key='secret key',\n-                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key')\n \n e = sa.encrypt(p)\n e\n \n-assert(isinstance(e, IP))\n-* after encryption packet should be encapsulated with the given ip tunnel header\n-assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n-assert(e.chksum != p.chksum)\n-assert(e.proto == socket.IPPROTO_ESP)\n+assert(isinstance(e, IPv6))\n+assert(e.src == '11::22' and e.dst == '22::11')\n+assert(e.nh == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n assert(e[ESP].spi == sa.spi)\n-* after encryption the original packet payload should be readable\n-assert('testdata' in e[ESP].data)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n * simulate the alteration of the packet before decryption\n-e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+e[ESP].seq += 1\n \n * integrity verification should fail\n try:\n@@ -281,11 +2689,8 @@ try:\n except IPSecIntegrityError, err:\n     err\n \n-###############################################################################\n-+ IPv6 / ESP\n-\n #######################################\n-= IPv6 / ESP - Transport - DES - NULL\n+= IPv6 / ESP - Transport - AES-GCM - NULL\n \n p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n@@ -294,7 +2699,7 @@ p = IPv6(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='DES', crypt_key='8bytekey',\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n                          auth_algo='NULL', auth_key=None)\n \n e = sa.encrypt(p)\n@@ -302,7 +2707,6 @@ e\n \n assert(isinstance(e, IPv6))\n assert(e.src == '11::22' and e.dst == '22::11')\n-* the encrypted packet should have an ESP layer\n assert(e.nh == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n@@ -313,11 +2717,11 @@ assert('testdata' not in e[ESP].data)\n d = sa.decrypt(e)\n d\n \n-* after decryption the original packet payload should be unaltered\n+* after decryption original packet should be preserved\n assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv6 / ESP - Transport - NULL - HMAC-MD5-96\n+= IPv6 / ESP - Transport - AES-GCM - NULL - altered packet\n \n p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n@@ -326,30 +2730,34 @@ p = IPv6(str(p))\n p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n-                         crypt_algo='NULL', crypt_key=None,\n-                         auth_algo='HMAC-MD5-96', auth_key='secret key')\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None)\n \n e = sa.encrypt(p)\n e\n \n assert(isinstance(e, IPv6))\n assert(e.src == '11::22' and e.dst == '22::11')\n-* the encrypted packet should have an ESP layer\n assert(e.nh == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n assert(e[ESP].spi == sa.spi)\n-* after encryption the original packet payload should be readable\n-assert('testdata' in e[ESP].data)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n-* integrity verification should pass\n-d = sa.decrypt(e)\n+* simulate the alteration of the packet before decryption\n+e[ESP].seq += 1\n \n-* after decryption the original packet payload should be unaltered\n-assert(d[TCP] == p[TCP])\n+* integrity verification should fail\n+try:\n+    d = sa.decrypt(e)\n+    assert(False)\n+except IPSecIntegrityError, err:\n+    err\n \n #######################################\n-= IPv6 / ESP - Transport - NULL - HMAC-MD5-96 - altered packet\n+= IPv6 / ESP - Tunnel - NULL - NULL\n+~ -crypto\n \n p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n@@ -359,33 +2767,29 @@ p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n                          crypt_algo='NULL', crypt_key=None,\n-                         auth_algo='HMAC-MD5-96', auth_key='secret key')\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IPv6(src='aa::bb', dst='bb::aa'))\n \n e = sa.encrypt(p)\n e\n \n assert(isinstance(e, IPv6))\n-assert(e.src == '11::22' and e.dst == '22::11')\n-* the encrypted packet should have an ESP layer\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == 'aa::bb' and e.dst == 'bb::aa')\n assert(e.nh == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n assert(e[ESP].spi == sa.spi)\n-* after encryption the original packet payload should be readable\n assert('testdata' in e[ESP].data)\n \n-* simulate the alteration of the packet before decryption\n-e[ESP].data = e[ESP].data.replace('\\x01', '\\x21')\n+d = sa.decrypt(e)\n+d\n \n-* integrity verification should fail\n-try:\n-    d = sa.decrypt(e)\n-    assert(False)\n-except IPSecIntegrityError, err:\n-    err\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv6 / ESP - Tunnel - 3DES - NULL\n+= IPv6 / ESP - Tunnel - AES-CBC - NULL\n \n p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n@@ -414,11 +2818,11 @@ assert('testdata' not in e[ESP].data)\n d = sa.decrypt(e)\n d\n \n-* after decryption original packet should be preserved\n-assert(d == p)\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv6 / ESP - Tunnel - NULL - SHA2-384-192\n+= IPv6 / ESP - Tunnel - NULL - HMAC-SHA1-96\n \n p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n@@ -428,7 +2832,7 @@ p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n                          crypt_algo='NULL', crypt_key=None,\n-                         auth_algo='SHA2-384-192', auth_key='secret key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n                          tunnel_header=IPv6(src='aa::bb', dst='bb::aa'))\n \n e = sa.encrypt(p)\n@@ -441,17 +2845,16 @@ assert(e.nh == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n assert(e[ESP].spi == sa.spi)\n-* after encryption the original packet payload should be readable\n assert('testdata' in e[ESP].data)\n \n * integrity verification should pass\n d = sa.decrypt(e)\n \n-* after decryption the original packet should be preserved\n-assert(d == p)\n+* after decryption the original packet payload should be unaltered\n+assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv6 / ESP - Tunnel - NULL - SHA2-384-192 - altered packet\n+= IPv6 / ESP - Tunnel - NULL - HMAC-SHA1-96 - altered packet\n \n p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n@@ -461,7 +2864,7 @@ p\n \n sa = SecurityAssociation(ESP, spi=0x222,\n                          crypt_algo='NULL', crypt_key=None,\n-                         auth_algo='SHA2-384-192', auth_key='secret key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n                          tunnel_header=IPv6(src='aa::bb', dst='bb::aa'))\n \n e = sa.encrypt(p)\n@@ -474,7 +2877,6 @@ assert(e.nh == socket.IPPROTO_ESP)\n assert(e.haslayer(ESP))\n assert(not e.haslayer(TCP))\n assert(e[ESP].spi == sa.spi)\n-* after encryption the original packet payload should be readable\n assert('testdata' in e[ESP].data)\n \n * simulate the alteration of the packet before decryption\n@@ -487,37 +2889,33 @@ try:\n except IPSecIntegrityError, err:\n     err\n \n-###############################################################################\n-+ IPv4 / AH\n-\n #######################################\n-= IPv4 / AH - Transport - HMAC-SHA1-96\n+= IPv6 / ESP - Tunnel - AES-CBC - HMAC-SHA1-96\n \n-p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n p /= Raw('testdata')\n-p = IP(str(p))\n+p = IPv6(str(p))\n p\n \n-sa = SecurityAssociation(AH, spi=0x222,\n-                         auth_algo='HMAC-SHA1-96', auth_key='sixteenbytes key')\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n+                         tunnel_header=IPv6(src='aa::bb', dst='bb::aa'))\n \n e = sa.encrypt(p)\n e\n \n-assert(isinstance(e, IP))\n-assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n-assert(e.chksum != p.chksum)\n-* the encrypted packet should have an AH layer\n-assert(e.proto == socket.IPPROTO_AH)\n-assert(e.haslayer(AH))\n-assert(e.haslayer(TCP))\n-assert(e[AH].spi == sa.spi)\n-\n-* alter mutable fields in the packet\n-e.ttl = 2\n+assert(isinstance(e, IPv6))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == 'aa::bb' and e.dst == 'bb::aa')\n+assert(e.nh == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n-* integrity verification should pass\n d = sa.decrypt(e)\n d\n \n@@ -525,31 +2923,34 @@ d\n assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv4 / AH - Transport - HMAC-SHA1-96 - altered packet\n+= IPv6 / ESP - Tunnel - AES-CBC - HMAC-SHA1-96 - altered packet\n \n-p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n p /= Raw('testdata')\n-p = IP(str(p))\n+p = IPv6(str(p))\n p\n \n-sa = SecurityAssociation(AH, spi=0x222,\n-                         auth_algo='HMAC-SHA1-96', auth_key='sixteenbytes key')\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-CBC', crypt_key='sixteenbytes key',\n+                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n+                         tunnel_header=IPv6(src='aa::bb', dst='bb::aa'))\n \n e = sa.encrypt(p)\n e\n \n-assert(isinstance(e, IP))\n-assert(e.src == '1.1.1.1' and e.dst == '2.2.2.2')\n-assert(e.chksum != p.chksum)\n-* the encrypted packet should have an AH layer\n-assert(e.proto == socket.IPPROTO_AH)\n-assert(e.haslayer(AH))\n-assert(e.haslayer(TCP))\n-assert(e[AH].spi == sa.spi)\n+assert(isinstance(e, IPv6))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == 'aa::bb' and e.dst == 'bb::aa')\n+assert(e.nh == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n * simulate the alteration of the packet before decryption\n-e[TCP].sport = 5\n+e[ESP].seq += 1\n \n * integrity verification should fail\n try:\n@@ -559,65 +2960,67 @@ except IPSecIntegrityError, err:\n     err\n \n #######################################\n-= IPv4 / AH - Tunnel - SHA2-256-128\n+= IPv6 / ESP - Tunnel - AES-GCM - NULL\n \n-p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n p /= Raw('testdata')\n-p = IP(str(p))\n+p = IPv6(str(p))\n p\n \n-sa = SecurityAssociation(AH, spi=0x222,\n-                         auth_algo='SHA2-256-128', auth_key='secret key',\n-                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IPv6(src='aa::bb', dst='bb::aa'))\n \n e = sa.encrypt(p)\n e\n \n-assert(isinstance(e, IP))\n-assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n-assert(e.chksum != p.chksum)\n-assert(e.proto == socket.IPPROTO_AH)\n-assert(e.haslayer(AH))\n-assert(e.haslayer(TCP))\n-assert(e[AH].spi == sa.spi)\n-\n-* alter mutable fields in the packet\n-e.ttl = 2\n+assert(isinstance(e, IPv6))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == 'aa::bb' and e.dst == 'bb::aa')\n+assert(e.nh == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n-* integrity verification should pass\n d = sa.decrypt(e)\n d\n \n-* after decryption the original packet should be unaltered\n-assert(d == p)\n+* after decryption original packet should be preserved\n+assert(d[TCP] == p[TCP])\n \n #######################################\n-= IPv4 / AH - Tunnel - HMAC-SHA1-96 - altered packet\n+= IPv6 / ESP - Tunnel - AES-GCM - NULL - altered packet\n \n-p = IP(src='1.1.1.1', dst='2.2.2.2')\n+p = IPv6(src='11::22', dst='22::11')\n p /= TCP(sport=45012, dport=80)\n p /= Raw('testdata')\n-p = IP(str(p))\n+p = IPv6(str(p))\n p\n \n-sa = SecurityAssociation(AH, spi=0x222,\n-                         auth_algo='HMAC-SHA1-96', auth_key='secret key',\n-                         tunnel_header=IP(src='11.11.11.11', dst='22.22.22.22'))\n+sa = SecurityAssociation(ESP, spi=0x222,\n+                         crypt_algo='AES-GCM', crypt_key='16bytekey+4bytenonce',\n+                         auth_algo='NULL', auth_key=None,\n+                         tunnel_header=IPv6(src='aa::bb', dst='bb::aa'))\n \n e = sa.encrypt(p)\n e\n \n-assert(isinstance(e, IP))\n-assert(e.src == '11.11.11.11' and e.dst == '22.22.22.22')\n-assert(e.chksum != p.chksum)\n-assert(e.proto == socket.IPPROTO_AH)\n-assert(e.haslayer(AH))\n-assert(e.haslayer(TCP))\n-assert(e[AH].spi == sa.spi)\n+assert(isinstance(e, IPv6))\n+* after encryption packet should be encapsulated with the given ip tunnel header\n+assert(e.src == 'aa::bb' and e.dst == 'bb::aa')\n+assert(e.nh == socket.IPPROTO_ESP)\n+assert(e.haslayer(ESP))\n+assert(not e.haslayer(TCP))\n+assert(e[ESP].spi == sa.spi)\n+* after encryption the original packet payload should NOT be readable\n+assert('testdata' not in e[ESP].data)\n \n-* simulate the alteration of the packet before verification\n-e.dst = '4.4.4.4'\n+* simulate the alteration of the packet before decryption\n+e[ESP].seq += 1\n \n * integrity verification should fail\n try:\n@@ -822,3 +3225,4 @@ e[IPv6ExtHdrRouting].segleft = 0\n * integrity verification should pass\n d = sa.decrypt(e)\n d\n+\ndiff --git a/test/regression.uts b/test/regression.uts\n--- a/test/regression.uts\n+++ b/test/regression.uts\n@@ -580,10 +580,10 @@ assert(len(y[TFTP_Options].options) == 2 and y[TFTP_Option].oname == \"blksize\")\n \n \n = WEP tests\n-~ wifi wep Dot11 LLC SNAP IP TCP\n-conf.wepkey = \"ABCDEFGH\"\n+~ wifi crypto Dot11 LLC SNAP IP TCP\n+conf.wepkey = \"Fobar\"\n str(Dot11WEP()/LLC()/SNAP()/IP()/TCP(seq=12345678))\n-assert(_ == '\\x00\\x00\\x00\\x00\\x1e\\xafK5G\\x94\\xd4m\\x81\\xdav\\xd4,c\\xf1\\xfe{\\xfc\\xba\\xd6;T\\x93\\xd0\\t\\xdb\\xfc\\xa5\\xb9\\x85\\xce\\x05b\\x1cC\\x10\\xd7p\\xde22&\\xf0\\xbcUS\\x99\\x83Z\\\\D\\xa6')\n+assert(_ == '\\x00\\x00\\x00\\x00\\xe3OjYLw\\xc3x_%\\xd0\\xcf\\xdeu-\\xc3pH#\\x1eK\\xae\\xf5\\xde\\xe7\\xb8\\x1d,\\xa1\\xfe\\xe83\\xca\\xe1\\xfe\\xbd\\xfe\\xec\\x00)T`\\xde.\\x93Td\\x95C\\x0f\\x07\\xdd')\n Dot11WEP(_)\n assert(TCP in _ and _[TCP].seq == 12345678)\n \n", "problem_statement": "", "hints_text": "", "created_at": "2016-12-03T17:38:17Z"}