From 1951bf6444d4d5cdaaf0eee1b89a462c32b92b38 Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Sun, 15 Sep 2013 12:05:43 -0500 Subject: add cryptrec and openssl test vector loaders + tests --- tests/test_utils.py | 223 +++++++++++++++++++++++++++++++++++++++++++++++++++- tests/utils.py | 83 +++++++++++++++++++ 2 files changed, 304 insertions(+), 2 deletions(-) (limited to 'tests') diff --git a/tests/test_utils.py b/tests/test_utils.py index fd56dd30..3768c6fc 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -13,7 +13,9 @@ import textwrap -from .utils import load_nist_vectors, load_nist_vectors_from_file +from .utils import (load_nist_vectors, load_nist_vectors_from_file, + load_cryptrec_vectors, load_cryptrec_vectors_from_file, + load_openssl_vectors, load_openssl_vectors_from_file) def test_load_nist_vectors_encrypt(): @@ -179,7 +181,7 @@ def test_load_nist_vectors_from_file_encrypt(): ] -def test_load_nist_vectors_from_file_decypt(): +def test_load_nist_vectors_from_file_decrypt(): assert load_nist_vectors_from_file( "AES/KAT/CBCGFSbox128.rsp", "DECRYPT", @@ -228,3 +230,220 @@ def test_load_nist_vectors_from_file_decypt(): b"58c8e00b2631686d54eab84b91f0aca1" ), ] + + +def test_load_cryptrec_vectors(): + vector_data = textwrap.dedent(""" + # Vectors taken from http://info.isl.ntt.co.jp/crypt/eng/camellia/ + # Download is t_camelia.txt + + # Camellia with 128-bit key + + K No.001 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + + P No.001 : 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + C No.001 : 07 92 3A 39 EB 0A 81 7D 1C 4D 87 BD B8 2D 1F 1C + + P No.002 : 40 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + C No.002 : 48 CD 64 19 80 96 72 D2 34 92 60 D8 9A 08 D3 D3 + + K No.002 : 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + + P No.001 : 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 + C No.001 : 07 92 3A 39 EB 0A 81 7D 1C 4D 87 BD B8 2D 1F 1C + """).splitlines() + + assert load_cryptrec_vectors(vector_data) == [ + ( + b"00000000000000000000000000000000", + b"80000000000000000000000000000000", + b"07923A39EB0A817D1C4D87BDB82D1F1C", + ), + ( + b"00000000000000000000000000000000", + b"40000000000000000000000000000000", + b"48CD6419809672D2349260D89A08D3D3", + ), + ( + b"10000000000000000000000000000000", + b"80000000000000000000000000000000", + b"07923A39EB0A817D1C4D87BDB82D1F1C", + ), + ] + + +def test_load_cryptrec_vectors_from_file_encrypt(): + test_set = load_cryptrec_vectors_from_file( + "Camellia/NTT/camellia-128-ecb.txt" + ) + assert test_set[0] == ( + ( + b"00000000000000000000000000000000", + b"80000000000000000000000000000000", + b"07923A39EB0A817D1C4D87BDB82D1F1C", + ) + ) + assert len(test_set) == 1280 + + +def test_load_openssl_vectors_encrypt(): + vector_data = textwrap.dedent(""" + # We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt + # For all CFB128 encrypts and decrypts, the transformed sequence is + # CAMELLIA-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec + # CFB128-CAMELLIA128.Encrypt + CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:1 + CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:A53D28BB82DF741103EA4F921A44880B:1 + + # CFB128-CAMELLIA128.Decrypt + CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:0 + CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:A53D28BB82DF741103EA4F921A44880B:0 + """).splitlines() + + assert load_openssl_vectors(vector_data, "ENCRYPT") == [ + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"000102030405060708090A0B0C0D0E0F", + b"6BC1BEE22E409F96E93D7E117393172A", + b"14F7646187817EB586599146B82BD719", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"14F7646187817EB586599146B82BD719", + b"AE2D8A571E03AC9C9EB76FAC45AF8E51", + b"A53D28BB82DF741103EA4F921A44880B", + ), + ] + + +def test_load_openssl_vectors_decrypt(): + vector_data = textwrap.dedent(""" + # We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt + # For all CFB128 encrypts and decrypts, the transformed sequence is + # CAMELLIA-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec + # CFB128-CAMELLIA128.Encrypt + CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:1 + CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:A53D28BB82DF741103EA4F921A44880B:1 + + # CFB128-CAMELLIA128.Decrypt + CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:A53D28BB82DF741103EA4F921A44880B:30C81C46A35CE411E5FBC1191A0A52EF:9C2157A664626D1DEF9EA420FDE69B96:0 + CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:9C2157A664626D1DEF9EA420FDE69B96:F69F2445DF4F9B17AD2B417BE66C3710:742A25F0542340C7BAEF24CA8482BB09:0 + + """).splitlines() + + assert load_openssl_vectors(vector_data, "DECRYPT") == [ + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"A53D28BB82DF741103EA4F921A44880B", + b"30C81C46A35CE411E5FBC1191A0A52EF", + b"9C2157A664626D1DEF9EA420FDE69B96", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"9C2157A664626D1DEF9EA420FDE69B96", + b"F69F2445DF4F9B17AD2B417BE66C3710", + b"742A25F0542340C7BAEF24CA8482BB09", + ), + ] + + +def test_load_openssl_vectors_from_file_encrypt(): + test_list = load_openssl_vectors_from_file( + "Camellia/camellia-ofb.txt", + "ENCRYPT" + ) + assert len(test_list) == 12 + assert test_list[:4] == [ + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"000102030405060708090A0B0C0D0E0F", + b"6BC1BEE22E409F96E93D7E117393172A", + b"14F7646187817EB586599146B82BD719", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"50FE67CC996D32B6DA0937E99BAFEC60", + b"AE2D8A571E03AC9C9EB76FAC45AF8E51", + b"25623DB569CA51E01482649977E28D84", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"D9A4DADA0892239F6B8B3D7680E15674", + b"30C81C46A35CE411E5FBC1191A0A52EF", + b"C776634A60729DC657D12B9FCA801E98", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"A78819583F0308E7A6BF36B1386ABF23", + b"F69F2445DF4F9B17AD2B417BE66C3710", + b"D776379BE0E50825E681DA1A4C980E8E", + ), + ] + + +def test_load_openssl_vectors_from_file_decrypt(): + test_list = load_openssl_vectors_from_file( + "Camellia/camellia-ofb.txt", + "DECRYPT" + ) + assert len(test_list) == 12 + assert test_list[:4] == [ + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"000102030405060708090A0B0C0D0E0F", + b"6BC1BEE22E409F96E93D7E117393172A", + b"14F7646187817EB586599146B82BD719", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"50FE67CC996D32B6DA0937E99BAFEC60", + b"AE2D8A571E03AC9C9EB76FAC45AF8E51", + b"25623DB569CA51E01482649977E28D84", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"D9A4DADA0892239F6B8B3D7680E15674", + b"30C81C46A35CE411E5FBC1191A0A52EF", + b"C776634A60729DC657D12B9FCA801E98", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"A78819583F0308E7A6BF36B1386ABF23", + b"F69F2445DF4F9B17AD2B417BE66C3710", + b"D776379BE0E50825E681DA1A4C980E8E", + ), + ] + + +def test_load_openssl_vectors_from_file_no_enc_dec_flag(): + test_list = load_openssl_vectors_from_file( + "Camellia/camellia-cbc.txt", + "ENCRYPT" + ) + assert len(test_list) == 12 + assert test_list[:4] == [ + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"000102030405060708090A0B0C0D0E0F", + b"6BC1BEE22E409F96E93D7E117393172A", + b"1607CF494B36BBF00DAEB0B503C831AB", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"1607CF494B36BBF00DAEB0B503C831AB", + b"AE2D8A571E03AC9C9EB76FAC45AF8E51", + b"A2F2CF671629EF7840C5A5DFB5074887", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"A2F2CF671629EF7840C5A5DFB5074887", + b"30C81C46A35CE411E5FBC1191A0A52EF", + b"0F06165008CF8B8B5A63586362543E54", + ), + ( + b"2B7E151628AED2A6ABF7158809CF4F3C", + b"36A84CDAFD5F9A85ADA0F0A993D6D577", + b"F69F2445DF4F9B17AD2B417BE66C3710", + b"74C64268CDB8B8FAF5B34E8AF3732980", + ), + ] diff --git a/tests/utils.py b/tests/utils.py index 9362464e..bbb4843f 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -59,3 +59,86 @@ def load_nist_vectors_from_file(filename, op, fields): ) with open(os.path.join(base, filename), "r") as vector_file: return load_nist_vectors(vector_file, op, fields) + + +def load_cryptrec_vectors_from_file(filename): + base = os.path.join( + os.path.dirname(__file__), "primitives", "vectors", "CRYPTREC", + ) + with open(os.path.join(base, filename), "r") as vector_file: + return load_cryptrec_vectors(vector_file) + + +def load_cryptrec_vectors(vector_data): + keys, data = [], {} + + for line in vector_data: + line = line.strip() + + # Blank lines and comments are ignored + if not line or line.startswith("#"): + continue + + if line.startswith("K"): + keys.append(line.split(" : ")[1].replace(" ", "")) + # create an array under the key to hold all the P+C pairs + data[keys[-1]] = [] + elif line.startswith("P"): + # create a new dict to hold the next P+C pair + data[keys[-1]].append({}) + data[keys[-1]][-1]["P"] = line.split(" : ")[1].replace(" ", "") + elif line.startswith("C"): + data[keys[-1]][-1]["C"] = line.split(" : ")[1].replace(" ", "") + + cryptrec_list = [] + for key, value in data.items(): + for pair in value: + cryptrec_list.append( + (key.encode("ascii"), + pair["P"].encode("ascii"), + pair["C"].encode("ascii")) + ) + + return cryptrec_list + + +def load_openssl_vectors_from_file(filename, op): + base = os.path.join( + os.path.dirname(__file__), "primitives", "vectors", "OpenSSL", + ) + with open(os.path.join(base, filename), "r") as vector_file: + return load_openssl_vectors(vector_file, op) + + +def load_openssl_vectors(vector_data, op): + encrypt, decrypt = [], [] + + for line in vector_data: + line = line.strip() + + # Blank lines and comments are ignored + if not line or line.startswith("#"): + continue + + vector = line.split(":") + args_list = (vector[1].encode("ascii"), + vector[2].encode("ascii"), + vector[3].encode("ascii"), + vector[4].encode("ascii")) + # some OpenSSL vectors have a final field + # 0 for decrypt, 1 for encrypt + if len(vector) == 6: + if int(vector[5]) == 0: + decrypt.append(args_list) + else: + encrypt.append(args_list) + else: + # if they don't have 1 or 0 they are meant for both enc & dec + # and should be added to both the encrypt and decrypt list + encrypt.append(args_list) + decrypt.append(args_list) + + if op == "ENCRYPT": + return encrypt + else: + return decrypt -- cgit v1.2.3 From e58f83e7c82ca4a20e3172e6eaf8c2b2a9a7c546 Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Sun, 15 Sep 2013 13:55:30 -0500 Subject: sort the cryptrec loader dict's items to test reliably --- tests/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'tests') diff --git a/tests/utils.py b/tests/utils.py index bbb4843f..7d4b3a3e 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -91,7 +91,7 @@ def load_cryptrec_vectors(vector_data): data[keys[-1]][-1]["C"] = line.split(" : ")[1].replace(" ", "") cryptrec_list = [] - for key, value in data.items(): + for key, value in sorted(data.items()): for pair in value: cryptrec_list.append( (key.encode("ascii"), -- cgit v1.2.3 From 05d7214f4026d89a4b111e9bf0d4933a4847734f Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Sun, 15 Sep 2013 14:03:15 -0500 Subject: crazy pep8 contortions --- tests/test_utils.py | 67 +++++++++++++++++++++++++++++++++-------------------- 1 file changed, 42 insertions(+), 25 deletions(-) (limited to 'tests') diff --git a/tests/test_utils.py b/tests/test_utils.py index 3768c6fc..56edb3a5 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -287,18 +287,27 @@ def test_load_cryptrec_vectors_from_file_encrypt(): def test_load_openssl_vectors_encrypt(): - vector_data = textwrap.dedent(""" - # We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt - # For all CFB128 encrypts and decrypts, the transformed sequence is - # CAMELLIA-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec - # CFB128-CAMELLIA128.Encrypt - CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:1 - CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:A53D28BB82DF741103EA4F921A44880B:1 - - # CFB128-CAMELLIA128.Decrypt - CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:0 - CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:A53D28BB82DF741103EA4F921A44880B:0 - """).splitlines() + vector_data = textwrap.dedent( + """ + # We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt + # For all CFB128 encrypts and decrypts, the transformed sequence is + # CAMELLIA-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec + # CFB128-CAMELLIA128.Encrypt + """ + "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" + "000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:" + "14F7646187817EB586599146B82BD719:1\n" + "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" + "14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:" + "A53D28BB82DF741103EA4F921A44880B:1\n\n" + "# CFB128-CAMELLIA128.Decrypt\n" + "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" + "000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:" + "14F7646187817EB586599146B82BD719:0\n" + "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" + "14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:" + "A53D28BB82DF741103EA4F921A44880B:0" + ).splitlines() assert load_openssl_vectors(vector_data, "ENCRYPT") == [ ( @@ -317,19 +326,27 @@ def test_load_openssl_vectors_encrypt(): def test_load_openssl_vectors_decrypt(): - vector_data = textwrap.dedent(""" - # We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt - # For all CFB128 encrypts and decrypts, the transformed sequence is - # CAMELLIA-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec - # CFB128-CAMELLIA128.Encrypt - CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:14F7646187817EB586599146B82BD719:1 - CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:A53D28BB82DF741103EA4F921A44880B:1 - - # CFB128-CAMELLIA128.Decrypt - CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:A53D28BB82DF741103EA4F921A44880B:30C81C46A35CE411E5FBC1191A0A52EF:9C2157A664626D1DEF9EA420FDE69B96:0 - CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:9C2157A664626D1DEF9EA420FDE69B96:F69F2445DF4F9B17AD2B417BE66C3710:742A25F0542340C7BAEF24CA8482BB09:0 - - """).splitlines() + vector_data = textwrap.dedent( + """ + # We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt + # For all CFB128 encrypts and decrypts, the transformed sequence is + # CAMELLIA-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec + # CFB128-CAMELLIA128.Encrypt + """ + "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" + "000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:" + "14F7646187817EB586599146B82BD719:1\n" + "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" + "14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:" + "A53D28BB82DF741103EA4F921A44880B:1\n\n" + "# CFB128-CAMELLIA128.Decrypt\n" + "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" + "A53D28BB82DF741103EA4F921A44880B:30C81C46A35CE411E5FBC1191A0A52EF:" + "9C2157A664626D1DEF9EA420FDE69B96:0\n" + "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" + "9C2157A664626D1DEF9EA420FDE69B96:F69F2445DF4F9B17AD2B417BE66C3710:" + "742A25F0542340C7BAEF24CA8482BB09:0\n" + ).splitlines() assert load_openssl_vectors(vector_data, "DECRYPT") == [ ( -- cgit v1.2.3 From 057b5001adf7bfe0b4fe1c228cf7d1c17c3d00f5 Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Mon, 23 Sep 2013 12:49:48 -0500 Subject: simplify and annotate loaders based on review feedback --- tests/utils.py | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) (limited to 'tests') diff --git a/tests/utils.py b/tests/utils.py index 7d4b3a3e..62dfda27 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -70,7 +70,7 @@ def load_cryptrec_vectors_from_file(filename): def load_cryptrec_vectors(vector_data): - keys, data = [], {} + data = {} for line in vector_data: line = line.strip() @@ -80,15 +80,18 @@ def load_cryptrec_vectors(vector_data): continue if line.startswith("K"): - keys.append(line.split(" : ")[1].replace(" ", "")) + key = line.split(" : ")[1].replace(" ", "") # create an array under the key to hold all the P+C pairs - data[keys[-1]] = [] + # each key has many p+c pairs + data[key] = [] elif line.startswith("P"): # create a new dict to hold the next P+C pair - data[keys[-1]].append({}) - data[keys[-1]][-1]["P"] = line.split(" : ")[1].replace(" ", "") + pc_pair = {} + pc_pair["P"] = line.split(" : ")[1].replace(" ", "") elif line.startswith("C"): - data[keys[-1]][-1]["C"] = line.split(" : ")[1].replace(" ", "") + pc_pair["C"] = line.split(" : ")[1].replace(" ", "") + # after a C is found the P+C pair is complete + data[key].append(pc_pair) cryptrec_list = [] for key, value in sorted(data.items()): @@ -121,22 +124,22 @@ def load_openssl_vectors(vector_data, op): continue vector = line.split(":") - args_list = (vector[1].encode("ascii"), - vector[2].encode("ascii"), - vector[3].encode("ascii"), - vector[4].encode("ascii")) + params = (vector[1].encode("ascii"), # key + vector[2].encode("ascii"), # iv + vector[3].encode("ascii"), # ciphertext + vector[4].encode("ascii")) # plaintext # some OpenSSL vectors have a final field # 0 for decrypt, 1 for encrypt if len(vector) == 6: if int(vector[5]) == 0: - decrypt.append(args_list) + decrypt.append(params) else: - encrypt.append(args_list) + encrypt.append(params) else: # if they don't have 1 or 0 they are meant for both enc & dec # and should be added to both the encrypt and decrypt list - encrypt.append(args_list) - decrypt.append(args_list) + encrypt.append(params) + decrypt.append(params) if op == "ENCRYPT": return encrypt -- cgit v1.2.3 From 6b99a1b6d2e55e41bda5a42357e1b92f2e38d2ab Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Tue, 24 Sep 2013 16:50:21 -0500 Subject: remove distinction between encrypt/decrypt in the openssl loader * This was done because all the OpenSSL test vectors we're currently using are identical between encrypt/decrypt. * Removed a bunch of unneeded unit tests that checked the encrypt/decrypt vectors --- tests/test_utils.py | 112 ++++------------------------------------------------ tests/utils.py | 25 +++--------- 2 files changed, 13 insertions(+), 124 deletions(-) (limited to 'tests') diff --git a/tests/test_utils.py b/tests/test_utils.py index 56edb3a5..73394a51 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -286,7 +286,7 @@ def test_load_cryptrec_vectors_from_file_encrypt(): assert len(test_set) == 1280 -def test_load_openssl_vectors_encrypt(): +def test_load_openssl_vectors(): vector_data = textwrap.dedent( """ # We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt @@ -309,7 +309,7 @@ def test_load_openssl_vectors_encrypt(): "A53D28BB82DF741103EA4F921A44880B:0" ).splitlines() - assert load_openssl_vectors(vector_data, "ENCRYPT") == [ + assert load_openssl_vectors(vector_data) == [ ( b"2B7E151628AED2A6ABF7158809CF4F3C", b"000102030405060708090A0B0C0D0E0F", @@ -322,55 +322,6 @@ def test_load_openssl_vectors_encrypt(): b"AE2D8A571E03AC9C9EB76FAC45AF8E51", b"A53D28BB82DF741103EA4F921A44880B", ), - ] - - -def test_load_openssl_vectors_decrypt(): - vector_data = textwrap.dedent( - """ - # We don't support CFB{1,8}-CAMELLIAxxx.{En,De}crypt - # For all CFB128 encrypts and decrypts, the transformed sequence is - # CAMELLIA-bits-CFB:key:IV/ciphertext':plaintext:ciphertext:encdec - # CFB128-CAMELLIA128.Encrypt - """ - "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" - "000102030405060708090A0B0C0D0E0F:6BC1BEE22E409F96E93D7E117393172A:" - "14F7646187817EB586599146B82BD719:1\n" - "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" - "14F7646187817EB586599146B82BD719:AE2D8A571E03AC9C9EB76FAC45AF8E51:" - "A53D28BB82DF741103EA4F921A44880B:1\n\n" - "# CFB128-CAMELLIA128.Decrypt\n" - "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" - "A53D28BB82DF741103EA4F921A44880B:30C81C46A35CE411E5FBC1191A0A52EF:" - "9C2157A664626D1DEF9EA420FDE69B96:0\n" - "CAMELLIA-128-CFB:2B7E151628AED2A6ABF7158809CF4F3C:" - "9C2157A664626D1DEF9EA420FDE69B96:F69F2445DF4F9B17AD2B417BE66C3710:" - "742A25F0542340C7BAEF24CA8482BB09:0\n" - ).splitlines() - - assert load_openssl_vectors(vector_data, "DECRYPT") == [ - ( - b"2B7E151628AED2A6ABF7158809CF4F3C", - b"A53D28BB82DF741103EA4F921A44880B", - b"30C81C46A35CE411E5FBC1191A0A52EF", - b"9C2157A664626D1DEF9EA420FDE69B96", - ), - ( - b"2B7E151628AED2A6ABF7158809CF4F3C", - b"9C2157A664626D1DEF9EA420FDE69B96", - b"F69F2445DF4F9B17AD2B417BE66C3710", - b"742A25F0542340C7BAEF24CA8482BB09", - ), - ] - - -def test_load_openssl_vectors_from_file_encrypt(): - test_list = load_openssl_vectors_from_file( - "Camellia/camellia-ofb.txt", - "ENCRYPT" - ) - assert len(test_list) == 12 - assert test_list[:4] == [ ( b"2B7E151628AED2A6ABF7158809CF4F3C", b"000102030405060708090A0B0C0D0E0F", @@ -379,31 +330,16 @@ def test_load_openssl_vectors_from_file_encrypt(): ), ( b"2B7E151628AED2A6ABF7158809CF4F3C", - b"50FE67CC996D32B6DA0937E99BAFEC60", + b"14F7646187817EB586599146B82BD719", b"AE2D8A571E03AC9C9EB76FAC45AF8E51", - b"25623DB569CA51E01482649977E28D84", - ), - ( - b"2B7E151628AED2A6ABF7158809CF4F3C", - b"D9A4DADA0892239F6B8B3D7680E15674", - b"30C81C46A35CE411E5FBC1191A0A52EF", - b"C776634A60729DC657D12B9FCA801E98", - ), - ( - b"2B7E151628AED2A6ABF7158809CF4F3C", - b"A78819583F0308E7A6BF36B1386ABF23", - b"F69F2445DF4F9B17AD2B417BE66C3710", - b"D776379BE0E50825E681DA1A4C980E8E", + b"A53D28BB82DF741103EA4F921A44880B", ), ] -def test_load_openssl_vectors_from_file_decrypt(): - test_list = load_openssl_vectors_from_file( - "Camellia/camellia-ofb.txt", - "DECRYPT" - ) - assert len(test_list) == 12 +def test_load_openssl_vectors_from_file(): + test_list = load_openssl_vectors_from_file("Camellia/camellia-ofb.txt") + assert len(test_list) == 24 assert test_list[:4] == [ ( b"2B7E151628AED2A6ABF7158809CF4F3C", @@ -430,37 +366,3 @@ def test_load_openssl_vectors_from_file_decrypt(): b"D776379BE0E50825E681DA1A4C980E8E", ), ] - - -def test_load_openssl_vectors_from_file_no_enc_dec_flag(): - test_list = load_openssl_vectors_from_file( - "Camellia/camellia-cbc.txt", - "ENCRYPT" - ) - assert len(test_list) == 12 - assert test_list[:4] == [ - ( - b"2B7E151628AED2A6ABF7158809CF4F3C", - b"000102030405060708090A0B0C0D0E0F", - b"6BC1BEE22E409F96E93D7E117393172A", - b"1607CF494B36BBF00DAEB0B503C831AB", - ), - ( - b"2B7E151628AED2A6ABF7158809CF4F3C", - b"1607CF494B36BBF00DAEB0B503C831AB", - b"AE2D8A571E03AC9C9EB76FAC45AF8E51", - b"A2F2CF671629EF7840C5A5DFB5074887", - ), - ( - b"2B7E151628AED2A6ABF7158809CF4F3C", - b"A2F2CF671629EF7840C5A5DFB5074887", - b"30C81C46A35CE411E5FBC1191A0A52EF", - b"0F06165008CF8B8B5A63586362543E54", - ), - ( - b"2B7E151628AED2A6ABF7158809CF4F3C", - b"36A84CDAFD5F9A85ADA0F0A993D6D577", - b"F69F2445DF4F9B17AD2B417BE66C3710", - b"74C64268CDB8B8FAF5B34E8AF3732980", - ), - ] diff --git a/tests/utils.py b/tests/utils.py index 62dfda27..48a32ebe 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -105,16 +105,16 @@ def load_cryptrec_vectors(vector_data): return cryptrec_list -def load_openssl_vectors_from_file(filename, op): +def load_openssl_vectors_from_file(filename): base = os.path.join( os.path.dirname(__file__), "primitives", "vectors", "OpenSSL", ) with open(os.path.join(base, filename), "r") as vector_file: - return load_openssl_vectors(vector_file, op) + return load_openssl_vectors(vector_file) -def load_openssl_vectors(vector_data, op): - encrypt, decrypt = [], [] +def load_openssl_vectors(vector_data): + vectors = [] for line in vector_data: line = line.strip() @@ -130,18 +130,5 @@ def load_openssl_vectors(vector_data, op): vector[4].encode("ascii")) # plaintext # some OpenSSL vectors have a final field # 0 for decrypt, 1 for encrypt - if len(vector) == 6: - if int(vector[5]) == 0: - decrypt.append(params) - else: - encrypt.append(params) - else: - # if they don't have 1 or 0 they are meant for both enc & dec - # and should be added to both the encrypt and decrypt list - encrypt.append(params) - decrypt.append(params) - - if op == "ENCRYPT": - return encrypt - else: - return decrypt + vectors.append(params) + return vectors -- cgit v1.2.3 From e580598228caa28544fdd4fa53a29bb870858421 Mon Sep 17 00:00:00 2001 From: Paul Kehrer Date: Fri, 27 Sep 2013 11:26:01 -0500 Subject: simplify cryptrec loader, improve comments --- tests/utils.py | 44 +++++++++++++++++--------------------------- 1 file changed, 17 insertions(+), 27 deletions(-) (limited to 'tests') diff --git a/tests/utils.py b/tests/utils.py index 48a32ebe..d06c9e3b 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -70,7 +70,7 @@ def load_cryptrec_vectors_from_file(filename): def load_cryptrec_vectors(vector_data): - data = {} + cryptrec_list = [] for line in vector_data: line = line.strip() @@ -80,28 +80,14 @@ def load_cryptrec_vectors(vector_data): continue if line.startswith("K"): - key = line.split(" : ")[1].replace(" ", "") - # create an array under the key to hold all the P+C pairs - # each key has many p+c pairs - data[key] = [] + key = line.split(" : ")[1].replace(" ", "").encode("ascii") elif line.startswith("P"): - # create a new dict to hold the next P+C pair - pc_pair = {} - pc_pair["P"] = line.split(" : ")[1].replace(" ", "") + pt = line.split(" : ")[1].replace(" ", "").encode("ascii") elif line.startswith("C"): - pc_pair["C"] = line.split(" : ")[1].replace(" ", "") - # after a C is found the P+C pair is complete - data[key].append(pc_pair) - - cryptrec_list = [] - for key, value in sorted(data.items()): - for pair in value: - cryptrec_list.append( - (key.encode("ascii"), - pair["P"].encode("ascii"), - pair["C"].encode("ascii")) - ) - + ct = line.split(" : ")[1].replace(" ", "").encode("ascii") + # after a C is found the K+P+C tuple is complete + # there are many P+C pairs for each K + cryptrec_list.append((key, pt, ct)) return cryptrec_list @@ -124,11 +110,15 @@ def load_openssl_vectors(vector_data): continue vector = line.split(":") - params = (vector[1].encode("ascii"), # key - vector[2].encode("ascii"), # iv - vector[3].encode("ascii"), # ciphertext - vector[4].encode("ascii")) # plaintext - # some OpenSSL vectors have a final field - # 0 for decrypt, 1 for encrypt + params = ( + # key + vector[1].encode("ascii"), + # iv + vector[2].encode("ascii"), + # plaintext + vector[3].encode("ascii"), + # ciphertext + vector[4].encode("ascii") + ) vectors.append(params) return vectors -- cgit v1.2.3