From b235c84bb2541064353ac6016a0a2501ecca1c27 Mon Sep 17 00:00:00 2001 From: cheatfate Date: Sat, 2 Mar 2019 21:19:41 +0200 Subject: [PATCH] Add key interface with test vectors. --- libp2p.nimble | 1 + libp2p/crypto/crypto.nim | 487 +++++++++++++++++++++++++++++++++++++++ libp2p/crypto/ecnist.nim | 11 +- tests/testcrypto.nim | 398 ++++++++++++++++++++++++++++++++ 4 files changed, 893 insertions(+), 4 deletions(-) create mode 100644 libp2p/crypto/crypto.nim create mode 100644 tests/testcrypto.nim diff --git a/libp2p.nimble b/libp2p.nimble index f0a35c8ca..387c64a67 100644 --- a/libp2p.nimble +++ b/libp2p.nimble @@ -22,4 +22,5 @@ task test, "Runs the test suite": exec "nim c -r tests/testecnist" exec "nim c -r tests/testrsa" exec "nim c -r tests/tested25519" + exec "nim c -r tests/testcrypto" exec "nim c -r tests/testdaemon" diff --git a/libp2p/crypto/crypto.nim b/libp2p/crypto/crypto.nim new file mode 100644 index 000000000..39cc23f12 --- /dev/null +++ b/libp2p/crypto/crypto.nim @@ -0,0 +1,487 @@ +## Nim-Libp2p +## Copyright (c) 2018 Status Research & Development GmbH +## Licensed under either of +## * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE)) +## * MIT license ([LICENSE-MIT](LICENSE-MIT)) +## at your option. +## This file may not be copied, modified, or distributed except according to +## those terms. + +## This module implements Public Key and Private Key interface for libp2p. +import rsa, ecnist +import ed25519/ed25519 +import ../protobuf/minprotobuf +import nimcrypto/[rijndael, blowfish, sha, sha2, hash, hmac, utils] + +type + PKScheme* = enum + RSA = 0, + Ed25519, + Secp256k1, + ECDSA, + NoSupport + + CipherScheme* = enum + Aes128 = 0, + Aes256, + Blowfish + + DigestSheme* = enum + Sha1, + Sha256, + Sha512 + + ECDHEScheme* = EcCurveKind + + PublicKey* = object + case scheme*: PKScheme + of RSA: + rsakey*: RsaPublicKey + of Ed25519: + edkey*: EdPublicKey + of Secp256k1: + discard + of ECDSA: + eckey*: EcPublicKey + of NoSupport: + discard + + PrivateKey* = object + case scheme*: PKScheme + of RSA: + rsakey*: RsaPrivateKey + of Ed25519: + edkey*: EdPrivateKey + of Secp256k1: + discard + of ECDSA: + eckey*: EcPrivateKey + of NoSupport: + discard + + KeyPair* = object + seckey*: PrivateKey + pubkey*: PublicKey + + Secret* = object + ivsize*: int + keysize*: int + macsize*: int + data*: seq[byte] + + P2pKeyError* = object of Exception + +const + SupportedSchemes* = {RSA, Ed25519, ECDSA} + SupportedSchemesInt* = {int8(RSA), int8(Ed25519), int8(ECDSA)} + +proc random*(t: typedesc[PrivateKey], scheme: PKScheme, + bits = DefaultKeySize): PrivateKey = + ## Generate random private key for scheme ``scheme``. + ## + ## ``bits`` is number of bits for RSA key, ``bits`` value must be in + ## [512, 4096], default value is 2048 bits. + assert(scheme in SupportedSchemes) + result = PrivateKey(scheme: scheme) + if scheme == RSA: + result.rsakey = RsaPrivateKey.random(bits) + elif scheme == Ed25519: + result.edkey = EdPrivateKey.random() + elif scheme == ECDSA: + result.eckey = EcPrivateKey.random(Secp256r1) + +proc random*(t: typedesc[KeyPair], scheme: PKScheme, + bits = DefaultKeySize): KeyPair = + ## Generate random key pair for scheme ``scheme``. + ## + ## ``bits`` is number of bits for RSA key, ``bits`` value must be in + ## [512, 4096], default value is 2048 bits. + assert(scheme in SupportedSchemes) + result.seckey = PrivateKey(scheme: scheme) + result.pubkey = PublicKey(scheme: scheme) + if scheme == RSA: + var pair = RsaKeyPair.random(bits) + result.seckey.rsakey = pair.seckey + result.pubkey.rsakey = pair.pubkey + elif scheme == Ed25519: + var pair = EdKeyPair.random() + result.seckey.edkey = pair.seckey + result.pubkey.edkey = pair.pubkey + elif scheme == ECDSA: + var pair = EcKeyPair.random(Secp256r1) + result.seckey.eckey = pair.seckey + result.pubkey.eckey = pair.pubkey + +proc getKey*(key: PrivateKey): PublicKey = + ## Get public key from corresponding private key ``key``. + result = PublicKey(scheme: key.scheme) + if key.scheme == RSA: + result.rsakey = key.rsakey.getKey() + elif key.scheme == Ed25519: + result.edkey = key.edkey.getKey() + elif key.scheme == ECDSA: + result.eckey = key.eckey.getKey() + +proc toRawBytes*(key: PrivateKey, data: var openarray[byte]): int = + ## Serialize private key ``key`` (using scheme's own serialization) and store + ## it to ``data``. + ## + ## Returns number of bytes (octets) needed to store private key ``key``. + if key.scheme == RSA: + result = key.rsakey.toBytes(data) + elif key.scheme == Ed25519: + result = key.edkey.toBytes(data) + elif key.scheme == ECDSA: + result = key.eckey.toBytes(data) + +proc toRawBytes*(key: PublicKey, data: var openarray[byte]): int = + ## Serialize public key ``key`` (using scheme's own serialization) and store + ## it to ``data``. + ## + ## Returns number of bytes (octets) needed to store public key ``key``. + if key.scheme == RSA: + result = key.rsakey.toBytes(data) + elif key.scheme == Ed25519: + result = key.edkey.toBytes(data) + elif key.scheme == ECDSA: + result = key.eckey.toBytes(data) + +proc getRawBytes*(key: PrivateKey): seq[byte] = + ## Return private key ``key`` in binary form (using scheme's own + ## serialization). + if key.scheme == RSA: + result = key.rsakey.getBytes() + elif key.scheme == Ed25519: + result = key.edkey.getBytes() + elif key.scheme == ECDSA: + result = key.eckey.getBytes() + +proc getRawBytes*(key: PublicKey): seq[byte] = + ## Return public key ``key`` in binary form (using scheme's own + ## serialization). + if key.scheme == RSA: + result = key.rsakey.getBytes() + elif key.scheme == Ed25519: + result = key.edkey.getBytes() + elif key.scheme == ECDSA: + result = key.eckey.getBytes() + +proc toBytes*(key: PrivateKey, data: var openarray[byte]): int = + ## Serialize private key ``key`` (using libp2p protobuf scheme) and store + ## it to ``data``. + ## + ## Returns number of bytes (octets) needed to store private key ``key``. + var msg = initProtoBuffer() + msg.write(initProtoField(1, cast[uint64](key.scheme))) + msg.write(initProtoField(2, key.getRawBytes())) + msg.finish() + result = len(msg.buffer) + if len(data) >= result: + copyMem(addr data[0], addr msg.buffer[0], len(msg.buffer)) + +proc toBytes*(key: PublicKey, data: var openarray[byte]): int = + ## Serialize public key ``key`` (using libp2p protobuf scheme) and store + ## it to ``data``. + ## + ## Returns number of bytes (octets) needed to store public key ``key``. + var msg = initProtoBuffer() + msg.write(initProtoField(1, cast[uint64](key.scheme))) + msg.write(initProtoField(2, key.getRawBytes())) + msg.finish() + result = len(msg.buffer) + if len(data) >= result: + copyMem(addr data[0], addr msg.buffer[0], len(msg.buffer)) + +proc getBytes*(key: PrivateKey): seq[byte] = + ## Return private key ``key`` in binary form (using libp2p's protobuf + ## serialization). + var msg = initProtoBuffer() + msg.write(initProtoField(1, cast[uint64](key.scheme))) + msg.write(initProtoField(2, key.getRawBytes())) + msg.finish() + result = msg.buffer + +proc getBytes*(key: PublicKey): seq[byte] = + ## Return public key ``key`` in binary form (using libp2p's protobuf + ## serialization). + var msg = initProtoBuffer() + msg.write(initProtoField(1, cast[uint64](key.scheme))) + msg.write(initProtoField(2, key.getRawBytes())) + msg.finish() + result = msg.buffer + +proc init*(key: var PrivateKey, data: openarray[byte]): bool = + ## Initialize private key ``key`` from libp2p's protobuf serialized raw + ## binary form. + ## + ## Returns ``true`` on success. + var id: uint64 + var buffer: seq[byte] + if len(data) > 0: + var pb = initProtoBuffer(@data) + if pb.getVarintValue(1, id) != 0: + if pb.getBytes(2, buffer) != 0: + if cast[int8](id) in SupportedSchemesInt: + var scheme = cast[PKScheme](cast[int8](id)) + var nkey = PrivateKey(scheme: scheme) + if scheme == RSA: + if init(nkey.rsakey, buffer) == Asn1Status.Success: + key = nkey + result = true + elif scheme == Ed25519: + if init(nkey.edkey, buffer): + key = nkey + result = true + elif scheme == ECDSA: + if init(nkey.eckey, buffer) == Asn1Status.Success: + key = nkey + result = true + +proc init*(key: var PublicKey, data: openarray[byte]): bool = + ## Initialize public key ``key`` from libp2p's protobuf serialized raw + ## binary form. + ## + ## Returns ``true`` on success. + var id: uint64 + var buffer: seq[byte] + if len(data) > 0: + var pb = initProtoBuffer(@data) + if pb.getVarintValue(1, id) != 0: + if pb.getBytes(2, buffer) != 0: + if cast[int8](id) in SupportedSchemesInt: + var scheme = cast[PKScheme](cast[int8](id)) + var nkey = PublicKey(scheme: scheme) + if scheme == RSA: + if init(nkey.rsakey, buffer) == Asn1Status.Success: + key = nkey + result = true + elif scheme == Ed25519: + if init(nkey.edkey, buffer): + key = nkey + result = true + elif scheme == ECDSA: + if init(nkey.eckey, buffer) == Asn1Status.Success: + key = nkey + result = true + +proc init*(key: var PrivateKey, data: string): bool = + ## Initialize private key ``key`` from libp2p's protobuf serialized + ## hexadecimal string representation. + ## + ## Returns ``true`` on success. + result = key.init(fromHex(data)) + +proc init*(key: var PublicKey, data: string): bool = + ## Initialize public key ``key`` from libp2p's protobuf serialized + ## hexadecimal string representation. + ## + ## Returns ``true`` on success. + result = key.init(fromHex(data)) + +proc init*(t: typedesc[PrivateKey], data: openarray[byte]): PrivateKey = + ## Create new private key from libp2p's protobuf serialized binary form. + if not result.init(data): + raise newException(P2pKeyError, "Incorrect binary form") + +proc init*(t: typedesc[PublicKey], data: openarray[byte]): PublicKey = + ## Create new public key from libp2p's protobuf serialized binary form. + if not result.init(data): + raise newException(P2pKeyError, "Incorrect binary form") + +proc init*(t: typedesc[PrivateKey], data: string): PrivateKey = + ## Create new private key from libp2p's protobuf serialized hexadecimal string + ## form. + result = t.init(fromHex(data)) + +proc init*(t: typedesc[PublicKey], data: string): PublicKey = + ## Create new public key from libp2p's protobuf serialized hexadecimal string + ## form. + result = t.init(fromHex(data)) + +proc `==`*(key1, key2: PublicKey): bool = + ## Return ``true`` if two public keys ``key1`` and ``key2`` of the same + ## scheme and equal. + if key1.scheme == key2.scheme: + if key1.scheme == RSA: + result = (key1.rsakey == key2.rsakey) + elif key1.scheme == Ed25519: + result = (key1.edkey == key2.edkey) + elif key1.scheme == ECDSA: + result = (key1.eckey == key2.eckey) + +proc `==`*(key1, key2: PrivateKey): bool = + ## Return ``true`` if two private keys ``key1`` and ``key2`` of the same + ## scheme and equal. + if key1.scheme == key2.scheme: + if key1.scheme == RSA: + result = (key1.rsakey == key2.rsakey) + elif key1.scheme == Ed25519: + result = (key1.edkey == key2.edkey) + elif key1.scheme == ECDSA: + result = (key1.eckey == key2.eckey) + +proc `$`*(key: PrivateKey): string = + ## Get string representation of private key ``key``. + if key.scheme == RSA: + result = $(key.rsakey) + elif key.scheme == Ed25519: + result = "Ed25519 key (" + result.add($(key.edkey)) + result.add(")") + elif key.scheme == ECDSA: + result = "Secp256r1 key (" + result.add($(key.eckey)) + result.add(")") + +proc `$`*(key: PublicKey): string = + ## Get string representation of public key ``key``. + if key.scheme == RSA: + result = $(key.rsakey) + elif key.scheme == Ed25519: + result = "Ed25519 key (" + result.add($(key.edkey)) + result.add(")") + elif key.scheme == ECDSA: + result = "Secp256r1 key (" + result.add($(key.eckey)) + result.add(")") + +proc sign*(key: PrivateKey, data: openarray[byte]): seq[byte] = + ## Sign message ``data`` using private key ``key`` and return generated + ## signature in raw binary form. + if key.scheme == RSA: + var sig = key.rsakey.sign(data) + result = sig.getBytes() + elif key.scheme == Ed25519: + var sig = key.edkey.sign(data) + result = sig.getBytes() + elif key.scheme == ECDSA: + var sig = key.eckey.sign(data) + result = sig.getBytes() + +proc verify*(sig: openarray[byte], message: openarray[byte], + key: PublicKey): bool = + ## Verify signature ``sig`` using message ``message`` and public key ``key``. + ## Return ``true`` if message signature is valid. + if key.scheme == RSA: + var signature: RsaSignature + if signature.init(sig) == Asn1Status.Success: + result = signature.verify(message, key.rsakey) + elif key.scheme == Ed25519: + var signature: EdSignature + if signature.init(sig): + result = signature.verify(message, key.edkey) + elif key.scheme == ECDSA: + var signature: EcSignature + if signature.init(sig) == Asn1Status.Success: + result = signature.verify(message, key.eckey) + +template makeSecret(buffer, hmactype, secret, seed) = + var ctx: hmactype + var j = 0 + # We need to strip leading zeros, because Go bigint serialization do it. + var offset = 0 + for i in 0.. len(buffer): + todo = len(buffer) - j + copyMem(addr buffer[j], addr b.data[0], todo) + j += todo + ctx.init(secret.toOpenArray(offset, len(secret) - 1)) + ctx.update(a.data) + a = ctx.finish() + +proc stretchKeys*(cipherScheme: CipherScheme, hashScheme: DigestSheme, + secret: openarray[byte]): Secret = + ## Expand shared secret to cryptographic keys. + if cipherScheme == Aes128: + result.ivsize = aes128.sizeBlock + result.keysize = aes128.sizeKey + elif cipherScheme == Aes256: + result.ivsize = aes256.sizeBlock + result.keysize = aes256.sizeKey + elif cipherScheme == Blowfish: + result.ivsize = 8 + result.keysize = 32 + + var seed = "key expansion" + result.macsize = 20 + let length = result.ivsize + result.keysize + result.macsize + result.data = newSeq[byte](2 * length) + + if hashScheme == Sha256: + makeSecret(result.data, HMAC[sha256], secret, seed) + elif hashScheme == Sha512: + makeSecret(result.data, HMAC[sha512], secret, seed) + elif hashScheme == Sha1: + makeSecret(result.data, HMAC[sha1], secret, seed) + +template goffset*(secret, id, o: untyped): untyped = + id * (len(secret.data) shr 1) + o + +template ivOpenArray*(secret: Secret, id: int): untyped = + toOpenArray(secret.data, goffset(secret, id, 0), + goffset(secret, id, secret.ivsize - 1)) + +template keyOpenArray*(secret: Secret, id: int): untyped = + toOpenArray(secret.data, goffset(secret, id, secret.ivsize), + goffset(secret, id, secret.ivsize + secret.keysize - 1)) + +template macOpenArray*(secret: Secret, id: int): untyped = + toOpenArray(secret.data, goffset(secret, id, secret.ivsize + secret.keysize), + goffset(secret, id, secret.ivsize + secret.keysize + secret.macsize - 1)) + +proc iv*(secret: Secret, id: int): seq[byte] {.inline.} = + ## Get array of bytes with with initial vector. + result = newSeq[byte](secret.ivsize) + var offset = if id == 0: 0 else: (len(secret.data) div 2) + copyMem(addr result[0], unsafeAddr secret.data[offset], secret.ivsize) + +proc key*(secret: Secret, id: int): seq[byte] {.inline.} = + result = newSeq[byte](secret.keysize) + var offset = if id == 0: 0 else: (len(secret.data) div 2) + offset += secret.ivsize + copyMem(addr result[0], unsafeAddr secret.data[offset], secret.keysize) + +proc mac*(secret: Secret, id: int): seq[byte] {.inline.} = + result = newSeq[byte](secret.macsize) + var offset = if id == 0: 0 else: (len(secret.data) div 2) + offset += secret.ivsize + secret.keysize + copyMem(addr result[0], unsafeAddr secret.data[offset], secret.macsize) + +proc ephemeral*(scheme: ECDHEScheme): KeyPair = + ## Generate ephemeral keys used to perform ECDHE. + var keypair: EcKeyPair + if scheme == Secp256r1: + keypair = EcKeyPair.random(Secp256r1) + elif scheme == Secp384r1: + keypair = EcKeyPair.random(Secp384r1) + elif scheme == Secp521r1: + keypair = EcKeyPair.random(Secp521r1) + result.seckey = PrivateKey(scheme: ECDSA) + result.pubkey = PublicKey(scheme: ECDSA) + result.seckey.eckey = keypair.seckey + result.pubkey.eckey = keypair.pubkey + +proc makeSecret*(remoteEPublic: PublicKey, localEPrivate: PrivateKey, + data: var openarray[byte]): int = + ## Calculate shared secret using remote ephemeral public key + ## ``remoteEPublic`` and local ephemeral private key ``localEPrivate`` and + ## store shared secret to ``data`` + ## + ## Returns number of bytes (octets) used to store shared secret data, or + ## ``0`` on error. + if remoteEPublic.scheme == ECDSA: + if localEPrivate.scheme == remoteEPublic.scheme: + result = toSecret(remoteEPublic.eckey, localEPrivate.eckey, data) diff --git a/libp2p/crypto/ecnist.nim b/libp2p/crypto/ecnist.nim index 4c1c78775..52cedc826 100644 --- a/libp2p/crypto/ecnist.nim +++ b/libp2p/crypto/ecnist.nim @@ -29,6 +29,9 @@ const Sig256Length* = 64 Sig384Length* = 96 Sig521Length* = 132 + Secret256Length* = SecKey256Length + Secret384Length* = SecKey384Length + Secret521Length* = SecKey521Length type EcPrivateKey* = ref object @@ -727,11 +730,11 @@ proc toSecret*(pubkey: EcPublicKey, seckey: EcPrivateKey, var length = 0 if not isNil(mult): if seckey.key.curve == BR_EC_SECP256R1: - result = 32 + result = Secret256Length elif seckey.key.curve == BR_EC_SECP384R1: - result = 48 + result = Secret384Length elif seckey.key.curve == BR_EC_SECP521R1: - result = 66 + result = Secret521Length if len(data) >= result: var qplus1 = cast[pointer](cast[uint](mult.key.q) + 1'u) copyMem(addr data[0], qplus1, result) @@ -742,7 +745,7 @@ proc getSecret*(pubkey: EcPublicKey, seckey: EcPrivateKey): seq[byte] = ## shared secret. ## ## If error happens length of result array will be ``0``. - var data: array[66, byte] + var data: array[Secret521Length, byte] let res = toSecret(pubkey, seckey, data) if res > 0: result = newSeq[byte](res) diff --git a/tests/testcrypto.nim b/tests/testcrypto.nim new file mode 100644 index 000000000..65fc8dd2a --- /dev/null +++ b/tests/testcrypto.nim @@ -0,0 +1,398 @@ +## Nim-Libp2p +## Copyright (c) 2018 Status Research & Development GmbH +## Licensed under either of +## * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE)) +## * MIT license ([LICENSE-MIT](LICENSE-MIT)) +## at your option. +## This file may not be copied, modified, or distributed except according to +## those terms. + +## Test vectors was made using Go implementation +## https://github.com/libp2p/go-libp2p-crypto/blob/master/key.go +import unittest +import nimcrypto/utils +import ../libp2p/crypto/crypto + +const + PrivateKeys = [ + """080012BE023082013A020100024100AD8A7D5B0EB7C852C1464E4567651F412C + 692534E1600FDC5BDA9EDBFA9927AF0FFA7C52599BE62999E085C345D21C8D43 + 627CCC0E16D695C770E26D220AE709020301000102403B58BCFDC2CEBEC6EE29 + A8E2BB352DB71004F5205C62898A062F815C211AF722AADD1087C68E24015417 + E36632EEA2D2B1A20FF3D283A4C3881C724B3919FCF1022100D4BD1D7D15B328 + 4EFBBB5B2C6A11CFB7BCD9000C1010D69C808F370DFA751D47022100D0D4CB1B + BAB9F8C11376744F0D96D6E4BC2B12F4DF768AC9EEA79DAB24C8C12F02210089 + A3FA0A4E19E64083FA8A58C81FD2070CF651637C9988612584839855ADA44D02 + 20137DD91B5479693B743A992E8BC1297B9E08933361EC2996217D699D00C8F0 + 2702201A8D0497E8962E0AF5B15CA03085070F735B39876C54BA8908EDC87C42 + D9DADC""", + """080012E0043082025C02010002818100B91DCD5578C2FA3EA7D1DF62F59DEEDA + 834ECE568844554163E1803CDF4C2988BE182B8F957D3405BC745A33DA1E714A + BA13C316683767735ED72AE8B35648FD6E33A49D696FADB6499C63A09204F0BF + 77B44D3917DC746FB7B52040725746A3140E96E8682A02A4767C280DEFBE58C6 + ACB6DD1EE63F3F589F4C7941B27957F70203010001028180364CDFA66ABE06D9 + CA306DEE814DCA7A9E79C75CEAABE0B645AE2807B3188C36684C7EBAA7870A73 + 844C3D0968B9F5518E33ADCE2CD3D3ACABED41D0F08A26EE705E4277AF0D5816 + 491C626F6D2D5396A741B83D0730401B061A8C2DE19E18B07CE8798F387D4C79 + 78C92DA6F4080A45F93D0ADE50CF7E139DB7288EBA72D341024100DE9B394C60 + 6C396B65756CE4A2E3D77F66C3AFBDA0C09C3CD87EB60A35018BDA7D82FF119F + F6EBAAEC868E8ED1AD215C9EBF4073F26A1B187CDAFC862540B1C3024100D4E2 + D92E126D92B6795EBD7991A2D8A35147FAB73CFA4BBE74644CE8D1AEDE10A2FF + 33CEDF0B4961A89B1121C58D233309589BFBDE72D374ECB6A6859B0CC9BD0241 + 008B0ABB9C6831D11FB2CCC8CA7AB003BF9109B3B0A7430793BDCA4F9C4A857F + BC665F3740E400D02CFFF5FFFF571A63D73D54CA4661E942A965FB4675E7B8E4 + 0F02404A175D90DC57085DBBA60E79B6072030CF04272D08EAEFDBAC349053E3 + 4E61F916518D9D6D21477BD6AB896DE08C7B78B2C3051EC6CFDDEA6ECC2EEE87 + 050F5D02407BC18B68F253353D7DB89AA85A7CEC4069DAEB894828F83931ADC4 + 9A3255DFD0C9AAF9D09EBFAE831588A360EB0EEB89E45C9D136DCEEC8EAEBD3E + 65FBA9EE01""", + """080012A809308204A40201000282010100C8B014EC01E135D635F7E246BA7D42 + 3E2B36F45B052F0B644DA6B1B6DD964696F279BB9BB5F5C41EE3204F74EF70C2 + 28C8CDD97E4F19094274EB01C292EC25055CB3CECD1A41E8919A0C111602B1B8 + 5B4E43DBB2F4898C52738465F35E3085586CF01E407BE6CB5F0C08D0AD6D6FE0 + 2A43C932E124E9C8498E67BA323CC84A275ACCC20D586C04DAF54FE98018FF15 + 62E80514735A3237AA3C1DD2B4281FCAD3BD94952F0397A3F15B06269107C147 + C15645DCB507C566E66BF24E2745A05E4D31F364C2C50C0F5C9A6889378051BF + 05669EA905C2370548D6EF2CF66A4A5DC23F10B7614BC43CF0BFCC8711B6FF9F + 645FC2E5713ED1CB5975392B8C8652026902030100010282010018F9B0E0DE2B + 04E42FBB35B1CFAB9EFED5A9F5270EB2181CD77D1348CAB2D4FE1C17023E129B + 0F5938B2E0B090CBDB9DEFBF8E7DA5A25C00A54449E7C919125264830C0D8263 + 096A755D6312F62ADFE29D0EDCDC9C8A31A8612FECF0289CA93BA3F30E10C05A + AC9C9B86CD5187F91050B236EBDA1119F70F1065E04A383E44DC008A143630AD + B59064AB3D810C391B59BAEB8E7C29C38A6AD6B10EBAA456DCACFA00DB06CA61 + D630846EAF4B1A0292A695CBE5001BA8A2E419881263576358295E8B7A61E0A2 + 7EFCA0EC37810873792B0F80D2DD877DCE383A704DE13BC0E8EF6D1CF4C71DE7 + 306F6A0C3741DDCD81CF090746DD217925D5BEAF30B7D174B83102818100E35A + 50E392EF35CFFF9D24E0A71561E16E7CE99D13C3D9630305D74038F8F646D5CF + 440FEC38DFB145BAB25FA875C6B0B93DEF43CEDA51C52FF97BB02039913CD5BB + 36DB0D0B4DEAF0AF3A11D1DDD5991F18F6DDBEF4708B8B00DC6F99CC930E93D8 + 84BF118D204E9A83C7B2163252731813A67A4043459D943549D8AFAED7EF0281 + 8100E1F9A33FF755B1187302AD22B7C70FF2C6D4D5D8E765D337BECF3E417DDB + 57818588240F3A40FE2E6C73E3E0BA244FAFCC8988E010577AAD967D48203563 + 4CBA45B8166269E5E64214EB23CAE8B1619F3B7910FFE343E88B4E6CDC57CE8A + 736ECD5B8B455C4B004D7222298663EDD4A59BDB718CA436A86BC2BA53BC0E7D + B32702818100A5CFB7D0D1D7DE624D659980B2BAF8810628D9E47286D2E3D04F + 91364896E25EB50F0DEFA2F3B3C94136B162ECA4C0FD208CD8149727489DCCA8 + 629A085693E34F69D3CF1C8B530F76EC0528FBEB931DB2BD6D463A3F6259934E + 54769C2FC44CCC6D0C1BA1BC5084A3525AF13A190762E37B695E1DC2326283B5 + FD9EA83A974702818100C493B88AE5AB5AD2AD0210011AA40560A9CCEE76B0DD + 687F9EF283F2CEFC67441A18535E17CC0011FC705834DF58C5256625E2B72020 + 296D2673B7B1A51FCBD862DC0044FE606B0CE34BA6285682302D27BC6AA85F58 + 6CCBFA9E4293F3ED86FB4593B434D353BF609FBFCE25C57A5838F4BB522D0991 + 2EB40782B562EBAC37930281802E343D25B84AF8CAB1A298179FDE5F94D2EFF6 + 1E51EF4784E5BBE4DC230F17B884B0074CA4603416F72C10D9137D79E28967C4 + 8C0E4AEA1453952818FF9AD2FACCED7CE3A037D8545C151F57D35DED691CA53F + 8A5336590F7B080805A46701B01C9F9919E3890CA1A0373D909373638B57FD0C + 87627491C41F1BF1E9643DE7B4""", + """080012AD12308209290201000282020100E35735127777C52E66252B014E9650 + 01F3A515317B90DDAC8671F4F820AE67308DE2AA4162E99522CD6DA7EB9D7DB6 + 06489FEB77341A8FA058FAC832EE6EE5E978D512FF79461FC419A23B27C39C81 + BB635228B0DA5CFAE87080AC1AAE4619BF4576771E6E24A04D98D55ADA5CBA55 + 8EBE06ED14790D71438AFDC1FB9B4E2E623F221F8509A8CFE37265728EFBFAA6 + 0C76E6FBC4A473511CE6EE8A72C1CE1E5D67AB9FC4FA6FE797B854DFE7064C23 + 5ECB1379DB4B1E085F0042E19831D80CBE160A46C5154148A8D20E15C29F12AE + 208022EF094C5AC565153268DE8318CAFC82D2D71839EA136756FD4EBC3951F2 + 60EE5DA51A63D9AC7B80B7968D769CC82DCE2494BAFE9505C124E947E0E8D3F4 + A6B207EE195B3FFBFED028DCE59DB5CD60B1C6C316B4A712DAC2E8BF46E00611 + 6685BB77D56E00B2A63B74CFA5C7CAD003BD2DA9F865239DAB45FE52DAB9C792 + 8A705F3A0A3DCEC0B45A73DCE0A63DA1E24417ECD9C4B51342600CD2963BBA4F + A3DF170666B9804E1BCC9E7CF171571CB336F383B5A0FA375F7A7F72CC4F4460 + B8255F4F38556C360D712910B34A8ACE1C270175DFF5CECC7A34681835915BCE + 5FD4CA52D0F5A57685E28F5DCA1CA5A4410FDEAF516FC4F8226BCE2CFDBA9F83 + 0DD9A0903A18E009BBE818D52D11AD85974021CE0CC908DEC21FD6163EC7FD55 + 8150506FAE4FE6393EA3CC061EC9749DFD020301000102820200535C63E28C9A + 075C9729E3D60BDA0426630FD2709D8DA62B1FF5634D24B6AEB1D8251826F7BD + 0CE98108477D96F744AA9330C8A7A21C6733F5CCA7623D99BE8658BF50C30AD6 + 12C9D6586D768C3CB4396116FC42B51F4905B85306489644B02639B351C47FC0 + C06313BA9020E7C58F9FD2C03968BB66997499DFA8A4B8F2F701218342A986BC + 36D680D90023BBF3D1B55A5822539DB58735A0DC313A19249A6FC796DFF3DB9C + F2FFE8207F257862ACC9928F66AC69A3EE8FDF49A6ED26C1C11266848824B641 + 85021A5BFDD0AA81B005CCD6826E1768655F466180A0AED3858307F985D3A550 + D6A29AFC3145C582EDEC6B1B3D722AD0E37539E297BAF19655B3FD0DCBBF06DF + 65135B59D6FD56F2587523B231C7736A39D1C73967E56EF9E1D093DE6136F74A + CFABE1B0917F0C67724EA16FC7BD0CF57FF5AED3941AE5DA068A48B3F5726A56 + 223DAF96A24F0D4D22E2CE81B189D0A75A52ECFA50AEE24149E8285E2FD0892E + 0D028EE5F39CEF0C070418C3C8CEAE1243481417F2277FC9207E8F78841653AF + 674B1C37A6E9CBF4D9EAB1DB9B43D19AA1F4E24F7A6416A4EE6DB565CDD05616 + A33EF1A61D74DF07506ACAE38DE6820F384560D39A53DD35302CEC5CDF0A6E42 + 239EC3344EC5088C3E4787480F876223BBFCF70E48F39A37C4B43B33000F1D7B + 38128484865BC4E9614C3F8AB7FAB0829574ECFB30AAE5E954810282010100F9 + E86D7571EF36C6A6735EEDEE2AA87FA7A6D269B0EC79D6A4053BB7327ACBBE00 + 8C5C713A056FCEF6777A5A3BC0BE7DB5B94032425394EF579F9847041765E3A0 + 9E9DBD942C8C09BB8EBCB8F5E941055F75BCD2DB1337A93FE2D66B2D4F3F6741 + FAC20024402A067BD69892D830B8069D93AD3C47A46E12C78D6BA6292F3D3270 + 2F72DC29DF1FDA9BCE4467D13D0A7BA4A69E65B1205F443CB015533788B62919 + EEA289BA5BAC4B943DA27B611FAAE83119CD5F877763475109ACECC97018BBC4 + 973E34A83C09DD43EF6E4FBECC79BF8B5A9BDABEF78E139FFD5C549848B0B593 + 377F105F5A4B2B44FCACC4745C56B54ABAD14DF31ABF738861F032D48DDE5D02 + 82010100E8E1F25C4EDDF32B479E092C19C824DC02AF331570EE89A557F69936 + F40567377C1CFA0C077716EE8289D7F0467FA6CF96D483B62AFFCE075A8911EE + 47E77B56550F2874BA4FA9B6BDEB00606DFE4BE54A2257DCA1AB0B7C394973B3 + CAE48F9CB352452A6DDC1A8FA28AB85372F3E028C4CA44EE54EA61716F829FF9 + 6FABDEC82EE86B1213C5355778F0262F5E1DC5F292F4BD663D3C37438A4469BB + BDFCB3D0E0DE81C16154EBD1204F1D8AED4CFC97FFEB3066780EE143E78E2886 + 0FB637A62F3B6E85428C6FD4F357017AF9647E33E16D1DDF17FF524E53FB8E4D + 3FE2B24D5DE0FEC1F9D2A6EA9CC63A3AA406584651A2CA6EB7A68AE00E8332C2 + 185F842102820100367ACBF9F17793BA64A8FC05E488DA28D2149504437499EF + 07DCB832ECC746494A774EE3C42151498E0367E1E9EACFDC39D483C131226572 + 73E8AFDAB372A25CA8344BF0FB2F66EBEC3E66B7EFAC04E7B5F2C5D235BE0FC1 + 4ED315A951BC57F71BB41DBCC82A50BF0F1A2E32BCFC89F1AF42755E91C3AFD7 + 5A3763435AF11867397BAE8F7E754CCD6C6FE00BBDDA8FC17A987429791EB485 + FCB0EA4534F311BB0E132ECDD5998C8B016B1A53C94D8D058746B7B5DEA3513A + 47D953205F9D9756BFB9B4EEE7CA06E07CA1E2AB71CDC3B0D521509EB448E569 + 33D498DF3C3F847E60F49537AD81D2A74127D0461793D5B739EE5618A729AA98 + F61F5BACC917906502820101008F88DB810B56FF0E78D8ADDC91936B2C73371A + AC276BCE48AB7BA1195EB389D787D6B04303C2E1CE6584A22444BF5EC7E9B5D7 + EC4A7A59B8EC93390AFD246E3F5AB3BA029FE683BACF396D8501A64F8EE5EF5E + E9EC76E8E04ACABBD65FC219C5C23C7DC6D5E96831894428B1BE5313A0ED11A2 + 04A72FC29950DA58D13B83DA0ED5E288439F0DD87FAE598D9F7A49AD7C8218F8 + 37709C918F3E44464AE1A1440F04D9FF6D7A19063361CF816CE42FA42BE71F45 + 3892DCD0F8B25A4B1DBDC7586B4407446A3C0724D2429D289B6BE50567E29407 + 6A3E772E7A7A86BC415E93D1C39F8E1256EA2C6C9683C42595890D24114B35A3 + C133CE212051B1897259E55D210282010100999A507C3D551ECC5F68A63C80E5 + DC15177996E55203CDA99B69C1C6B4E2D7DE52660412BFD7CE9AC7C7427533A3 + A442DCA58CB14F7B776D3D9A681FC7D3762A789E4BFBC7D854704CFE1726154C + DB9F1DC399AF2A687AFB2FCBD110EBD5A00AE8CA70DA5C94670AF149B909BC91 + 829848B4479470D843E800D366F735F7BCE5F209775156FB57F6B77316CD54F2 + 558938D43D500160A280F299906C8119BF67E6B080522EB7BF074E3E20141EA3 + 4F4DAABB32A15D3693E301ED3F0E35F2F663EC3F3F93DD63063ECFB12FD29CCE + F01A15B0BE6BA9BB352F11FF7DC08DB863BE69A77E4F3644EA12F949A3167FC8 + 2E67516B0572EC62AB9F05775636808B9E3C""", + """08031279307702010104202D19BABF4420E2F25F075A71DA9DA86E29596C6013 + B8FD50D5999F98DF636226A00A06082A8648CE3D030107A14403420004AA407C + C163A2BFF807DAE1BB58A67A3C1A3C80CF83C31C9736607407137511F06812B6 + F497BA747F5CA6CB69E21ADA2F291A6040D2D58BD254E1ECCB13B72999""", + """08011240B9EA7F0357B5C1247E4FCB5AD09C46818ECB07318CA84711875F4C6C + E6B946186A4EB44E0D714B2A2D48263D75CF52D30BEF9D9AE2A9FEB7DAF1775F + E731065A""" + ] + + PublicKeys = [ + """0800125E305C300D06092A864886F70D0101010500034B003048024100AD8A7D + 5B0EB7C852C1464E4567651F412C692534E1600FDC5BDA9EDBFA9927AF0FFA7C + 52599BE62999E085C345D21C8D43627CCC0E16D695C770E26D220AE709020301 + 0001""", + """080012A20130819F300D06092A864886F70D010101050003818D003081890281 + 8100B91DCD5578C2FA3EA7D1DF62F59DEEDA834ECE568844554163E1803CDF4C + 2988BE182B8F957D3405BC745A33DA1E714ABA13C316683767735ED72AE8B356 + 48FD6E33A49D696FADB6499C63A09204F0BF77B44D3917DC746FB7B520407257 + 46A3140E96E8682A02A4767C280DEFBE58C6ACB6DD1EE63F3F589F4C7941B279 + 57F70203010001""", + """080012A60230820122300D06092A864886F70D01010105000382010F00308201 + 0A0282010100C8B014EC01E135D635F7E246BA7D423E2B36F45B052F0B644DA6 + B1B6DD964696F279BB9BB5F5C41EE3204F74EF70C228C8CDD97E4F19094274EB + 01C292EC25055CB3CECD1A41E8919A0C111602B1B85B4E43DBB2F4898C527384 + 65F35E3085586CF01E407BE6CB5F0C08D0AD6D6FE02A43C932E124E9C8498E67 + BA323CC84A275ACCC20D586C04DAF54FE98018FF1562E80514735A3237AA3C1D + D2B4281FCAD3BD94952F0397A3F15B06269107C147C15645DCB507C566E66BF2 + 4E2745A05E4D31F364C2C50C0F5C9A6889378051BF05669EA905C2370548D6EF + 2CF66A4A5DC23F10B7614BC43CF0BFCC8711B6FF9F645FC2E5713ED1CB597539 + 2B8C865202690203010001""", + """080012A60430820222300D06092A864886F70D01010105000382020F00308202 + 0A0282020100E35735127777C52E66252B014E965001F3A515317B90DDAC8671 + F4F820AE67308DE2AA4162E99522CD6DA7EB9D7DB606489FEB77341A8FA058FA + C832EE6EE5E978D512FF79461FC419A23B27C39C81BB635228B0DA5CFAE87080 + AC1AAE4619BF4576771E6E24A04D98D55ADA5CBA558EBE06ED14790D71438AFD + C1FB9B4E2E623F221F8509A8CFE37265728EFBFAA60C76E6FBC4A473511CE6EE + 8A72C1CE1E5D67AB9FC4FA6FE797B854DFE7064C235ECB1379DB4B1E085F0042 + E19831D80CBE160A46C5154148A8D20E15C29F12AE208022EF094C5AC5651532 + 68DE8318CAFC82D2D71839EA136756FD4EBC3951F260EE5DA51A63D9AC7B80B7 + 968D769CC82DCE2494BAFE9505C124E947E0E8D3F4A6B207EE195B3FFBFED028 + DCE59DB5CD60B1C6C316B4A712DAC2E8BF46E006116685BB77D56E00B2A63B74 + CFA5C7CAD003BD2DA9F865239DAB45FE52DAB9C7928A705F3A0A3DCEC0B45A73 + DCE0A63DA1E24417ECD9C4B51342600CD2963BBA4FA3DF170666B9804E1BCC9E + 7CF171571CB336F383B5A0FA375F7A7F72CC4F4460B8255F4F38556C360D7129 + 10B34A8ACE1C270175DFF5CECC7A34681835915BCE5FD4CA52D0F5A57685E28F + 5DCA1CA5A4410FDEAF516FC4F8226BCE2CFDBA9F830DD9A0903A18E009BBE818 + D52D11AD85974021CE0CC908DEC21FD6163EC7FD558150506FAE4FE6393EA3CC + 061EC9749DFD0203010001""", + """0803125B3059301306072A8648CE3D020106082A8648CE3D03010703420004AA + 407CC163A2BFF807DAE1BB58A67A3C1A3C80CF83C31C9736607407137511F068 + 12B6F497BA747F5CA6CB69E21ADA2F291A6040D2D58BD254E1ECCB13B72999""", + """080112206A4EB44E0D714B2A2D48263D75CF52D30BEF9D9AE2A9FEB7DAF1775F + E731065A""" + ] + + # Key expanding test vectors obtained from Go implementation + # https://github.com/libp2p/go-libp2p-crypto/blob/master/key.go + + Secrets = [ + # AES-128 SHA-256 + "4F13360145891C202B74FDCA838A85A37CBAEBF5E0774CC344BD6DABA9C4C86A", + """4ED31DA5EEA36277CA9E1C198F3EBB89AE4A6B18B76E48CAE8AEC23A7D0D4E8F + 700D6696AB01365278E5C45C2B4B1807""", + """01D4FBB5104F9B8DEDA95B447C1401A35F995B6BEFE20DBEFF9F7A13B7DA2831 + FB5A7EA194C4CE1ECE340B993C4C2C53FE641227DB7428B62BF4083686F6FF8F + BE8C""", + # Edge case (where Go implementation returns 65 bytes of secret) + # Nim implementation has leading `00`. + """00691BB84462F460D603B3F5FA0031D8DE195234C65B8890CBB6F84456E9718D + 4572749FC6040D0602698EEE6CCF6FB83101A26925D1A3AB40FB45BF98EAF06A + 2693""", + # AES-256 SHA-512 + "1F29EC3E0A07994D2ACCEA23A2F570DA9C7A7E39D5026FE6340C1E551E1ADAAF", + """85C20386C1EA1575DD8D111111DBC8B43CA630BEE4BB9AD91658719FF307C0BE + 0065935B8B849BE80E0D08A3D39098C3""", + """01779213E2993A77F1E1BB3B4DB77B5900B53A3A31CDE95D352C695643879824 + C8EE6501DC8679F5735869251256830A31357B34FF463B9292C02CD22CD30351 + C44F""", + # Edge case (where Go implementation returns 65 bytes of secret) + # Nim implementation has leading `00`. + """001CC33294544D898781010258C2FB81F02429D2DD54D0B59B8CD2335F57498F + D4E444BEC94DA7BE2BAF3E3796AFA8388F626AEB3178355991985EE5FFC9D1AA + CAD9""", + # AES-256 SHA-1 + "85076756644AAC06A47B29E25CB39B3E0C717152EE587F50C5A10281DB7F2FA5", + """256D46C5E5449AA7B9BE985646D5F32E455BB4B7AAF3566507A023B72801A7BC + 5066647E82DE2BC37FE22AB0DE440F77""", + """01FF82C71215CFFD7A42A5CED03BD2256D4A5B6850472A5C5CA90665D510F038 + A21F3A6EA0BB0A64113960C54DDAFC5E7A5F018E4413D7CC93C736A8D30579ED + 5A2B""", + # Edge case (where Go implementation returns 65 bytes of secret) + # Nim implementation has leading `00`. + """00360D9410E58534AC6A89CA5AC17E9455F619DCA71A6C2FB6F3156AE58DDB91 + 6E9A7D223D1D7DD05D5475BFC4C517C85475600AAF6F28703ED1203281369A41 + 9A7C""" + ] + + Ivs = [ + "F643627AA8B91D40BA644B894C7F148E", + "F1D6521E4EE59248F7CCFA6D6C916A32", + "937D77D24441858AF5040C9A81B3D178", + "C7D6AE667F38A3E0C77F4AC96D82112F", + "735E51C37802A6E72277EE74C829A84D", + "617BAEA342062AE87B7A5D5D9F99371C", + "B535FFA95043C90C5FEEF3654E846445", + "3B2D2219A7EE18AB9164910821955C05", + + "DACC23805C4ED233A7100A488AB5D68F", + "C5BFA3F8BF0D8436840D1AAAF091BD69", + "54CA4A681AEB8B5793A450100244256F", + "D1EB94C73D4C033EA4130B47669F4485", + "1F1ADF6BBDE1DFC5F922D672D2344F3A", + "A828F6D249F38A917CD297F7BDDE7B70", + "54FC8070579A17F6DAD342174062D60A", + "D33C7696183DA21C5CD40AB677BECE7C", + + "9EFF93741DC080A15B9E554080AB9869", + "7A007E351C9A5C930D01645D97648F8C", + "934DB2529D1D3AC37BAD56FD1E522196", + "30D19C3C1AB9A3391A5F88E92307261D", + "32ED1A961630D94A279F99757B3131CB", + "003ABE572377D59B74713425854FED29", + "3338850C0A4D7BD53C70E40FA0079AA2", + "62787F194DC218C5B0DAFD806F0D3125" + ] + + CipherKeys = [ + "8C2964320284FAD935AFEC1AFEC9EEF7", + "622A9292256B012F3EBE814C0DB22095", + "3171DCDBE794BB6CAADDDD71E1751F2C", + "5E1519DFCABA2AF17AA4AA580CC1B76E", + "8B7AC311FF7B7EA7B4E55E37688DA2BD", + "6BB6E06A3A92D5C300598023330712D4", + "D794A6B794C1E3501A24240D348B9A62", + "45E2FFAC35B7647AD5045C8581F39BF0", + + "B2F8CDBD11B158DC68120E10A6D04C0B272DC3F698EB56B18094275076307CEB", + "E0238BAA6B77646CD708DD00DE1FD17C6BB45F184348F512F4AE64E00CEA37B9", + "CE009DE8D1C76C2793540A8B24774E09B0F84590B583F1A0551AC0CF1E911BF9", + "ED5F14E36F4F2F80084571B24FD55C870B9C2AD937694B75B90E67D3591DC921", + "1607CC9FF2B19E8F0CDA902D5996948E8EA8CFFA03F956038497684088A88B2F", + "FC2797D1040FF162A90275EBA3FCC4330C2BDC28D23DA80B89842C2D7A6EFA06", + "B83698789ED8E3B44E48EAAEB291B3003AD95FAF344EBA1B9071F4FB46A4E4E9", + "5D90C579971B7B7F9ECDE55EBCE8921B807AAD45D61952228758BA80F4490E8F", + + "1C429A32A2E16168D3E3F942AEEAD708456C6566D800D5B7A6DCE8184739F16D", + "84987E7CC9F71243408454DD0787F438CCB62C79ED56078FD920FFFD7D5C44FF", + "971372E385E0F9FED8F67C922D0F5EB77D7D7818F63B26EF80C4D3C81D9E1B97", + "F20AE0A5387B2D1D38B8B340466D252F894C00C5907EE3A510442E4F38966AB0", + "B58F32D83C7A91B6B1DA731334D70502348CD82EFB8258C0AE316B983F2F1E1E", + "5903FE75A1C328BE6C98EB4A4EFF19C67D3C52C87B3131047F3773201D44BFCE", + "55EAD85B3124C36828ED3A43698952111EECE8C7FB156D71EE3F84E088B4F4CE", + "E4C99C782A88B69E5D83F4DEFDD2AE61A397486E17EC9EAE6EC679A75E47BBCD" + ] + + MacKeys = [ + "2C812CB8425299B485CEE0BC97778F540380F14F", + "8AB685E8A66256480E794B0ADC09BCF4014883C8", + "C68EF3F3102D0CEFC0924FEF17D51FABC23EA54C", + "F177BD066555CF25327C32C807D2E44B7DAC3EFF", + "57176FF3103FA0F4EB58B9E49133C48B4DE9BDE6", + "0C9ECECB80DF43CA2720DD340DD992A80AAB56DB", + "028BCC3F5559CF43DA1B0C1A03E263C90D04DD77", + "02DAF3FF888999C6121CA50F1D49C10FF55F1ACF", + + "6F015DDA49E0DFABD5532E6CB08709CE43F326EC", + "68C703B3867247723D21A8C58BA9109DDBB359EF", + "6C91DBB5FE99B94A11D0937D0F4E50F2BCB248F3", + "D5A856ECC5820D611111BE8CEAAD781E6E4E549D", + "9DCEB01D9657A69D40B1885C392FA850486E32B3", + "EE66A1579D732E99A8500F48595BF25289E722DB", + "E692EC73B0A2E68625221E1D01BA0E6B24BCB43F", + "8613E8F86D2DD1CF3CEDC52AD91423F2F31E0003", + + "F8A7EF47F37257B54A5028424E64F172E532E7E7", + "4D3596723AECD3DF21A20E956755782E783C9E4A", + "484860090D99F4B702C809294037E6C7F6E58BBA", + "15163D55C0A32E79E0EDD8E8EDA5AC9564B5488C", + "6116BCB44773E3342AB5671D2AC107D4C9EC0757", + "1CA3FCA023C72B7695481CA815856FEF0C5D7E9E", + "E34004C383C36201DC23E062DAE791C76738C28E", + "FA5CB0689A1DFDBAE8618BC079D70E318377B0DA" + ] + + + + +proc cmp(a, b: openarray[byte]): bool = + result = (@a == @b) + +proc testStretcher(s, e: int, cs: CipherScheme, ds: DigestSheme): bool = + for i in s..