From f020ff471213253e691be6a3c28261633cb71429 Mon Sep 17 00:00:00 2001 From: cheatfate Date: Fri, 30 Mar 2018 10:03:32 +0300 Subject: [PATCH] Finished with ECIES review and adopted tests. --- ethp2p/ecies.nim | 299 ++------------------------------------------ tests/testecies.nim | 194 ++++++++++++++-------------- 2 files changed, 106 insertions(+), 387 deletions(-) diff --git a/ethp2p/ecies.nim b/ethp2p/ecies.nim index 8ebc8ce..3f49f54 100644 --- a/ethp2p/ecies.nim +++ b/ethp2p/ecies.nim @@ -21,10 +21,8 @@ type EciesStatus* = enum Success, ## Operation was successful BufferOverrun, ## Output buffer size is too small - EmptyMessage, ## Attempt to encrypt/decrypt empty message RandomError, ## Could not obtain random data EcdhError, ## ECDH shared secret could not be calculated - IncorrectSize, ## ECIES data has incorrect size (size is too low) WrongHeader, ## ECIES header is incorrect IncorrectKey, ## Recovered public key is invalid IncorrectTag, ## ECIES tag verification failed @@ -72,11 +70,9 @@ proc kdf*(data: openarray[byte]): array[KeyLength, byte] {.noInit.} = var ctx: sha256 var counter: uint32 var counterLe: uint32 - let reps = ((KeyLength + 7) * 8) div (int(ctx.sizeDigest) * 8) + let reps = ((KeyLength + 7) * 8) div (int(ctx.sizeBlock) * 8) var offset = 0 - # REVIEW: There is a relationship between KeyLength and sha256.sizeDigest here - # that could be expressed in the code with a static assert. - var storage = newSeq[byte](KeyLength * (reps + 1)) + var storage = newSeq[byte](int(ctx.sizeDigest) * (reps + 1)) while counter <= uint32(reps): counter = counter + 1 counterLe = LSWAP(counter) @@ -91,14 +87,14 @@ proc kdf*(data: openarray[byte]): array[KeyLength, byte] {.noInit.} = proc eciesEncrypt*(input: openarray[byte], output: var openarray[byte], pubkey: PublicKey, - sharedmac: openarray[byte]): EciesStatus = + sharedmac: openarray[byte] = emptyMac): EciesStatus = ## Encrypt data with ECIES method using given public key `pubkey`. ## ``input`` - input data ## ``output`` - output data ## ``pubkey`` - ECC public key ## ``sharedmac`` - additional data used to calculate encrypted message MAC ## Length of output data can be calculated using ``eciesEncryptedLength()`` - ## macro. + ## template. var encKey: array[aes128.sizeKey, byte] cipher: CTR[aes128] @@ -138,7 +134,7 @@ proc eciesEncrypt*(input: openarray[byte], output: var openarray[byte], cipher.clear() so = eciesIvPos() - eo = so + aes128.sizeBlock + len(input) + eo = so + aes128.sizeBlock + len(input) - 1 ctx.init(macKey.data) ctx.update(toOpenArray(output, so, eo)) if len(sharedmac) > 0: @@ -146,7 +142,8 @@ proc eciesEncrypt*(input: openarray[byte], output: var openarray[byte], var tag = ctx.finish() so = eciesTagPos(len(input)) - copyMem(addr output[so], addr tag.data[0], ctx.sizeDigest) + # ctx.sizeDigest() crash compiler + copyMem(addr output[so], addr tag.data[0], sha256.sizeDigest) ctx.clear() result = Success @@ -154,14 +151,14 @@ proc eciesEncrypt*(input: openarray[byte], output: var openarray[byte], proc eciesDecrypt*(input: openarray[byte], output: var openarray[byte], seckey: PrivateKey, - sharedmac: openarray[byte]): EciesStatus = + sharedmac: openarray[byte] = emptyMac): EciesStatus = ## Decrypt data with ECIES method using given private key `seckey`. ## ``input`` - input data ## ``output`` - output data ## ``pubkey`` - ECC private key ## ``sharedmac`` - additional data used to calculate encrypted message MAC ## Length of output data can be calculated using ``eciesDecryptedLength()`` - ## macro. + ## template. var pubkey: PublicKey encKey: array[aes128.sizeKey, byte] @@ -194,7 +191,7 @@ proc eciesDecrypt*(input: openarray[byte], let datsize = eciesDecryptedLength(len(input)) ctx.init(macKey.data) burnMem(macKey) - ctx.update(toOpenArray(input, eciesIvPos(), eciesIvPos() + macsize)) + ctx.update(toOpenArray(input, eciesIvPos(), eciesIvPos() + macsize - 1)) if len(sharedmac) > 0: ctx.update(sharedmac) var tag = ctx.finish() @@ -206,279 +203,7 @@ proc eciesDecrypt*(input: openarray[byte], cipher.init(encKey, header.iv) burnMem(encKey) - cipher.decrypt(toOpenArray(input, eciesDataPos(), eciesDataPos() + datsize), - output) + cipher.decrypt(toOpenArray(input, eciesDataPos(), + eciesDataPos() + datsize - 1), output) cipher.clear() result = Success - - -# proc eciesEncrypt*(inp, oup: ptr byte, inl, oul: int, pubkey: PublicKey, -# shmac: ptr byte = nil, shlen: int = 0): EciesStatus = -# ## Encrypt data with ECIES method to the given public key `pubkey`. -# ## -# ## `inp` - [INPUT] pointer to input data -# ## `oup` - [INPUT] pointer to output data -# ## `inl` - [INPUT] input data size -# ## `oul` - [INPUT] output data size -# ## `pubkey` - [INPUT] Ecc secp256k1 public key -# ## `shmac` - [INPUT] additional mac data -# ## `shlen` - [INPUT] additional mac data size - -# var -# encKey: array[aes128.sizeKey, byte] -# cipher: CTR[aes128] -# ctx: HMAC[sha256] -# iv: array[aes128.sizeBlock, byte] -# secret: SharedSecret -# material: array[KeyLength, byte] - -# assert(not isNil(inp) and not isNil(oup)) -# assert(inl > 0 and oul > 0) - -# if oul < eciesEncryptedLength(inl): -# return(BufferOverrun) -# if randomBytes(addr iv[0], len(iv)) != len(iv): -# return(RandomError) - -# var ephemeral = newKeyPair() -# var output = cast[ptr UncheckedArray[byte]](oup) -# var epub = ephemeral.pubkey.getRaw() - -# if ecdhAgree(ephemeral.seckey, pubkey, secret) != EccStatus.Success: -# return(EcdhError) - -# material = kdf(secret) -# burnMem(secret) - -# copyMem(addr encKey[0], addr material[0], aes128.sizeKey) -# var macKey = sha256.digest(material, ostart = KeyLength div 2) -# burnMem(material) - -# var header = cast[ptr EciesHeader](oup) -# header.version = 0x04 -# header.pubkey = epub.data -# header.iv = iv - -# cipher.init(addr encKey[0], addr iv[0]) -# cipher.encrypt(inp, cast[ptr byte](addr header.data), uint(inl)) -# burnMem(encKey) -# cipher.clear() - -# ctx.init(cast[ptr byte](addr macKey.data[0]), uint(sha256.sizeDigest)) -# burnMem(macKey) -# ctx.update(cast[ptr byte](addr header.iv), uint(eciesMacLength(inl))) -# if not isNil(shmac) and shlen > 0: -# ctx.update(shmac, uint(shlen)) -# var tag = ctx.finish() -# ctx.clear() - -# # echo dump(output, oul) - -# let tagPos = cast[ptr byte](cast[uint](addr header.data) + uint(inl)) -# copyMem(tagPos, addr tag.data[0], sha256.sizeDigest) -# result = Success - -# proc eciesDecrypt*(inp, oup: ptr byte, inl, oul: int, seckey: PrivateKey, -# shmac: ptr byte = nil, shlen: int = 0): EciesStatus = -# ## Decrypt data with ECIES method using the given private key `seckey`. -# ## -# ## `inp` - [INPUT] pointer to input data -# ## `oup` - [INPUT] pointer to output data -# ## `inl` - [INPUT] input data size -# ## `oul` - [INPUT] output data size -# ## `seckey` - [INPUT] Ecc secp256k1 private key -# ## `shmac` - [INPUT] additional mac data (default = nil) -# ## `shlen` - [INPUT] additional mac data size (default = 0) - -# var -# pubkey: PublicKey -# encKey: array[aes128.sizeKey, byte] -# cipher: CTR[aes128] -# ctx: HMAC[sha256] -# secret: SharedSecret - -# assert(not isNil(inp) and not isNil(oup)) -# assert(inl > 0 and oul > 0) - -# var input = cast[ptr UncheckedArray[byte]](inp) -# if inl <= eciesOverheadLength(): -# return(IncorrectSize) -# if inl - eciesOverheadLength() > oul: -# return(BufferOverrun) - -# var header = cast[ptr EciesHeader](input) -# if header.version != 0x04: -# return(WrongHeader) - -# if recoverPublicKey(addr input[1], KeyLength * 2, -# pubkey) != EccStatus.Success: -# return(IncorrectKey) - -# if ecdhAgree(seckey, pubkey, secret) != EccStatus.Success: -# return(EcdhError) - -# var material = kdf(secret) -# burnMem(secret) -# copyMem(addr encKey[0], addr material[0], aes128.sizeKey) -# var macKey = sha256.digest(material, ostart = KeyLength div 2) -# burnMem(material) - -# let macsize = eciesMacLength(inl - eciesOverheadLength()) -# ctx.init(addr macKey.data[0], uint(sha256.sizeDigest)) -# burnMem(macKey) -# ctx.update(cast[ptr byte](addr header.iv), uint(macsize)) -# if not isNil(shmac) and shlen > 0: -# ctx.update(shmac, uint(shlen)) -# var tag = ctx.finish() -# ctx.clear() - -# if not equalMem(addr tag.data[0], addr input[eciesMacPos(inl)], -# sha256.sizeDigest): -# return(IncorrectTag) - -# cipher.init(addr encKey[0], cast[ptr byte](addr header.iv)) -# burnMem(encKey) -# cipher.decrypt(cast[ptr byte](addr header.data), -# cast[ptr byte](oup), uint(inl - eciesOverheadLength())) -# cipher.clear() -# result = Success - -# proc eciesEncrypt*[A, B](input: openarray[A], -# pubkey: PublicKey, -# output: var openarray[B], -# outlen: var int, -# ostart: int = 0, -# ofinish: int = -1): EciesStatus = -# ## Encrypt data with ECIES method to the given public key `pubkey`. -# ## -# ## `input` - [INPUT] input data -# ## `pubkey` - [INPUT] Ecc secp256k1 public key -# ## `output` - [OUTPUT] output data -# ## `outlen` - [OUTPUT] output data size -# ## `ostart` - [INPUT] starting index in `data` (default = -1, start of input) -# ## `ofinish` - [INPUT] ending index in `data` (default = -1, whole input) -# ## -# ## Encryption is done on `data` with inclusive range [ostart, ofinish] -# ## Negative values of `ostart` and `ofinish` are treated as index with value -# ## (len(data) + `ostart/ofinish`). - -# let so = if ostart < 0: (len(input) + ostart) else: ostart -# let eo = if ofinish < 0: (len(input) + ofinish) else: ofinish -# let length = (eo - so + 1) * sizeof(A) -# # We don't need to check `so` because compiler will do it for `data[so]`. -# if eo >= len(input): -# return(BufferOverrun) -# if len(input) == 0: -# return(EmptyMessage) -# let esize = eciesEncryptedLength(length) -# if (len(output) * sizeof(B)) < esize: -# return(BufferOverrun) -# outlen = esize -# result = eciesEncrypt(cast[ptr byte](unsafeAddr input[so]), addr output[0], -# length, esize, pubkey) - -# proc eciesEncrypt*[A, B, C](input: openarray[A], -# pubkey: PublicKey, -# output: var openarray[B], -# outlen: var int, -# shmac: openarray[C], -# ostart: int = 0, -# ofinish: int = -1): EciesStatus = -# ## Encrypt data with ECIES method to the given public key `pubkey`. -# ## -# ## `input` - [INPUT] input data -# ## `pubkey` - [INPUT] Ecc secp256k1 public key -# ## `output` - [OUTPUT] output data -# ## `outlen` - [OUTPUT] output data size -# ## `shmac` - [INPUT] additional mac data -# ## `ostart` - [INPUT] starting index in `data` (default = -1, start of input) -# ## `ofinish` - [INPUT] ending index in `data` (default = -1, whole input) -# ## -# ## Encryption is done on `data` with inclusive range [ostart, ofinish] -# ## Negative values of `ostart` and `ofinish` are treated as index with value -# ## (len(data) + `ostart/ofinish`). - -# let so = if ostart < 0: (len(input) + ostart) else: ostart -# let eo = if ofinish < 0: (len(input) + ofinish) else: ofinish -# let length = (eo - so + 1) * sizeof(A) -# # We don't need to check `so` because compiler will do it for `data[so]`. -# if eo >= len(input): -# return(BufferOverrun) -# if len(input) == 0: -# return(EmptyMessage) -# let esize = eciesEncryptedLength(length) -# if len(output) * sizeof(B) < esize: -# return(BufferOverrun) -# outlen = esize -# result = eciesEncrypt(cast[ptr byte](unsafeAddr input[so]), addr output[0], -# length, esize, pubkey, -# cast[ptr byte](unsafeAddr shmac[0]), -# len(shmac) * sizeof(C)) - -# proc eciesDecrypt*[A, B](input: openarray[A], -# seckey: PrivateKey, -# output: var openarray[B], -# outlen: var int, -# ostart: int = 0, -# ofinish: int = -1): EciesStatus = -# ## Decrypt data with ECIES method using given private key `seckey`. -# ## -# ## `input` - [INPUT] input data -# ## `seckey` - [INPUT] Ecc secp256k1 private key -# ## `output` - [OUTPUT] output data -# ## `outlen` - [OUTPUT] output data size -# ## `ostart` - [INPUT] starting index in `data` (default = -1, start of input) -# ## `ofinish` - [INPUT] ending index in `data` (default = -1, whole input) -# ## -# ## Decryption is done on `data` with inclusive range [ostart, ofinish] - -# let so = if ostart < 0: (len(input) + ostart) else: ostart -# let eo = if ofinish < 0: (len(input) + ofinish) else: ofinish -# let length = (eo - so + 1) * sizeof(A) -# # We don't need to check `so` because compiler will do it for `data[so]`. -# if eo >= len(input): -# return(BufferOverrun) -# if len(input) == 0: -# return(EmptyMessage) -# let dsize = eciesDecryptedLength(length) -# if len(output) * sizeof(B) < dsize: -# return(BufferOverrun) -# outlen = dsize -# result = eciesDecrypt(cast[ptr byte](unsafeAddr input[so]), addr output[0], -# length, dsize, seckey) - -# proc eciesDecrypt*[A, B, C](input: openarray[A], -# seckey: PrivateKey, -# output: var openarray[B], -# outlen: var int, -# shmac: openarray[C], -# ostart: int = 0, -# ofinish: int = -1): EciesStatus = -# ## Decrypt data with ECIES method using given private key `seckey`. -# ## -# ## `input` - [INPUT] input data -# ## `seckey` - [INPUT] Ecc secp256k1 private key -# ## `output` - [OUTPUT] output data -# ## `outlen` - [OUTPUT] output data size -# ## `shmac` - additional mac data -# ## `ostart` - starting index in `data` (default = -1, data[0]) -# ## `ofinish` - ending index in `data` (default = -1, data[len(data) - 1]) -# ## -# ## Decryption is done on `data` with inclusive range [ostart, ofinish] - -# let so = if ostart < 0: (len(input) + ostart) else: ostart -# let eo = if ofinish < 0: (len(input) + ofinish) else: ofinish -# let length = (eo - so + 1) * sizeof(A) -# # We don't need to check `so` because compiler will do it for `data[so]`. -# if eo >= len(input): -# return(BufferOverrun) -# if len(input) == 0: -# return(EmptyMessage) -# let dsize = eciesDecryptedLength(length) -# if len(output) * sizeof(B) < dsize: -# return(BufferOverrun) -# outlen = dsize -# result = eciesDecrypt(cast[ptr byte](unsafeAddr input[so]), addr output[0], -# length, dsize, seckey, -# cast[ptr byte](unsafeAddr shmac[0]), -# len(shmac) * sizeof(C)) diff --git a/tests/testecies.nim b/tests/testecies.nim index c34f4c7..f14bdc9 100644 --- a/tests/testecies.nim +++ b/tests/testecies.nim @@ -57,109 +57,103 @@ suite "ECIES test suite": var encr = newSeq[byte](eciesEncryptedLength(len(m))) var decr = newSeq[byte](len(m)) var shmac = [0x13'u8, 0x13'u8] - var outlen = 0 var s = newPrivateKey() var p = s.getPublicKey() check: # Without additional mac data - eciesEncrypt(plain, encr, p, [0'u8]) == EciesStatus.Success - eciesDecrypt(encr, decr, s, [0'u8]) == EciesStatus.Success - equalMem(addr m[0], addr decr[0], outlen) == true - # # With additional mac data - # eciesEncrypt(m, p, encr, outlen, shmac) == EciesStatus.Success - # eciesDecrypt(encr, s, decr, outlen, shmac) == EciesStatus.Success - # outlen == len(m) - # equalMem(addr m[0], addr decr[0], outlen) == true + eciesEncrypt(plain, encr, p) == EciesStatus.Success + eciesDecrypt(encr, decr, s) == EciesStatus.Success + equalMem(addr m[0], addr decr[0], len(m)) + # With additional mac data + eciesEncrypt(plain, encr, p, shmac) == EciesStatus.Success + eciesDecrypt(encr, decr, s, shmac) == EciesStatus.Success + equalMem(addr m[0], addr decr[0], len(m)) - # test "ECIES/py-evm/cpp-ethereum test_ecies.py#L43/rlpx.cpp#L187": - # # ECIES - # # https://github.com/ethereum/py-evm/blob/master/tests/p2p/test_ecies.py#L43 - # # https://github.com/ethereum/cpp-ethereum/blob/develop/test/unittests/libp2p/rlpx.cpp#L187 - # const secretKeys = [ - # "c45f950382d542169ea207959ee0220ec1491755abe405cd7498d6b16adb6df8", - # "5e173f6ac3c669587538e7727cf19b782a4f2fda07c1eaa662c593e5e85e3051" - # ] - # const cipherText = [ - # """04a0274c5951e32132e7f088c9bdfdc76c9d91f0dc6078e848f8e3361193dbdc - # 43b94351ea3d89e4ff33ddcefbc80070498824857f499656c4f79bbd97b6c51a - # 514251d69fd1785ef8764bd1d262a883f780964cce6a14ff206daf1206aa073a - # 2d35ce2697ebf3514225bef186631b2fd2316a4b7bcdefec8d75a1025ba2c540 - # 4a34e7795e1dd4bc01c6113ece07b0df13b69d3ba654a36e35e69ff9d482d88d - # 2f0228e7d96fe11dccbb465a1831c7d4ad3a026924b182fc2bdfe016a6944312 - # 021da5cc459713b13b86a686cf34d6fe6615020e4acf26bf0d5b7579ba813e77 - # 23eb95b3cef9942f01a58bd61baee7c9bdd438956b426a4ffe238e61746a8c93 - # d5e10680617c82e48d706ac4953f5e1c4c4f7d013c87d34a06626f498f34576d - # c017fdd3d581e83cfd26cf125b6d2bda1f1d56""", - # """049934a7b2d7f9af8fd9db941d9da281ac9381b5740e1f64f7092f3588d4f87f - # 5ce55191a6653e5e80c1c5dd538169aa123e70dc6ffc5af1827e546c0e958e42 - # dad355bcc1fcb9cdf2cf47ff524d2ad98cbf275e661bf4cf00960e74b5956b79 - # 9771334f426df007350b46049adb21a6e78ab1408d5e6ccde6fb5e69f0f4c92b - # b9c725c02f99fa72b9cdc8dd53cff089e0e73317f61cc5abf6152513cb7d833f - # 09d2851603919bf0fbe44d79a09245c6e8338eb502083dc84b846f2fee1cc310 - # d2cc8b1b9334728f97220bb799376233e113""" - # ] - # const expectText = [ - # """884c36f7ae6b406637c1f61b2f57e1d2cab813d24c6559aaf843c3f48962f32f - # 46662c066d39669b7b2e3ba14781477417600e7728399278b1b5d801a519aa57 - # 0034fdb5419558137e0d44cd13d319afe5629eeccb47fd9dfe55cc6089426e46 - # cc762dd8a0636e07a54b31169eba0c7a20a1ac1ef68596f1f283b5c676bae406 - # 4abfcce24799d09f67e392632d3ffdc12e3d6430dcb0ea19c318343ffa7aae74 - # d4cd26fecb93657d1cd9e9eaf4f8be720b56dd1d39f190c4e1c6b7ec66f077bb - # 1100""", - # """802b052f8b066640bba94a4fc39d63815c377fced6fcb84d27f791c9921ddf3e - # 9bf0108e298f490812847109cbd778fae393e80323fd643209841a3b7f110397 - # f37ec61d84cea03dcc5e8385db93248584e8af4b4d1c832d8c7453c0089687a7 - # 00""" - # ] - # var data: array[1024, byte] - # var outlen = 0 - # for i in 0..1: - # var s = secretKeys[i].getPrivateKey() - # var cipher = fromHex(stripSpaces(cipherText[i])) - # var expect = fromHex(stripSpaces(expectText[i])) - # check: - # eciesDecrypt(cipher, s, data, outlen) == EciesStatus.Success - # outlen == len(expect) - # compare(data, expect) == true + test "ECIES/py-evm/cpp-ethereum test_ecies.py#L43/rlpx.cpp#L187": + # ECIES + # https://github.com/ethereum/py-evm/blob/master/tests/p2p/test_ecies.py#L43 + # https://github.com/ethereum/cpp-ethereum/blob/develop/test/unittests/libp2p/rlpx.cpp#L187 + const secretKeys = [ + "c45f950382d542169ea207959ee0220ec1491755abe405cd7498d6b16adb6df8", + "5e173f6ac3c669587538e7727cf19b782a4f2fda07c1eaa662c593e5e85e3051" + ] + const cipherText = [ + """04a0274c5951e32132e7f088c9bdfdc76c9d91f0dc6078e848f8e3361193dbdc + 43b94351ea3d89e4ff33ddcefbc80070498824857f499656c4f79bbd97b6c51a + 514251d69fd1785ef8764bd1d262a883f780964cce6a14ff206daf1206aa073a + 2d35ce2697ebf3514225bef186631b2fd2316a4b7bcdefec8d75a1025ba2c540 + 4a34e7795e1dd4bc01c6113ece07b0df13b69d3ba654a36e35e69ff9d482d88d + 2f0228e7d96fe11dccbb465a1831c7d4ad3a026924b182fc2bdfe016a6944312 + 021da5cc459713b13b86a686cf34d6fe6615020e4acf26bf0d5b7579ba813e77 + 23eb95b3cef9942f01a58bd61baee7c9bdd438956b426a4ffe238e61746a8c93 + d5e10680617c82e48d706ac4953f5e1c4c4f7d013c87d34a06626f498f34576d + c017fdd3d581e83cfd26cf125b6d2bda1f1d56""", + """049934a7b2d7f9af8fd9db941d9da281ac9381b5740e1f64f7092f3588d4f87f + 5ce55191a6653e5e80c1c5dd538169aa123e70dc6ffc5af1827e546c0e958e42 + dad355bcc1fcb9cdf2cf47ff524d2ad98cbf275e661bf4cf00960e74b5956b79 + 9771334f426df007350b46049adb21a6e78ab1408d5e6ccde6fb5e69f0f4c92b + b9c725c02f99fa72b9cdc8dd53cff089e0e73317f61cc5abf6152513cb7d833f + 09d2851603919bf0fbe44d79a09245c6e8338eb502083dc84b846f2fee1cc310 + d2cc8b1b9334728f97220bb799376233e113""" + ] + const expectText = [ + """884c36f7ae6b406637c1f61b2f57e1d2cab813d24c6559aaf843c3f48962f32f + 46662c066d39669b7b2e3ba14781477417600e7728399278b1b5d801a519aa57 + 0034fdb5419558137e0d44cd13d319afe5629eeccb47fd9dfe55cc6089426e46 + cc762dd8a0636e07a54b31169eba0c7a20a1ac1ef68596f1f283b5c676bae406 + 4abfcce24799d09f67e392632d3ffdc12e3d6430dcb0ea19c318343ffa7aae74 + d4cd26fecb93657d1cd9e9eaf4f8be720b56dd1d39f190c4e1c6b7ec66f077bb + 1100""", + """802b052f8b066640bba94a4fc39d63815c377fced6fcb84d27f791c9921ddf3e + 9bf0108e298f490812847109cbd778fae393e80323fd643209841a3b7f110397 + f37ec61d84cea03dcc5e8385db93248584e8af4b4d1c832d8c7453c0089687a7 + 00""" + ] + var data: array[1024, byte] + for i in 0..1: + var s = secretKeys[i].getPrivateKey() + var cipher = fromHex(stripSpaces(cipherText[i])) + var expect = fromHex(stripSpaces(expectText[i])) + check: + eciesDecrypt(cipher, data, s) == EciesStatus.Success + compare(data, expect) == true - # test "ECIES/cpp-ethereum rlpx.cpp#L432-L459": - # # ECIES - # # https://github.com/ethereum/cpp-ethereum/blob/develop/test/unittests/libp2p/rlpx.cpp#L432-L459 - # const secretKeys = [ - # "57baf2c62005ddec64c357d96183ebc90bf9100583280e848aa31d683cad73cb", - # "472413e97f1fd58d84e28a559479e6b6902d2e8a0cee672ef38a3a35d263886b", - # "472413e97f1fd58d84e28a559479e6b6902d2e8a0cee672ef38a3a35d263886b", - # "472413e97f1fd58d84e28a559479e6b6902d2e8a0cee672ef38a3a35d263886b" - # ] - # const cipherData = [ - # """04ff2c874d0a47917c84eea0b2a4141ca95233720b5c70f81a8415bae1dc7b74 - # 6b61df7558811c1d6054333907333ef9bb0cc2fbf8b34abb9730d14e0140f455 - # 3f4b15d705120af46cf653a1dc5b95b312cf8444714f95a4f7a0425b67fc064d - # 18f4d0a528761565ca02d97faffdac23de10""", - # """046f647e1bd8a5cd1446d31513bac233e18bdc28ec0e59d46de453137a725995 - # 33f1e97c98154343420d5f16e171e5107999a7c7f1a6e26f57bcb0d2280655d0 - # 8fb148d36f1d4b28642d3bb4a136f0e33e3dd2e3cffe4b45a03fb7c5b5ea5e65 - # 617250fdc89e1a315563c20504b9d3a72555""", - # """0443c24d6ccef3ad095140760bb143078b3880557a06392f17c5e368502d7953 - # 2bc18903d59ced4bbe858e870610ab0d5f8b7963dd5c9c4cf81128d10efd7c7a - # a80091563c273e996578403694673581829e25a865191bdc9954db14285b56eb - # 0043b6288172e0d003c10f42fe413222e273d1d4340c38a2d8344d7aadcbc846 - # ee""", - # """04c4e40c86bb5324e017e598c6d48c19362ae527af8ab21b077284a4656c8735 - # e62d73fb3d740acefbec30ca4c024739a1fcdff69ecaf03301eebf156eb5f17c - # ca6f9d7a7e214a1f3f6e34d1ee0ec00ce0ef7d2b242fbfec0f276e17941f9f1b - # fbe26de10a15a6fac3cda039904ddd1d7e06e7b96b4878f61860e47f0b84c8ce - # b64f6a900ff23844f4359ae49b44154980a626d3c73226c19e""" - # ] - # const expectData = [ - # "a", "a", "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" - # ] - # var data: array[1024, byte] - # var outlen = 0 - # for i in 0..3: - # var s = secretKeys[i].getPrivateKey() - # var cipher = fromHex(stripSpaces(cipherData[i])) - # check: - # eciesDecrypt(cipher, s, data, outlen) == EciesStatus.Success - # outlen == len(expectData[i]) - # compare(data, expectData[i]) == true + test "ECIES/cpp-ethereum rlpx.cpp#L432-L459": + # ECIES + # https://github.com/ethereum/cpp-ethereum/blob/develop/test/unittests/libp2p/rlpx.cpp#L432-L459 + const secretKeys = [ + "57baf2c62005ddec64c357d96183ebc90bf9100583280e848aa31d683cad73cb", + "472413e97f1fd58d84e28a559479e6b6902d2e8a0cee672ef38a3a35d263886b", + "472413e97f1fd58d84e28a559479e6b6902d2e8a0cee672ef38a3a35d263886b", + "472413e97f1fd58d84e28a559479e6b6902d2e8a0cee672ef38a3a35d263886b" + ] + const cipherData = [ + """04ff2c874d0a47917c84eea0b2a4141ca95233720b5c70f81a8415bae1dc7b74 + 6b61df7558811c1d6054333907333ef9bb0cc2fbf8b34abb9730d14e0140f455 + 3f4b15d705120af46cf653a1dc5b95b312cf8444714f95a4f7a0425b67fc064d + 18f4d0a528761565ca02d97faffdac23de10""", + """046f647e1bd8a5cd1446d31513bac233e18bdc28ec0e59d46de453137a725995 + 33f1e97c98154343420d5f16e171e5107999a7c7f1a6e26f57bcb0d2280655d0 + 8fb148d36f1d4b28642d3bb4a136f0e33e3dd2e3cffe4b45a03fb7c5b5ea5e65 + 617250fdc89e1a315563c20504b9d3a72555""", + """0443c24d6ccef3ad095140760bb143078b3880557a06392f17c5e368502d7953 + 2bc18903d59ced4bbe858e870610ab0d5f8b7963dd5c9c4cf81128d10efd7c7a + a80091563c273e996578403694673581829e25a865191bdc9954db14285b56eb + 0043b6288172e0d003c10f42fe413222e273d1d4340c38a2d8344d7aadcbc846 + ee""", + """04c4e40c86bb5324e017e598c6d48c19362ae527af8ab21b077284a4656c8735 + e62d73fb3d740acefbec30ca4c024739a1fcdff69ecaf03301eebf156eb5f17c + ca6f9d7a7e214a1f3f6e34d1ee0ec00ce0ef7d2b242fbfec0f276e17941f9f1b + fbe26de10a15a6fac3cda039904ddd1d7e06e7b96b4878f61860e47f0b84c8ce + b64f6a900ff23844f4359ae49b44154980a626d3c73226c19e""" + ] + const expectData = [ + "a", "a", "aaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + ] + var data: array[1024, byte] + for i in 0..3: + var s = secretKeys[i].getPrivateKey() + var cipher = fromHex(stripSpaces(cipherData[i])) + check: + eciesDecrypt(cipher, data, s) == EciesStatus.Success + compare(data, expectData[i]) == true