Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-crypto

Source of release 0.6.0

0.6.0 / src / rsa_kat_tests.lucb

## RSA verification vectors: BearSSL's raw public-operation, PKCS#1 v1.5 and
## RSASSA-PSS (pkcs-1v2-1) known answers and its modular exponentiation inputs
## (10 to 500-bit moduli), the complete Wycheproof rsa_signature files for
## 2048/3072/4096/8192-bit keys with SHA-256/384/512 and every RSASSA-PSS file
## over SHA-1/SHA-2 hashes, and OpenSSL's RSA verification stanzas. Vectors
## with hashes this package lacks (MD5-SHA1, SHA-512/224) are counted out of
## scope. Test keys below 2048 bits are admitted with `smallest = 1024`.
import bignum
import rsa
import sha1
import sha2
import vector_file

func text(field: const u8[]) -> str:
    return (str)field

## The digest of `message`; zero for a hash this package lacks.
func message_digest(name: str, message: const u8[], out: u8[]) -> usize!:
    if name == "sha1":
        return try sha1.digest(message, out)
    if name == "sha224" or name == "sha256" or name == "sha384" or name == "sha512":
        return try sha2.digest(message, out, name)
    return 0

func supported(name: str) -> bool:
    return name == "sha1" or name == "sha224" or name == "sha256" or name == "sha384" or name == "sha512"

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/rsa_pss.txt")
    var n: u8[512]
    var e: u8[8]
    var key = rsa.PublicKey()
    while lines.next():
        if try lines.is(0, "key"):
            let a = try lines.decode(1, n)
            let b = try lines.decode(2, e)
            key = try rsa.public_key(n[..<a], e[..<b], 1024)
            continue
        var message: u8[512]
        var salt: u8[64]
        var signature: u8[512]
        var digest: u8[20]
        let m = try lines.decode(1, message)
        let s = try lines.decode(2, salt)
        let k = try lines.decode(3, signature)
        _ = try sha1.digest(message[..<m], digest)
        assert(try rsa.verify_pss(&key, "sha1", digest, signature[..<k], s), "BearSSL PSS KAT rejected")
        assert(try rsa.verify_pss(&key, "sha1", digest, signature[..<k], rsa.any_salt), "BearSSL PSS KAT rejected (auto salt)")
        signature[k // 2] ^= 1
        assert(not (try rsa.verify_pss(&key, "sha1", digest, signature[..<k], s)), "BearSSL PSS tampered signature accepted")
        counts.passed += 1
    lines.close()
    lines = try vector_file.Lines.open(directory, "bearssl/rsa_pkcs1.txt")
    defer lines.close()
    var modulus = bignum.Natural()
    while lines.next():
        if try lines.is(0, "key"):
            let a = try lines.decode(1, n)
            let b = try lines.decode(2, e)
            key = try rsa.public_key(n[..<a], e[..<b], 1024)
            modulus = try bignum.Natural.from_bytes(n[..<a])
            continue
        var first: u8[128]
        var second: u8[128]
        if try lines.is(0, "public"):
            let size = try lines.decode(1, first)
            _ = try lines.decode(2, second)
            let base = try bignum.Natural.from_bytes(first[..<size])
            let result = try bignum.modular_power(&base, e[..<3], &modulus)
            var out: u8[128]
            try result.to_bytes(out[..<size])
            assert(out[..<size] == second[..<size], "BearSSL RSA public operation mismatch")
        else:
            let h = try lines.decode(2, first)
            let k = try lines.decode(3, second)
            let algorithm = text(try lines.field(1))
            assert(try rsa.verify_pkcs1(&key, algorithm, first[..<h], second[..<k]), "BearSSL PKCS#1 KAT rejected")
            first[5] ^= 1
            assert(not (try rsa.verify_pkcs1(&key, algorithm, first[..<h], second[..<k])), "PKCS#1 accepted a changed digest")
        counts.passed += 1

func modpow(directory: str) -> usize!:
    var lines = try vector_file.Lines.open(directory, "bearssl/modpow.txt")
    defer lines.close()
    var count: usize = 0
    while lines.next():
        var m: u8[64]
        var x: u8[64]
        var e: u8[64]
        var expected: u8[64]
        let size = try lines.decode(0, m)
        _ = try lines.decode(1, x)
        _ = try lines.decode(2, e)
        _ = try lines.decode(3, expected)
        let modulus = try bignum.Natural.from_bytes(m[..<size])
        let base = try bignum.Natural.from_bytes(x[..<size])
        let result = try bignum.modular_power(&base, e[..<size], &modulus)
        var out: u8[64]
        try result.to_bytes(out[..<size])
        assert(out[..<size] == expected[..<size], "modular exponentiation mismatch")
        count += 1
    return count

## One Wycheproof file. PKCS#1 files have "key N E" lines; PSS files add the
## hash, MGF hash and salt length.
func wycheproof(directory: str, name: str, pss: bool, hash_name: str, counts: Counts*) -> !:
    var lines = try vector_file.Lines.open(directory, name)
    defer lines.close()
    var key = rsa.PublicKey()
    var algorithm = hash_name
    var mask = hash_name
    var salt: usize = 0
    var usable = true
    var n: u8[1100]
    var e: u8[16]
    while lines.next():
        if try lines.is(0, "key"):
            let a = try lines.decode(1, n)
            let b = try lines.decode(2, e)
            key = try rsa.public_key(n[..<a], e[..<b], 1024)
            if pss:
                algorithm = text(try lines.field(3))
                mask = text(try lines.field(4))
                let digits = try lines.field(5)
                salt = 0
                for i in 0..<digits.length: salt = salt * 10 + (usize)(digits[i] - '0')
            usable = supported(algorithm) and supported(mask)
            continue
        if not usable:
            counts.out_of_scope += 1
            continue
        var message: u8[4096]
        var signature: u8[2048]
        var digest: u8[64]
        let m = try lines.decode(1, message)
        let k = try lines.decode(2, signature)
        let d = try message_digest(algorithm, message[..<m], digest)
        var accepted = false
        if pss:
            accepted = try rsa.verify_pss(&key, algorithm, digest[..<d], signature[..<k], salt, mask)
        else:
            accepted = try rsa.verify_pkcs1(&key, algorithm, digest[..<d], signature[..<k])
        if try lines.is(0, "valid"):
            assert(accepted, "valid Wycheproof RSA signature rejected")
            counts.passed += 1
        else:
            # "acceptable" PKCS#1 cases omit the NULL parameters; they are refused.
            assert(not accepted, "invalid Wycheproof RSA signature accepted")
            counts.rejected += 1

func openssl(directory: str, counts: Counts*) -> !:
    var lines = try vector_file.Lines.open(directory, "openssl/rsa.txt")
    defer lines.close()
    while lines.next():
        let algorithm = text(try lines.field(3))
        let mask = text(try lines.field(4))
        if not supported(algorithm) or not supported(mask):
            counts.out_of_scope += 1
            continue
        var n: u8[512]
        var e: u8[8]
        let a = try lines.decode(1, n)
        let b = try lines.decode(2, e)
        let key = try rsa.public_key(n[..<a], e[..<b], 1024)
        var input: u8[512]
        var signature: u8[512]
        var digest: u8[512]
        let m = try lines.decode(7, input)
        let k = try lines.decode(8, signature)
        var d = m
        if try lines.is(6, "1"):
            for i in 0..<m: digest[i] = input[i]
        else:
            d = try message_digest(algorithm, input[..<m], digest)
        var accepted = false
        if try lines.is(0, "pss"):
            var salt = rsa.any_salt
            if not (try lines.is(5, "auto")):
                let digits = try lines.field(5)
                salt = 0
                for i in 0..<digits.length: salt = salt * 10 + (usize)(digits[i] - '0')
            accepted = try rsa.verify_pss(&key, algorithm, digest[..<d], signature[..<k], salt, mask)
        else:
            accepted = try rsa.verify_pkcs1(&key, algorithm, digest[..<d], signature[..<k])
        if try lines.is(9, "ok"):
            assert(accepted, "OpenSSL RSA signature rejected")
            counts.passed += 1
        else:
            assert(not accepted, "OpenSSL RSA 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)
    let powers = try modpow(directory)
    var wp = Counts()
    for bits in ["2048", "3072", "4096", "8192"]:
        for hash_name in ["sha256", "sha384", "sha512"]:
            var name: u8[64]
            var at: usize = 0
            for part in ["wycheproof/rsa_signature_", bits, "_", hash_name, ".txt"]:
                for i in 0..<part.length:
                    name[at + i] = part.bytes[i]
                at += part.length
            try wycheproof(directory, (str)name[..<at], false, hash_name, &wp)
    for file in ["rsa_pss_2048_sha256_mgf1_0", "rsa_pss_2048_sha256_mgf1_32", "rsa_pss_2048_sha256_mgf1sha1_20",
                 "rsa_pss_2048_sha384_mgf1_48", "rsa_pss_3072_sha256_mgf1_32", "rsa_pss_4096_sha256_mgf1_32",
                 "rsa_pss_4096_sha384_mgf1_48", "rsa_pss_4096_sha512_mgf1_32", "rsa_pss_4096_sha512_mgf1_64",
                 "rsa_pss_misc", "rsa_pss_2048_sha256_mgf1_0_params", "rsa_pss_2048_sha256_mgf1_32_params",
                 "rsa_pss_2048_sha512_mgf1sha256_32_params", "rsa_pss_3072_sha256_mgf1_32_params",
                 "rsa_pss_4096_sha512_mgf1_32_params", "rsa_pss_4096_sha512_mgf1_64_params", "rsa_pss_misc_params"]:
        var name: u8[96]
        var at: usize = 0
        for part in ["wycheproof/", file, ".txt"]:
            for i in 0..<part.length:
                name[at + i] = part.bytes[i]
            at += part.length
        try wycheproof(directory, (str)name[..<at], true, "", &wp)
    var ossl = Counts()
    try openssl(directory, &ossl)
    assert(kat.passed == 64 and powers == 491, "unexpected BearSSL RSA counts")
    assert(wp.passed == 1739 and wp.rejected == 3693 and wp.out_of_scope == 0, "unexpected Wycheproof RSA counts")
    assert(ossl.passed == 67 and ossl.rejected == 13 and ossl.out_of_scope == 6, "unexpected OpenSSL RSA counts")
    print(f"PASS RSA: BearSSL {kat.passed} + {powers} modpow, Wycheproof {wp.passed} valid, {wp.rejected} refused (+{wp.out_of_scope} other hashes), OpenSSL {ossl.passed} ok, {ossl.rejected} errors (+{ossl.out_of_scope} other hashes)")
    return 0