dymokomi/luce-crypto
Source of release 0.6.0
0.6.0 / src / ecdsa_kat_tests.lucb
## ECDSA over P-256 and P-384: BearSSL's RFC 6979 known answers (verify, raw
## and DER, with a flipped digest bit, and deterministic P-256 signing), the
## complete Wycheproof ecdsa_secp256r1_sha256/sha512 and
## ecdsa_secp384r1_sha256/sha384/sha512 files in DER and IEEE P1363 form, the
## NIST CAVP SigVer cases for both curves, and OpenSSL's ECDSA stanzas.
## P-521, other curves and SHA-1 signing are counted as out of scope.
import p256
import p384
import sha1
import sha2
import vector_file
## The digest of `message` under a vector's hash name; zero when unsupported.
func message_digest(name: const u8[], message: const u8[], out: u8[]) -> usize!:
if name == b"sha1":
return try sha1.digest(message, out)
for candidate in ["sha224", "sha256", "sha384", "sha512"]:
if name == candidate.bytes:
return try sha2.digest(message, out, candidate)
return 0
func check(wide: bool, x: const u8[], y: const u8[], digest: const u8[], r: const u8[], s: const u8[]) -> bool:
if wide:
return p384.verify(x, y, digest, r, s) catch: recover false
return p256.verify(x, y, digest, r, s) catch: recover false
## Verify a DER or raw (r || s) signature; malformed encodings are rejections.
func check_encoded(wide: bool, raw: bool, x: const u8[], y: const u8[], digest: const u8[], signature: const u8[]) -> bool:
let w: usize = 48 if wide else 32
var r: u8[48]
var s: u8[48]
if raw:
if signature.length != 2 * w:
return false
for i in 0..<w:
r[i] = signature[i]
s[i] = signature[w + i]
elif not vector_file.ecdsa_from_der(signature, r[..<w], s[..<w]):
return false
return check(wide, x, y, digest, r[..<w], s[..<w])
struct Counts:
var passed: usize
var rejected: usize
var out_of_scope: usize
func bearssl(directory: str, counts: Counts*) -> !:
var lines = try vector_file.Lines.open(directory, "bearssl/ecdsa.txt")
defer lines.close()
var keys: u8[3 * 199]
while lines.next():
if try lines.is(0, "key"):
let slot: usize = 0 if try lines.is(1, "p256") else (1 if try lines.is(1, "p384") else 2)
_ = try lines.decode(2, keys[slot * 199..<slot * 199 + 133])
_ = try lines.decode(3, keys[slot * 199 + 133..<slot * 199 + 199])
continue
if try lines.is(0, "p521"):
counts.out_of_scope += 1
continue
let wide = try lines.is(0, "p384")
let w: usize = 48 if wide else 32
let base: usize = 199 if wide else 0
let x = keys[base + 1..<base + 1 + w]
let y = keys[base + 1 + w..<base + 1 + 2 * w]
var message: u8[16]
var digest: u8[64]
var raw: u8[96]
var der: u8[110]
let m = try lines.decode(2, message)
let n = try message_digest(try lines.field(1), message[..<m], digest)
let raw_size = try lines.decode(4, raw)
let der_size = try lines.decode(5, der)
for encoded in [false, true]:
let signature = der[..<der_size] if encoded else raw[..<raw_size]
assert(check_encoded(wide, not encoded, x, y, digest[..<n], signature), "BearSSL ECDSA KAT rejected")
digest[0] ^= 0x80
assert(not check_encoded(wide, not encoded, x, y, digest[..<n], signature), "ECDSA accepted a changed digest")
digest[0] ^= 0x80
if not wide and n != 20:
var r: u8[32]
var s: u8[32]
try p256.sign(keys[133..<165], digest[..<n], r, s)
assert(r == raw[..<32] and s == raw[32..<64], "RFC 6979 P-256 signature mismatch")
var encoded: u8[80]
let size = vector_file.ecdsa_to_der(r, s, encoded)
assert(encoded[..<size] == der[..<der_size], "RFC 6979 P-256 DER mismatch")
elif not wide:
counts.out_of_scope += 1
counts.passed += 1
func wycheproof(directory: str, name: str, wide: bool, hash_name: str, raw: bool, valid: usize*, invalid: usize*) -> !:
var lines = try vector_file.Lines.open(directory, name)
defer lines.close()
let w: usize = 48 if wide else 32
var x: u8[48]
var y: u8[48]
while lines.next():
if try lines.is(0, "key"):
assert(try lines.decode(1, x) == w and try lines.decode(2, y) == w)
continue
var message: u8[4096]
var signature: u8[8192]
var digest: u8[64]
let m = try lines.decode(1, message)
let n = try lines.decode(2, signature)
let d = try message_digest(hash_name.bytes, message[..<m], digest)
let accepted = check_encoded(wide, raw, x[..<w], y[..<w], digest[..<d], signature[..<n])
if try lines.is(0, "valid"):
assert(accepted, "valid Wycheproof ECDSA signature rejected")
*valid += 1
else:
assert(not accepted, "invalid Wycheproof ECDSA signature accepted")
*invalid += 1
func cavp(directory: str, counts: Counts*) -> !:
var lines = try vector_file.Lines.open(directory, "cavp/ecdsa_sigver_0.txt")
defer lines.close()
while lines.next():
let wide = try lines.is(0, "P-384")
if not wide and not (try lines.is(0, "P-256")):
counts.out_of_scope += 1
continue
let w: usize = 48 if wide else 32
var x: u8[48]
var y: u8[48]
var r: u8[48]
var s: u8[48]
var message: u8[256]
var digest: u8[64]
_ = try lines.decode(2, x[..<w])
_ = try lines.decode(3, y[..<w])
_ = try lines.decode(4, r[..<w])
_ = try lines.decode(5, s[..<w])
let m = try lines.decode(6, message)
let n = try message_digest(try lines.field(1), message[..<m], digest)
assert(n != 0)
let accepted = check(wide, x[..<w], y[..<w], digest[..<n], r[..<w], s[..<w])
if try lines.is(7, "P"):
assert(accepted, "CAVP SigVer pass case rejected")
counts.passed += 1
else:
assert(not accepted, "CAVP SigVer fail case accepted")
counts.rejected += 1
func openssl(directory: str, counts: Counts*) -> !:
var lines = try vector_file.Lines.open(directory, "openssl/ecdsa.txt")
defer lines.close()
while lines.next():
let wide = try lines.is(1, "p384")
let w: usize = 48 if wide else 32
var x: u8[48]
var y: u8[48]
var input: u8[256]
var signature: u8[160]
var digest: u8[64]
if try lines.is(0, "keypair"):
var d: u8[48]
_ = try lines.decode(3, d[..<w])
_ = try lines.decode(4, x[..<w])
_ = try lines.decode(5, y[..<w])
var gx: u8[48]
var gy: u8[48]
if wide:
assert(try p384.multiply_generator(d[..<w], gx[..<w], gy[..<w]))
else:
assert(try p256.multiply_generator(d[..<w], gx[..<w], gy[..<w]))
assert(gx[..<w] == x[..<w] and gy[..<w] == y[..<w], "OpenSSL EC key pair mismatch")
counts.passed += 1
elif try lines.is(0, "digestsign"):
var d: u8[32]
_ = try lines.decode(3, d)
let m = try lines.decode(4, input)
let size = try lines.decode(5, signature)
let n = try message_digest(try lines.field(2), input[..<m], digest)
if n == 20:
counts.out_of_scope += 1
continue
var r: u8[32]
var s: u8[32]
try p256.sign(d, digest[..<n], r, s)
var encoded: u8[80]
let encoded_size = vector_file.ecdsa_to_der(r, s, encoded)
assert(encoded[..<encoded_size] == signature[..<size], "OpenSSL RFC 6979 signature mismatch")
counts.passed += 1
else:
_ = try lines.decode(3, x[..<w])
_ = try lines.decode(4, y[..<w])
let m = try lines.decode(5, input)
let size = try lines.decode(6, signature)
var n = m
if try lines.is(0, "verify"):
for i in 0..<m: digest[i] = input[i]
else:
n = try message_digest(try lines.field(2), input[..<m], digest)
let accepted = check_encoded(wide, false, x[..<w], y[..<w], digest[..<n], signature[..<size])
if try lines.is(7, "ok"):
assert(accepted, "OpenSSL ECDSA signature rejected")
counts.passed += 1
else:
assert(not accepted, "OpenSSL ECDSA error case accepted")
counts.rejected += 1
## Optional argument: the vector directory (default tests/vectors).
pub func main(arguments: str[]) -> i32!:
let directory = arguments[1] if arguments.length > 1 else "tests/vectors"
var kat = Counts()
try bearssl(directory, &kat)
var valid: usize = 0
var invalid: usize = 0
try wycheproof(directory, "wycheproof/ecdsa_secp256r1_sha256.txt", false, "sha256", false, &valid, &invalid)
try wycheproof(directory, "wycheproof/ecdsa_secp256r1_sha256_p1363.txt", false, "sha256", true, &valid, &invalid)
try wycheproof(directory, "wycheproof/ecdsa_secp256r1_sha512.txt", false, "sha512", false, &valid, &invalid)
try wycheproof(directory, "wycheproof/ecdsa_secp256r1_sha512_p1363.txt", false, "sha512", true, &valid, &invalid)
try wycheproof(directory, "wycheproof/ecdsa_secp384r1_sha256.txt", true, "sha256", false, &valid, &invalid)
try wycheproof(directory, "wycheproof/ecdsa_secp384r1_sha384.txt", true, "sha384", false, &valid, &invalid)
try wycheproof(directory, "wycheproof/ecdsa_secp384r1_sha384_p1363.txt", true, "sha384", true, &valid, &invalid)
try wycheproof(directory, "wycheproof/ecdsa_secp384r1_sha512.txt", true, "sha512", false, &valid, &invalid)
try wycheproof(directory, "wycheproof/ecdsa_secp384r1_sha512_p1363.txt", true, "sha512", true, &valid, &invalid)
var sigver = Counts()
try cavp(directory, &sigver)
var ossl = Counts()
try openssl(directory, &ossl)
assert(kat.passed == 20 and kat.out_of_scope == 12, "unexpected BearSSL ECDSA counts")
assert(valid == 1842 and invalid == 1906, "unexpected Wycheproof ECDSA counts")
assert(sigver.passed == 30 and sigver.rejected == 120 and sigver.out_of_scope == 975, "unexpected CAVP SigVer counts")
assert(ossl.passed == 36 and ossl.rejected == 26 and ossl.out_of_scope == 2, "unexpected OpenSSL ECDSA counts")
print(f"PASS ECDSA P-256/P-384: BearSSL {kat.passed} (+{kat.out_of_scope} P-521/SHA-1-signing out of scope), Wycheproof {valid} valid, {invalid} invalid, CAVP SigVer {sigver.passed} pass, {sigver.rejected} fail (+{sigver.out_of_scope} other curves), OpenSSL {ossl.passed} ok, {ossl.rejected} errors (+{ossl.out_of_scope} SHA-1 signing)")
return 0