You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
930 lines
29 KiB
930 lines
29 KiB
# This file is dual licensed under the terms of the Apache License, Version
|
|
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
|
|
# for complete details.
|
|
|
|
from __future__ import absolute_import, division, print_function
|
|
|
|
import binascii
|
|
import collections
|
|
import json
|
|
import math
|
|
import os
|
|
import re
|
|
from contextlib import contextmanager
|
|
|
|
import pytest
|
|
|
|
import six
|
|
|
|
from cryptography.exceptions import UnsupportedAlgorithm
|
|
|
|
import cryptography_vectors
|
|
|
|
|
|
HashVector = collections.namedtuple("HashVector", ["message", "digest"])
|
|
KeyedHashVector = collections.namedtuple(
|
|
"KeyedHashVector", ["message", "digest", "key"]
|
|
)
|
|
|
|
|
|
def check_backend_support(backend, item):
|
|
for mark in item.node.iter_markers("supported"):
|
|
if not mark.kwargs["only_if"](backend):
|
|
pytest.skip("{0} ({1})".format(
|
|
mark.kwargs["skip_message"], backend
|
|
))
|
|
|
|
|
|
@contextmanager
|
|
def raises_unsupported_algorithm(reason):
|
|
with pytest.raises(UnsupportedAlgorithm) as exc_info:
|
|
yield exc_info
|
|
|
|
assert exc_info.value._reason is reason
|
|
|
|
|
|
def load_vectors_from_file(filename, loader, mode="r"):
|
|
with cryptography_vectors.open_vector_file(filename, mode) as vector_file:
|
|
return loader(vector_file)
|
|
|
|
|
|
def load_nist_vectors(vector_data):
|
|
test_data = None
|
|
data = []
|
|
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
# Blank lines, comments, and section headers are ignored
|
|
if not line or line.startswith("#") or (line.startswith("[") and
|
|
line.endswith("]")):
|
|
continue
|
|
|
|
if line.strip() == "FAIL":
|
|
test_data["fail"] = True
|
|
continue
|
|
|
|
# Build our data using a simple Key = Value format
|
|
name, value = [c.strip() for c in line.split("=")]
|
|
|
|
# Some tests (PBKDF2) contain \0, which should be interpreted as a
|
|
# null character rather than literal.
|
|
value = value.replace("\\0", "\0")
|
|
|
|
# COUNT is a special token that indicates a new block of data
|
|
if name.upper() == "COUNT":
|
|
test_data = {}
|
|
data.append(test_data)
|
|
continue
|
|
# For all other tokens we simply want the name, value stored in
|
|
# the dictionary
|
|
else:
|
|
test_data[name.lower()] = value.encode("ascii")
|
|
|
|
return data
|
|
|
|
|
|
def load_cryptrec_vectors(vector_data):
|
|
cryptrec_list = []
|
|
|
|
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"):
|
|
key = line.split(" : ")[1].replace(" ", "").encode("ascii")
|
|
elif line.startswith("P"):
|
|
pt = line.split(" : ")[1].replace(" ", "").encode("ascii")
|
|
elif line.startswith("C"):
|
|
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": key,
|
|
"plaintext": pt,
|
|
"ciphertext": ct
|
|
})
|
|
else:
|
|
raise ValueError("Invalid line in file '{}'".format(line))
|
|
return cryptrec_list
|
|
|
|
|
|
def load_hash_vectors(vector_data):
|
|
vectors = []
|
|
key = None
|
|
msg = None
|
|
md = None
|
|
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if not line or line.startswith("#") or line.startswith("["):
|
|
continue
|
|
|
|
if line.startswith("Len"):
|
|
length = int(line.split(" = ")[1])
|
|
elif line.startswith("Key"):
|
|
# HMAC vectors contain a key attribute. Hash vectors do not.
|
|
key = line.split(" = ")[1].encode("ascii")
|
|
elif line.startswith("Msg"):
|
|
# In the NIST vectors they have chosen to represent an empty
|
|
# string as hex 00, which is of course not actually an empty
|
|
# string. So we parse the provided length and catch this edge case.
|
|
msg = line.split(" = ")[1].encode("ascii") if length > 0 else b""
|
|
elif line.startswith("MD") or line.startswith("Output"):
|
|
md = line.split(" = ")[1]
|
|
# after MD is found the Msg+MD (+ potential key) tuple is complete
|
|
if key is not None:
|
|
vectors.append(KeyedHashVector(msg, md, key))
|
|
key = None
|
|
msg = None
|
|
md = None
|
|
else:
|
|
vectors.append(HashVector(msg, md))
|
|
msg = None
|
|
md = None
|
|
else:
|
|
raise ValueError("Unknown line in hash vector")
|
|
return vectors
|
|
|
|
|
|
def load_pkcs1_vectors(vector_data):
|
|
"""
|
|
Loads data out of RSA PKCS #1 vector files.
|
|
"""
|
|
private_key_vector = None
|
|
public_key_vector = None
|
|
attr = None
|
|
key = None
|
|
example_vector = None
|
|
examples = []
|
|
vectors = []
|
|
for line in vector_data:
|
|
if (
|
|
line.startswith("# PSS Example") or
|
|
line.startswith("# OAEP Example") or
|
|
line.startswith("# PKCS#1 v1.5")
|
|
):
|
|
if example_vector:
|
|
for key, value in six.iteritems(example_vector):
|
|
hex_str = "".join(value).replace(" ", "").encode("ascii")
|
|
example_vector[key] = hex_str
|
|
examples.append(example_vector)
|
|
|
|
attr = None
|
|
example_vector = collections.defaultdict(list)
|
|
|
|
if line.startswith("# Message"):
|
|
attr = "message"
|
|
continue
|
|
elif line.startswith("# Salt"):
|
|
attr = "salt"
|
|
continue
|
|
elif line.startswith("# Seed"):
|
|
attr = "seed"
|
|
continue
|
|
elif line.startswith("# Signature"):
|
|
attr = "signature"
|
|
continue
|
|
elif line.startswith("# Encryption"):
|
|
attr = "encryption"
|
|
continue
|
|
elif (
|
|
example_vector and
|
|
line.startswith("# =============================================")
|
|
):
|
|
for key, value in six.iteritems(example_vector):
|
|
hex_str = "".join(value).replace(" ", "").encode("ascii")
|
|
example_vector[key] = hex_str
|
|
examples.append(example_vector)
|
|
example_vector = None
|
|
attr = None
|
|
elif example_vector and line.startswith("#"):
|
|
continue
|
|
else:
|
|
if attr is not None and example_vector is not None:
|
|
example_vector[attr].append(line.strip())
|
|
continue
|
|
|
|
if (
|
|
line.startswith("# Example") or
|
|
line.startswith("# =============================================")
|
|
):
|
|
if key:
|
|
assert private_key_vector
|
|
assert public_key_vector
|
|
|
|
for key, value in six.iteritems(public_key_vector):
|
|
hex_str = "".join(value).replace(" ", "")
|
|
public_key_vector[key] = int(hex_str, 16)
|
|
|
|
for key, value in six.iteritems(private_key_vector):
|
|
hex_str = "".join(value).replace(" ", "")
|
|
private_key_vector[key] = int(hex_str, 16)
|
|
|
|
private_key_vector["examples"] = examples
|
|
examples = []
|
|
|
|
assert (
|
|
private_key_vector['public_exponent'] ==
|
|
public_key_vector['public_exponent']
|
|
)
|
|
|
|
assert (
|
|
private_key_vector['modulus'] ==
|
|
public_key_vector['modulus']
|
|
)
|
|
|
|
vectors.append(
|
|
(private_key_vector, public_key_vector)
|
|
)
|
|
|
|
public_key_vector = collections.defaultdict(list)
|
|
private_key_vector = collections.defaultdict(list)
|
|
key = None
|
|
attr = None
|
|
|
|
if private_key_vector is None or public_key_vector is None:
|
|
# Random garbage to defeat CPython's peephole optimizer so that
|
|
# coverage records correctly: https://bugs.python.org/issue2506
|
|
1 + 1
|
|
continue
|
|
|
|
if line.startswith("# Private key"):
|
|
key = private_key_vector
|
|
elif line.startswith("# Public key"):
|
|
key = public_key_vector
|
|
elif line.startswith("# Modulus:"):
|
|
attr = "modulus"
|
|
elif line.startswith("# Public exponent:"):
|
|
attr = "public_exponent"
|
|
elif line.startswith("# Exponent:"):
|
|
if key is public_key_vector:
|
|
attr = "public_exponent"
|
|
else:
|
|
assert key is private_key_vector
|
|
attr = "private_exponent"
|
|
elif line.startswith("# Prime 1:"):
|
|
attr = "p"
|
|
elif line.startswith("# Prime 2:"):
|
|
attr = "q"
|
|
elif line.startswith("# Prime exponent 1:"):
|
|
attr = "dmp1"
|
|
elif line.startswith("# Prime exponent 2:"):
|
|
attr = "dmq1"
|
|
elif line.startswith("# Coefficient:"):
|
|
attr = "iqmp"
|
|
elif line.startswith("#"):
|
|
attr = None
|
|
else:
|
|
if key is not None and attr is not None:
|
|
key[attr].append(line.strip())
|
|
return vectors
|
|
|
|
|
|
def load_rsa_nist_vectors(vector_data):
|
|
test_data = None
|
|
p = None
|
|
salt_length = None
|
|
data = []
|
|
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
# Blank lines and section headers are ignored
|
|
if not line or line.startswith("["):
|
|
continue
|
|
|
|
if line.startswith("# Salt len:"):
|
|
salt_length = int(line.split(":")[1].strip())
|
|
continue
|
|
elif line.startswith("#"):
|
|
continue
|
|
|
|
# Build our data using a simple Key = Value format
|
|
name, value = [c.strip() for c in line.split("=")]
|
|
|
|
if name == "n":
|
|
n = int(value, 16)
|
|
elif name == "e" and p is None:
|
|
e = int(value, 16)
|
|
elif name == "p":
|
|
p = int(value, 16)
|
|
elif name == "q":
|
|
q = int(value, 16)
|
|
elif name == "SHAAlg":
|
|
if p is None:
|
|
test_data = {
|
|
"modulus": n,
|
|
"public_exponent": e,
|
|
"salt_length": salt_length,
|
|
"algorithm": value,
|
|
"fail": False
|
|
}
|
|
else:
|
|
test_data = {
|
|
"modulus": n,
|
|
"p": p,
|
|
"q": q,
|
|
"algorithm": value
|
|
}
|
|
if salt_length is not None:
|
|
test_data["salt_length"] = salt_length
|
|
data.append(test_data)
|
|
elif name == "e" and p is not None:
|
|
test_data["public_exponent"] = int(value, 16)
|
|
elif name == "d":
|
|
test_data["private_exponent"] = int(value, 16)
|
|
elif name == "Result":
|
|
test_data["fail"] = value.startswith("F")
|
|
# For all other tokens we simply want the name, value stored in
|
|
# the dictionary
|
|
else:
|
|
test_data[name.lower()] = value.encode("ascii")
|
|
|
|
return data
|
|
|
|
|
|
def load_fips_dsa_key_pair_vectors(vector_data):
|
|
"""
|
|
Loads data out of the FIPS DSA KeyPair vector files.
|
|
"""
|
|
vectors = []
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if not line or line.startswith("#") or line.startswith("[mod"):
|
|
continue
|
|
|
|
if line.startswith("P"):
|
|
vectors.append({'p': int(line.split("=")[1], 16)})
|
|
elif line.startswith("Q"):
|
|
vectors[-1]['q'] = int(line.split("=")[1], 16)
|
|
elif line.startswith("G"):
|
|
vectors[-1]['g'] = int(line.split("=")[1], 16)
|
|
elif line.startswith("X") and 'x' not in vectors[-1]:
|
|
vectors[-1]['x'] = int(line.split("=")[1], 16)
|
|
elif line.startswith("X") and 'x' in vectors[-1]:
|
|
vectors.append({'p': vectors[-1]['p'],
|
|
'q': vectors[-1]['q'],
|
|
'g': vectors[-1]['g'],
|
|
'x': int(line.split("=")[1], 16)
|
|
})
|
|
elif line.startswith("Y"):
|
|
vectors[-1]['y'] = int(line.split("=")[1], 16)
|
|
|
|
return vectors
|
|
|
|
|
|
def load_fips_dsa_sig_vectors(vector_data):
|
|
"""
|
|
Loads data out of the FIPS DSA SigVer vector files.
|
|
"""
|
|
vectors = []
|
|
sha_regex = re.compile(
|
|
r"\[mod = L=...., N=..., SHA-(?P<sha>1|224|256|384|512)\]"
|
|
)
|
|
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
|
|
sha_match = sha_regex.match(line)
|
|
if sha_match:
|
|
digest_algorithm = "SHA-{0}".format(sha_match.group("sha"))
|
|
|
|
if line.startswith("[mod"):
|
|
continue
|
|
|
|
name, value = [c.strip() for c in line.split("=")]
|
|
|
|
if name == "P":
|
|
vectors.append({'p': int(value, 16),
|
|
'digest_algorithm': digest_algorithm})
|
|
elif name == "Q":
|
|
vectors[-1]['q'] = int(value, 16)
|
|
elif name == "G":
|
|
vectors[-1]['g'] = int(value, 16)
|
|
elif name == "Msg" and 'msg' not in vectors[-1]:
|
|
hexmsg = value.strip().encode("ascii")
|
|
vectors[-1]['msg'] = binascii.unhexlify(hexmsg)
|
|
elif name == "Msg" and 'msg' in vectors[-1]:
|
|
hexmsg = value.strip().encode("ascii")
|
|
vectors.append({'p': vectors[-1]['p'],
|
|
'q': vectors[-1]['q'],
|
|
'g': vectors[-1]['g'],
|
|
'digest_algorithm':
|
|
vectors[-1]['digest_algorithm'],
|
|
'msg': binascii.unhexlify(hexmsg)})
|
|
elif name == "X":
|
|
vectors[-1]['x'] = int(value, 16)
|
|
elif name == "Y":
|
|
vectors[-1]['y'] = int(value, 16)
|
|
elif name == "R":
|
|
vectors[-1]['r'] = int(value, 16)
|
|
elif name == "S":
|
|
vectors[-1]['s'] = int(value, 16)
|
|
elif name == "Result":
|
|
vectors[-1]['result'] = value.split("(")[0].strip()
|
|
|
|
return vectors
|
|
|
|
|
|
# https://tools.ietf.org/html/rfc4492#appendix-A
|
|
_ECDSA_CURVE_NAMES = {
|
|
"P-192": "secp192r1",
|
|
"P-224": "secp224r1",
|
|
"P-256": "secp256r1",
|
|
"P-384": "secp384r1",
|
|
"P-521": "secp521r1",
|
|
|
|
"K-163": "sect163k1",
|
|
"K-233": "sect233k1",
|
|
"K-256": "secp256k1",
|
|
"K-283": "sect283k1",
|
|
"K-409": "sect409k1",
|
|
"K-571": "sect571k1",
|
|
|
|
"B-163": "sect163r2",
|
|
"B-233": "sect233r1",
|
|
"B-283": "sect283r1",
|
|
"B-409": "sect409r1",
|
|
"B-571": "sect571r1",
|
|
}
|
|
|
|
|
|
def load_fips_ecdsa_key_pair_vectors(vector_data):
|
|
"""
|
|
Loads data out of the FIPS ECDSA KeyPair vector files.
|
|
"""
|
|
vectors = []
|
|
key_data = None
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
|
|
if line[1:-1] in _ECDSA_CURVE_NAMES:
|
|
curve_name = _ECDSA_CURVE_NAMES[line[1:-1]]
|
|
|
|
elif line.startswith("d = "):
|
|
if key_data is not None:
|
|
vectors.append(key_data)
|
|
|
|
key_data = {
|
|
"curve": curve_name,
|
|
"d": int(line.split("=")[1], 16)
|
|
}
|
|
|
|
elif key_data is not None:
|
|
if line.startswith("Qx = "):
|
|
key_data["x"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("Qy = "):
|
|
key_data["y"] = int(line.split("=")[1], 16)
|
|
|
|
assert key_data is not None
|
|
vectors.append(key_data)
|
|
|
|
return vectors
|
|
|
|
|
|
def load_fips_ecdsa_signing_vectors(vector_data):
|
|
"""
|
|
Loads data out of the FIPS ECDSA SigGen vector files.
|
|
"""
|
|
vectors = []
|
|
|
|
curve_rx = re.compile(
|
|
r"\[(?P<curve>[PKB]-[0-9]{3}),SHA-(?P<sha>1|224|256|384|512)\]"
|
|
)
|
|
|
|
data = None
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
curve_match = curve_rx.match(line)
|
|
if curve_match:
|
|
curve_name = _ECDSA_CURVE_NAMES[curve_match.group("curve")]
|
|
digest_name = "SHA-{0}".format(curve_match.group("sha"))
|
|
|
|
elif line.startswith("Msg = "):
|
|
if data is not None:
|
|
vectors.append(data)
|
|
|
|
hexmsg = line.split("=")[1].strip().encode("ascii")
|
|
|
|
data = {
|
|
"curve": curve_name,
|
|
"digest_algorithm": digest_name,
|
|
"message": binascii.unhexlify(hexmsg)
|
|
}
|
|
|
|
elif data is not None:
|
|
if line.startswith("Qx = "):
|
|
data["x"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("Qy = "):
|
|
data["y"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("R = "):
|
|
data["r"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("S = "):
|
|
data["s"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("d = "):
|
|
data["d"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("Result = "):
|
|
data["fail"] = line.split("=")[1].strip()[0] == "F"
|
|
|
|
assert data is not None
|
|
vectors.append(data)
|
|
return vectors
|
|
|
|
|
|
def load_kasvs_dh_vectors(vector_data):
|
|
"""
|
|
Loads data out of the KASVS key exchange vector data
|
|
"""
|
|
|
|
result_rx = re.compile(r"([FP]) \(([0-9]+) -")
|
|
|
|
vectors = []
|
|
data = {
|
|
"fail_z": False,
|
|
"fail_agree": False
|
|
}
|
|
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
|
|
if line.startswith("P = "):
|
|
data["p"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("Q = "):
|
|
data["q"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("G = "):
|
|
data["g"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("Z = "):
|
|
z_hex = line.split("=")[1].strip().encode("ascii")
|
|
data["z"] = binascii.unhexlify(z_hex)
|
|
elif line.startswith("XstatCAVS = "):
|
|
data["x1"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("YstatCAVS = "):
|
|
data["y1"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("XstatIUT = "):
|
|
data["x2"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("YstatIUT = "):
|
|
data["y2"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("Result = "):
|
|
result_str = line.split("=")[1].strip()
|
|
match = result_rx.match(result_str)
|
|
|
|
if match.group(1) == "F":
|
|
if int(match.group(2)) in (5, 10):
|
|
data["fail_z"] = True
|
|
else:
|
|
data["fail_agree"] = True
|
|
|
|
vectors.append(data)
|
|
|
|
data = {
|
|
"p": data["p"],
|
|
"q": data["q"],
|
|
"g": data["g"],
|
|
"fail_z": False,
|
|
"fail_agree": False
|
|
}
|
|
|
|
return vectors
|
|
|
|
|
|
def load_kasvs_ecdh_vectors(vector_data):
|
|
"""
|
|
Loads data out of the KASVS key exchange vector data
|
|
"""
|
|
|
|
curve_name_map = {
|
|
"P-192": "secp192r1",
|
|
"P-224": "secp224r1",
|
|
"P-256": "secp256r1",
|
|
"P-384": "secp384r1",
|
|
"P-521": "secp521r1",
|
|
}
|
|
|
|
result_rx = re.compile(r"([FP]) \(([0-9]+) -")
|
|
|
|
tags = []
|
|
sets = {}
|
|
vectors = []
|
|
|
|
# find info in header
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if line.startswith("#"):
|
|
parm = line.split("Parameter set(s) supported:")
|
|
if len(parm) == 2:
|
|
names = parm[1].strip().split()
|
|
for n in names:
|
|
tags.append("[%s]" % n)
|
|
break
|
|
|
|
# Sets Metadata
|
|
tag = None
|
|
curve = None
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
|
|
if line in tags:
|
|
tag = line
|
|
curve = None
|
|
elif line.startswith("[Curve selected:"):
|
|
curve = curve_name_map[line.split(':')[1].strip()[:-1]]
|
|
|
|
if tag is not None and curve is not None:
|
|
sets[tag.strip("[]")] = curve
|
|
tag = None
|
|
if len(tags) == len(sets):
|
|
break
|
|
|
|
# Data
|
|
data = {
|
|
"CAVS": {},
|
|
"IUT": {},
|
|
}
|
|
tag = None
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
|
|
if line.startswith("["):
|
|
tag = line.split()[0][1:]
|
|
elif line.startswith("COUNT = "):
|
|
data["COUNT"] = int(line.split("=")[1])
|
|
elif line.startswith("dsCAVS = "):
|
|
data["CAVS"]["d"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("QsCAVSx = "):
|
|
data["CAVS"]["x"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("QsCAVSy = "):
|
|
data["CAVS"]["y"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("dsIUT = "):
|
|
data["IUT"]["d"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("QsIUTx = "):
|
|
data["IUT"]["x"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("QsIUTy = "):
|
|
data["IUT"]["y"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("OI = "):
|
|
data["OI"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("Z = "):
|
|
data["Z"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("DKM = "):
|
|
data["DKM"] = int(line.split("=")[1], 16)
|
|
elif line.startswith("Result = "):
|
|
result_str = line.split("=")[1].strip()
|
|
match = result_rx.match(result_str)
|
|
|
|
if match.group(1) == "F":
|
|
data["fail"] = True
|
|
else:
|
|
data["fail"] = False
|
|
data["errno"] = int(match.group(2))
|
|
|
|
data["curve"] = sets[tag]
|
|
|
|
vectors.append(data)
|
|
|
|
data = {
|
|
"CAVS": {},
|
|
"IUT": {},
|
|
}
|
|
|
|
return vectors
|
|
|
|
|
|
def load_x963_vectors(vector_data):
|
|
"""
|
|
Loads data out of the X9.63 vector data
|
|
"""
|
|
|
|
vectors = []
|
|
|
|
# Sets Metadata
|
|
hashname = None
|
|
vector = {}
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if line.startswith("[SHA"):
|
|
hashname = line[1:-1]
|
|
shared_secret_len = 0
|
|
shared_info_len = 0
|
|
key_data_len = 0
|
|
elif line.startswith("[shared secret length"):
|
|
shared_secret_len = int(line[1:-1].split("=")[1].strip())
|
|
elif line.startswith("[SharedInfo length"):
|
|
shared_info_len = int(line[1:-1].split("=")[1].strip())
|
|
elif line.startswith("[key data length"):
|
|
key_data_len = int(line[1:-1].split("=")[1].strip())
|
|
elif line.startswith("COUNT"):
|
|
count = int(line.split("=")[1].strip())
|
|
vector["hash"] = hashname
|
|
vector["count"] = count
|
|
vector["shared_secret_length"] = shared_secret_len
|
|
vector["sharedinfo_length"] = shared_info_len
|
|
vector["key_data_length"] = key_data_len
|
|
elif line.startswith("Z"):
|
|
vector["Z"] = line.split("=")[1].strip()
|
|
assert math.ceil(shared_secret_len / 8) * 2 == len(vector["Z"])
|
|
elif line.startswith("SharedInfo"):
|
|
if shared_info_len != 0:
|
|
vector["sharedinfo"] = line.split("=")[1].strip()
|
|
silen = len(vector["sharedinfo"])
|
|
assert math.ceil(shared_info_len / 8) * 2 == silen
|
|
elif line.startswith("key_data"):
|
|
vector["key_data"] = line.split("=")[1].strip()
|
|
assert math.ceil(key_data_len / 8) * 2 == len(vector["key_data"])
|
|
vectors.append(vector)
|
|
vector = {}
|
|
|
|
return vectors
|
|
|
|
|
|
def load_nist_kbkdf_vectors(vector_data):
|
|
"""
|
|
Load NIST SP 800-108 KDF Vectors
|
|
"""
|
|
vectors = []
|
|
test_data = None
|
|
tag = {}
|
|
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
|
|
if line.startswith("[") and line.endswith("]"):
|
|
tag_data = line[1:-1]
|
|
name, value = [c.strip() for c in tag_data.split("=")]
|
|
if value.endswith('_BITS'):
|
|
value = int(value.split('_')[0])
|
|
tag.update({name.lower(): value})
|
|
continue
|
|
|
|
tag.update({name.lower(): value.lower()})
|
|
elif line.startswith("COUNT="):
|
|
test_data = dict()
|
|
test_data.update(tag)
|
|
vectors.append(test_data)
|
|
elif line.startswith("L"):
|
|
name, value = [c.strip() for c in line.split("=")]
|
|
test_data[name.lower()] = int(value)
|
|
else:
|
|
name, value = [c.strip() for c in line.split("=")]
|
|
test_data[name.lower()] = value.encode("ascii")
|
|
|
|
return vectors
|
|
|
|
|
|
def load_ed25519_vectors(vector_data):
|
|
data = []
|
|
for line in vector_data:
|
|
secret_key, public_key, message, signature, _ = line.split(':')
|
|
# In the vectors the first element is secret key + public key
|
|
secret_key = secret_key[0:64]
|
|
# In the vectors the signature section is signature + message
|
|
signature = signature[0:128]
|
|
data.append({
|
|
"secret_key": secret_key,
|
|
"public_key": public_key,
|
|
"message": message,
|
|
"signature": signature
|
|
})
|
|
return data
|
|
|
|
|
|
def load_nist_ccm_vectors(vector_data):
|
|
test_data = None
|
|
section_data = None
|
|
global_data = {}
|
|
new_section = False
|
|
data = []
|
|
|
|
for line in vector_data:
|
|
line = line.strip()
|
|
|
|
# Blank lines and comments should be ignored
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
|
|
# Some of the CCM vectors have global values for this. They are always
|
|
# at the top before the first section header (see: VADT, VNT, VPT)
|
|
if line.startswith(("Alen", "Plen", "Nlen", "Tlen")):
|
|
name, value = [c.strip() for c in line.split("=")]
|
|
global_data[name.lower()] = int(value)
|
|
continue
|
|
|
|
# section headers contain length data we might care about
|
|
if line.startswith("["):
|
|
new_section = True
|
|
section_data = {}
|
|
section = line[1:-1]
|
|
items = [c.strip() for c in section.split(",")]
|
|
for item in items:
|
|
name, value = [c.strip() for c in item.split("=")]
|
|
section_data[name.lower()] = int(value)
|
|
continue
|
|
|
|
name, value = [c.strip() for c in line.split("=")]
|
|
|
|
if name.lower() in ("key", "nonce") and new_section:
|
|
section_data[name.lower()] = value.encode("ascii")
|
|
continue
|
|
|
|
new_section = False
|
|
|
|
# Payload is sometimes special because these vectors are absurd. Each
|
|
# example may or may not have a payload. If it does not then the
|
|
# previous example's payload should be used. We accomplish this by
|
|
# writing it into the section_data. Because we update each example
|
|
# with the section data it will be overwritten if a new payload value
|
|
# is present. NIST should be ashamed of their vector creation.
|
|
if name.lower() == "payload":
|
|
section_data[name.lower()] = value.encode("ascii")
|
|
|
|
# Result is a special token telling us if the test should pass/fail.
|
|
# This is only present in the DVPT CCM tests
|
|
if name.lower() == "result":
|
|
if value.lower() == "pass":
|
|
test_data["fail"] = False
|
|
else:
|
|
test_data["fail"] = True
|
|
continue
|
|
|
|
# COUNT is a special token that indicates a new block of data
|
|
if name.lower() == "count":
|
|
test_data = {}
|
|
test_data.update(global_data)
|
|
test_data.update(section_data)
|
|
data.append(test_data)
|
|
continue
|
|
# For all other tokens we simply want the name, value stored in
|
|
# the dictionary
|
|
else:
|
|
test_data[name.lower()] = value.encode("ascii")
|
|
|
|
return data
|
|
|
|
|
|
class WycheproofTest(object):
|
|
def __init__(self, testgroup, testcase):
|
|
self.testgroup = testgroup
|
|
self.testcase = testcase
|
|
|
|
def __repr__(self):
|
|
return "<WycheproofTest({!r}, {!r}, tcId={})>".format(
|
|
self.testgroup, self.testcase, self.testcase["tcId"],
|
|
)
|
|
|
|
@property
|
|
def valid(self):
|
|
return self.testcase["result"] == "valid"
|
|
|
|
@property
|
|
def acceptable(self):
|
|
return self.testcase["result"] == "acceptable"
|
|
|
|
@property
|
|
def invalid(self):
|
|
return self.testcase["result"] == "invalid"
|
|
|
|
def has_flag(self, flag):
|
|
return flag in self.testcase["flags"]
|
|
|
|
|
|
def skip_if_wycheproof_none(wycheproof):
|
|
# This is factored into its own function so we can easily test both
|
|
# branches
|
|
if wycheproof is None:
|
|
pytest.skip("--wycheproof-root not provided")
|
|
|
|
|
|
def load_wycheproof_tests(wycheproof, test_file):
|
|
path = os.path.join(wycheproof, "testvectors", test_file)
|
|
with open(path) as f:
|
|
data = json.load(f)
|
|
for group in data["testGroups"]:
|
|
cases = group.pop("tests")
|
|
for c in cases:
|
|
yield WycheproofTest(group, c)
|