| {"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"} | |