From 89de6e1afe89670f022739cb720e4db0fb0a129e Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Fri, 31 Mar 2023 14:33:48 -0700 Subject: [PATCH 01/56] Move RSA (en|de)cryption out of the FIPS module. Change-Id: I330ac0fa7f0b2c9984d12da831d8f34019ea2c49 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58526 Reviewed-by: David Benjamin Commit-Queue: Adam Langley --- crypto/CMakeLists.txt | 1 + crypto/evp/p_rsa.c | 2 +- crypto/fipsmodule/rsa/internal.h | 30 +- crypto/fipsmodule/rsa/padding.c | 293 +--------------- crypto/fipsmodule/rsa/rsa.c | 77 +---- crypto/fipsmodule/rsa/rsa_impl.c | 155 +-------- crypto/rsa_extra/internal.h | 77 +++++ crypto/rsa_extra/rsa_crypt.c | 563 +++++++++++++++++++++++++++++++ 8 files changed, 670 insertions(+), 528 deletions(-) create mode 100644 crypto/rsa_extra/internal.h create mode 100644 crypto/rsa_extra/rsa_crypt.c diff --git a/crypto/CMakeLists.txt b/crypto/CMakeLists.txt index 6cc16a8b84..b45256cf03 100644 --- a/crypto/CMakeLists.txt +++ b/crypto/CMakeLists.txt @@ -204,6 +204,7 @@ add_library( refcount_c11.c refcount_lock.c rsa_extra/rsa_asn1.c + rsa_extra/rsa_crypt.c rsa_extra/rsa_print.c stack/stack.c siphash/siphash.c diff --git a/crypto/evp/p_rsa.c b/crypto/evp/p_rsa.c index dc224500c2..15eb1efbd4 100644 --- a/crypto/evp/p_rsa.c +++ b/crypto/evp/p_rsa.c @@ -67,7 +67,7 @@ #include #include "../internal.h" -#include "../fipsmodule/rsa/internal.h" +#include "../rsa_extra/internal.h" #include "internal.h" diff --git a/crypto/fipsmodule/rsa/internal.h b/crypto/fipsmodule/rsa/internal.h index d0b5a4ae86..12394a4454 100644 --- a/crypto/fipsmodule/rsa/internal.h +++ b/crypto/fipsmodule/rsa/internal.h @@ -67,6 +67,8 @@ extern "C" { #endif +#define RSA_PKCS1_PADDING_SIZE 11 + // Default implementations of RSA operations. const RSA_METHOD *RSA_default_method(void); @@ -75,8 +77,6 @@ size_t rsa_default_size(const RSA *rsa); int rsa_default_sign_raw(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, const uint8_t *in, size_t in_len, int padding); -int rsa_default_decrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, - const uint8_t *in, size_t in_len, int padding); int rsa_default_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in, size_t len); @@ -90,21 +90,13 @@ int BN_BLINDING_invert(BIGNUM *n, const BN_BLINDING *b, BN_MONT_CTX *mont_ctx, BN_CTX *ctx); +int PKCS1_MGF1(uint8_t *out, size_t len, const uint8_t *seed, size_t seed_len, + const EVP_MD *md); int RSA_padding_add_PKCS1_type_1(uint8_t *to, size_t to_len, const uint8_t *from, size_t from_len); int RSA_padding_check_PKCS1_type_1(uint8_t *out, size_t *out_len, size_t max_out, const uint8_t *from, size_t from_len); -int RSA_padding_add_PKCS1_type_2(uint8_t *to, size_t to_len, - const uint8_t *from, size_t from_len); -int RSA_padding_check_PKCS1_type_2(uint8_t *out, size_t *out_len, - size_t max_out, const uint8_t *from, - size_t from_len); -int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len, - size_t max_out, const uint8_t *from, - size_t from_len, const uint8_t *param, - size_t param_len, const EVP_MD *md, - const EVP_MD *mgf1md); int RSA_padding_add_none(uint8_t *to, size_t to_len, const uint8_t *from, size_t from_len); @@ -112,10 +104,16 @@ int RSA_padding_add_none(uint8_t *to, size_t to_len, const uint8_t *from, // within DoS bounds. int rsa_check_public_key(const RSA *rsa); -// RSA_private_transform calls either the method-specific |private_transform| -// function (if given) or the generic one. See the comment for -// |private_transform| in |rsa_meth_st|. -int RSA_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in, +// rsa_private_transform_no_self_test calls either the method-specific +// |private_transform| function (if given) or the generic one. See the comment +// for |private_transform| in |rsa_meth_st|. +int rsa_private_transform_no_self_test(RSA *rsa, uint8_t *out, + const uint8_t *in, size_t len); + +// rsa_private_transform acts the same as |rsa_private_transform_no_self_test| +// but, in FIPS mode, performs an RSA self test before calling the default RSA +// implementation. +int rsa_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in, size_t len); diff --git a/crypto/fipsmodule/rsa/padding.c b/crypto/fipsmodule/rsa/padding.c index 85f7835a64..998e4591a4 100644 --- a/crypto/fipsmodule/rsa/padding.c +++ b/crypto/fipsmodule/rsa/padding.c @@ -71,8 +71,6 @@ #include "../../internal.h" -#define RSA_PKCS1_PADDING_SIZE 11 - int RSA_padding_add_PKCS1_type_1(uint8_t *to, size_t to_len, const uint8_t *from, size_t from_len) { // See RFC 8017, section 9.2. @@ -146,109 +144,6 @@ int RSA_padding_check_PKCS1_type_1(uint8_t *out, size_t *out_len, return 1; } -static void rand_nonzero(uint8_t *out, size_t len) { - FIPS_service_indicator_lock_state(); - RAND_bytes(out, len); - - for (size_t i = 0; i < len; i++) { - while (out[i] == 0) { - RAND_bytes(out + i, 1); - } - } - - FIPS_service_indicator_unlock_state(); -} - -int RSA_padding_add_PKCS1_type_2(uint8_t *to, size_t to_len, - const uint8_t *from, size_t from_len) { - // See RFC 8017, section 7.2.1. - if (to_len < RSA_PKCS1_PADDING_SIZE) { - OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); - return 0; - } - - if (from_len > to_len - RSA_PKCS1_PADDING_SIZE) { - OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE); - return 0; - } - - to[0] = 0; - to[1] = 2; - - size_t padding_len = to_len - 3 - from_len; - rand_nonzero(to + 2, padding_len); - to[2 + padding_len] = 0; - OPENSSL_memcpy(to + to_len - from_len, from, from_len); - return 1; -} - -int RSA_padding_check_PKCS1_type_2(uint8_t *out, size_t *out_len, - size_t max_out, const uint8_t *from, - size_t from_len) { - if (from_len == 0) { - OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY); - return 0; - } - - // PKCS#1 v1.5 decryption. See "PKCS #1 v2.2: RSA Cryptography - // Standard", section 7.2.2. - if (from_len < RSA_PKCS1_PADDING_SIZE) { - // |from| is zero-padded to the size of the RSA modulus, a public value, so - // this can be rejected in non-constant time. - OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); - return 0; - } - - crypto_word_t first_byte_is_zero = constant_time_eq_w(from[0], 0); - crypto_word_t second_byte_is_two = constant_time_eq_w(from[1], 2); - - crypto_word_t zero_index = 0, looking_for_index = CONSTTIME_TRUE_W; - for (size_t i = 2; i < from_len; i++) { - crypto_word_t equals0 = constant_time_is_zero_w(from[i]); - zero_index = - constant_time_select_w(looking_for_index & equals0, i, zero_index); - looking_for_index = constant_time_select_w(equals0, 0, looking_for_index); - } - - // The input must begin with 00 02. - crypto_word_t valid_index = first_byte_is_zero; - valid_index &= second_byte_is_two; - - // We must have found the end of PS. - valid_index &= ~looking_for_index; - - // PS must be at least 8 bytes long, and it starts two bytes into |from|. - valid_index &= constant_time_ge_w(zero_index, 2 + 8); - - // Skip the zero byte. - zero_index++; - - // NOTE: Although this logic attempts to be constant time, the API contracts - // of this function and |RSA_decrypt| with |RSA_PKCS1_PADDING| make it - // impossible to completely avoid Bleichenbacher's attack. Consumers should - // use |RSA_PADDING_NONE| and perform the padding check in constant-time - // combined with a swap to a random session key or other mitigation. - CONSTTIME_DECLASSIFY(&valid_index, sizeof(valid_index)); - CONSTTIME_DECLASSIFY(&zero_index, sizeof(zero_index)); - - if (!valid_index) { - OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR); - return 0; - } - - const size_t msg_len = from_len - zero_index; - if (msg_len > max_out) { - // This shouldn't happen because this function is always called with - // |max_out| as the key size and |from_len| is bounded by the key size. - OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR); - return 0; - } - - OPENSSL_memcpy(out, &from[zero_index], msg_len); - *out_len = msg_len; - return 1; -} - int RSA_padding_add_none(uint8_t *to, size_t to_len, const uint8_t *from, size_t from_len) { if (from_len > to_len) { @@ -265,8 +160,8 @@ int RSA_padding_add_none(uint8_t *to, size_t to_len, const uint8_t *from, return 1; } -static int PKCS1_MGF1(uint8_t *out, size_t len, const uint8_t *seed, - size_t seed_len, const EVP_MD *md) { +int PKCS1_MGF1(uint8_t *out, size_t len, const uint8_t *seed, size_t seed_len, + const EVP_MD *md) { int ret = 0; EVP_MD_CTX ctx; EVP_MD_CTX_init(&ctx); @@ -310,184 +205,6 @@ static int PKCS1_MGF1(uint8_t *out, size_t len, const uint8_t *seed, return ret; } -int RSA_padding_add_PKCS1_OAEP_mgf1(uint8_t *to, size_t to_len, - const uint8_t *from, size_t from_len, - const uint8_t *param, size_t param_len, - const EVP_MD *md, const EVP_MD *mgf1md) { - if (md == NULL) { - md = EVP_sha1(); - } - if (mgf1md == NULL) { - mgf1md = md; - } - - size_t mdlen = EVP_MD_size(md); - - if (to_len < 2 * mdlen + 2) { - OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); - return 0; - } - - size_t emlen = to_len - 1; - if (from_len > emlen - 2 * mdlen - 1) { - OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE); - return 0; - } - - if (emlen < 2 * mdlen + 1) { - OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); - return 0; - } - - to[0] = 0; - uint8_t *seed = to + 1; - uint8_t *db = to + mdlen + 1; - - uint8_t *dbmask = NULL; - int ret = 0; - FIPS_service_indicator_lock_state(); - if (!EVP_Digest(param, param_len, db, NULL, md, NULL)) { - goto out; - } - OPENSSL_memset(db + mdlen, 0, emlen - from_len - 2 * mdlen - 1); - db[emlen - from_len - mdlen - 1] = 0x01; - OPENSSL_memcpy(db + emlen - from_len - mdlen, from, from_len); - if (!RAND_bytes(seed, mdlen)) { - goto out; - } - - dbmask = OPENSSL_malloc(emlen - mdlen); - if (dbmask == NULL) { - goto out; - } - - if (!PKCS1_MGF1(dbmask, emlen - mdlen, seed, mdlen, mgf1md)) { - goto out; - } - for (size_t i = 0; i < emlen - mdlen; i++) { - db[i] ^= dbmask[i]; - } - - uint8_t seedmask[EVP_MAX_MD_SIZE]; - if (!PKCS1_MGF1(seedmask, mdlen, db, emlen - mdlen, mgf1md)) { - goto out; - } - for (size_t i = 0; i < mdlen; i++) { - seed[i] ^= seedmask[i]; - } - ret = 1; - -out: - OPENSSL_free(dbmask); - FIPS_service_indicator_unlock_state(); - return ret; -} - -int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len, - size_t max_out, const uint8_t *from, - size_t from_len, const uint8_t *param, - size_t param_len, const EVP_MD *md, - const EVP_MD *mgf1md) { - uint8_t *db = NULL; - - if (md == NULL) { - md = EVP_sha1(); - } - if (mgf1md == NULL) { - mgf1md = md; - } - - size_t mdlen = EVP_MD_size(md); - - // The encoded message is one byte smaller than the modulus to ensure that it - // doesn't end up greater than the modulus. Thus there's an extra "+1" here - // compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2. - if (from_len < 1 + 2*mdlen + 1) { - // 'from_len' is the length of the modulus, i.e. does not depend on the - // particular ciphertext. - goto decoding_err; - } - - size_t dblen = from_len - mdlen - 1; - FIPS_service_indicator_lock_state(); - db = OPENSSL_malloc(dblen); - if (db == NULL) { - goto err; - } - - const uint8_t *maskedseed = from + 1; - const uint8_t *maskeddb = from + 1 + mdlen; - - uint8_t seed[EVP_MAX_MD_SIZE]; - if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) { - goto err; - } - for (size_t i = 0; i < mdlen; i++) { - seed[i] ^= maskedseed[i]; - } - - if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) { - goto err; - } - for (size_t i = 0; i < dblen; i++) { - db[i] ^= maskeddb[i]; - } - - uint8_t phash[EVP_MAX_MD_SIZE]; - if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) { - goto err; - } - - crypto_word_t bad = ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen)); - bad |= ~constant_time_is_zero_w(from[0]); - - crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W; - size_t one_index = 0; - for (size_t i = mdlen; i < dblen; i++) { - crypto_word_t equals1 = constant_time_eq_w(db[i], 1); - crypto_word_t equals0 = constant_time_eq_w(db[i], 0); - one_index = - constant_time_select_w(looking_for_one_byte & equals1, i, one_index); - looking_for_one_byte = - constant_time_select_w(equals1, 0, looking_for_one_byte); - bad |= looking_for_one_byte & ~equals0; - } - - bad |= looking_for_one_byte; - - // Whether the overall padding was valid or not in OAEP is public. - if (constant_time_declassify_w(bad)) { - goto decoding_err; - } - - // Once the padding is known to be valid, the output length is also public. - static_assert(sizeof(size_t) <= sizeof(crypto_word_t), - "size_t does not fit in crypto_word_t"); - one_index = constant_time_declassify_w(one_index); - - one_index++; - size_t mlen = dblen - one_index; - if (max_out < mlen) { - OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); - goto err; - } - - OPENSSL_memcpy(out, db + one_index, mlen); - *out_len = mlen; - OPENSSL_free(db); - FIPS_service_indicator_unlock_state(); - return 1; - -decoding_err: - // To avoid chosen ciphertext attacks, the error message should not reveal - // which kind of decoding error happened. - OPENSSL_PUT_ERROR(RSA, RSA_R_OAEP_DECODING_ERROR); - err: - OPENSSL_free(db); - FIPS_service_indicator_unlock_state(); - return 0; -} - static const uint8_t kPSSZeroes[] = {0, 0, 0, 0, 0, 0, 0, 0}; int RSA_verify_PKCS1_PSS_mgf1(const RSA *rsa, const uint8_t *mHash, @@ -504,9 +221,9 @@ int RSA_verify_PKCS1_PSS_mgf1(const RSA *rsa, const uint8_t *mHash, FIPS_service_indicator_lock_state(); // Negative sLen has special meanings: - // -1 sLen == hLen - // -2 salt length is autorecovered from signature - // -N reserved + // -1 sLen == hLen + // -2 salt length is autorecovered from signature + // -N reserved size_t hLen = EVP_MD_size(Hash); if (sLen == -1) { sLen = (int)hLen; diff --git a/crypto/fipsmodule/rsa/rsa.c b/crypto/fipsmodule/rsa/rsa.c index 2139275f82..dffc8aa1ba 100644 --- a/crypto/fipsmodule/rsa/rsa.c +++ b/crypto/fipsmodule/rsa/rsa.c @@ -288,21 +288,6 @@ int RSA_set0_crt_params(RSA *rsa, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp) { return 1; } -int RSA_public_encrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, - int padding) { - size_t out_len; - - if (!RSA_encrypt(rsa, &out_len, to, RSA_size(rsa), from, flen, padding)) { - return -1; - } - - if (out_len > INT_MAX) { - OPENSSL_PUT_ERROR(RSA, ERR_R_OVERFLOW); - return -1; - } - return (int)out_len; -} - static int rsa_sign_raw_no_self_test(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, const uint8_t *in, size_t in_len, int padding) { @@ -320,58 +305,6 @@ int RSA_sign_raw(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, padding); } -int RSA_private_encrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, - int padding) { - size_t out_len; - - if (!RSA_sign_raw(rsa, &out_len, to, RSA_size(rsa), from, flen, padding)) { - return -1; - } - - if (out_len > INT_MAX) { - OPENSSL_PUT_ERROR(RSA, ERR_R_OVERFLOW); - return -1; - } - return (int)out_len; -} - -int RSA_decrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, - const uint8_t *in, size_t in_len, int padding) { - if (rsa->meth->decrypt) { - return rsa->meth->decrypt(rsa, out_len, out, max_out, in, in_len, padding); - } - - return rsa_default_decrypt(rsa, out_len, out, max_out, in, in_len, padding); -} - -int RSA_private_decrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, - int padding) { - size_t out_len; - if (!RSA_decrypt(rsa, &out_len, to, RSA_size(rsa), from, flen, padding)) { - return -1; - } - - if (out_len > INT_MAX) { - OPENSSL_PUT_ERROR(RSA, ERR_R_OVERFLOW); - return -1; - } - return (int)out_len; -} - -int RSA_public_decrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, - int padding) { - size_t out_len; - if (!RSA_verify_raw(rsa, &out_len, to, RSA_size(rsa), from, flen, padding)) { - return -1; - } - - if (out_len > INT_MAX) { - OPENSSL_PUT_ERROR(RSA, ERR_R_OVERFLOW); - return -1; - } - return (int)out_len; -} - unsigned RSA_size(const RSA *rsa) { size_t ret = rsa->meth->size ? rsa->meth->size(rsa) : rsa_default_size(rsa); // RSA modulus sizes are bounded by |BIGNUM|, which must fit in |unsigned|. @@ -962,8 +895,8 @@ int RSA_check_fips(RSA *key) { return ret; } -int RSA_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in, - size_t len) { +int rsa_private_transform_no_self_test(RSA *rsa, uint8_t *out, + const uint8_t *in, size_t len) { if (rsa->meth->private_transform) { return rsa->meth->private_transform(rsa, out, in, len); } @@ -971,6 +904,12 @@ int RSA_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in, return rsa_default_private_transform(rsa, out, in, len); } +int rsa_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in, + size_t len) { + boringssl_ensure_rsa_self_test(); + return rsa_private_transform_no_self_test(rsa, out, in, len); +} + int RSA_flags(const RSA *rsa) { return rsa->flags; } int RSA_test_flags(const RSA *rsa, int flags) { return rsa->flags & flags; } diff --git a/crypto/fipsmodule/rsa/rsa_impl.c b/crypto/fipsmodule/rsa/rsa_impl.c index 4500b1a808..dabcd2fc02 100644 --- a/crypto/fipsmodule/rsa/rsa_impl.c +++ b/crypto/fipsmodule/rsa/rsa_impl.c @@ -266,94 +266,6 @@ size_t rsa_default_size(const RSA *rsa) { return BN_num_bytes(rsa->n); } -int RSA_encrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, - const uint8_t *in, size_t in_len, int padding) { - boringssl_ensure_rsa_self_test(); - - if (!rsa_check_public_key(rsa)) { - return 0; - } - - const unsigned rsa_size = RSA_size(rsa); - BIGNUM *f, *result; - uint8_t *buf = NULL; - BN_CTX *ctx = NULL; - int i, ret = 0; - - if (max_out < rsa_size) { - OPENSSL_PUT_ERROR(RSA, RSA_R_OUTPUT_BUFFER_TOO_SMALL); - return 0; - } - - ctx = BN_CTX_new(); - if (ctx == NULL) { - goto err; - } - - BN_CTX_start(ctx); - f = BN_CTX_get(ctx); - result = BN_CTX_get(ctx); - buf = OPENSSL_malloc(rsa_size); - if (!f || !result || !buf) { - goto err; - } - - switch (padding) { - case RSA_PKCS1_PADDING: - i = RSA_padding_add_PKCS1_type_2(buf, rsa_size, in, in_len); - break; - case RSA_PKCS1_OAEP_PADDING: - // Use the default parameters: SHA-1 for both hashes and no label. - i = RSA_padding_add_PKCS1_OAEP_mgf1(buf, rsa_size, in, in_len, - NULL, 0, NULL, NULL); - break; - case RSA_NO_PADDING: - i = RSA_padding_add_none(buf, rsa_size, in, in_len); - break; - default: - OPENSSL_PUT_ERROR(RSA, RSA_R_UNKNOWN_PADDING_TYPE); - goto err; - } - - if (i <= 0) { - goto err; - } - - if (BN_bin2bn(buf, rsa_size, f) == NULL) { - goto err; - } - - if (BN_ucmp(f, rsa->n) >= 0) { - // usually the padding functions would catch this - OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_MODULUS); - goto err; - } - - if (!BN_MONT_CTX_set_locked(&rsa->mont_n, &rsa->lock, rsa->n, ctx) || - !BN_mod_exp_mont(result, f, rsa->e, &rsa->mont_n->N, ctx, rsa->mont_n)) { - goto err; - } - - // put in leading 0 bytes if the number is less than the length of the - // modulus - if (!BN_bn2bin_padded(out, rsa_size, result)) { - OPENSSL_PUT_ERROR(RSA, ERR_R_INTERNAL_ERROR); - goto err; - } - - *out_len = rsa_size; - ret = 1; - -err: - if (ctx != NULL) { - BN_CTX_end(ctx); - BN_CTX_free(ctx); - } - OPENSSL_free(buf); - - return ret; -} - // MAX_BLINDINGS_PER_RSA defines the maximum number of cached BN_BLINDINGs per // RSA*. Then this limit is exceeded, BN_BLINDING objects will be created and // destroyed as needed. @@ -516,7 +428,7 @@ int rsa_default_sign_raw(RSA *rsa, size_t *out_len, uint8_t *out, goto err; } - if (!RSA_private_transform(rsa, out, buf, rsa_size)) { + if (!rsa_private_transform_no_self_test(rsa, out, buf, rsa_size)) { goto err; } @@ -530,71 +442,6 @@ int rsa_default_sign_raw(RSA *rsa, size_t *out_len, uint8_t *out, return ret; } -int rsa_default_decrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, - const uint8_t *in, size_t in_len, int padding) { - boringssl_ensure_rsa_self_test(); - - const unsigned rsa_size = RSA_size(rsa); - uint8_t *buf = NULL; - int ret = 0; - - if (max_out < rsa_size) { - OPENSSL_PUT_ERROR(RSA, RSA_R_OUTPUT_BUFFER_TOO_SMALL); - return 0; - } - - if (padding == RSA_NO_PADDING) { - buf = out; - } else { - // Allocate a temporary buffer to hold the padded plaintext. - buf = OPENSSL_malloc(rsa_size); - if (buf == NULL) { - goto err; - } - } - - if (in_len != rsa_size) { - OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_LEN_NOT_EQUAL_TO_MOD_LEN); - goto err; - } - - if (!RSA_private_transform(rsa, buf, in, rsa_size)) { - goto err; - } - - switch (padding) { - case RSA_PKCS1_PADDING: - ret = - RSA_padding_check_PKCS1_type_2(out, out_len, rsa_size, buf, rsa_size); - break; - case RSA_PKCS1_OAEP_PADDING: - // Use the default parameters: SHA-1 for both hashes and no label. - ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, out_len, rsa_size, buf, - rsa_size, NULL, 0, NULL, NULL); - break; - case RSA_NO_PADDING: - *out_len = rsa_size; - ret = 1; - break; - default: - OPENSSL_PUT_ERROR(RSA, RSA_R_UNKNOWN_PADDING_TYPE); - goto err; - } - - CONSTTIME_DECLASSIFY(&ret, sizeof(ret)); - if (!ret) { - OPENSSL_PUT_ERROR(RSA, RSA_R_PADDING_CHECK_FAILED); - } else { - CONSTTIME_DECLASSIFY(out, *out_len); - } - -err: - if (padding != RSA_NO_PADDING) { - OPENSSL_free(buf); - } - - return ret; -} static int mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx); diff --git a/crypto/rsa_extra/internal.h b/crypto/rsa_extra/internal.h new file mode 100644 index 0000000000..6317cfc01c --- /dev/null +++ b/crypto/rsa_extra/internal.h @@ -0,0 +1,77 @@ +/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) + * All rights reserved. + * + * This package is an SSL implementation written + * by Eric Young (eay@cryptsoft.com). + * The implementation was written so as to conform with Netscapes SSL. + * + * This library is free for commercial and non-commercial use as long as + * the following conditions are aheared to. The following conditions + * apply to all code found in this distribution, be it the RC4, RSA, + * lhash, DES, etc., code; not just the SSL code. The SSL documentation + * included with this distribution is covered by the same copyright terms + * except that the holder is Tim Hudson (tjh@cryptsoft.com). + * + * Copyright remains Eric Young's, and as such any Copyright notices in + * the code are not to be removed. + * If this package is used in a product, Eric Young should be given attribution + * as the author of the parts of the library used. + * This can be in the form of a textual message at program startup or + * in documentation (online or textual) provided with the package. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * "This product includes cryptographic software written by + * Eric Young (eay@cryptsoft.com)" + * The word 'cryptographic' can be left out if the rouines from the library + * being used are not cryptographic related :-). + * 4. If you include any Windows specific code (or a derivative thereof) from + * the apps directory (application code) you must include an acknowledgement: + * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" + * + * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * The licence and distribution terms for any publically available version or + * derivative of this code cannot be changed. i.e. this code cannot simply be + * copied and put under another distribution licence + * [including the GNU Public Licence.] */ + + +#ifndef OPENSSL_HEADER_RSA_EXTRA_INTERNAL_H +#define OPENSSL_HEADER_RSA_EXTRA_INTERNAL_H + +#if defined(__cplusplus) +extern "C" { +#endif + + +int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len, + size_t max_out, const uint8_t *from, + size_t from_len, const uint8_t *param, + size_t param_len, const EVP_MD *md, + const EVP_MD *mgf1md); + + +#if defined(__cplusplus) +} // extern C +#endif + +#endif // OPENSSL_HEADER_RSA_EXTRA_INTERNAL_H diff --git a/crypto/rsa_extra/rsa_crypt.c b/crypto/rsa_extra/rsa_crypt.c new file mode 100644 index 0000000000..97afa3db34 --- /dev/null +++ b/crypto/rsa_extra/rsa_crypt.c @@ -0,0 +1,563 @@ +/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) + * All rights reserved. + * + * This package is an SSL implementation written + * by Eric Young (eay@cryptsoft.com). + * The implementation was written so as to conform with Netscapes SSL. + * + * This library is free for commercial and non-commercial use as long as + * the following conditions are aheared to. The following conditions + * apply to all code found in this distribution, be it the RC4, RSA, + * lhash, DES, etc., code; not just the SSL code. The SSL documentation + * included with this distribution is covered by the same copyright terms + * except that the holder is Tim Hudson (tjh@cryptsoft.com). + * + * Copyright remains Eric Young's, and as such any Copyright notices in + * the code are not to be removed. + * If this package is used in a product, Eric Young should be given attribution + * as the author of the parts of the library used. + * This can be in the form of a textual message at program startup or + * in documentation (online or textual) provided with the package. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * "This product includes cryptographic software written by + * Eric Young (eay@cryptsoft.com)" + * The word 'cryptographic' can be left out if the rouines from the library + * being used are not cryptographic related :-). + * 4. If you include any Windows specific code (or a derivative thereof) from + * the apps directory (application code) you must include an acknowledgement: + * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" + * + * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * The licence and distribution terms for any publically available version or + * derivative of this code cannot be changed. i.e. this code cannot simply be + * copied and put under another distribution licence + * [including the GNU Public Licence.] */ + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include "../fipsmodule/bn/internal.h" +#include "../fipsmodule/rsa/internal.h" +#include "../internal.h" +#include "internal.h" + + +static void rand_nonzero(uint8_t *out, size_t len) { + RAND_bytes(out, len); + + for (size_t i = 0; i < len; i++) { + while (out[i] == 0) { + RAND_bytes(out + i, 1); + } + } +} + +int RSA_padding_add_PKCS1_OAEP_mgf1(uint8_t *to, size_t to_len, + const uint8_t *from, size_t from_len, + const uint8_t *param, size_t param_len, + const EVP_MD *md, const EVP_MD *mgf1md) { + if (md == NULL) { + md = EVP_sha1(); + } + if (mgf1md == NULL) { + mgf1md = md; + } + + size_t mdlen = EVP_MD_size(md); + + if (to_len < 2 * mdlen + 2) { + OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); + return 0; + } + + size_t emlen = to_len - 1; + if (from_len > emlen - 2 * mdlen - 1) { + OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE); + return 0; + } + + if (emlen < 2 * mdlen + 1) { + OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); + return 0; + } + + to[0] = 0; + uint8_t *seed = to + 1; + uint8_t *db = to + mdlen + 1; + + uint8_t *dbmask = NULL; + int ret = 0; + if (!EVP_Digest(param, param_len, db, NULL, md, NULL)) { + goto out; + } + OPENSSL_memset(db + mdlen, 0, emlen - from_len - 2 * mdlen - 1); + db[emlen - from_len - mdlen - 1] = 0x01; + OPENSSL_memcpy(db + emlen - from_len - mdlen, from, from_len); + if (!RAND_bytes(seed, mdlen)) { + goto out; + } + + dbmask = OPENSSL_malloc(emlen - mdlen); + if (dbmask == NULL) { + goto out; + } + + if (!PKCS1_MGF1(dbmask, emlen - mdlen, seed, mdlen, mgf1md)) { + goto out; + } + for (size_t i = 0; i < emlen - mdlen; i++) { + db[i] ^= dbmask[i]; + } + + uint8_t seedmask[EVP_MAX_MD_SIZE]; + if (!PKCS1_MGF1(seedmask, mdlen, db, emlen - mdlen, mgf1md)) { + goto out; + } + for (size_t i = 0; i < mdlen; i++) { + seed[i] ^= seedmask[i]; + } + ret = 1; + +out: + OPENSSL_free(dbmask); + return ret; +} + +int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len, + size_t max_out, const uint8_t *from, + size_t from_len, const uint8_t *param, + size_t param_len, const EVP_MD *md, + const EVP_MD *mgf1md) { + uint8_t *db = NULL; + + if (md == NULL) { + md = EVP_sha1(); + } + if (mgf1md == NULL) { + mgf1md = md; + } + + size_t mdlen = EVP_MD_size(md); + + // The encoded message is one byte smaller than the modulus to ensure that it + // doesn't end up greater than the modulus. Thus there's an extra "+1" here + // compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2. + if (from_len < 1 + 2 * mdlen + 1) { + // 'from_len' is the length of the modulus, i.e. does not depend on the + // particular ciphertext. + goto decoding_err; + } + + size_t dblen = from_len - mdlen - 1; + db = OPENSSL_malloc(dblen); + if (db == NULL) { + goto err; + } + + const uint8_t *maskedseed = from + 1; + const uint8_t *maskeddb = from + 1 + mdlen; + + uint8_t seed[EVP_MAX_MD_SIZE]; + if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) { + goto err; + } + for (size_t i = 0; i < mdlen; i++) { + seed[i] ^= maskedseed[i]; + } + + if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) { + goto err; + } + for (size_t i = 0; i < dblen; i++) { + db[i] ^= maskeddb[i]; + } + + uint8_t phash[EVP_MAX_MD_SIZE]; + if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) { + goto err; + } + + crypto_word_t bad = ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen)); + bad |= ~constant_time_is_zero_w(from[0]); + + crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W; + size_t one_index = 0; + for (size_t i = mdlen; i < dblen; i++) { + crypto_word_t equals1 = constant_time_eq_w(db[i], 1); + crypto_word_t equals0 = constant_time_eq_w(db[i], 0); + one_index = + constant_time_select_w(looking_for_one_byte & equals1, i, one_index); + looking_for_one_byte = + constant_time_select_w(equals1, 0, looking_for_one_byte); + bad |= looking_for_one_byte & ~equals0; + } + + bad |= looking_for_one_byte; + + // Whether the overall padding was valid or not in OAEP is public. + if (constant_time_declassify_w(bad)) { + goto decoding_err; + } + + // Once the padding is known to be valid, the output length is also public. + static_assert(sizeof(size_t) <= sizeof(crypto_word_t), + "size_t does not fit in crypto_word_t"); + one_index = constant_time_declassify_w(one_index); + + one_index++; + size_t mlen = dblen - one_index; + if (max_out < mlen) { + OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE); + goto err; + } + + OPENSSL_memcpy(out, db + one_index, mlen); + *out_len = mlen; + OPENSSL_free(db); + return 1; + +decoding_err: + // To avoid chosen ciphertext attacks, the error message should not reveal + // which kind of decoding error happened. + OPENSSL_PUT_ERROR(RSA, RSA_R_OAEP_DECODING_ERROR); +err: + OPENSSL_free(db); + return 0; +} + +static int rsa_padding_add_PKCS1_type_2(uint8_t *to, size_t to_len, + const uint8_t *from, size_t from_len) { + // See RFC 8017, section 7.2.1. + if (to_len < RSA_PKCS1_PADDING_SIZE) { + OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); + return 0; + } + + if (from_len > to_len - RSA_PKCS1_PADDING_SIZE) { + OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE); + return 0; + } + + to[0] = 0; + to[1] = 2; + + size_t padding_len = to_len - 3 - from_len; + rand_nonzero(to + 2, padding_len); + to[2 + padding_len] = 0; + OPENSSL_memcpy(to + to_len - from_len, from, from_len); + return 1; +} + +static int rsa_padding_check_PKCS1_type_2(uint8_t *out, size_t *out_len, + size_t max_out, const uint8_t *from, + size_t from_len) { + if (from_len == 0) { + OPENSSL_PUT_ERROR(RSA, RSA_R_EMPTY_PUBLIC_KEY); + return 0; + } + + // PKCS#1 v1.5 decryption. See "PKCS #1 v2.2: RSA Cryptography + // Standard", section 7.2.2. + if (from_len < RSA_PKCS1_PADDING_SIZE) { + // |from| is zero-padded to the size of the RSA modulus, a public value, so + // this can be rejected in non-constant time. + OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); + return 0; + } + + crypto_word_t first_byte_is_zero = constant_time_eq_w(from[0], 0); + crypto_word_t second_byte_is_two = constant_time_eq_w(from[1], 2); + + crypto_word_t zero_index = 0, looking_for_index = CONSTTIME_TRUE_W; + for (size_t i = 2; i < from_len; i++) { + crypto_word_t equals0 = constant_time_is_zero_w(from[i]); + zero_index = + constant_time_select_w(looking_for_index & equals0, i, zero_index); + looking_for_index = constant_time_select_w(equals0, 0, looking_for_index); + } + + // The input must begin with 00 02. + crypto_word_t valid_index = first_byte_is_zero; + valid_index &= second_byte_is_two; + + // We must have found the end of PS. + valid_index &= ~looking_for_index; + + // PS must be at least 8 bytes long, and it starts two bytes into |from|. + valid_index &= constant_time_ge_w(zero_index, 2 + 8); + + // Skip the zero byte. + zero_index++; + + // NOTE: Although this logic attempts to be constant time, the API contracts + // of this function and |RSA_decrypt| with |RSA_PKCS1_PADDING| make it + // impossible to completely avoid Bleichenbacher's attack. Consumers should + // use |RSA_PADDING_NONE| and perform the padding check in constant-time + // combined with a swap to a random session key or other mitigation. + CONSTTIME_DECLASSIFY(&valid_index, sizeof(valid_index)); + CONSTTIME_DECLASSIFY(&zero_index, sizeof(zero_index)); + + if (!valid_index) { + OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR); + return 0; + } + + const size_t msg_len = from_len - zero_index; + if (msg_len > max_out) { + // This shouldn't happen because this function is always called with + // |max_out| as the key size and |from_len| is bounded by the key size. + OPENSSL_PUT_ERROR(RSA, RSA_R_PKCS_DECODING_ERROR); + return 0; + } + + OPENSSL_memcpy(out, &from[zero_index], msg_len); + *out_len = msg_len; + return 1; +} + +int RSA_public_encrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, + int padding) { + size_t out_len; + + if (!RSA_encrypt(rsa, &out_len, to, RSA_size(rsa), from, flen, padding)) { + return -1; + } + + if (out_len > INT_MAX) { + OPENSSL_PUT_ERROR(RSA, ERR_R_OVERFLOW); + return -1; + } + return (int)out_len; +} + +int RSA_private_encrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, + int padding) { + size_t out_len; + + if (!RSA_sign_raw(rsa, &out_len, to, RSA_size(rsa), from, flen, padding)) { + return -1; + } + + if (out_len > INT_MAX) { + OPENSSL_PUT_ERROR(RSA, ERR_R_OVERFLOW); + return -1; + } + return (int)out_len; +} + +int RSA_encrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, + const uint8_t *in, size_t in_len, int padding) { + if (!rsa_check_public_key(rsa)) { + return 0; + } + + const unsigned rsa_size = RSA_size(rsa); + BIGNUM *f, *result; + uint8_t *buf = NULL; + BN_CTX *ctx = NULL; + int i, ret = 0; + + if (max_out < rsa_size) { + OPENSSL_PUT_ERROR(RSA, RSA_R_OUTPUT_BUFFER_TOO_SMALL); + return 0; + } + + ctx = BN_CTX_new(); + if (ctx == NULL) { + goto err; + } + + BN_CTX_start(ctx); + f = BN_CTX_get(ctx); + result = BN_CTX_get(ctx); + buf = OPENSSL_malloc(rsa_size); + if (!f || !result || !buf) { + goto err; + } + + switch (padding) { + case RSA_PKCS1_PADDING: + i = rsa_padding_add_PKCS1_type_2(buf, rsa_size, in, in_len); + break; + case RSA_PKCS1_OAEP_PADDING: + // Use the default parameters: SHA-1 for both hashes and no label. + i = RSA_padding_add_PKCS1_OAEP_mgf1(buf, rsa_size, in, in_len, NULL, 0, + NULL, NULL); + break; + case RSA_NO_PADDING: + i = RSA_padding_add_none(buf, rsa_size, in, in_len); + break; + default: + OPENSSL_PUT_ERROR(RSA, RSA_R_UNKNOWN_PADDING_TYPE); + goto err; + } + + if (i <= 0) { + goto err; + } + + if (BN_bin2bn(buf, rsa_size, f) == NULL) { + goto err; + } + + if (BN_ucmp(f, rsa->n) >= 0) { + // usually the padding functions would catch this + OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE_FOR_MODULUS); + goto err; + } + + if (!BN_MONT_CTX_set_locked(&rsa->mont_n, &rsa->lock, rsa->n, ctx) || + !BN_mod_exp_mont(result, f, rsa->e, &rsa->mont_n->N, ctx, rsa->mont_n)) { + goto err; + } + + // put in leading 0 bytes if the number is less than the length of the + // modulus + if (!BN_bn2bin_padded(out, rsa_size, result)) { + OPENSSL_PUT_ERROR(RSA, ERR_R_INTERNAL_ERROR); + goto err; + } + + *out_len = rsa_size; + ret = 1; + +err: + if (ctx != NULL) { + BN_CTX_end(ctx); + BN_CTX_free(ctx); + } + OPENSSL_free(buf); + + return ret; +} + +static int rsa_default_decrypt(RSA *rsa, size_t *out_len, uint8_t *out, + size_t max_out, const uint8_t *in, size_t in_len, + int padding) { + const unsigned rsa_size = RSA_size(rsa); + uint8_t *buf = NULL; + int ret = 0; + + if (max_out < rsa_size) { + OPENSSL_PUT_ERROR(RSA, RSA_R_OUTPUT_BUFFER_TOO_SMALL); + return 0; + } + + if (padding == RSA_NO_PADDING) { + buf = out; + } else { + // Allocate a temporary buffer to hold the padded plaintext. + buf = OPENSSL_malloc(rsa_size); + if (buf == NULL) { + goto err; + } + } + + if (in_len != rsa_size) { + OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_LEN_NOT_EQUAL_TO_MOD_LEN); + goto err; + } + + if (!rsa_private_transform(rsa, buf, in, rsa_size)) { + goto err; + } + + switch (padding) { + case RSA_PKCS1_PADDING: + ret = + rsa_padding_check_PKCS1_type_2(out, out_len, rsa_size, buf, rsa_size); + break; + case RSA_PKCS1_OAEP_PADDING: + // Use the default parameters: SHA-1 for both hashes and no label. + ret = RSA_padding_check_PKCS1_OAEP_mgf1(out, out_len, rsa_size, buf, + rsa_size, NULL, 0, NULL, NULL); + break; + case RSA_NO_PADDING: + *out_len = rsa_size; + ret = 1; + break; + default: + OPENSSL_PUT_ERROR(RSA, RSA_R_UNKNOWN_PADDING_TYPE); + goto err; + } + + CONSTTIME_DECLASSIFY(&ret, sizeof(ret)); + if (!ret) { + OPENSSL_PUT_ERROR(RSA, RSA_R_PADDING_CHECK_FAILED); + } else { + CONSTTIME_DECLASSIFY(out, *out_len); + } + +err: + if (padding != RSA_NO_PADDING) { + OPENSSL_free(buf); + } + + return ret; +} + +int RSA_decrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, + const uint8_t *in, size_t in_len, int padding) { + if (rsa->meth->decrypt) { + return rsa->meth->decrypt(rsa, out_len, out, max_out, in, in_len, padding); + } + + return rsa_default_decrypt(rsa, out_len, out, max_out, in, in_len, padding); +} + +int RSA_private_decrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, + int padding) { + size_t out_len; + if (!RSA_decrypt(rsa, &out_len, to, RSA_size(rsa), from, flen, padding)) { + return -1; + } + + if (out_len > INT_MAX) { + OPENSSL_PUT_ERROR(RSA, ERR_R_OVERFLOW); + return -1; + } + return (int)out_len; +} + +int RSA_public_decrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, + int padding) { + size_t out_len; + if (!RSA_verify_raw(rsa, &out_len, to, RSA_size(rsa), from, flen, padding)) { + return -1; + } + + if (out_len > INT_MAX) { + OPENSSL_PUT_ERROR(RSA, ERR_R_OVERFLOW); + return -1; + } + return (int)out_len; +} From c5f762dc7dec560cb1e273a49c8dba442752565b Mon Sep 17 00:00:00 2001 From: Steven Valdez Date: Mon, 20 Mar 2023 10:43:08 -0400 Subject: [PATCH 02/56] Add Trust Token version using standardized hash2curve. Change-Id: I6e53434246f3fef06d4f88924bfe1cbfad0543e8 Bug: chromium:1414562 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58205 Reviewed-by: David Benjamin Commit-Queue: Steven Valdez --- crypto/ec_extra/hash_to_curve.c | 12 ++ crypto/ec_extra/internal.h | 8 ++ crypto/trust_token/internal.h | 58 +++++++++ crypto/trust_token/pmbtoken.c | 174 +++++++++++++++++++++++++ crypto/trust_token/trust_token.c | 35 +++++ crypto/trust_token/trust_token_test.cc | 32 ++++- crypto/trust_token/voprf.c | 113 ++++++++++++++++ include/openssl/trust_token.h | 8 ++ 8 files changed, 437 insertions(+), 3 deletions(-) diff --git a/crypto/ec_extra/hash_to_curve.c b/crypto/ec_extra/hash_to_curve.c index fecd5356c6..6c9abf937a 100644 --- a/crypto/ec_extra/hash_to_curve.c +++ b/crypto/ec_extra/hash_to_curve.c @@ -466,6 +466,18 @@ int EC_hash_to_curve_p384_xmd_sha384_sswu(const EC_GROUP *group, EC_POINT *out, msg, msg_len); } +int ec_hash_to_scalar_p384_xmd_sha384( + const EC_GROUP *group, EC_SCALAR *out, const uint8_t *dst, size_t dst_len, + const uint8_t *msg, size_t msg_len) { + if (EC_GROUP_get_curve_name(group) != NID_secp384r1) { + OPENSSL_PUT_ERROR(EC, EC_R_GROUP_MISMATCH); + return 0; + } + + return hash_to_scalar(group, EVP_sha384(), out, dst, dst_len, /*k=*/192, msg, + msg_len); +} + int ec_hash_to_curve_p384_xmd_sha512_sswu_draft07( const EC_GROUP *group, EC_RAW_POINT *out, const uint8_t *dst, size_t dst_len, const uint8_t *msg, size_t msg_len) { diff --git a/crypto/ec_extra/internal.h b/crypto/ec_extra/internal.h index c7f517dee8..cf6ff2fa12 100644 --- a/crypto/ec_extra/internal.h +++ b/crypto/ec_extra/internal.h @@ -44,6 +44,14 @@ OPENSSL_EXPORT int ec_hash_to_curve_p384_xmd_sha384_sswu( const EC_GROUP *group, EC_RAW_POINT *out, const uint8_t *dst, size_t dst_len, const uint8_t *msg, size_t msg_len); +// ec_hash_to_scalar_p384_xmd_sha384 hashes |msg| to a scalar on |group| +// and writes the result to |out|, using the hash_to_field operation from the +// P384_XMD:SHA-384_SSWU_RO_ suite from draft-irtf-cfrg-hash-to-curve-16, but +// generating a value modulo the group order rather than a field element. +OPENSSL_EXPORT int ec_hash_to_scalar_p384_xmd_sha384( + const EC_GROUP *group, EC_SCALAR *out, const uint8_t *dst, size_t dst_len, + const uint8_t *msg, size_t msg_len); + // ec_hash_to_curve_p384_xmd_sha512_sswu_draft07 hashes |msg| to a point on // |group| and writes the result to |out|, implementing the // P384_XMD:SHA-512_SSWU_RO_ suite from draft-irtf-cfrg-hash-to-curve-07. It diff --git a/crypto/trust_token/internal.h b/crypto/trust_token/internal.h index 093b4acd79..e940565f22 100644 --- a/crypto/trust_token/internal.h +++ b/crypto/trust_token/internal.h @@ -154,6 +154,38 @@ int pmbtoken_exp2_read(const TRUST_TOKEN_ISSUER_KEY *key, // function is used to confirm H was computed as expected. OPENSSL_EXPORT int pmbtoken_exp2_get_h_for_testing(uint8_t out[97]); +// The following functions implement the corresponding |TRUST_TOKENS_METHOD| +// functions for |TRUST_TOKENS_pst_v1|'s PMBTokens construction which uses +// P-384. +int pmbtoken_pst1_generate_key(CBB *out_private, CBB *out_public); +int pmbtoken_pst1_derive_key_from_secret(CBB *out_private, CBB *out_public, + const uint8_t *secret, + size_t secret_len); +int pmbtoken_pst1_client_key_from_bytes(TRUST_TOKEN_CLIENT_KEY *key, + const uint8_t *in, size_t len); +int pmbtoken_pst1_issuer_key_from_bytes(TRUST_TOKEN_ISSUER_KEY *key, + const uint8_t *in, size_t len); +STACK_OF(TRUST_TOKEN_PRETOKEN) *pmbtoken_pst1_blind(CBB *cbb, size_t count, + int include_message, + const uint8_t *msg, + size_t msg_len); +int pmbtoken_pst1_sign(const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, + size_t num_requested, size_t num_to_issue, + uint8_t private_metadata); +STACK_OF(TRUST_TOKEN) *pmbtoken_pst1_unblind( + const TRUST_TOKEN_CLIENT_KEY *key, + const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count, + uint32_t key_id); +int pmbtoken_pst1_read(const TRUST_TOKEN_ISSUER_KEY *key, + uint8_t out_nonce[TRUST_TOKEN_NONCE_SIZE], + uint8_t *out_private_metadata, const uint8_t *token, + size_t token_len, int include_message, + const uint8_t *msg, size_t msg_len); + +// pmbtoken_pst1_get_h_for_testing returns H in uncompressed coordinates. This +// function is used to confirm H was computed as expected. +OPENSSL_EXPORT int pmbtoken_pst1_get_h_for_testing(uint8_t out[97]); + // VOPRF. // @@ -191,6 +223,32 @@ int voprf_exp2_read(const TRUST_TOKEN_ISSUER_KEY *key, size_t token_len, int include_message, const uint8_t *msg, size_t msg_len); +// The following functions implement the corresponding |TRUST_TOKENS_METHOD| +// functions for |TRUST_TOKENS_pst_v1|'s VOPRF construction which uses P-384. +int voprf_pst1_generate_key(CBB *out_private, CBB *out_public); +int voprf_pst1_derive_key_from_secret(CBB *out_private, CBB *out_public, + const uint8_t *secret, size_t secret_len); +int voprf_pst1_client_key_from_bytes(TRUST_TOKEN_CLIENT_KEY *key, + const uint8_t *in, size_t len); +int voprf_pst1_issuer_key_from_bytes(TRUST_TOKEN_ISSUER_KEY *key, + const uint8_t *in, size_t len); +STACK_OF(TRUST_TOKEN_PRETOKEN) *voprf_pst1_blind(CBB *cbb, size_t count, + int include_message, + const uint8_t *msg, + size_t msg_len); +int voprf_pst1_sign(const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, + size_t num_requested, size_t num_to_issue, + uint8_t private_metadata); +STACK_OF(TRUST_TOKEN) *voprf_pst1_unblind( + const TRUST_TOKEN_CLIENT_KEY *key, + const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count, + uint32_t key_id); +int voprf_pst1_read(const TRUST_TOKEN_ISSUER_KEY *key, + uint8_t out_nonce[TRUST_TOKEN_NONCE_SIZE], + uint8_t *out_private_metadata, const uint8_t *token, + size_t token_len, int include_message, const uint8_t *msg, + size_t msg_len); + // Trust Tokens internals. diff --git a/crypto/trust_token/pmbtoken.c b/crypto/trust_token/pmbtoken.c index 0e3d4bcb5d..dcb94665d2 100644 --- a/crypto/trust_token/pmbtoken.c +++ b/crypto/trust_token/pmbtoken.c @@ -1508,3 +1508,177 @@ int pmbtoken_exp2_get_h_for_testing(uint8_t out[97]) { ec_point_to_bytes(pmbtoken_exp2_method.group, &h, POINT_CONVERSION_UNCOMPRESSED, out, 97) == 97; } + +// PMBTokens PST v1. + +static int pmbtoken_pst1_hash_t(const EC_GROUP *group, EC_RAW_POINT *out, + const uint8_t t[TRUST_TOKEN_NONCE_SIZE]) { + const uint8_t kHashTLabel[] = "PMBTokens PST V1 HashT"; + return ec_hash_to_curve_p384_xmd_sha384_sswu( + group, out, kHashTLabel, sizeof(kHashTLabel), t, TRUST_TOKEN_NONCE_SIZE); +} + +static int pmbtoken_pst1_hash_s(const EC_GROUP *group, EC_RAW_POINT *out, + const EC_AFFINE *t, + const uint8_t s[TRUST_TOKEN_NONCE_SIZE]) { + const uint8_t kHashSLabel[] = "PMBTokens PST V1 HashS"; + int ret = 0; + CBB cbb; + uint8_t *buf = NULL; + size_t len; + if (!CBB_init(&cbb, 0) || + !point_to_cbb(&cbb, group, t) || + !CBB_add_bytes(&cbb, s, TRUST_TOKEN_NONCE_SIZE) || + !CBB_finish(&cbb, &buf, &len) || + !ec_hash_to_curve_p384_xmd_sha384_sswu( + group, out, kHashSLabel, sizeof(kHashSLabel), buf, len)) { + goto err; + } + + ret = 1; + +err: + OPENSSL_free(buf); + CBB_cleanup(&cbb); + return ret; +} + +static int pmbtoken_pst1_hash_c(const EC_GROUP *group, EC_SCALAR *out, + uint8_t *buf, size_t len) { + const uint8_t kHashCLabel[] = "PMBTokens PST V1 HashC"; + return ec_hash_to_scalar_p384_xmd_sha384( + group, out, kHashCLabel, sizeof(kHashCLabel), buf, len); +} + +static int pmbtoken_pst1_hash_to_scalar(const EC_GROUP *group, EC_SCALAR *out, + uint8_t *buf, size_t len) { + const uint8_t kHashLabel[] = "PMBTokens PST V1 HashToScalar"; + return ec_hash_to_scalar_p384_xmd_sha384( + group, out, kHashLabel, sizeof(kHashLabel), buf, len); +} + +static int pmbtoken_pst1_ok = 0; +static PMBTOKEN_METHOD pmbtoken_pst1_method; +static CRYPTO_once_t pmbtoken_pst1_method_once = CRYPTO_ONCE_INIT; + +static void pmbtoken_pst1_init_method_impl(void) { + // This is the output of |ec_hash_to_scalar_p384_xmd_sha384| with DST + // "PMBTokens PST V1 HashH" and message "generator". + static const uint8_t kH[] = { + 0x04, 0x4c, 0xfa, 0xd4, 0x33, 0x6d, 0x8c, 0x4e, 0x18, 0xce, 0x1a, + 0x82, 0x7b, 0x53, 0x8c, 0xf8, 0x63, 0x18, 0xe5, 0xa3, 0x96, 0x0d, + 0x05, 0xde, 0xf4, 0x83, 0xa7, 0xd8, 0xde, 0x9c, 0x50, 0x81, 0x38, + 0xc9, 0x38, 0x25, 0xa3, 0x70, 0x97, 0xc1, 0x1c, 0x33, 0x2e, 0x83, + 0x68, 0x64, 0x9c, 0x53, 0x73, 0xc3, 0x03, 0xc1, 0xa9, 0xd8, 0x92, + 0xa2, 0x32, 0xf4, 0x22, 0x40, 0x07, 0x2d, 0x9b, 0x6f, 0xab, 0xff, + 0x2a, 0x92, 0x03, 0xb1, 0x73, 0x09, 0x1a, 0x6a, 0x4a, 0xc2, 0x4c, + 0xac, 0x13, 0x59, 0xf4, 0x28, 0x0e, 0x78, 0x69, 0xa5, 0xdf, 0x0d, + 0x74, 0xeb, 0x14, 0xca, 0x8a, 0x32, 0xbb, 0xd3, 0x91 + }; + + pmbtoken_pst1_ok = pmbtoken_init_method( + &pmbtoken_pst1_method, NID_secp384r1, kH, sizeof(kH), + pmbtoken_pst1_hash_t, pmbtoken_pst1_hash_s, pmbtoken_pst1_hash_c, + pmbtoken_pst1_hash_to_scalar, 0); +} + +static int pmbtoken_pst1_init_method(void) { + CRYPTO_once(&pmbtoken_pst1_method_once, pmbtoken_pst1_init_method_impl); + if (!pmbtoken_pst1_ok) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_INTERNAL_ERROR); + return 0; + } + return 1; +} + +int pmbtoken_pst1_generate_key(CBB *out_private, CBB *out_public) { + if (!pmbtoken_pst1_init_method()) { + return 0; + } + + return pmbtoken_generate_key(&pmbtoken_pst1_method, out_private, out_public); +} + + +int pmbtoken_pst1_derive_key_from_secret(CBB *out_private, CBB *out_public, + const uint8_t *secret, + size_t secret_len) { + if (!pmbtoken_pst1_init_method()) { + return 0; + } + + return pmbtoken_derive_key_from_secret(&pmbtoken_pst1_method, out_private, + out_public, secret, secret_len); +} + +int pmbtoken_pst1_client_key_from_bytes(TRUST_TOKEN_CLIENT_KEY *key, + const uint8_t *in, size_t len) { + if (!pmbtoken_pst1_init_method()) { + return 0; + } + return pmbtoken_client_key_from_bytes(&pmbtoken_pst1_method, key, in, len); +} + +int pmbtoken_pst1_issuer_key_from_bytes(TRUST_TOKEN_ISSUER_KEY *key, + const uint8_t *in, size_t len) { + if (!pmbtoken_pst1_init_method()) { + return 0; + } + return pmbtoken_issuer_key_from_bytes(&pmbtoken_pst1_method, key, in, len); +} + +STACK_OF(TRUST_TOKEN_PRETOKEN) *pmbtoken_pst1_blind(CBB *cbb, size_t count, + int include_message, + const uint8_t *msg, + size_t msg_len) { + if (!pmbtoken_pst1_init_method()) { + return NULL; + } + return pmbtoken_blind(&pmbtoken_pst1_method, cbb, count, include_message, msg, + msg_len); +} + +int pmbtoken_pst1_sign(const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, + size_t num_requested, size_t num_to_issue, + uint8_t private_metadata) { + if (!pmbtoken_pst1_init_method()) { + return 0; + } + return pmbtoken_sign(&pmbtoken_pst1_method, key, cbb, cbs, num_requested, + num_to_issue, private_metadata); +} + +STACK_OF(TRUST_TOKEN) *pmbtoken_pst1_unblind( + const TRUST_TOKEN_CLIENT_KEY *key, + const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count, + uint32_t key_id) { + if (!pmbtoken_pst1_init_method()) { + return NULL; + } + return pmbtoken_unblind(&pmbtoken_pst1_method, key, pretokens, cbs, count, + key_id); +} + +int pmbtoken_pst1_read(const TRUST_TOKEN_ISSUER_KEY *key, + uint8_t out_nonce[TRUST_TOKEN_NONCE_SIZE], + uint8_t *out_private_metadata, const uint8_t *token, + size_t token_len, int include_message, + const uint8_t *msg, size_t msg_len) { + if (!pmbtoken_pst1_init_method()) { + return 0; + } + return pmbtoken_read(&pmbtoken_pst1_method, key, out_nonce, + out_private_metadata, token, token_len, include_message, + msg, msg_len); +} + +int pmbtoken_pst1_get_h_for_testing(uint8_t out[97]) { + if (!pmbtoken_pst1_init_method()) { + return 0; + } + EC_AFFINE h; + return ec_jacobian_to_affine(pmbtoken_pst1_method.group, &h, + &pmbtoken_pst1_method.h) && + ec_point_to_bytes(pmbtoken_pst1_method.group, &h, + POINT_CONVERSION_UNCOMPRESSED, out, 97) == 97; +} diff --git a/crypto/trust_token/trust_token.c b/crypto/trust_token/trust_token.c index 7cccf1afc7..93172c37c2 100644 --- a/crypto/trust_token/trust_token.c +++ b/crypto/trust_token/trust_token.c @@ -78,6 +78,41 @@ const TRUST_TOKEN_METHOD *TRUST_TOKEN_experiment_v2_pmb(void) { return &kMethod; } +const TRUST_TOKEN_METHOD *TRUST_TOKEN_pst_v1_voprf(void) { + static const TRUST_TOKEN_METHOD kMethod = { + voprf_pst1_generate_key, + voprf_pst1_derive_key_from_secret, + voprf_pst1_client_key_from_bytes, + voprf_pst1_issuer_key_from_bytes, + voprf_pst1_blind, + voprf_pst1_sign, + voprf_pst1_unblind, + voprf_pst1_read, + 0, /* has_private_metadata */ + 6, /* max_keys */ + 0, /* has_srr */ + }; + return &kMethod; +} + +const TRUST_TOKEN_METHOD *TRUST_TOKEN_pst_v1_pmb(void) { + static const TRUST_TOKEN_METHOD kMethod = { + pmbtoken_pst1_generate_key, + pmbtoken_pst1_derive_key_from_secret, + pmbtoken_pst1_client_key_from_bytes, + pmbtoken_pst1_issuer_key_from_bytes, + pmbtoken_pst1_blind, + pmbtoken_pst1_sign, + pmbtoken_pst1_unblind, + pmbtoken_pst1_read, + 1, /* has_private_metadata */ + 3, /* max_keys */ + 0, /* has_srr */ + }; + return &kMethod; +} + + void TRUST_TOKEN_PRETOKEN_free(TRUST_TOKEN_PRETOKEN *pretoken) { OPENSSL_free(pretoken); } diff --git a/crypto/trust_token/trust_token_test.cc b/crypto/trust_token/trust_token_test.cc index ae4eb5ce8a..376eacfe34 100644 --- a/crypto/trust_token/trust_token_test.cc +++ b/crypto/trust_token/trust_token_test.cc @@ -292,11 +292,35 @@ TEST(TrustTokenTest, HExp2) { EXPECT_EQ(Bytes(h), Bytes(expected_bytes, expected_len)); } +// Test that H in |TRUST_TOKEN_pst_v1_pmb| was computed correctly. +TEST(TrustTokenTest, HPST1) { + const EC_GROUP *group = EC_GROUP_new_by_curve_name(NID_secp384r1); + ASSERT_TRUE(group); + + const uint8_t kHGen[] = "generator"; + const uint8_t kHLabel[] = "PMBTokens PST V1 HashH"; + + bssl::UniquePtr expected_h(EC_POINT_new(group)); + ASSERT_TRUE(expected_h); + ASSERT_TRUE(ec_hash_to_curve_p384_xmd_sha384_sswu( + group, &expected_h->raw, kHLabel, sizeof(kHLabel), kHGen, sizeof(kHGen))); + uint8_t expected_bytes[1 + 2 * EC_MAX_BYTES]; + size_t expected_len = + EC_POINT_point2oct(group, expected_h.get(), POINT_CONVERSION_UNCOMPRESSED, + expected_bytes, sizeof(expected_bytes), nullptr); + + uint8_t h[97]; + ASSERT_TRUE(pmbtoken_pst1_get_h_for_testing(h)); + EXPECT_EQ(Bytes(h), Bytes(expected_bytes, expected_len)); +} + static std::vector AllMethods() { return { TRUST_TOKEN_experiment_v1(), TRUST_TOKEN_experiment_v2_voprf(), - TRUST_TOKEN_experiment_v2_pmb() + TRUST_TOKEN_experiment_v2_pmb(), + TRUST_TOKEN_pst_v1_voprf(), + TRUST_TOKEN_pst_v1_pmb() }; } @@ -773,7 +797,8 @@ TEST_P(TrustTokenMetadataTest, TruncatedProof) { if (method() == TRUST_TOKEN_experiment_v1()) { token_length += 4; } - if (method() == TRUST_TOKEN_experiment_v2_voprf()) { + if (method() == TRUST_TOKEN_experiment_v2_voprf() || + method() == TRUST_TOKEN_pst_v1_voprf()) { token_length = 1 + 2 * BN_num_bytes(&group->field); } for (size_t i = 0; i < count; i++) { @@ -841,7 +866,8 @@ TEST_P(TrustTokenMetadataTest, ExcessDataProof) { if (method() == TRUST_TOKEN_experiment_v1()) { token_length += 4; } - if (method() == TRUST_TOKEN_experiment_v2_voprf()) { + if (method() == TRUST_TOKEN_experiment_v2_voprf() || + method() == TRUST_TOKEN_pst_v1_voprf()) { token_length = 1 + 2 * BN_num_bytes(&group->field); } for (size_t i = 0; i < count; i++) { diff --git a/crypto/trust_token/voprf.c b/crypto/trust_token/voprf.c index 49a324ef2f..d414bfd52e 100644 --- a/crypto/trust_token/voprf.c +++ b/crypto/trust_token/voprf.c @@ -829,3 +829,116 @@ int voprf_exp2_read(const TRUST_TOKEN_ISSUER_KEY *key, return voprf_read(&voprf_exp2_method, key, out_nonce, token, token_len, include_message, msg, msg_len); } + +// VOPRF PST v1. + +static int voprf_pst1_hash_to_group(const EC_GROUP *group, EC_RAW_POINT *out, + const uint8_t t[TRUST_TOKEN_NONCE_SIZE]) { + const uint8_t kHashTLabel[] = "TrustToken VOPRF PST V1 HashToGroup"; + return ec_hash_to_curve_p384_xmd_sha384_sswu( + group, out, kHashTLabel, sizeof(kHashTLabel), t, TRUST_TOKEN_NONCE_SIZE); +} + +static int voprf_pst1_hash_to_scalar(const EC_GROUP *group, EC_SCALAR *out, + uint8_t *buf, size_t len) { + const uint8_t kHashCLabel[] = "TrustToken VOPRF PST V1 HashToScalar"; + return ec_hash_to_scalar_p384_xmd_sha384( + group, out, kHashCLabel, sizeof(kHashCLabel), buf, len); +} + +static int voprf_pst1_ok = 0; +static VOPRF_METHOD voprf_pst1_method; +static CRYPTO_once_t voprf_pst1_method_once = CRYPTO_ONCE_INIT; + +static void voprf_pst1_init_method_impl(void) { + voprf_pst1_ok = + voprf_init_method(&voprf_pst1_method, NID_secp384r1, + voprf_pst1_hash_to_group, voprf_pst1_hash_to_scalar); +} + +static int voprf_pst1_init_method(void) { + CRYPTO_once(&voprf_pst1_method_once, voprf_pst1_init_method_impl); + if (!voprf_pst1_ok) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_INTERNAL_ERROR); + return 0; + } + return 1; +} + +int voprf_pst1_generate_key(CBB *out_private, CBB *out_public) { + if (!voprf_pst1_init_method()) { + return 0; + } + + return voprf_generate_key(&voprf_pst1_method, out_private, out_public); +} + +int voprf_pst1_derive_key_from_secret(CBB *out_private, CBB *out_public, + const uint8_t *secret, + size_t secret_len) { + if (!voprf_pst1_init_method()) { + return 0; + } + + return voprf_derive_key_from_secret(&voprf_pst1_method, out_private, + out_public, secret, secret_len); +} + +int voprf_pst1_client_key_from_bytes(TRUST_TOKEN_CLIENT_KEY *key, + const uint8_t *in, size_t len) { + if (!voprf_pst1_init_method()) { + return 0; + } + return voprf_client_key_from_bytes(&voprf_pst1_method, key, in, len); +} + +int voprf_pst1_issuer_key_from_bytes(TRUST_TOKEN_ISSUER_KEY *key, + const uint8_t *in, size_t len) { + if (!voprf_pst1_init_method()) { + return 0; + } + return voprf_issuer_key_from_bytes(&voprf_pst1_method, key, in, len); +} + +STACK_OF(TRUST_TOKEN_PRETOKEN) *voprf_pst1_blind(CBB *cbb, size_t count, + int include_message, + const uint8_t *msg, + size_t msg_len) { + if (!voprf_pst1_init_method()) { + return NULL; + } + return voprf_blind(&voprf_pst1_method, cbb, count, include_message, msg, + msg_len); +} + +int voprf_pst1_sign(const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, + size_t num_requested, size_t num_to_issue, + uint8_t private_metadata) { + if (!voprf_pst1_init_method() || private_metadata != 0) { + return 0; + } + return voprf_sign(&voprf_pst1_method, key, cbb, cbs, num_requested, + num_to_issue); +} + +STACK_OF(TRUST_TOKEN) *voprf_pst1_unblind( + const TRUST_TOKEN_CLIENT_KEY *key, + const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count, + uint32_t key_id) { + if (!voprf_pst1_init_method()) { + return NULL; + } + return voprf_unblind(&voprf_pst1_method, key, pretokens, cbs, count, key_id); +} + +int voprf_pst1_read(const TRUST_TOKEN_ISSUER_KEY *key, + uint8_t out_nonce[TRUST_TOKEN_NONCE_SIZE], + uint8_t *out_private_metadata, const uint8_t *token, + size_t token_len, int include_message, const uint8_t *msg, + size_t msg_len) { + if (!voprf_pst1_init_method()) { + return 0; + } + return voprf_read(&voprf_pst1_method, key, out_nonce, token, token_len, + include_message, msg, msg_len); +} diff --git a/include/openssl/trust_token.h b/include/openssl/trust_token.h index 03ce4b820c..b6aa6b34e2 100644 --- a/include/openssl/trust_token.h +++ b/include/openssl/trust_token.h @@ -48,6 +48,14 @@ OPENSSL_EXPORT const TRUST_TOKEN_METHOD *TRUST_TOKEN_experiment_v2_voprf(void); // PMBTokens and P-384 with up to 3 keys, without RR verification. OPENSSL_EXPORT const TRUST_TOKEN_METHOD *TRUST_TOKEN_experiment_v2_pmb(void); +// TRUST_TOKEN_pst_v1_voprf is an experimental Trust Tokens protocol +// using VOPRFs and P-384 with up to 6 keys, without RR verification. +OPENSSL_EXPORT const TRUST_TOKEN_METHOD *TRUST_TOKEN_pst_v1_voprf(void); + +// TRUST_TOKEN_pst_v1_pmb is an experimental Trust Tokens protocol using +// PMBTokens and P-384 with up to 3 keys, without RR verification. +OPENSSL_EXPORT const TRUST_TOKEN_METHOD *TRUST_TOKEN_pst_v1_pmb(void); + // trust_token_st represents a single-use token for the Trust Token protocol. // For the client, this is the token and its corresponding signature. For the // issuer, this is the token itself. From 94235101d2fb07ce8cf57c0afcdc22593abc54a7 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 12 Apr 2023 09:43:33 -0400 Subject: [PATCH 03/56] Fix up do_ext_i2d's error-handling Thanks to wangjiale3 for noticing a leak of ext_oct on malloc error in https://boringssl-review.googlesource.com/c/boringssl/+/58488. This is a fixed version of that CL, and also fixes a leak of ext_der on malloc failure. Change-Id: I2c7ece6b2950a9cb807d78e72b2fddc21897a019 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58686 Reviewed-by: Bob Beck Auto-Submit: David Benjamin Commit-Queue: Bob Beck --- crypto/x509v3/v3_conf.c | 34 +++++++++++++++------------------- 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/crypto/x509v3/v3_conf.c b/crypto/x509v3/v3_conf.c index 8f71502f14..598fba3db8 100644 --- a/crypto/x509v3/v3_conf.c +++ b/crypto/x509v3/v3_conf.c @@ -202,42 +202,38 @@ static X509_EXTENSION *do_ext_nconf(const CONF *conf, const X509V3_CTX *ctx, static X509_EXTENSION *do_ext_i2d(const X509V3_EXT_METHOD *method, int ext_nid, int crit, void *ext_struc) { + // Convert the extension's internal representation to DER. unsigned char *ext_der; int ext_len; - ASN1_OCTET_STRING *ext_oct; - X509_EXTENSION *ext; - // Convert internal representation to DER if (method->it) { ext_der = NULL; ext_len = ASN1_item_i2d(ext_struc, &ext_der, ASN1_ITEM_ptr(method->it)); if (ext_len < 0) { - goto merr; + return NULL; } } else { - unsigned char *p; + // TODO(davidben): Remove support for the "old-style" ASN.1 callbacks. Every + // |X509V3_EXT_METHOD|, both inside and outside the library, has an + // |ASN1_ITEM|, and this codepath is missing handling. ext_len = method->i2d(ext_struc, NULL); if (!(ext_der = OPENSSL_malloc(ext_len))) { - goto merr; + return NULL; } - p = ext_der; + unsigned char *p = ext_der; method->i2d(ext_struc, &p); } - if (!(ext_oct = ASN1_OCTET_STRING_new())) { - goto merr; - } - ext_oct->data = ext_der; - ext_oct->length = ext_len; - ext = X509_EXTENSION_create_by_NID(NULL, ext_nid, crit, ext_oct); - if (!ext) { - goto merr; + ASN1_OCTET_STRING *ext_oct = ASN1_OCTET_STRING_new(); + if (ext_oct == NULL) { + OPENSSL_free(ext_der); + return NULL; } - ASN1_OCTET_STRING_free(ext_oct); + ASN1_STRING_set0(ext_oct, ext_der, ext_len); + X509_EXTENSION *ext = + X509_EXTENSION_create_by_NID(NULL, ext_nid, crit, ext_oct); + ASN1_OCTET_STRING_free(ext_oct); return ext; - -merr: - return NULL; } // Given an internal structure, nid and critical flag create an extension From 8cacbd93b8788cfb46f6a4d7e11b99c29b3752bd Mon Sep 17 00:00:00 2001 From: Bob Beck Date: Wed, 5 Apr 2023 14:38:38 -0600 Subject: [PATCH 04/56] Add functions to allow the mocking of AES hw support for testing. Bug: 586 Change-Id: I5bc8e6df3a5a14e6b218f41181d06406e835f9c1 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58605 Reviewed-by: Adam Langley Commit-Queue: Bob Beck --- include/openssl/ssl.h | 12 ++++++++++++ ssl/encrypted_client_hello.cc | 17 ++++++++++------ ssl/handshake_client.cc | 12 ++++++++---- ssl/internal.h | 33 ++++++++++++++++++++++++++----- ssl/s3_both.cc | 9 +++++---- ssl/ssl_cipher.cc | 5 +++-- ssl/ssl_lib.cc | 37 ++++++++++++++++++++++++++++++----- ssl/test/bssl_shim.cc | 6 ++---- ssl/tls13_server.cc | 7 +++++-- 9 files changed, 106 insertions(+), 32 deletions(-) diff --git a/include/openssl/ssl.h b/include/openssl/ssl.h index b4d669a260..68253bd174 100644 --- a/include/openssl/ssl.h +++ b/include/openssl/ssl.h @@ -5413,6 +5413,18 @@ OPENSSL_EXPORT bool SSL_get_traffic_secrets( const SSL *ssl, Span *out_read_traffic_secret, Span *out_write_traffic_secret); +// SSL_CTX_set_aes_hw_override_for_testing sets |override_value| to +// override checking for aes hardware support for testing. If |override_value| +// is set to true, the library will behave as if aes hardware support is +// present. If it is set to false, the library will behave as if aes hardware +// support is not present. +OPENSSL_EXPORT void SSL_CTX_set_aes_hw_override_for_testing( + SSL_CTX *ctx, bool override_value); + +// SSL_set_aes_hw_override_for_testing acts the same as +// |SSL_CTX_set_aes_override_for_testing| but only configures a single |SSL*|. +OPENSSL_EXPORT void SSL_set_aes_hw_override_for_testing(SSL *ssl, + bool override_value); BSSL_NAMESPACE_END diff --git a/ssl/encrypted_client_hello.cc b/ssl/encrypted_client_hello.cc index 8d35f18b40..a5492e9a0c 100644 --- a/ssl/encrypted_client_hello.cc +++ b/ssl/encrypted_client_hello.cc @@ -601,8 +601,8 @@ bool ssl_is_valid_ech_config_list(Span ech_config_list) { static bool select_ech_cipher_suite(const EVP_HPKE_KDF **out_kdf, const EVP_HPKE_AEAD **out_aead, - Span cipher_suites) { - const bool has_aes_hardware = EVP_has_aes_hardware(); + Span cipher_suites, + const bool has_aes_hardware) { const EVP_HPKE_AEAD *aead = nullptr; CBS cbs = cipher_suites; while (CBS_len(&cbs) != 0) { @@ -660,7 +660,10 @@ bool ssl_select_ech_config(SSL_HANDSHAKE *hs, Span out_enc, const EVP_HPKE_AEAD *aead; if (supported && // ech_config.kem_id == EVP_HPKE_DHKEM_X25519_HKDF_SHA256 && - select_ech_cipher_suite(&kdf, &aead, ech_config.cipher_suites)) { + select_ech_cipher_suite(&kdf, &aead, ech_config.cipher_suites, + hs->ssl->config->aes_hw_override + ? hs->ssl->config->aes_hw_override_value + : EVP_has_aes_hardware())) { ScopedCBB info; static const uint8_t kInfoLabel[] = "tls ech"; // includes trailing NUL if (!CBB_init(info.get(), sizeof(kInfoLabel) + ech_config.raw.size()) || @@ -714,9 +717,11 @@ static bool setup_ech_grease(SSL_HANDSHAKE *hs) { } const uint16_t kdf_id = EVP_HPKE_HKDF_SHA256; - const EVP_HPKE_AEAD *aead = EVP_has_aes_hardware() - ? EVP_hpke_aes_128_gcm() - : EVP_hpke_chacha20_poly1305(); + const bool has_aes_hw = hs->ssl->config->aes_hw_override + ? hs->ssl->config->aes_hw_override_value + : EVP_has_aes_hardware(); + const EVP_HPKE_AEAD *aead = + has_aes_hw ? EVP_hpke_aes_128_gcm() : EVP_hpke_chacha20_poly1305(); static_assert(ssl_grease_ech_config_id < sizeof(hs->grease_seed), "hs->grease_seed is too small"); uint8_t config_id = hs->grease_seed[ssl_grease_ech_config_id]; diff --git a/ssl/handshake_client.cc b/ssl/handshake_client.cc index 3e6301919c..7fe2a2b567 100644 --- a/ssl/handshake_client.cc +++ b/ssl/handshake_client.cc @@ -239,8 +239,12 @@ static bool ssl_write_client_cipher_list(const SSL_HANDSHAKE *hs, CBB *out, TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff, ssl->config->only_fips_cipher_suites_in_tls13); - if (!EVP_has_aes_hardware() && // - include_chacha20 && // + const bool has_aes_hw = ssl->config->aes_hw_override + ? ssl->config->aes_hw_override_value + : EVP_has_aes_hardware(); + + if (!has_aes_hw && // + include_chacha20 && // !CBB_add_u16(&child, TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff)) { return false; } @@ -248,8 +252,8 @@ static bool ssl_write_client_cipher_list(const SSL_HANDSHAKE *hs, CBB *out, !CBB_add_u16(&child, TLS1_3_CK_AES_256_GCM_SHA384 & 0xffff)) { return false; } - if (EVP_has_aes_hardware() && // - include_chacha20 && // + if (has_aes_hw && // + include_chacha20 && // !CBB_add_u16(&child, TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff)) { return false; } diff --git a/ssl/internal.h b/ssl/internal.h index b4d853aec3..15ad6c2172 100644 --- a/ssl/internal.h +++ b/ssl/internal.h @@ -633,9 +633,11 @@ const EVP_MD *ssl_get_handshake_digest(uint16_t version, // newly-allocated |SSLCipherPreferenceList| containing the result. It returns // true on success and false on failure. If |strict| is true, nonsense will be // rejected. If false, nonsense will be silently ignored. An empty result is -// considered an error regardless of |strict|. +// considered an error regardless of |strict|. |has_aes_hw| indicates if the +// list should be ordered based on having support for AES in hardware or not. bool ssl_create_cipher_list(UniquePtr *out_cipher_list, - const char *rule_str, bool strict); + const bool has_aes_hw, const char *rule_str, + bool strict); // ssl_cipher_auth_mask_for_key returns the mask of cipher |algorithm_auth| // values suitable for use with |key| in TLS 1.2 and below. @@ -659,9 +661,12 @@ size_t ssl_cipher_get_record_split_len(const SSL_CIPHER *cipher); // ssl_choose_tls13_cipher returns an |SSL_CIPHER| corresponding with the best // available from |cipher_suites| compatible with |version|, |group_id|, and -// |only_fips|. It returns NULL if there isn't a compatible cipher. -const SSL_CIPHER *ssl_choose_tls13_cipher(CBS cipher_suites, uint16_t version, - uint16_t group_id, bool only_fips); +// |only_fips|. It returns NULL if there isn't a compatible cipher. |has_aes_hw| +// indicates if the choice should be made as if support for AES in hardware +// is available. +const SSL_CIPHER *ssl_choose_tls13_cipher(CBS cipher_suites, bool has_aes_hw, + uint16_t version, uint16_t group_id, + bool only_fips); // ssl_tls13_cipher_meets_policy returns true if |cipher_id| is acceptable given // |only_fips|. (For now there's only a single policy and so the policy argument @@ -3111,6 +3116,15 @@ struct SSL_CONFIG { // only_fips_cipher_suites_in_tls13 constrains the selection of cipher suites // in TLS 1.3 such that only FIPS approved ones will be selected. bool only_fips_cipher_suites_in_tls13 : 1; + + // aes_hw_override if set indicates we should override checking for aes + // hardware support, and use the value in aes_hw_override_value instead. + bool aes_hw_override : 1; + + // aes_hw_override_value is used for testing to indicate the support or lack + // of support for AES hw. The value is only considered if |aes_hw_override| is + // true. + bool aes_hw_override_value : 1; }; // From RFC 8446, used in determining PSK modes. @@ -3722,6 +3736,15 @@ struct ssl_ctx_st { // in TLS 1.3 such that only FIPS approved ones will be selected. bool only_fips_cipher_suites_in_tls13 : 1; + // aes_hw_override if set indicates we should override checking for AES + // hardware support, and use the value in aes_hw_override_value instead. + bool aes_hw_override : 1; + + // aes_hw_override_value is used for testing to indicate the support or lack + // of support for AES hardware. The value is only considered if + // |aes_hw_override| is true. + bool aes_hw_override_value : 1; + private: ~ssl_ctx_st(); friend OPENSSL_EXPORT void SSL_CTX_free(SSL_CTX *); diff --git a/ssl/s3_both.cc b/ssl/s3_both.cc index eb9da0da79..f8352f3d75 100644 --- a/ssl/s3_both.cc +++ b/ssl/s3_both.cc @@ -663,7 +663,7 @@ void tls_next_message(SSL *ssl) { // the client. class CipherScorer { public: - CipherScorer() : aes_is_fine_(EVP_has_aes_hardware()) {} + CipherScorer(bool has_aes_hw) : aes_is_fine_(has_aes_hw) {} typedef std::tuple Score; @@ -702,14 +702,15 @@ bool ssl_tls13_cipher_meets_policy(uint16_t cipher_id, bool only_fips) { } } -const SSL_CIPHER *ssl_choose_tls13_cipher(CBS cipher_suites, uint16_t version, - uint16_t group_id, bool only_fips) { +const SSL_CIPHER *ssl_choose_tls13_cipher(CBS cipher_suites, bool has_aes_hw, + uint16_t version, uint16_t group_id, + bool only_fips) { if (CBS_len(&cipher_suites) % 2 != 0) { return nullptr; } const SSL_CIPHER *best = nullptr; - CipherScorer scorer; + CipherScorer scorer(has_aes_hw); CipherScorer::Score best_score = scorer.MinScore(); while (CBS_len(&cipher_suites) > 0) { diff --git a/ssl/ssl_cipher.cc b/ssl/ssl_cipher.cc index b08eb206d8..73564b390e 100644 --- a/ssl/ssl_cipher.cc +++ b/ssl/ssl_cipher.cc @@ -1148,7 +1148,8 @@ static bool ssl_cipher_process_rulestr(const char *rule_str, } bool ssl_create_cipher_list(UniquePtr *out_cipher_list, - const char *rule_str, bool strict) { + const bool has_aes_hw, const char *rule_str, + bool strict) { // Return with error if nothing to do. if (rule_str == NULL || out_cipher_list == NULL) { return false; @@ -1179,7 +1180,7 @@ bool ssl_create_cipher_list(UniquePtr *out_cipher_list, // CHACHA20 unless there is hardware support for fast and constant-time // AES_GCM. Of the two CHACHA20 variants, the new one is preferred over the // old one. - if (EVP_has_aes_hardware()) { + if (has_aes_hw) { ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_AES128GCM, ~0u, 0, CIPHER_ADD, -1, false, &head, &tail); ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_AES256GCM, ~0u, 0, CIPHER_ADD, -1, diff --git a/ssl/ssl_lib.cc b/ssl/ssl_lib.cc index 86e8eb33e2..c035825133 100644 --- a/ssl/ssl_lib.cc +++ b/ssl/ssl_lib.cc @@ -484,6 +484,17 @@ bool SSL_get_traffic_secrets(const SSL *ssl, return true; } +void SSL_CTX_set_aes_hw_override_for_testing(SSL_CTX *ctx, + bool override_value) { + ctx->aes_hw_override = true; + ctx->aes_hw_override_value = override_value; +} + +void SSL_set_aes_hw_override_for_testing(SSL *ssl, bool override_value) { + ssl->config->aes_hw_override = true; + ssl->config->aes_hw_override_value = override_value; +} + BSSL_NAMESPACE_END using namespace bssl; @@ -525,7 +536,9 @@ ssl_ctx_st::ssl_ctx_st(const SSL_METHOD *ssl_method) false_start_allowed_without_alpn(false), handoff(false), enable_early_data(false), - only_fips_cipher_suites_in_tls13(false) { + only_fips_cipher_suites_in_tls13(false), + aes_hw_override(false), + aes_hw_override_value(false) { CRYPTO_MUTEX_init(&lock); CRYPTO_new_ex_data(&ex_data); } @@ -647,6 +660,8 @@ SSL *SSL_new(SSL_CTX *ctx) { ssl->config->permute_extensions = ctx->permute_extensions; ssl->config->only_fips_cipher_suites_in_tls13 = ctx->only_fips_cipher_suites_in_tls13; + ssl->config->aes_hw_override = ctx->aes_hw_override; + ssl->config->aes_hw_override_value = ctx->aes_hw_override_value; if (!ssl->config->supported_group_list.CopyFrom(ctx->supported_group_list) || !ssl->config->alpn_client_proto_list.CopyFrom( @@ -2026,18 +2041,27 @@ const char *SSL_get_cipher_list(const SSL *ssl, int n) { } int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str) { - return ssl_create_cipher_list(&ctx->cipher_list, str, false /* not strict */); + const bool has_aes_hw = ctx->aes_hw_override ? ctx->aes_hw_override_value + : EVP_has_aes_hardware(); + return ssl_create_cipher_list(&ctx->cipher_list, has_aes_hw, str, + false /* not strict */); } int SSL_CTX_set_strict_cipher_list(SSL_CTX *ctx, const char *str) { - return ssl_create_cipher_list(&ctx->cipher_list, str, true /* strict */); + const bool has_aes_hw = ctx->aes_hw_override ? ctx->aes_hw_override_value + : EVP_has_aes_hardware(); + return ssl_create_cipher_list(&ctx->cipher_list, has_aes_hw, str, + true /* strict */); } int SSL_set_cipher_list(SSL *ssl, const char *str) { if (!ssl->config) { return 0; } - return ssl_create_cipher_list(&ssl->config->cipher_list, str, + const bool has_aes_hw = ssl->config->aes_hw_override + ? ssl->config->aes_hw_override_value + : EVP_has_aes_hardware(); + return ssl_create_cipher_list(&ssl->config->cipher_list, has_aes_hw, str, false /* not strict */); } @@ -2045,7 +2069,10 @@ int SSL_set_strict_cipher_list(SSL *ssl, const char *str) { if (!ssl->config) { return 0; } - return ssl_create_cipher_list(&ssl->config->cipher_list, str, + const bool has_aes_hw = ssl->config->aes_hw_override + ? ssl->config->aes_hw_override_value + : EVP_has_aes_hardware(); + return ssl_create_cipher_list(&ssl->config->cipher_list, has_aes_hw, str, true /* strict */); } diff --git a/ssl/test/bssl_shim.cc b/ssl/test/bssl_shim.cc index 684c254fa9..c64bb167fe 100644 --- a/ssl/test/bssl_shim.cc +++ b/ssl/test/bssl_shim.cc @@ -583,16 +583,14 @@ static bool CheckHandshakeProperties(SSL *ssl, bool is_resume, } uint16_t cipher_id = SSL_CIPHER_get_protocol_id(SSL_get_current_cipher(ssl)); - if (config->expect_cipher_aes != 0 && - EVP_has_aes_hardware() && + if (config->expect_cipher_aes != 0 && EVP_has_aes_hardware() && config->expect_cipher_aes != cipher_id) { fprintf(stderr, "Cipher ID was %04x, wanted %04x (has AES hardware)\n", cipher_id, config->expect_cipher_aes); return false; } - if (config->expect_cipher_no_aes != 0 && - !EVP_has_aes_hardware() && + if (config->expect_cipher_no_aes != 0 && !EVP_has_aes_hardware() && config->expect_cipher_no_aes != cipher_id) { fprintf(stderr, "Cipher ID was %04x, wanted %04x (no AES hardware)\n", cipher_id, config->expect_cipher_no_aes); diff --git a/ssl/tls13_server.cc b/ssl/tls13_server.cc index 0bbe97f273..c97e3f5502 100644 --- a/ssl/tls13_server.cc +++ b/ssl/tls13_server.cc @@ -116,8 +116,11 @@ static const SSL_CIPHER *choose_tls13_cipher( const uint16_t version = ssl_protocol_version(ssl); - return ssl_choose_tls13_cipher(cipher_suites, version, group_id, - ssl->config->only_fips_cipher_suites_in_tls13); + return ssl_choose_tls13_cipher( + cipher_suites, + ssl->config->aes_hw_override ? ssl->config->aes_hw_override_value + : EVP_has_aes_hardware(), + version, group_id, ssl->config->only_fips_cipher_suites_in_tls13); } static bool add_new_session_tickets(SSL_HANDSHAKE *hs, bool *out_sent_tickets) { From abfd5ebc87ddca0fab9fca067c9d7edbc355eae8 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 12 Apr 2023 16:30:01 -0400 Subject: [PATCH 05/56] Restore some default cases in tasn_dec.c and tasn_enc.c This reverts a small portion of 8c8629bfd89436e5019b6bd3c65cff4bf1a76b76. The parsers for ANY remain unchanged, but we inadvertently changed a corner case of ASN1_PRINTABLE MSTRINGs. This is a huge mess. utype in these switch cases is usually the type of the ASN1_ITEM, but, with ANY and MSTRING, it is the tag of the value we found. (An MSTRING or "multi-string" is a CHOICE of string-like types.) When parsing ANY, this is moot because the is_supported_universal_type logic ensures we'll never pass in an invalid type. When encoding ANY, this only happens if you manually construct such an ASN1_TYPE. MSTRINGs *should* be similar because of the bitmask they apply on tag types. However, there is one MSTRING type whose bitmask, B_ASN1_PRINTABLE, includes B_ASN1_UNKNOWN. ASN1_tag2bit, arbitrarily maps eight unsupported tags to B_ASN1_UNKNOWN and instead of zero. These are: - ObjectDescriptor - EXTERNAL - REAL - EMBEDDED PDV - RELATIVE-OID - TIME (note this is not the same as the X.509 Time CHOICE type) - [UNIVERSAL 15], which is not even a defined type! - CHARACTER STRING (ENUMERATED is also mapped to B_ASN1_UNKNOWN, but it's supported.) These eight tags were previously accepted in d2i_X509_NAME but 8c8629bfd89436e5019b6bd3c65cff4bf1a76b76 inadvertently started rejecting them. For now, restore the default in the switch/case so that we accept them again. Per https://crbug.com/boringssl/412, attribute values are ANY DEFINED BY types, so we actually should be accepting *all* types. We do not, because B_ASN1_PRINTABLE is completely incoherent. But because ANY is the correct type, going from the original incoherent set, to this new, smaller incoherent set is arguably a regression. This is a minimal fix. Long-term, we should handle that ANY correctly, and avoid unexpected ASN1_STRING type values, by mapping all unsupported types to V_ASN1_OTHER. This would allow us to support all types correctly. A follow-up change will do that. Update-Note: The X.509 name parser will go back to accepting a handful of universal tag types that were inadvertently rejected in 8c8629bfd89436e5019b6bd3c65cff4bf1a76b76. It is extremely unlikely that anyone uses these as they're unsupported, obscure types. This CL also makes our ASN1_TYPE encoder slightly more permissive again, if the caller manually constructs an legacy in-memory representation of an unsupported tag. But the follow-up change will restore the stricter behavior. Bug: 412, 561 Change-Id: Ia44a270f12f3021154761a1cd285707416d8787e Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58705 Auto-Submit: David Benjamin Commit-Queue: Bob Beck Reviewed-by: Bob Beck --- crypto/asn1/asn1_test.cc | 10 ++-- crypto/asn1/tasn_dec.c | 12 +++-- crypto/asn1/tasn_enc.c | 11 +++-- crypto/x509/x509_test.cc | 100 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 122 insertions(+), 11 deletions(-) diff --git a/crypto/asn1/asn1_test.cc b/crypto/asn1/asn1_test.cc index 5c43793709..849cfe90c4 100644 --- a/crypto/asn1/asn1_test.cc +++ b/crypto/asn1/asn1_test.cc @@ -107,8 +107,12 @@ TEST(ASN1Test, UnknownTags) { TestSerialize(obj.get(), i2d_ASN1_TYPE, kTag128); // The historical in-memory representation of |kTag128| was for both - // |obj->type| and |obj->value.asn1_string->type| to be NULL. This is no - // longer used and should be rejected by the encoder. + // |obj->type| and |obj->value.asn1_string->type| to be 128. This is no + // longer used but is still accepted by the encoder. + // + // TODO(crbug.com/boringssl/412): The encoder should reject it. However, it is + // still needed to support some edge cases in |ASN1_PRINTABLE|. When that is + // fixed, test that we reject it. obj.reset(ASN1_TYPE_new()); ASSERT_TRUE(obj); obj->type = 128; @@ -116,7 +120,7 @@ TEST(ASN1Test, UnknownTags) { ASSERT_TRUE(obj->value.asn1_string); const uint8_t zero = 0; ASSERT_TRUE(ASN1_STRING_set(obj->value.asn1_string, &zero, sizeof(zero))); - EXPECT_EQ(-1, i2d_ASN1_TYPE(obj.get(), nullptr)); + TestSerialize(obj.get(), i2d_ASN1_TYPE, kTag128); // If a tag is known, but has the wrong constructed bit, it should be // rejected, not placed in |V_ASN1_OTHER|. diff --git a/crypto/asn1/tasn_dec.c b/crypto/asn1/tasn_dec.c index 622ed458a4..24ab04f270 100644 --- a/crypto/asn1/tasn_dec.c +++ b/crypto/asn1/tasn_dec.c @@ -837,7 +837,14 @@ static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, long len, case V_ASN1_UTF8STRING: case V_ASN1_OTHER: case V_ASN1_SET: - case V_ASN1_SEQUENCE: { + case V_ASN1_SEQUENCE: + // TODO(crbug.com/boringssl/412): This default case should be removed, now + // that we've resolved https://crbug.com/boringssl/561. However, it is still + // needed to support some edge cases in |ASN1_PRINTABLE|. |ASN1_PRINTABLE| + // broadly doesn't tolerate unrecognized universal tags, but except for + // eight values that map to |B_ASN1_UNKNOWN| instead of zero. See the + // X509Test.NameAttributeValues test. + default: { CBS cbs; CBS_init(&cbs, cont, (size_t)len); if (utype == V_ASN1_BMPSTRING) { @@ -900,9 +907,6 @@ static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, long len, } break; } - default: - OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE); - goto err; } // If ASN1_ANY and NULL type fix up value if (typ && (utype == V_ASN1_NULL)) { diff --git a/crypto/asn1/tasn_enc.c b/crypto/asn1/tasn_enc.c index b0d72ce86e..e85400b2c8 100644 --- a/crypto/asn1/tasn_enc.c +++ b/crypto/asn1/tasn_enc.c @@ -693,15 +693,18 @@ static int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cout, int *out_omit, case V_ASN1_SET: // This is not a valid |ASN1_ITEM| type, but it appears in |ASN1_TYPE|. case V_ASN1_OTHER: + // TODO(crbug.com/boringssl/412): This default case should be removed, now + // that we've resolved https://crbug.com/boringssl/561. However, it is still + // needed to support some edge cases in |ASN1_PRINTABLE|. |ASN1_PRINTABLE| + // broadly doesn't tolerate unrecognized universal tags, but except for + // eight values that map to |B_ASN1_UNKNOWN| instead of zero. See the + // X509Test.NameAttributeValues test. + default: // All based on ASN1_STRING and handled the same strtmp = (ASN1_STRING *)*pval; cont = strtmp->data; len = strtmp->length; break; - - default: - OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE); - return -1; } if (cout && len) { OPENSSL_memcpy(cout, cont, len); diff --git a/crypto/x509/x509_test.cc b/crypto/x509/x509_test.cc index 056d56a4b3..530c24d5cc 100644 --- a/crypto/x509/x509_test.cc +++ b/crypto/x509/x509_test.cc @@ -6549,3 +6549,103 @@ TEST(X509Test, SortRDN) { 0x02, 0x41, 0x42}; EXPECT_EQ(Bytes(kExpected), Bytes(der, der_len)); } + +TEST(X509Test, NameAttributeValues) { + // 1.2.840.113554.4.1.72585.0. We use an unrecognized OID because using an + // arbitrary ASN.1 type as the value for commonName is invalid. Our parser + // does not check this, but best to avoid unrelated errors in tests, in case + // we decide to later. + static const uint8_t kOID[] = {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, + 0x04, 0x01, 0x84, 0xb7, 0x09, 0x00}; + + const struct { + CBS_ASN1_TAG der_tag; + std::string der_contents; + int str_type; + std::string str_contents; + } kTests[] = { + // String types are parsed as string types. + {CBS_ASN1_BITSTRING, std::string("\0", 1), V_ASN1_BIT_STRING, ""}, + {CBS_ASN1_UTF8STRING, "abc", V_ASN1_UTF8STRING, "abc"}, + {CBS_ASN1_NUMERICSTRING, "123", V_ASN1_NUMERICSTRING, "123"}, + {CBS_ASN1_PRINTABLESTRING, "abc", V_ASN1_PRINTABLESTRING, "abc"}, + {CBS_ASN1_T61STRING, "abc", V_ASN1_T61STRING, "abc"}, + {CBS_ASN1_IA5STRING, "abc", V_ASN1_IA5STRING, "abc"}, + {CBS_ASN1_UNIVERSALSTRING, std::string("\0\0\0a", 4), + V_ASN1_UNIVERSALSTRING, std::string("\0\0\0a", 4)}, + {CBS_ASN1_BMPSTRING, std::string("\0a", 2), V_ASN1_BMPSTRING, + std::string("\0a", 2)}, + + // ENUMERATED is supported but, currently, INTEGER is not. + {CBS_ASN1_ENUMERATED, "\x01", V_ASN1_ENUMERATED, "\x01"}, + + // SEQUENCE is supported but, currently, SET is not. Note the + // |ASN1_STRING| representation will include the tag and length. + {CBS_ASN1_SEQUENCE, "", V_ASN1_SEQUENCE, std::string("\x30\x00", 2)}, + + // These types are not actually supported by the library but, + // historically, we would parse them, and not other unsupported types, due + // to quirks of |ASN1_tag2bit|. + {7, "", V_ASN1_OBJECT_DESCRIPTOR, ""}, + {8, "", V_ASN1_EXTERNAL, ""}, + {9, "", V_ASN1_REAL, ""}, + {11, "", 11 /* EMBEDDED PDV */, ""}, + {13, "", 13 /* RELATIVE-OID */, ""}, + {14, "", 14 /* TIME */, ""}, + {15, "", 15 /* not a type; reserved value */, ""}, + {29, "", 29 /* CHARACTER STRING */, ""}, + + // TODO(crbug.com/boringssl/412): Attribute values are an ANY DEFINED BY + // type, so we actually shoudl be accepting all ASN.1 types. We currently + // do not and only accept the above types. Extend this test when we fix + // this. + }; + for (const auto &t : kTests) { + SCOPED_TRACE(t.der_tag); + SCOPED_TRACE(Bytes(t.der_contents)); + + // Construct an X.509 name containing a single RDN with a single attribute: + // kOID with the specified value. + bssl::ScopedCBB cbb; + ASSERT_TRUE(CBB_init(cbb.get(), 128)); + CBB seq, rdn, attr, attr_type, attr_value; + ASSERT_TRUE(CBB_add_asn1(cbb.get(), &seq, CBS_ASN1_SEQUENCE)); + ASSERT_TRUE(CBB_add_asn1(&seq, &rdn, CBS_ASN1_SET)); + ASSERT_TRUE(CBB_add_asn1(&rdn, &attr, CBS_ASN1_SEQUENCE)); + ASSERT_TRUE(CBB_add_asn1(&attr, &attr_type, CBS_ASN1_OBJECT)); + ASSERT_TRUE(CBB_add_bytes(&attr_type, kOID, sizeof(kOID))); + ASSERT_TRUE(CBB_add_asn1(&attr, &attr_value, t.der_tag)); + ASSERT_TRUE(CBB_add_bytes( + &attr_value, reinterpret_cast(t.der_contents.data()), + t.der_contents.size())); + ASSERT_TRUE(CBB_flush(cbb.get())); + SCOPED_TRACE(Bytes(CBB_data(cbb.get()), CBB_len(cbb.get()))); + + // The input should parse. + const uint8_t *inp = CBB_data(cbb.get()); + bssl::UniquePtr name( + d2i_X509_NAME(nullptr, &inp, CBB_len(cbb.get()))); + ASSERT_TRUE(name); + EXPECT_EQ(inp, CBB_data(cbb.get()) + CBB_len(cbb.get())) + << "input was not fully consumed"; + + // Check there is a single attribute with the expected in-memory + // representation. + ASSERT_EQ(1, X509_NAME_entry_count(name.get())); + const X509_NAME_ENTRY *entry = X509_NAME_get_entry(name.get(), 0); + const ASN1_OBJECT *obj = X509_NAME_ENTRY_get_object(entry); + EXPECT_EQ(Bytes(OBJ_get0_data(obj), OBJ_length(obj)), Bytes(kOID)); + const ASN1_STRING *value = X509_NAME_ENTRY_get_data(entry); + EXPECT_EQ(ASN1_STRING_type(value), t.str_type); + EXPECT_EQ(Bytes(ASN1_STRING_get0_data(value), ASN1_STRING_length(value)), + Bytes(t.str_contents)); + + // The name should re-encode with the same input. + uint8_t *der = nullptr; + int der_len = i2d_X509_NAME(name.get(), &der); + ASSERT_GE(der_len, 0); + bssl::UniquePtr free_der(der); + EXPECT_EQ(Bytes(der, der_len), + (Bytes(CBB_data(cbb.get()), CBB_len(cbb.get())))); + } +} From 8abd1b5e8c5391dcc4d8574d06fb9727635f9606 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 12 Apr 2023 10:07:53 -0400 Subject: [PATCH 06/56] Remove support for "old-style" X509V3_EXT_METHODs. I don't believe these codepaths have ever been run. All the built-in X509V3_EXT_METHODs are ASN1_ITEM-based, as are all callers I found of X509V3_EXT_add and X509V3_EXT_add_list. Also document not to use those APIs because they're pointless and (for now) not even thread-safe. Making them thread-safe is doable, but it'd add rwlock contention in certificate verification, unless we first rework certificate verification to ignore custom registrations, because it never uses them anyway. But that only proves that this whole feature was pointless, so this time may be better spent trying to get rid of this API. Update-Note: Externally-installed X509V3_EXT_METHODs now must be ASN1_ITEM-based. I believe all existing ones already are. If there are any that aren't, let us know. We'll either revert this for now, or export a way to implement custom ASN1_ITEMs, or, most likely, try to move the caller off custom X509V3_EXT_METHODs altogether. Like most of OpenSSL's other global registration APIs, this one is unsafe (two callers may conflict) and there isn't much reason to register it with the library because OpenSSL doesn't do much with the registration anyway. Bug: 590 Change-Id: Ice0e246d50069e10e6cca8949f60fac474d0846c Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58687 Reviewed-by: Bob Beck Commit-Queue: David Benjamin --- crypto/x509v3/v3_conf.c | 28 ++++----------------- crypto/x509v3/v3_lib.c | 29 ++++++---------------- crypto/x509v3/v3_prn.c | 40 +++++++++++------------------- include/openssl/x509v3.h | 53 ++++++++++++++++++++++++++++++++++++++-- 4 files changed, 78 insertions(+), 72 deletions(-) diff --git a/crypto/x509v3/v3_conf.c b/crypto/x509v3/v3_conf.c index 598fba3db8..7904c7f7ec 100644 --- a/crypto/x509v3/v3_conf.c +++ b/crypto/x509v3/v3_conf.c @@ -192,35 +192,17 @@ static X509_EXTENSION *do_ext_nconf(const CONF *conf, const X509V3_CTX *ctx, } ext = do_ext_i2d(method, ext_nid, crit, ext_struc); - if (method->it) { - ASN1_item_free(ext_struc, ASN1_ITEM_ptr(method->it)); - } else { - method->ext_free(ext_struc); - } + ASN1_item_free(ext_struc, ASN1_ITEM_ptr(method->it)); return ext; } static X509_EXTENSION *do_ext_i2d(const X509V3_EXT_METHOD *method, int ext_nid, int crit, void *ext_struc) { // Convert the extension's internal representation to DER. - unsigned char *ext_der; - int ext_len; - if (method->it) { - ext_der = NULL; - ext_len = ASN1_item_i2d(ext_struc, &ext_der, ASN1_ITEM_ptr(method->it)); - if (ext_len < 0) { - return NULL; - } - } else { - // TODO(davidben): Remove support for the "old-style" ASN.1 callbacks. Every - // |X509V3_EXT_METHOD|, both inside and outside the library, has an - // |ASN1_ITEM|, and this codepath is missing handling. - ext_len = method->i2d(ext_struc, NULL); - if (!(ext_der = OPENSSL_malloc(ext_len))) { - return NULL; - } - unsigned char *p = ext_der; - method->i2d(ext_struc, &p); + unsigned char *ext_der = NULL; + int ext_len = ASN1_item_i2d(ext_struc, &ext_der, ASN1_ITEM_ptr(method->it)); + if (ext_len < 0) { + return NULL; } ASN1_OCTET_STRING *ext_oct = ASN1_OCTET_STRING_new(); diff --git a/crypto/x509v3/v3_lib.c b/crypto/x509v3/v3_lib.c index d33b51f51c..623a7c69da 100644 --- a/crypto/x509v3/v3_lib.c +++ b/crypto/x509v3/v3_lib.c @@ -57,6 +57,7 @@ */ /* X509 v3 extension utilities */ +#include #include #include @@ -78,6 +79,9 @@ static int ext_stack_cmp(const X509V3_EXT_METHOD *const *a, } int X509V3_EXT_add(X509V3_EXT_METHOD *ext) { + // We only support |ASN1_ITEM|-based extensions. + assert(ext->it != NULL); + // TODO(davidben): This should be locked. Also check for duplicates. if (!ext_list && !(ext_list = sk_X509V3_EXT_METHOD_new(ext_stack_cmp))) { ext_list_free(ext); @@ -136,15 +140,7 @@ int X509V3_EXT_free(int nid, void *ext_data) { return 0; } - if (ext_method->it != NULL) { - ASN1_item_free(ext_data, ASN1_ITEM_ptr(ext_method->it)); - } else if (ext_method->ext_free != NULL) { - ext_method->ext_free(ext_data); - } else { - OPENSSL_PUT_ERROR(X509V3, X509V3_R_CANNOT_FIND_FREE_FUNCTION); - return 0; - } - + ASN1_item_free(ext_data, ASN1_ITEM_ptr(ext_method->it)); return 1; } @@ -201,23 +197,14 @@ void *X509V3_EXT_d2i(const X509_EXTENSION *ext) { return NULL; } p = ext->value->data; - void *ret; - if (method->it) { - ret = - ASN1_item_d2i(NULL, &p, ext->value->length, ASN1_ITEM_ptr(method->it)); - } else { - ret = method->d2i(NULL, &p, ext->value->length); - } + void *ret = + ASN1_item_d2i(NULL, &p, ext->value->length, ASN1_ITEM_ptr(method->it)); if (ret == NULL) { return NULL; } // Check for trailing data. if (p != ext->value->data + ext->value->length) { - if (method->it) { - ASN1_item_free(ret, ASN1_ITEM_ptr(method->it)); - } else { - method->ext_free(ret); - } + ASN1_item_free(ret, ASN1_ITEM_ptr(method->it)); OPENSSL_PUT_ERROR(X509V3, X509V3_R_TRAILING_DATA_IN_EXTENSION); return NULL; } diff --git a/crypto/x509v3/v3_prn.c b/crypto/x509v3/v3_prn.c index ce9c18770d..f6260e2483 100644 --- a/crypto/x509v3/v3_prn.c +++ b/crypto/x509v3/v3_prn.c @@ -105,59 +105,47 @@ void X509V3_EXT_val_prn(BIO *out, const STACK_OF(CONF_VALUE) *val, int indent, int X509V3_EXT_print(BIO *out, const X509_EXTENSION *ext, unsigned long flag, int indent) { - void *ext_str = NULL; - char *value = NULL; - const X509V3_EXT_METHOD *method; - STACK_OF(CONF_VALUE) *nval = NULL; - int ok = 1; - - if (!(method = X509V3_EXT_get(ext))) { + const X509V3_EXT_METHOD *method = X509V3_EXT_get(ext); + if (method == NULL) { return unknown_ext_print(out, ext, flag, indent, 0); } const ASN1_STRING *ext_data = X509_EXTENSION_get_data(ext); const unsigned char *p = ASN1_STRING_get0_data(ext_data); - if (method->it) { - ext_str = ASN1_item_d2i(NULL, &p, ASN1_STRING_length(ext_data), - ASN1_ITEM_ptr(method->it)); - } else { - ext_str = method->d2i(NULL, &p, ASN1_STRING_length(ext_data)); - } - + void *ext_str = ASN1_item_d2i(NULL, &p, ASN1_STRING_length(ext_data), + ASN1_ITEM_ptr(method->it)); if (!ext_str) { return unknown_ext_print(out, ext, flag, indent, 1); } + char *value = NULL; + STACK_OF(CONF_VALUE) *nval = NULL; + int ok = 0; if (method->i2s) { if (!(value = method->i2s(method, ext_str))) { - ok = 0; goto err; } BIO_printf(out, "%*s%s", indent, "", value); } else if (method->i2v) { if (!(nval = method->i2v(method, ext_str, NULL))) { - ok = 0; goto err; } X509V3_EXT_val_prn(out, nval, indent, method->ext_flags & X509V3_EXT_MULTILINE); } else if (method->i2r) { if (!method->i2r(method, ext_str, out, indent)) { - ok = 0; + goto err; } } else { - ok = 0; + OPENSSL_PUT_ERROR(X509V3, X509V3_R_OPERATION_NOT_DEFINED); + goto err; } + ok = 1; + err: sk_CONF_VALUE_pop_free(nval, X509V3_conf_free); - if (value) { - OPENSSL_free(value); - } - if (method->it) { - ASN1_item_free(ext_str, ASN1_ITEM_ptr(method->it)); - } else { - method->ext_free(ext_str); - } + OPENSSL_free(value); + ASN1_item_free(ext_str, ASN1_ITEM_ptr(method->it)); return ok; } diff --git a/include/openssl/x509v3.h b/include/openssl/x509v3.h index c8548f7739..a96faa7e8b 100644 --- a/include/openssl/x509v3.h +++ b/include/openssl/x509v3.h @@ -104,9 +104,13 @@ typedef void *(*X509V3_EXT_R2I)(const X509V3_EXT_METHOD *method, struct v3_ext_method { int ext_nid; int ext_flags; - // If this is set the following four fields are ignored + + // it determines how values of this extension are allocated, released, parsed, + // and marshalled. This must be non-NULL. ASN1_ITEM_EXP *it; - // Old style ASN1 calls + + // The following functions are ignored in favor of |it|. They are retained in + // the struct only for source compatibility with existing struct definitions. X509V3_EXT_NEW ext_new; X509V3_EXT_FREE ext_free; X509V3_EXT_D2I d2i; @@ -663,9 +667,54 @@ OPENSSL_EXPORT ASN1_INTEGER *s2i_ASN1_INTEGER(const X509V3_EXT_METHOD *meth, const char *value); OPENSSL_EXPORT char *i2s_ASN1_ENUMERATED(const X509V3_EXT_METHOD *meth, const ASN1_ENUMERATED *aint); + +// X509V3_EXT_add registers |ext| as a custom extension for the extension type +// |ext->ext_nid|. |ext| must be valid for the remainder of the address space's +// lifetime. It returns one on success and zero on error. +// +// WARNING: This function modifies global state. If other code in the same +// address space also registers an extension with type |ext->ext_nid|, the two +// registrations will conflict. Which registration takes effect is undefined. If +// the two registrations use incompatible in-memory representations, code +// expecting the other registration will then cast a type to the wrong type, +// resulting in a potentially exploitable memory error. This conflict can also +// occur if BoringSSL later adds support for |ext->ext_nid|, with a different +// in-memory representation than the one expected by |ext|. +// +// This function, additionally, is not thread-safe and cannot be called +// concurrently with any other BoringSSL function. +// +// As a result, it is impossible to safely use this function. Registering a +// custom extension has no impact on certificate verification so, instead, +// callers should simply handle the custom extension with the byte-based +// |X509_EXTENSION| APIs directly. Registering |ext| with the library has little +// practical value. OPENSSL_EXPORT int X509V3_EXT_add(X509V3_EXT_METHOD *ext); + +// X509V3_EXT_add_list calls |X509V3_EXT_add| on |&extlist[0]|, |&extlist[1]|, +// and so on, until some |extlist[i]->ext_nid| is -1. It returns one on success +// and zero on error. +// +// WARNING: Do not use this function. See |X509V3_EXT_add|. OPENSSL_EXPORT int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist); + +// X509V3_EXT_add_alias registers a custom extension with NID |nid_to|. The +// corresponding ASN.1 type is copied from |nid_from|. It returns one on success +// and zero on error. +// +// WARNING: Do not use this function. See |X509V3_EXT_add|. OPENSSL_EXPORT int X509V3_EXT_add_alias(int nid_to, int nid_from); + +// X509V3_EXT_cleanup removes all custom extensions registered with +// |X509V3_EXT_add*|. +// +// WARNING: This function modifies global state and will impact custom +// extensions registered by any code in the same address space. It, +// additionally, is not thread-safe and cannot be called concurrently with any +// other BoringSSL function. +// +// Instead of calling this function, allow memory from custom extensions to be +// released on process exit, along with other global program state. OPENSSL_EXPORT void X509V3_EXT_cleanup(void); OPENSSL_EXPORT const X509V3_EXT_METHOD *X509V3_EXT_get( From 5fb362c66a57b4d1e300a1d56b461bbb69e8c8ae Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Thu, 13 Apr 2023 10:21:47 -0400 Subject: [PATCH 07/56] Remove X509V3_EXT_add_list and X509V3_EXT_cleanup These are already unused, though add and add_alias will need more work. In doing so, simplify the X509V3_EXT_DYNAMIC business. I added some cleanup calls to https://boringssl-review.googlesource.com/2208, but that should have been in the error-handling path of X509V3_EXT_add_alias, the only case that cares about this. Update-Note: Removed unused API. Bug: 590 Change-Id: Idd97366d90d7aab0ca2e020c76a7c8065b3dd7ff Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58765 Commit-Queue: Bob Beck Reviewed-by: Bob Beck Auto-Submit: David Benjamin --- crypto/x509v3/v3_lib.c | 29 ++++------------------------- include/openssl/x509v3.h | 20 -------------------- 2 files changed, 4 insertions(+), 45 deletions(-) diff --git a/crypto/x509v3/v3_lib.c b/crypto/x509v3/v3_lib.c index 623a7c69da..52528eac01 100644 --- a/crypto/x509v3/v3_lib.c +++ b/crypto/x509v3/v3_lib.c @@ -71,8 +71,6 @@ #include "ext_dat.h" static STACK_OF(X509V3_EXT_METHOD) *ext_list = NULL; -static void ext_list_free(X509V3_EXT_METHOD *ext); - static int ext_stack_cmp(const X509V3_EXT_METHOD *const *a, const X509V3_EXT_METHOD *const *b) { return ((*a)->ext_nid - (*b)->ext_nid); @@ -84,11 +82,9 @@ int X509V3_EXT_add(X509V3_EXT_METHOD *ext) { // TODO(davidben): This should be locked. Also check for duplicates. if (!ext_list && !(ext_list = sk_X509V3_EXT_METHOD_new(ext_stack_cmp))) { - ext_list_free(ext); return 0; } if (!sk_X509V3_EXT_METHOD_push(ext_list, ext)) { - ext_list_free(ext); return 0; } sk_X509V3_EXT_METHOD_sort(ext_list); @@ -144,15 +140,6 @@ int X509V3_EXT_free(int nid, void *ext_data) { return 1; } -int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist) { - for (; extlist->ext_nid != -1; extlist++) { - if (!X509V3_EXT_add(extlist)) { - return 0; - } - } - return 1; -} - int X509V3_EXT_add_alias(int nid_to, int nid_from) { const X509V3_EXT_METHOD *ext; X509V3_EXT_METHOD *tmpext; @@ -167,19 +154,11 @@ int X509V3_EXT_add_alias(int nid_to, int nid_from) { } *tmpext = *ext; tmpext->ext_nid = nid_to; - tmpext->ext_flags |= X509V3_EXT_DYNAMIC; - return X509V3_EXT_add(tmpext); -} - -void X509V3_EXT_cleanup(void) { - sk_X509V3_EXT_METHOD_pop_free(ext_list, ext_list_free); - ext_list = NULL; -} - -static void ext_list_free(X509V3_EXT_METHOD *ext) { - if (ext->ext_flags & X509V3_EXT_DYNAMIC) { - OPENSSL_free(ext); + if (!X509V3_EXT_add(tmpext)) { + OPENSSL_free(tmpext); + return 0; } + return 1; } // Legacy function: we don't need to add standard extensions any more because diff --git a/include/openssl/x509v3.h b/include/openssl/x509v3.h index a96faa7e8b..ee90f584fb 100644 --- a/include/openssl/x509v3.h +++ b/include/openssl/x509v3.h @@ -134,7 +134,6 @@ struct v3_ext_method { DEFINE_STACK_OF(X509V3_EXT_METHOD) // ext_flags values -#define X509V3_EXT_DYNAMIC 0x1 #define X509V3_EXT_CTX_DEP 0x2 #define X509V3_EXT_MULTILINE 0x4 @@ -691,13 +690,6 @@ OPENSSL_EXPORT char *i2s_ASN1_ENUMERATED(const X509V3_EXT_METHOD *meth, // practical value. OPENSSL_EXPORT int X509V3_EXT_add(X509V3_EXT_METHOD *ext); -// X509V3_EXT_add_list calls |X509V3_EXT_add| on |&extlist[0]|, |&extlist[1]|, -// and so on, until some |extlist[i]->ext_nid| is -1. It returns one on success -// and zero on error. -// -// WARNING: Do not use this function. See |X509V3_EXT_add|. -OPENSSL_EXPORT int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist); - // X509V3_EXT_add_alias registers a custom extension with NID |nid_to|. The // corresponding ASN.1 type is copied from |nid_from|. It returns one on success // and zero on error. @@ -705,18 +697,6 @@ OPENSSL_EXPORT int X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist); // WARNING: Do not use this function. See |X509V3_EXT_add|. OPENSSL_EXPORT int X509V3_EXT_add_alias(int nid_to, int nid_from); -// X509V3_EXT_cleanup removes all custom extensions registered with -// |X509V3_EXT_add*|. -// -// WARNING: This function modifies global state and will impact custom -// extensions registered by any code in the same address space. It, -// additionally, is not thread-safe and cannot be called concurrently with any -// other BoringSSL function. -// -// Instead of calling this function, allow memory from custom extensions to be -// released on process exit, along with other global program state. -OPENSSL_EXPORT void X509V3_EXT_cleanup(void); - OPENSSL_EXPORT const X509V3_EXT_METHOD *X509V3_EXT_get( const X509_EXTENSION *ext); OPENSSL_EXPORT const X509V3_EXT_METHOD *X509V3_EXT_get_nid(int nid); From 298e6c2b9c97ca17ee8cf65d24819ec19420013c Mon Sep 17 00:00:00 2001 From: Nabil Wadih Date: Tue, 4 Apr 2023 13:39:27 -0700 Subject: [PATCH 08/56] expose a reset API on hmac which resets the current instance back to its original state keeping the same key as initially used Change-Id: Ie781e2a20da26b50b34f35ea0a5cfc578b64ee7f Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58565 Reviewed-by: Bob Beck Commit-Queue: Bob Beck --- rust/bssl-crypto/src/hmac.rs | 56 ++++++++++++++++++++++++++++++++++-- 1 file changed, 54 insertions(+), 2 deletions(-) diff --git a/rust/bssl-crypto/src/hmac.rs b/rust/bssl-crypto/src/hmac.rs index 3da5f31f21..7dbf39ba5b 100644 --- a/rust/bssl-crypto/src/hmac.rs +++ b/rust/bssl-crypto/src/hmac.rs @@ -79,6 +79,11 @@ impl HmacSha256 { pub fn verify_truncated_left(self, tag: &[u8]) -> Result<(), MacError> { self.0.verify_truncated_left(tag) } + + /// Resets the hmac instance to its initial state + pub fn reset(&mut self) { + self.0.reset() + } } /// The BoringSSL HMAC-SHA512 implementation. The operations may panic if memory allocation fails @@ -120,6 +125,11 @@ impl HmacSha512 { pub fn verify_truncated_left(self, tag: &[u8]) -> Result<(), MacError> { self.0.verify_truncated_left(tag) } + + /// Resets the hmac instance to its initial state + pub fn reset(&mut self) { + self.0.reset() + } } /// Error type for when the output of the hmac operation is not equal to the expected value. @@ -268,6 +278,27 @@ impl Hmac { .then_some(()) .ok_or(MacError) } + + /// Resets the hmac instance to its original state + fn reset(&mut self) { + // Passing a null ptr for the key will re-use the existing key + // Safety: + // - HMAC_Init_ex must be called with a context previously created with HMAC_CTX_new, + // which will always be the case if it is coming from self + // - HMAC_Init_ex may return an error if key is null but the md is different from + // before. The MD is guaranteed to be the same because it comes from the same generic param + // - HMAC_Init_ex returns 0 on allocation failure in which case we panic + let result = unsafe { + bssl_sys::HMAC_Init_ex( + self.ctx, + ptr::null_mut(), + 0, + M::get_md().as_ptr(), + ptr::null_mut(), + ) + }; + assert!(result > 0, "Allocation failure in bssl_sys::HMAC_Init_ex"); + } } impl Drop for Hmac { @@ -295,8 +326,29 @@ mod tests { hmac.update(data); let hmac_result: [u8; 32] = hmac.finalize(); - // let hmac_result = - // hmac(Md::sha256(), &key, data, &mut out).expect("Couldn't calculate sha256 hmac"); + assert_eq!(&hmac_result, &expected_hmac); + } + + #[test] + fn hmac_sha256_reset_test() { + let expected_hmac = [ + 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53, 0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0xb, + 0xf1, 0x2b, 0x88, 0x1d, 0xc2, 0x0, 0xc9, 0x83, 0x3d, 0xa7, 0x26, 0xe9, 0x37, 0x6c, + 0x2e, 0x32, 0xcf, 0xf7, + ]; + + let key: [u8; 20] = [0x0b; 20]; + let data = b"Hi There"; + let incorrect_data = b"This data does not match the expected mac"; + + let mut hmac = HmacSha256::new_from_slice(&key); + hmac.update(incorrect_data); + hmac.reset(); + + // hmac should be back to original state, so now when we update with the correct data it + // should work + hmac.update(data); + let hmac_result: [u8; 32] = hmac.finalize(); assert_eq!(&hmac_result, &expected_hmac); } From 4ae4fb76c809bfc48a5ab100670395ce404244ce Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Tue, 11 Apr 2023 18:25:37 +0000 Subject: [PATCH 09/56] Drop CECPQ2 support. HRSS itself remains in libcrypto because there are some direct users of it. But this will let it be dropped by the linker in many cases. Change-Id: I870eda30c9ed1d08693c770e9e7df45a2711b7df Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58645 Commit-Queue: Adam Langley Reviewed-by: David Benjamin Reviewed-by: Adam Langley --- crypto/obj/obj_dat.h | 4 +- crypto/obj/obj_mac.num | 1 - crypto/obj/objects.txt | 1 - include/openssl/nid.h | 3 - include/openssl/ssl.h | 1 - ssl/extensions.cc | 3 +- ssl/ssl_key_share.cc | 98 --- ssl/ssl_test.cc | 4 +- ssl/test/fuzzer.h | 5 +- ssl/test/runner/common.go | 18 +- ssl/test/runner/handshake_server.go | 6 +- ssl/test/runner/hrss/hrss.go | 1212 --------------------------- ssl/test/runner/key_agreement.go | 89 +- ssl/test/runner/runner.go | 68 +- ssl/test/test_config.cc | 4 +- 15 files changed, 57 insertions(+), 1460 deletions(-) delete mode 100644 ssl/test/runner/hrss/hrss.go diff --git a/crypto/obj/obj_dat.h b/crypto/obj/obj_dat.h index d879233abf..7cd11536bc 100644 --- a/crypto/obj/obj_dat.h +++ b/crypto/obj/obj_dat.h @@ -8777,7 +8777,7 @@ static const ASN1_OBJECT kObjects[NUM_NID] = { {"AuthPSK", "auth-psk", NID_auth_psk, 0, NULL, 0}, {"KxANY", "kx-any", NID_kx_any, 0, NULL, 0}, {"AuthANY", "auth-any", NID_auth_any, 0, NULL, 0}, - {"CECPQ2", "CECPQ2", NID_CECPQ2, 0, NULL, 0}, + {NULL, NULL, NID_undef, 0, NULL, 0}, {"ED448", "ED448", NID_ED448, 3, &kObjectData[6181], 0}, {"X448", "X448", NID_X448, 3, &kObjectData[6184], 0}, {"SHA512-256", "sha512-256", NID_sha512_256, 9, &kObjectData[6187], 0}, @@ -8846,7 +8846,6 @@ static const uint16_t kNIDsInShortNameOrder[] = { 110 /* CAST5-CFB */, 109 /* CAST5-ECB */, 111 /* CAST5-OFB */, - 959 /* CECPQ2 */, 894 /* CMAC */, 13 /* CN */, 141 /* CRLReason */, @@ -9758,7 +9757,6 @@ static const uint16_t kNIDsInLongNameOrder[] = { 285 /* Biometric Info */, 179 /* CA Issuers */, 785 /* CA Repository */, - 959 /* CECPQ2 */, 131 /* Code Signing */, 783 /* Diffie-Hellman based MAC */, 382 /* Directory */, diff --git a/crypto/obj/obj_mac.num b/crypto/obj/obj_mac.num index c0473bca32..583f6e3648 100644 --- a/crypto/obj/obj_mac.num +++ b/crypto/obj/obj_mac.num @@ -947,7 +947,6 @@ auth_ecdsa 955 auth_psk 956 kx_any 957 auth_any 958 -CECPQ2 959 ED448 960 X448 961 sha512_256 962 diff --git a/crypto/obj/objects.txt b/crypto/obj/objects.txt index 11151f920c..cad6a3bc79 100644 --- a/crypto/obj/objects.txt +++ b/crypto/obj/objects.txt @@ -1333,7 +1333,6 @@ secg-scheme 14 3 : dhSinglePass-cofactorDH-sha512kdf-scheme : dh-cofactor-kdf # NIDs for post quantum key agreements (no corresponding OIDs). - : CECPQ2 : X25519Kyber768 : P256Kyber768 : P384Kyber768 diff --git a/include/openssl/nid.h b/include/openssl/nid.h index cf5691d71d..64c9c9c335 100644 --- a/include/openssl/nid.h +++ b/include/openssl/nid.h @@ -4235,9 +4235,6 @@ extern "C" { #define LN_auth_any "auth-any" #define NID_auth_any 958 -#define SN_CECPQ2 "CECPQ2" -#define NID_CECPQ2 959 - #define SN_ED448 "ED448" #define NID_ED448 960 #define OBJ_ED448 1L, 3L, 101L, 113L diff --git a/include/openssl/ssl.h b/include/openssl/ssl.h index 68253bd174..da78d1a5ae 100644 --- a/include/openssl/ssl.h +++ b/include/openssl/ssl.h @@ -2334,7 +2334,6 @@ OPENSSL_EXPORT int SSL_set1_curves_list(SSL *ssl, const char *curves); #define SSL_CURVE_SECP384R1 24 #define SSL_CURVE_SECP521R1 25 #define SSL_CURVE_X25519 29 -#define SSL_CURVE_CECPQ2 16696 #define SSL_CURVE_X25519KYBER768 0x6399 #define SSL_CURVE_P256KYBER768 0xfe32 diff --git a/ssl/extensions.cc b/ssl/extensions.cc index ba92360355..4d9651b794 100644 --- a/ssl/extensions.cc +++ b/ssl/extensions.cc @@ -206,7 +206,6 @@ static bool tls1_check_duplicate_extensions(const CBS *cbs) { static bool is_post_quantum_group(uint16_t id) { switch (id) { - case SSL_CURVE_CECPQ2: case SSL_CURVE_X25519KYBER768: case SSL_CURVE_P256KYBER768: return true; @@ -414,7 +413,7 @@ bool tls1_set_curves_list(Array *out_group_ids, const char *curves) { bool tls1_check_group_id(const SSL_HANDSHAKE *hs, uint16_t group_id) { if (is_post_quantum_group(group_id) && ssl_protocol_version(hs->ssl) < TLS1_3_VERSION) { - // CECPQ2(b) requires TLS 1.3. + // Post-quantum "groups" require TLS 1.3. return false; } diff --git a/ssl/ssl_key_share.cc b/ssl/ssl_key_share.cc index 5741c6b2e5..8885246f3e 100644 --- a/ssl/ssl_key_share.cc +++ b/ssl/ssl_key_share.cc @@ -192,101 +192,6 @@ class X25519KeyShare : public SSLKeyShare { uint8_t private_key_[32]; }; -class CECPQ2KeyShare : public SSLKeyShare { - public: - CECPQ2KeyShare() {} - - uint16_t GroupID() const override { return SSL_CURVE_CECPQ2; } - - bool Generate(CBB *out) override { - uint8_t x25519_public_key[32]; - X25519_keypair(x25519_public_key, x25519_private_key_); - - uint8_t hrss_entropy[HRSS_GENERATE_KEY_BYTES]; - HRSS_public_key hrss_public_key; - RAND_bytes(hrss_entropy, sizeof(hrss_entropy)); - if (!HRSS_generate_key(&hrss_public_key, &hrss_private_key_, - hrss_entropy)) { - return false; - } - - uint8_t hrss_public_key_bytes[HRSS_PUBLIC_KEY_BYTES]; - HRSS_marshal_public_key(hrss_public_key_bytes, &hrss_public_key); - - if (!CBB_add_bytes(out, x25519_public_key, sizeof(x25519_public_key)) || - !CBB_add_bytes(out, hrss_public_key_bytes, - sizeof(hrss_public_key_bytes))) { - return false; - } - - return true; - } - - bool Encap(CBB *out_ciphertext, Array *out_secret, - uint8_t *out_alert, Span peer_key) override { - Array secret; - if (!secret.Init(32 + HRSS_KEY_BYTES)) { - return false; - } - - uint8_t x25519_public_key[32]; - X25519_keypair(x25519_public_key, x25519_private_key_); - - HRSS_public_key peer_public_key; - if (peer_key.size() != 32 + HRSS_PUBLIC_KEY_BYTES || - !HRSS_parse_public_key(&peer_public_key, peer_key.data() + 32) || - !X25519(secret.data(), x25519_private_key_, peer_key.data())) { - *out_alert = SSL_AD_DECODE_ERROR; - OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_ECPOINT); - return false; - } - - uint8_t ciphertext[HRSS_CIPHERTEXT_BYTES]; - uint8_t entropy[HRSS_ENCAP_BYTES]; - RAND_bytes(entropy, sizeof(entropy)); - - if (!HRSS_encap(ciphertext, secret.data() + 32, &peer_public_key, - entropy) || - !CBB_add_bytes(out_ciphertext, x25519_public_key, - sizeof(x25519_public_key)) || - !CBB_add_bytes(out_ciphertext, ciphertext, sizeof(ciphertext))) { - return false; - } - - *out_secret = std::move(secret); - return true; - } - - bool Decap(Array *out_secret, uint8_t *out_alert, - Span ciphertext) override { - *out_alert = SSL_AD_INTERNAL_ERROR; - - Array secret; - if (!secret.Init(32 + HRSS_KEY_BYTES)) { - return false; - } - - if (ciphertext.size() != 32 + HRSS_CIPHERTEXT_BYTES || - !X25519(secret.data(), x25519_private_key_, ciphertext.data())) { - *out_alert = SSL_AD_DECODE_ERROR; - OPENSSL_PUT_ERROR(SSL, SSL_R_BAD_ECPOINT); - return false; - } - - if (!HRSS_decap(secret.data() + 32, &hrss_private_key_, - ciphertext.data() + 32, ciphertext.size() - 32)) { - return false; - } - - *out_secret = std::move(secret); - return true; - } - - private: - uint8_t x25519_private_key_[32]; - HRSS_private_key hrss_private_key_; -}; - class X25519Kyber768KeyShare : public SSLKeyShare { public: X25519Kyber768KeyShare() {} @@ -405,7 +310,6 @@ constexpr NamedGroup kNamedGroups[] = { {NID_secp384r1, SSL_CURVE_SECP384R1, "P-384", "secp384r1"}, {NID_secp521r1, SSL_CURVE_SECP521R1, "P-521", "secp521r1"}, {NID_X25519, SSL_CURVE_X25519, "X25519", "x25519"}, - {NID_CECPQ2, SSL_CURVE_CECPQ2, "CECPQ2", "CECPQ2"}, {NID_X25519Kyber768, SSL_CURVE_X25519KYBER768, "X25519KYBER", "X25519Kyber"}, {NID_P256Kyber768, SSL_CURVE_P256KYBER768, "P256KYBER", "P256Kyber"}, @@ -429,8 +333,6 @@ UniquePtr SSLKeyShare::Create(uint16_t group_id) { return MakeUnique(NID_secp521r1, SSL_CURVE_SECP521R1); case SSL_CURVE_X25519: return MakeUnique(); - case SSL_CURVE_CECPQ2: - return MakeUnique(); case SSL_CURVE_X25519KYBER768: return MakeUnique(); case SSL_CURVE_P256KYBER768: diff --git a/ssl/ssl_test.cc b/ssl/ssl_test.cc index 85c06a5080..854068f44b 100644 --- a/ssl/ssl_test.cc +++ b/ssl/ssl_test.cc @@ -401,8 +401,8 @@ static const CurveTest kCurveTests[] = { { SSL_CURVE_SECP256R1 }, }, { - "P-256:CECPQ2", - { SSL_CURVE_SECP256R1, SSL_CURVE_CECPQ2 }, + "P-256:X25519KYBER", + { SSL_CURVE_SECP256R1, SSL_CURVE_X25519KYBER768 }, }, { diff --git a/ssl/test/fuzzer.h b/ssl/test/fuzzer.h index 00b5e84431..8f73fc01a1 100644 --- a/ssl/test/fuzzer.h +++ b/ssl/test/fuzzer.h @@ -418,8 +418,9 @@ class TLSFuzzer { return false; } - static const int kCurves[] = {NID_CECPQ2, NID_X25519, NID_X9_62_prime256v1, - NID_secp384r1, NID_secp521r1}; + static const int kCurves[] = {NID_X25519Kyber768, NID_X25519, + NID_X9_62_prime256v1, NID_secp384r1, + NID_secp521r1}; if (!SSL_CTX_set1_curves(ctx_.get(), kCurves, OPENSSL_ARRAY_SIZE(kCurves))) { return false; diff --git a/ssl/test/runner/common.go b/ssl/test/runner/common.go index 38542831fd..ce06779be0 100644 --- a/ssl/test/runner/common.go +++ b/ssl/test/runner/common.go @@ -148,12 +148,12 @@ var tls13HelloRetryRequest = []uint8{ type CurveID uint16 const ( - CurveP224 CurveID = 21 - CurveP256 CurveID = 23 - CurveP384 CurveID = 24 - CurveP521 CurveID = 25 - CurveX25519 CurveID = 29 - CurveCECPQ2 CurveID = 16696 + CurveP224 CurveID = 21 + CurveP256 CurveID = 23 + CurveP384 CurveID = 24 + CurveP521 CurveID = 25 + CurveX25519 CurveID = 29 + CurveX25519Kyber768 CurveID = 0x6399 ) // TLS Elliptic Curve Point Formats @@ -1890,9 +1890,9 @@ type ProtocolBugs struct { // hello retry. FailIfHelloRetryRequested bool - // FailedIfCECPQ2Offered will cause a server to reject a ClientHello if CECPQ2 + // FailedIfKyberOffered will cause a server to reject a ClientHello if Kyber // is supported. - FailIfCECPQ2Offered bool + FailIfKyberOffered bool // ExpectKeyShares, if not nil, lists (in order) the curves that a ClientHello // should have key shares for. @@ -1996,7 +1996,7 @@ func (c *Config) maxVersion(isDTLS bool) uint16 { return ret } -var defaultCurvePreferences = []CurveID{CurveCECPQ2, CurveX25519, CurveP256, CurveP384, CurveP521} +var defaultCurvePreferences = []CurveID{CurveX25519, CurveP256, CurveP384, CurveP521} func (c *Config) curvePreferences() []CurveID { if c == nil || len(c.CurvePreferences) == 0 { diff --git a/ssl/test/runner/handshake_server.go b/ssl/test/runner/handshake_server.go index de297a6635..4f3cf7546a 100644 --- a/ssl/test/runner/handshake_server.go +++ b/ssl/test/runner/handshake_server.go @@ -280,10 +280,10 @@ func (hs *serverHandshakeState) readClientHello() error { } } - if config.Bugs.FailIfCECPQ2Offered { + if config.Bugs.FailIfKyberOffered { for _, offeredCurve := range hs.clientHello.supportedCurves { if isPqGroup(offeredCurve) { - return errors.New("tls: CECPQ2 was offered") + return errors.New("tls: X25519Kyber768 was offered") } } } @@ -1467,7 +1467,7 @@ func (hs *serverHandshakeState) processClientHello() (isResume bool, err error) Curves: for _, curve := range hs.clientHello.supportedCurves { if isPqGroup(curve) && c.vers < VersionTLS13 { - // CECPQ2 is TLS 1.3-only. + // Post-quantum is TLS 1.3 only. continue } diff --git a/ssl/test/runner/hrss/hrss.go b/ssl/test/runner/hrss/hrss.go deleted file mode 100644 index 9f4fdd776b..0000000000 --- a/ssl/test/runner/hrss/hrss.go +++ /dev/null @@ -1,1212 +0,0 @@ -package hrss - -import ( - "crypto/hmac" - "crypto/sha256" - "crypto/subtle" - "encoding/binary" - "io" - "math/bits" -) - -const ( - PublicKeySize = modQBytes - CiphertextSize = modQBytes -) - -const ( - N = 701 - Q = 8192 - mod3Bytes = 140 - modQBytes = 1138 -) - -const ( - bitsPerWord = bits.UintSize - wordsPerPoly = (N + bitsPerWord - 1) / bitsPerWord - fullWordsPerPoly = N / bitsPerWord - bitsInLastWord = N % bitsPerWord -) - -// poly3 represents a degree-N polynomial over GF(3). Each coefficient is -// bitsliced across the |s| and |a| arrays, like this: -// -// s | a | value -// ----------------- -// 0 | 0 | 0 -// 0 | 1 | 1 -// 1 | 0 | 2 (aka -1) -// 1 | 1 | -// -// ('s' is for sign, and 'a' is just a letter.) -// -// Once bitsliced as such, the following circuits can be used to implement -// addition and multiplication mod 3: -// -// (s3, a3) = (s1, a1) × (s2, a2) -// s3 = (s2 ∧ a1) ⊕ (s1 ∧ a2) -// a3 = (s1 ∧ s2) ⊕ (a1 ∧ a2) -// -// (s3, a3) = (s1, a1) + (s2, a2) -// t1 = ~(s1 ∨ a1) -// t2 = ~(s2 ∨ a2) -// s3 = (a1 ∧ a2) ⊕ (t1 ∧ s2) ⊕ (t2 ∧ s1) -// a3 = (s1 ∧ s2) ⊕ (t1 ∧ a2) ⊕ (t2 ∧ a1) -// -// Negating a value just involves swapping s and a. -type poly3 struct { - s [wordsPerPoly]uint - a [wordsPerPoly]uint -} - -func (p *poly3) trim() { - p.s[wordsPerPoly-1] &= (1 << bitsInLastWord) - 1 - p.a[wordsPerPoly-1] &= (1 << bitsInLastWord) - 1 -} - -func (p *poly3) zero() { - for i := range p.a { - p.s[i] = 0 - p.a[i] = 0 - } -} - -func (p *poly3) fromDiscrete(in *poly) { - var shift uint - s := p.s[:] - a := p.a[:] - s[0] = 0 - a[0] = 0 - - for _, v := range in { - s[0] >>= 1 - s[0] |= uint((v>>1)&1) << (bitsPerWord - 1) - a[0] >>= 1 - a[0] |= uint(v&1) << (bitsPerWord - 1) - shift++ - if shift == bitsPerWord { - s = s[1:] - a = a[1:] - s[0] = 0 - a[0] = 0 - shift = 0 - } - } - - a[0] >>= bitsPerWord - shift - s[0] >>= bitsPerWord - shift -} - -func (p *poly3) fromModQ(in *poly) int { - var shift uint - s := p.s[:] - a := p.a[:] - s[0] = 0 - a[0] = 0 - ok := 1 - - for _, v := range in { - vMod3, vOk := modQToMod3(v) - ok &= vOk - - s[0] >>= 1 - s[0] |= uint((vMod3>>1)&1) << (bitsPerWord - 1) - a[0] >>= 1 - a[0] |= uint(vMod3&1) << (bitsPerWord - 1) - shift++ - if shift == bitsPerWord { - s = s[1:] - a = a[1:] - s[0] = 0 - a[0] = 0 - shift = 0 - } - } - - a[0] >>= bitsPerWord - shift - s[0] >>= bitsPerWord - shift - - return ok -} - -func (p *poly3) fromDiscreteMod3(in *poly) { - var shift uint - s := p.s[:] - a := p.a[:] - s[0] = 0 - a[0] = 0 - - for _, v := range in { - // This duplicates the 13th bit upwards to the top of the - // uint16, essentially treating it as a sign bit and converting - // into a signed int16. The signed value is reduced mod 3, - // yeilding {-2, -1, 0, 1, 2}. - v = uint16((int16(v<<3)>>3)%3) & 7 - - // We want to map v thus: - // {-2, -1, 0, 1, 2} -> {1, 2, 0, 1, 2}. We take the bottom - // three bits and then the constants below, when shifted by - // those three bits, perform the required mapping. - s[0] >>= 1 - s[0] |= (0xbc >> v) << (bitsPerWord - 1) - a[0] >>= 1 - a[0] |= (0x7a >> v) << (bitsPerWord - 1) - shift++ - if shift == bitsPerWord { - s = s[1:] - a = a[1:] - s[0] = 0 - a[0] = 0 - shift = 0 - } - } - - a[0] >>= bitsPerWord - shift - s[0] >>= bitsPerWord - shift -} - -func (p *poly3) marshal(out []byte) { - s := p.s[:] - a := p.a[:] - sw := s[0] - aw := a[0] - var shift int - - for i := 0; i < 700; i += 5 { - acc, scale := 0, 1 - for j := 0; j < 5; j++ { - v := int(aw&1) | int(sw&1)<<1 - acc += scale * v - scale *= 3 - - shift++ - if shift == bitsPerWord { - s = s[1:] - a = a[1:] - sw = s[0] - aw = a[0] - shift = 0 - } else { - sw >>= 1 - aw >>= 1 - } - } - - out[0] = byte(acc) - out = out[1:] - } -} - -func (p *poly) fromMod2(in *poly2) { - var shift uint - words := in[:] - word := words[0] - - for i := range p { - p[i] = uint16(word & 1) - word >>= 1 - shift++ - if shift == bitsPerWord { - words = words[1:] - word = words[0] - shift = 0 - } - } -} - -func (p *poly) fromMod3(in *poly3) { - var shift uint - s := in.s[:] - a := in.a[:] - sw := s[0] - aw := a[0] - - for i := range p { - p[i] = uint16(aw&1 | (sw&1)<<1) - aw >>= 1 - sw >>= 1 - shift++ - if shift == bitsPerWord { - a = a[1:] - s = s[1:] - aw = a[0] - sw = s[0] - shift = 0 - } - } -} - -func (p *poly) fromMod3ToModQ(in *poly3) { - var shift uint - s := in.s[:] - a := in.a[:] - sw := s[0] - aw := a[0] - - for i := range p { - p[i] = mod3ToModQ(uint16(aw&1 | (sw&1)<<1)) - aw >>= 1 - sw >>= 1 - shift++ - if shift == bitsPerWord { - a = a[1:] - s = s[1:] - aw = a[0] - sw = s[0] - shift = 0 - } - } -} - -func lsbToAll(v uint) uint { - return uint(int(v<<(bitsPerWord-1)) >> (bitsPerWord - 1)) -} - -func (p *poly3) mulConst(ms, ma uint) { - ms = lsbToAll(ms) - ma = lsbToAll(ma) - - for i := range p.a { - p.s[i], p.a[i] = (ma&p.s[i])^(ms&p.a[i]), (ma&p.a[i])^(ms&p.s[i]) - } -} - -func cmovWords(out, in *[wordsPerPoly]uint, mov uint) { - for i := range out { - out[i] = (out[i] & ^mov) | (in[i] & mov) - } -} - -func rotWords(out, in *[wordsPerPoly]uint, bits uint) { - start := bits / bitsPerWord - n := (N - bits) / bitsPerWord - - for i := uint(0); i < n; i++ { - out[i] = in[start+i] - } - - carry := in[wordsPerPoly-1] - - for i := uint(0); i < start; i++ { - out[n+i] = carry | in[i]<> (bitsPerWord - bitsInLastWord) - } - - out[wordsPerPoly-1] = carry -} - -// rotBits right-rotates the bits in |in|. bits must be a non-zero power of two -// and less than bitsPerWord. -func rotBits(out, in *[wordsPerPoly]uint, bits uint) { - if (bits == 0 || (bits & (bits - 1)) != 0 || bits > bitsPerWord/2 || bitsInLastWord < bitsPerWord/2) { - panic("internal error"); - } - - carry := in[wordsPerPoly-1] << (bitsPerWord - bits) - - for i := wordsPerPoly - 2; i >= 0; i-- { - out[i] = carry | in[i]>>bits - carry = in[i] << (bitsPerWord - bits) - } - - out[wordsPerPoly-1] = carry>>(bitsPerWord-bitsInLastWord) | in[wordsPerPoly-1]>>bits -} - -func (p *poly3) rotWords(bits uint, in *poly3) { - rotWords(&p.s, &in.s, bits) - rotWords(&p.a, &in.a, bits) -} - -func (p *poly3) rotBits(bits uint, in *poly3) { - rotBits(&p.s, &in.s, bits) - rotBits(&p.a, &in.a, bits) -} - -func (p *poly3) cmov(in *poly3, mov uint) { - cmovWords(&p.s, &in.s, mov) - cmovWords(&p.a, &in.a, mov) -} - -func (p *poly3) rot(bits uint) { - if bits > N { - panic("invalid") - } - var shifted poly3 - - shift := uint(9) - for ; (1 << shift) >= bitsPerWord; shift-- { - shifted.rotWords(1<>shift)) - } - for ; shift < 9; shift-- { - shifted.rotBits(1<>shift)) - } -} - -func (p *poly3) fmadd(ms, ma uint, in *poly3) { - ms = lsbToAll(ms) - ma = lsbToAll(ma) - - for i := range p.a { - products := (ma & in.s[i]) ^ (ms & in.a[i]) - producta := (ma & in.a[i]) ^ (ms & in.s[i]) - - ns1Ana1 := ^p.s[i] & ^p.a[i] - ns2Ana2 := ^products & ^producta - - p.s[i], p.a[i] = (p.a[i]&producta)^(ns1Ana1&products)^(p.s[i]&ns2Ana2), (p.s[i]&products)^(ns1Ana1&producta)^(p.a[i]&ns2Ana2) - } -} - -func (p *poly3) modPhiN() { - factora := uint(int(p.s[wordsPerPoly-1]<<(bitsPerWord-bitsInLastWord)) >> (bitsPerWord - 1)) - factors := uint(int(p.a[wordsPerPoly-1]<<(bitsPerWord-bitsInLastWord)) >> (bitsPerWord - 1)) - ns2Ana2 := ^factors & ^factora - - for i := range p.s { - ns1Ana1 := ^p.s[i] & ^p.a[i] - p.s[i], p.a[i] = (p.a[i]&factora)^(ns1Ana1&factors)^(p.s[i]&ns2Ana2), (p.s[i]&factors)^(ns1Ana1&factora)^(p.a[i]&ns2Ana2) - } -} - -func (p *poly3) cswap(other *poly3, swap uint) { - for i := range p.s { - sums := swap & (p.s[i] ^ other.s[i]) - p.s[i] ^= sums - other.s[i] ^= sums - - suma := swap & (p.a[i] ^ other.a[i]) - p.a[i] ^= suma - other.a[i] ^= suma - } -} - -func (p *poly3) mulx() { - carrys := (p.s[wordsPerPoly-1] >> (bitsInLastWord - 1)) & 1 - carrya := (p.a[wordsPerPoly-1] >> (bitsInLastWord - 1)) & 1 - - for i := range p.s { - outCarrys := p.s[i] >> (bitsPerWord - 1) - outCarrya := p.a[i] >> (bitsPerWord - 1) - p.s[i] <<= 1 - p.a[i] <<= 1 - p.s[i] |= carrys - p.a[i] |= carrya - carrys = outCarrys - carrya = outCarrya - } -} - -func (p *poly3) divx() { - var carrys, carrya uint - - for i := len(p.s) - 1; i >= 0; i-- { - outCarrys := p.s[i] & 1 - outCarrya := p.a[i] & 1 - p.s[i] >>= 1 - p.a[i] >>= 1 - p.s[i] |= carrys << (bitsPerWord - 1) - p.a[i] |= carrya << (bitsPerWord - 1) - carrys = outCarrys - carrya = outCarrya - } -} - -type poly2 [wordsPerPoly]uint - -func (p *poly2) fromDiscrete(in *poly) { - var shift uint - words := p[:] - words[0] = 0 - - for _, v := range in { - words[0] >>= 1 - words[0] |= uint(v&1) << (bitsPerWord - 1) - shift++ - if shift == bitsPerWord { - words = words[1:] - words[0] = 0 - shift = 0 - } - } - - words[0] >>= bitsPerWord - shift -} - -func (p *poly2) setPhiN() { - for i := range p { - p[i] = ^uint(0) - } - p[wordsPerPoly-1] &= (1 << bitsInLastWord) - 1 -} - -func (p *poly2) cswap(other *poly2, swap uint) { - for i := range p { - sum := swap & (p[i] ^ other[i]) - p[i] ^= sum - other[i] ^= sum - } -} - -func (p *poly2) fmadd(m uint, in *poly2) { - m = ^(m - 1) - - for i := range p { - p[i] ^= in[i] & m - } -} - -func (p *poly2) lshift1() { - var carry uint - for i := range p { - nextCarry := p[i] >> (bitsPerWord - 1) - p[i] <<= 1 - p[i] |= carry - carry = nextCarry - } -} - -func (p *poly2) rshift1() { - var carry uint - for i := len(p) - 1; i >= 0; i-- { - nextCarry := p[i] & 1 - p[i] >>= 1 - p[i] |= carry << (bitsPerWord - 1) - carry = nextCarry - } -} - -func (p *poly2) rot(bits uint) { - if bits > N { - panic("invalid") - } - var shifted [wordsPerPoly]uint - out := (*[wordsPerPoly]uint)(p) - - shift := uint(9) - for ; (1 << shift) >= bitsPerWord; shift-- { - rotWords(&shifted, out, 1<>shift)) - } - for ; shift < 9; shift-- { - rotBits(&shifted, out, 1<>shift)) - } -} - -type poly [N]uint16 - -func (in *poly) marshal(out []byte) { - p := in[:] - - for len(p) >= 8 { - out[0] = byte(p[0]) - out[1] = byte(p[0]>>8) | byte((p[1]&0x07)<<5) - out[2] = byte(p[1] >> 3) - out[3] = byte(p[1]>>11) | byte((p[2]&0x3f)<<2) - out[4] = byte(p[2]>>6) | byte((p[3]&0x01)<<7) - out[5] = byte(p[3] >> 1) - out[6] = byte(p[3]>>9) | byte((p[4]&0x0f)<<4) - out[7] = byte(p[4] >> 4) - out[8] = byte(p[4]>>12) | byte((p[5]&0x7f)<<1) - out[9] = byte(p[5]>>7) | byte((p[6]&0x03)<<6) - out[10] = byte(p[6] >> 2) - out[11] = byte(p[6]>>10) | byte((p[7]&0x1f)<<3) - out[12] = byte(p[7] >> 5) - - p = p[8:] - out = out[13:] - } - - // There are four remaining values. - out[0] = byte(p[0]) - out[1] = byte(p[0]>>8) | byte((p[1]&0x07)<<5) - out[2] = byte(p[1] >> 3) - out[3] = byte(p[1]>>11) | byte((p[2]&0x3f)<<2) - out[4] = byte(p[2]>>6) | byte((p[3]&0x01)<<7) - out[5] = byte(p[3] >> 1) - out[6] = byte(p[3] >> 9) -} - -func (out *poly) unmarshal(in []byte) bool { - p := out[:] - for i := 0; i < 87; i++ { - p[0] = uint16(in[0]) | uint16(in[1]&0x1f)<<8 - p[1] = uint16(in[1]>>5) | uint16(in[2])<<3 | uint16(in[3]&3)<<11 - p[2] = uint16(in[3]>>2) | uint16(in[4]&0x7f)<<6 - p[3] = uint16(in[4]>>7) | uint16(in[5])<<1 | uint16(in[6]&0xf)<<9 - p[4] = uint16(in[6]>>4) | uint16(in[7])<<4 | uint16(in[8]&1)<<12 - p[5] = uint16(in[8]>>1) | uint16(in[9]&0x3f)<<7 - p[6] = uint16(in[9]>>6) | uint16(in[10])<<2 | uint16(in[11]&7)<<10 - p[7] = uint16(in[11]>>3) | uint16(in[12])<<5 - - p = p[8:] - in = in[13:] - } - - // There are four coefficients left over - p[0] = uint16(in[0]) | uint16(in[1]&0x1f)<<8 - p[1] = uint16(in[1]>>5) | uint16(in[2])<<3 | uint16(in[3]&3)<<11 - p[2] = uint16(in[3]>>2) | uint16(in[4]&0x7f)<<6 - p[3] = uint16(in[4]>>7) | uint16(in[5])<<1 | uint16(in[6]&0xf)<<9 - - if in[6]&0xf0 != 0 { - return false - } - - out[N-1] = 0 - var top int - for _, v := range out { - top += int(v) - } - - out[N-1] = uint16(-top) % Q - return true -} - -func (in *poly) marshalS3(out []byte) { - p := in[:] - for len(p) >= 5 { - out[0] = byte(p[0] + p[1]*3 + p[2]*9 + p[3]*27 + p[4]*81) - out = out[1:] - p = p[5:] - } -} - -func (out *poly) unmarshalS3(in []byte) bool { - p := out[:] - for i := 0; i < 140; i++ { - c := in[0] - if c >= 243 { - return false - } - p[0] = uint16(c % 3) - p[1] = uint16((c / 3) % 3) - p[2] = uint16((c / 9) % 3) - p[3] = uint16((c / 27) % 3) - p[4] = uint16((c / 81) % 3) - - p = p[5:] - in = in[1:] - } - - out[N-1] = 0 - return true -} - -func (p *poly) modPhiN() { - for i := range p { - p[i] = (p[i] + Q - p[N-1]) % Q - } -} - -func (out *poly) shortSample(in []byte) { - // b a result - // 00 00 00 - // 00 01 01 - // 00 10 10 - // 00 11 11 - // 01 00 10 - // 01 01 00 - // 01 10 01 - // 01 11 11 - // 10 00 01 - // 10 01 10 - // 10 10 00 - // 10 11 11 - // 11 00 11 - // 11 01 11 - // 11 10 11 - // 11 11 11 - - // 1111 1111 1100 1001 1101 0010 1110 0100 - // f f c 9 d 2 e 4 - const lookup = uint32(0xffc9d2e4) - - p := out[:] - for i := 0; i < 87; i++ { - v := binary.LittleEndian.Uint32(in) - v2 := (v & 0x55555555) + ((v >> 1) & 0x55555555) - for j := 0; j < 8; j++ { - p[j] = uint16(lookup >> ((v2 & 15) << 1) & 3) - v2 >>= 4 - } - p = p[8:] - in = in[4:] - } - - // There are four values remaining. - v := binary.LittleEndian.Uint32(in) - v2 := (v & 0x55555555) + ((v >> 1) & 0x55555555) - for j := 0; j < 4; j++ { - p[j] = uint16(lookup >> ((v2 & 15) << 1) & 3) - v2 >>= 4 - } - - out[N-1] = 0 -} - -func (out *poly) shortSamplePlus(in []byte) { - out.shortSample(in) - - var sum uint16 - for i := 0; i < N-1; i++ { - sum += mod3ResultToModQ(out[i] * out[i+1]) - } - - scale := 1 + (1 & (sum >> 12)) - for i := 0; i < len(out); i += 2 { - out[i] = (out[i] * scale) % 3 - } -} - -func mul(out, scratch, a, b []uint16) { - const schoolbookLimit = 32 - if len(a) < schoolbookLimit { - for i := 0; i < len(a)*2; i++ { - out[i] = 0 - } - for i := range a { - for j := range b { - out[i+j] += a[i] * b[j] - } - } - return - } - - lowLen := len(a) / 2 - highLen := len(a) - lowLen - aLow, aHigh := a[:lowLen], a[lowLen:] - bLow, bHigh := b[:lowLen], b[lowLen:] - - for i := 0; i < lowLen; i++ { - out[i] = aHigh[i] + aLow[i] - } - if highLen != lowLen { - out[lowLen] = aHigh[lowLen] - } - - for i := 0; i < lowLen; i++ { - out[highLen+i] = bHigh[i] + bLow[i] - } - if highLen != lowLen { - out[highLen+lowLen] = bHigh[lowLen] - } - - mul(scratch, scratch[2*highLen:], out[:highLen], out[highLen:highLen*2]) - mul(out[lowLen*2:], scratch[2*highLen:], aHigh, bHigh) - mul(out, scratch[2*highLen:], aLow, bLow) - - for i := 0; i < lowLen*2; i++ { - scratch[i] -= out[i] + out[lowLen*2+i] - } - if lowLen != highLen { - scratch[lowLen*2] -= out[lowLen*4] - } - - for i := 0; i < 2*highLen; i++ { - out[lowLen+i] += scratch[i] - } -} - -func (out *poly) mul(a, b *poly) { - var prod, scratch [2 * N]uint16 - mul(prod[:], scratch[:], a[:], b[:]) - for i := range out { - out[i] = (prod[i] + prod[i+N]) % Q - } -} - -func (p3 *poly3) mulMod3(x, y *poly3) { - // (𝑥^n - 1) is a multiple of Φ(N) so we can work mod (𝑥^n - 1) here and - // (reduce mod Φ(N) afterwards. - x3 := *x - y3 := *y - s := x3.s[:] - a := x3.a[:] - sw := s[0] - aw := a[0] - p3.zero() - var shift uint - for i := 0; i < N; i++ { - p3.fmadd(sw, aw, &y3) - sw >>= 1 - aw >>= 1 - shift++ - if shift == bitsPerWord { - s = s[1:] - a = a[1:] - sw = s[0] - aw = a[0] - shift = 0 - } - y3.mulx() - } - p3.modPhiN() -} - -// mod3ToModQ maps {0, 1, 2, 3} to {0, 1, Q-1, 0xffff} -// The case of n == 3 should never happen but is included so that modQToMod3 -// can easily catch invalid inputs. -func mod3ToModQ(n uint16) uint16 { - return uint16(uint64(0xffff1fff00010000) >> (16 * n)) -} - -// modQToMod3 maps {0, 1, Q-1} to {(0, 0), (0, 1), (1, 0)} and also returns an int -// which is one if the input is in range and zero otherwise. -func modQToMod3(n uint16) (uint16, int) { - result := (n&3 - (n>>1)&1) - return result, subtle.ConstantTimeEq(int32(mod3ToModQ(result)), int32(n)) -} - -// mod3ResultToModQ maps {0, 1, 2, 4} to {0, 1, Q-1, 1} -func mod3ResultToModQ(n uint16) uint16 { - return ((((uint16(0x13) >> n) & 1) - 1) & 0x1fff) | ((uint16(0x12) >> n) & 1) - //shift := (uint(0x324) >> (2 * n)) & 3 - //return uint16(uint64(0x00011fff00010000) >> (16 * shift)) -} - -// mulXMinus1 sets out to a×(𝑥 - 1) mod (𝑥^n - 1) -func (out *poly) mulXMinus1() { - // Multiplying by (𝑥 - 1) means negating each coefficient and adding in - // the value of the previous one. - origOut700 := out[700] - - for i := N - 1; i > 0; i-- { - out[i] = (Q - out[i] + out[i-1]) % Q - } - out[0] = (Q - out[0] + origOut700) % Q -} - -func (out *poly) lift(a *poly) { - // We wish to calculate a/(𝑥-1) mod Φ(N) over GF(3), where Φ(N) is the - // Nth cyclotomic polynomial, i.e. 1 + 𝑥 + … + 𝑥^700 (since N is prime). - - // 1/(𝑥-1) has a fairly basic structure that we can exploit to speed this up: - // - // R. = PolynomialRing(GF(3)…) - // inv = R.cyclotomic_polynomial(1).inverse_mod(R.cyclotomic_polynomial(n)) - // list(inv)[:15] - // [1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2] - // - // This three-element pattern of coefficients repeats for the whole - // polynomial. - // - // Next define the overbar operator such that z̅ = z[0] + - // reverse(z[1:]). (Index zero of a polynomial here is the coefficient - // of the constant term. So index one is the coefficient of 𝑥 and so - // on.) - // - // A less odd way to define this is to see that z̅ negates the indexes, - // so z̅[0] = z[-0], z̅[1] = z[-1] and so on. - // - // The use of z̅ is that, when working mod (𝑥^701 - 1), vz[0] = , vz[1] = , …. (Where is the inner product: the sum - // of the point-wise products.) Although we calculated the inverse mod - // Φ(N), we can work mod (𝑥^N - 1) and reduce mod Φ(N) at the end. - // (That's because (𝑥^N - 1) is a multiple of Φ(N).) - // - // When working mod (𝑥^N - 1), multiplication by 𝑥 is a right-rotation - // of the list of coefficients. - // - // Thus we can consider what the pattern of z̅, 𝑥z̅, 𝑥^2z̅, … looks like: - // - // def reverse(xs): - // suffix = list(xs[1:]) - // suffix.reverse() - // return [xs[0]] + suffix - // - // def rotate(xs): - // return [xs[-1]] + xs[:-1] - // - // zoverbar = reverse(list(inv) + [0]) - // xzoverbar = rotate(reverse(list(inv) + [0])) - // x2zoverbar = rotate(rotate(reverse(list(inv) + [0]))) - // - // zoverbar[:15] - // [1, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1] - // xzoverbar[:15] - // [0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0] - // x2zoverbar[:15] - // [2, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2] - // - // (For a formula for z̅, see lemma two of appendix B.) - // - // After the first three elements have been taken care of, all then have - // a repeating three-element cycle. The next value (𝑥^3z̅) involves - // three rotations of the first pattern, thus the three-element cycle - // lines up. However, the discontinuity in the first three elements - // obviously moves to a different position. Consider the difference - // between 𝑥^3z̅ and z̅: - // - // [x-y for (x,y) in zip(zoverbar, x3zoverbar)][:15] - // [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] - // - // This pattern of differences is the same for all elements, although it - // obviously moves right with the rotations. - // - // From this, we reach algorithm eight of appendix B. - - // Handle the first three elements of the inner products. - out[0] = a[0] + a[2] - out[1] = a[1] - out[2] = 2*a[0] + a[2] - - // Use the repeating pattern to complete the first three inner products. - for i := 3; i < 699; i += 3 { - out[0] += 2*a[i] + a[i+2] - out[1] += a[i] + 2*a[i+1] - out[2] += a[i+1] + 2*a[i+2] - } - - // Handle the fact that the three-element pattern doesn't fill the - // polynomial exactly (since 701 isn't a multiple of three). - out[2] += a[700] - out[0] += 2 * a[699] - out[1] += a[699] + 2*a[700] - - out[0] = out[0] % 3 - out[1] = out[1] % 3 - out[2] = out[2] % 3 - - // Calculate the remaining inner products by taking advantage of the - // fact that the pattern repeats every three cycles and the pattern of - // differences is moves with the rotation. - for i := 3; i < N; i++ { - // Add twice something is the same as subtracting when working - // mod 3. Doing it this way avoids underflow. Underflow is bad - // because "% 3" doesn't work correctly for negative numbers - // here since underflow will wrap to 2^16-1 and 2^16 isn't a - // multiple of three. - out[i] = (out[i-3] + 2*(a[i-2]+a[i-1]+a[i])) % 3 - } - - // Reduce mod Φ(N) by subtracting a multiple of out[700] from every - // element and convert to mod Q. (See above about adding twice as - // subtraction.) - v := out[700] * 2 - for i := range out { - out[i] = mod3ToModQ((out[i] + v) % 3) - } - - out.mulXMinus1() -} - -func (a *poly) cswap(b *poly, swap uint16) { - for i := range a { - sum := swap & (a[i] ^ b[i]) - a[i] ^= sum - b[i] ^= sum - } -} - -func lt(a, b uint) uint { - if a < b { - return ^uint(0) - } - return 0 -} - -func bsMul(s1, a1, s2, a2 uint) (s3, a3 uint) { - s3 = (a1 & s2) ^ (s1 & a2) - a3 = (a1 & a2) ^ (s1 & s2) - return -} - -func (out *poly3) invertMod3(in *poly3) { - // This algorithm follows algorithm 10 in the paper. (Although note that - // the paper appears to have a bug: k should start at zero, not one.) - // The best explanation for why it works is in the "Why it works" - // section of - // https://assets.onboardsecurity.com/static/downloads/NTRU/resources/NTRUTech014.pdf. - var k uint - degF, degG := uint(N-1), uint(N-1) - - var b, c, g poly3 - f := *in - - for i := range g.a { - g.a[i] = ^uint(0) - } - - b.a[0] = 1 - - var f0s, f0a uint - stillGoing := ^uint(0) - for i := 0; i < 2*(N-1)-1; i++ { - ss, sa := bsMul(f.s[0], f.a[0], g.s[0], g.a[0]) - ss, sa = sa&stillGoing&1, ss&stillGoing&1 - shouldSwap := ^uint(int((ss|sa)-1)>>(bitsPerWord-1)) & lt(degF, degG) - f.cswap(&g, shouldSwap) - b.cswap(&c, shouldSwap) - degF, degG = (degG&shouldSwap)|(degF & ^shouldSwap), (degF&shouldSwap)|(degG&^shouldSwap) - f.fmadd(ss, sa, &g) - b.fmadd(ss, sa, &c) - - f.divx() - f.s[wordsPerPoly-1] &= ((1 << bitsInLastWord) - 1) >> 1 - f.a[wordsPerPoly-1] &= ((1 << bitsInLastWord) - 1) >> 1 - c.mulx() - c.s[0] &= ^uint(1) - c.a[0] &= ^uint(1) - - degF-- - k += 1 & stillGoing - f0s = (stillGoing & f.s[0]) | (^stillGoing & f0s) - f0a = (stillGoing & f.a[0]) | (^stillGoing & f0a) - stillGoing = ^uint(int(degF-1) >> (bitsPerWord - 1)) - } - - k -= N & lt(N, k) - *out = b - out.rot(k) - out.mulConst(f0s, f0a) - out.modPhiN() -} - -func (out *poly) invertMod2(a *poly) { - // This algorithm follows mix of algorithm 10 in the paper and the first - // page of the PDF linked below. (Although note that the paper appears - // to have a bug: k should start at zero, not one.) The best explanation - // for why it works is in the "Why it works" section of - // https://assets.onboardsecurity.com/static/downloads/NTRU/resources/NTRUTech014.pdf. - var k uint - degF, degG := uint(N-1), uint(N-1) - - var f poly2 - f.fromDiscrete(a) - var b, c, g poly2 - g.setPhiN() - b[0] = 1 - - stillGoing := ^uint(0) - for i := 0; i < 2*(N-1)-1; i++ { - s := uint(f[0]&1) & stillGoing - shouldSwap := ^(s - 1) & lt(degF, degG) - f.cswap(&g, shouldSwap) - b.cswap(&c, shouldSwap) - degF, degG = (degG&shouldSwap)|(degF & ^shouldSwap), (degF&shouldSwap)|(degG&^shouldSwap) - f.fmadd(s, &g) - b.fmadd(s, &c) - - f.rshift1() - c.lshift1() - - degF-- - k += 1 & stillGoing - stillGoing = ^uint(int(degF-1) >> (bitsPerWord - 1)) - } - - k -= N & lt(N, k) - b.rot(k) - out.fromMod2(&b) -} - -func (out *poly) invert(origA *poly) { - // Inversion mod Q, which is done based on the result of inverting mod - // 2. See the NTRU paper, page three. - var a, tmp, tmp2, b poly - b.invertMod2(origA) - - // Negate a. - for i := range a { - a[i] = Q - origA[i] - } - - // We are working mod Q=2**13 and we need to iterate ceil(log_2(13)) - // times, which is four. - for i := 0; i < 4; i++ { - tmp.mul(&a, &b) - tmp[0] += 2 - tmp2.mul(&b, &tmp) - b = tmp2 - } - - *out = b -} - -type PublicKey struct { - h poly -} - -func ParsePublicKey(in []byte) (*PublicKey, bool) { - ret := new(PublicKey) - if !ret.h.unmarshal(in) { - return nil, false - } - return ret, true -} - -func (pub *PublicKey) Marshal() []byte { - ret := make([]byte, modQBytes) - pub.h.marshal(ret) - return ret -} - -func (pub *PublicKey) Encap(rand io.Reader) (ciphertext []byte, sharedKey []byte) { - var randBytes [352 + 352]byte - if _, err := io.ReadFull(rand, randBytes[:]); err != nil { - panic("rand failed") - } - - var m, r poly - m.shortSample(randBytes[:352]) - r.shortSample(randBytes[352:]) - - var mBytes, rBytes [mod3Bytes]byte - m.marshalS3(mBytes[:]) - r.marshalS3(rBytes[:]) - - ciphertext = pub.owf(&m, &r) - - h := sha256.New() - h.Write([]byte("shared key\x00")) - h.Write(mBytes[:]) - h.Write(rBytes[:]) - h.Write(ciphertext) - sharedKey = h.Sum(nil) - - return ciphertext, sharedKey -} - -func (pub *PublicKey) owf(m, r *poly) []byte { - for i := range r { - r[i] = mod3ToModQ(r[i]) - } - - var mq poly - mq.lift(m) - - var e poly - e.mul(r, &pub.h) - for i := range e { - e[i] = (e[i] + mq[i]) % Q - } - - ret := make([]byte, modQBytes) - e.marshal(ret[:]) - return ret -} - -type PrivateKey struct { - PublicKey - f, fp poly3 - hInv poly - hmacKey [32]byte -} - -func (priv *PrivateKey) Marshal() []byte { - var ret [2*mod3Bytes + modQBytes]byte - priv.f.marshal(ret[:]) - priv.fp.marshal(ret[mod3Bytes:]) - priv.h.marshal(ret[2*mod3Bytes:]) - return ret[:] -} - -func (priv *PrivateKey) Decap(ciphertext []byte) (sharedKey []byte, ok bool) { - if len(ciphertext) != modQBytes { - return nil, false - } - - var e poly - if !e.unmarshal(ciphertext) { - return nil, false - } - - var f poly - f.fromMod3ToModQ(&priv.f) - - var v1, m poly - v1.mul(&e, &f) - - var v13 poly3 - v13.fromDiscreteMod3(&v1) - // Note: v13 is not reduced mod phi(n). - - var m3 poly3 - m3.mulMod3(&v13, &priv.fp) - m3.modPhiN() - m.fromMod3(&m3) - - var mLift, delta poly - mLift.lift(&m) - for i := range delta { - delta[i] = (e[i] - mLift[i] + Q) % Q - } - delta.mul(&delta, &priv.hInv) - delta.modPhiN() - - var r poly3 - allOk := r.fromModQ(&delta) - - var mBytes, rBytes [mod3Bytes]byte - m.marshalS3(mBytes[:]) - r.marshal(rBytes[:]) - - var rPoly poly - rPoly.fromMod3(&r) - expectedCiphertext := priv.PublicKey.owf(&m, &rPoly) - - allOk &= subtle.ConstantTimeCompare(ciphertext, expectedCiphertext) - - hmacHash := hmac.New(sha256.New, priv.hmacKey[:]) - hmacHash.Write(ciphertext) - hmacDigest := hmacHash.Sum(nil) - - h := sha256.New() - h.Write([]byte("shared key\x00")) - h.Write(mBytes[:]) - h.Write(rBytes[:]) - h.Write(ciphertext) - sharedKey = h.Sum(nil) - - mask := uint8(allOk - 1) - for i := range sharedKey { - sharedKey[i] = (sharedKey[i] & ^mask) | (hmacDigest[i] & mask) - } - - return sharedKey, true -} - -func GenerateKey(rand io.Reader) PrivateKey { - var randBytes [352 + 352]byte - if _, err := io.ReadFull(rand, randBytes[:]); err != nil { - panic("rand failed") - } - - var f poly - f.shortSamplePlus(randBytes[:352]) - var priv PrivateKey - priv.f.fromDiscrete(&f) - priv.fp.invertMod3(&priv.f) - - var g poly - g.shortSamplePlus(randBytes[352:]) - - var pgPhi1 poly - for i := range g { - pgPhi1[i] = mod3ToModQ(g[i]) - } - for i := range pgPhi1 { - pgPhi1[i] = (pgPhi1[i] * 3) % Q - } - pgPhi1.mulXMinus1() - - var fModQ poly - fModQ.fromMod3ToModQ(&priv.f) - - var pfgPhi1 poly - pfgPhi1.mul(&fModQ, &pgPhi1) - - var i poly - i.invert(&pfgPhi1) - - priv.h.mul(&i, &pgPhi1) - priv.h.mul(&priv.h, &pgPhi1) - - priv.hInv.mul(&i, &fModQ) - priv.hInv.mul(&priv.hInv, &fModQ) - - return priv -} diff --git a/ssl/test/runner/key_agreement.go b/ssl/test/runner/key_agreement.go index 47cdbb8b0e..5739888f78 100644 --- a/ssl/test/runner/key_agreement.go +++ b/ssl/test/runner/key_agreement.go @@ -17,7 +17,6 @@ import ( "io" "math/big" - "boringssl.googlesource.com/boringssl/ssl/test/runner/hrss" "golang.org/x/crypto/curve25519" ) @@ -341,90 +340,6 @@ func (e *x25519KEM) decap(ciphertext []byte) (secret []byte, err error) { return out[:], nil } -// cecpq2KEM implements CECPQ2, which is HRSS+SXY combined with X25519. -type cecpq2KEM struct { - x25519PrivateKey [32]byte - hrssPrivateKey hrss.PrivateKey -} - -func (e *cecpq2KEM) generate(rand io.Reader) (publicKey []byte, err error) { - if _, err := io.ReadFull(rand, e.x25519PrivateKey[:]); err != nil { - return nil, err - } - - var x25519Public [32]byte - curve25519.ScalarBaseMult(&x25519Public, &e.x25519PrivateKey) - - e.hrssPrivateKey = hrss.GenerateKey(rand) - hrssPublic := e.hrssPrivateKey.PublicKey.Marshal() - - var ret []byte - ret = append(ret, x25519Public[:]...) - ret = append(ret, hrssPublic...) - return ret, nil -} - -func (e *cecpq2KEM) encap(rand io.Reader, peerKey []byte) (ciphertext []byte, secret []byte, err error) { - if len(peerKey) != 32+hrss.PublicKeySize { - return nil, nil, errors.New("tls: bad length CECPQ2 offer") - } - - if _, err := io.ReadFull(rand, e.x25519PrivateKey[:]); err != nil { - return nil, nil, err - } - - var x25519Shared, x25519PeerKey, x25519Public [32]byte - copy(x25519PeerKey[:], peerKey) - curve25519.ScalarBaseMult(&x25519Public, &e.x25519PrivateKey) - curve25519.ScalarMult(&x25519Shared, &e.x25519PrivateKey, &x25519PeerKey) - - // Per RFC 7748, reject the all-zero value in constant time. - var zeros [32]byte - if subtle.ConstantTimeCompare(zeros[:], x25519Shared[:]) == 1 { - return nil, nil, errors.New("tls: X25519 value with wrong order") - } - - hrssPublicKey, ok := hrss.ParsePublicKey(peerKey[32:]) - if !ok { - return nil, nil, errors.New("tls: bad CECPQ2 offer") - } - - hrssCiphertext, hrssShared := hrssPublicKey.Encap(rand) - - ciphertext = append(ciphertext, x25519Public[:]...) - ciphertext = append(ciphertext, hrssCiphertext...) - secret = append(secret, x25519Shared[:]...) - secret = append(secret, hrssShared...) - - return ciphertext, secret, nil -} - -func (e *cecpq2KEM) decap(ciphertext []byte) (secret []byte, err error) { - if len(ciphertext) != 32+hrss.CiphertextSize { - return nil, errors.New("tls: bad length CECPQ2 reply") - } - - var x25519Shared, x25519PeerKey [32]byte - copy(x25519PeerKey[:], ciphertext) - curve25519.ScalarMult(&x25519Shared, &e.x25519PrivateKey, &x25519PeerKey) - - // Per RFC 7748, reject the all-zero value in constant time. - var zeros [32]byte - if subtle.ConstantTimeCompare(zeros[:], x25519Shared[:]) == 1 { - return nil, errors.New("tls: X25519 value with wrong order") - } - - hrssShared, ok := e.hrssPrivateKey.Decap(ciphertext[32:]) - if !ok { - return nil, errors.New("tls: invalid HRSS ciphertext") - } - - secret = append(secret, x25519Shared[:]...) - secret = append(secret, hrssShared...) - - return secret, nil -} - func kemForCurveID(id CurveID, config *Config) (kemImplementation, bool) { switch id { case CurveP224: @@ -437,8 +352,6 @@ func kemForCurveID(id CurveID, config *Config) (kemImplementation, bool) { return &ecdhKEM{curve: elliptic.P521(), sendCompressed: config.Bugs.SendCompressedCoordinates}, true case CurveX25519: return &x25519KEM{setHighBit: config.Bugs.SetX25519HighBit}, true - case CurveCECPQ2: - return &cecpq2KEM{}, true default: return nil, false } @@ -587,7 +500,7 @@ func (ka *ecdheKeyAgreement) generateServerKeyExchange(config *Config, cert *Cer NextCandidate: for _, candidate := range preferredCurves { if isPqGroup(candidate) && version < VersionTLS13 { - // CECPQ2 is TLS 1.3-only. + // Post-quantum "groups" require TLS 1.3. continue } diff --git a/ssl/test/runner/runner.go b/ssl/test/runner/runner.go index 3d660da209..54bb7b4805 100644 --- a/ssl/test/runner/runner.go +++ b/ssl/test/runner/runner.go @@ -11371,13 +11371,12 @@ var testCurves = []struct { {"P-384", CurveP384}, {"P-521", CurveP521}, {"X25519", CurveX25519}, - {"CECPQ2", CurveCECPQ2}, } const bogusCurve = 0x1234 func isPqGroup(r CurveID) bool { - return r == CurveCECPQ2 + return r == CurveX25519Kyber768 } func addCurveTests() { @@ -11841,78 +11840,79 @@ func addCurveTests() { }, }) - // CECPQ2 should not be offered by a TLS < 1.3 client. + // Kyber should not be offered by a TLS < 1.3 client. testCases = append(testCases, testCase{ - name: "CECPQ2NotInTLS12", + name: "KyberNotInTLS12", config: Config{ Bugs: ProtocolBugs{ - FailIfCECPQ2Offered: true, + FailIfKyberOffered: true, }, }, flags: []string{ "-max-version", strconv.Itoa(VersionTLS12), - "-curves", strconv.Itoa(int(CurveCECPQ2)), + "-curves", strconv.Itoa(int(CurveX25519Kyber768)), "-curves", strconv.Itoa(int(CurveX25519)), }, }) - // CECPQ2 should not crash a TLS < 1.3 client if the server mistakenly + // Kyber should not crash a TLS < 1.3 client if the server mistakenly // selects it. testCases = append(testCases, testCase{ - name: "CECPQ2NotAcceptedByTLS12Client", + name: "KyberNotAcceptedByTLS12Client", config: Config{ Bugs: ProtocolBugs{ - SendCurve: CurveCECPQ2, + SendCurve: CurveX25519Kyber768, }, }, flags: []string{ "-max-version", strconv.Itoa(VersionTLS12), - "-curves", strconv.Itoa(int(CurveCECPQ2)), + "-curves", strconv.Itoa(int(CurveX25519Kyber768)), "-curves", strconv.Itoa(int(CurveX25519)), }, shouldFail: true, expectedError: ":WRONG_CURVE:", }) - // CECPQ2 should not be offered by default as a client. + // Kyber should not be offered by default as a client. testCases = append(testCases, testCase{ - name: "CECPQ2NotEnabledByDefaultInClients", + name: "KyberNotEnabledByDefaultInClients", config: Config{ MinVersion: VersionTLS13, Bugs: ProtocolBugs{ - FailIfCECPQ2Offered: true, + FailIfKyberOffered: true, }, }, }) - // If CECPQ2 is offered, both X25519 and CECPQ2 should have a key-share. + // If Kyber is offered, both X25519 and Kyber should have a key-share. testCases = append(testCases, testCase{ - name: "NotJustCECPQ2KeyShare", + name: "NotJustKyberKeyShare", config: Config{ MinVersion: VersionTLS13, Bugs: ProtocolBugs{ - ExpectedKeyShares: []CurveID{CurveCECPQ2, CurveX25519}, + ExpectedKeyShares: []CurveID{CurveX25519Kyber768, CurveX25519}, }, }, flags: []string{ - "-curves", strconv.Itoa(int(CurveCECPQ2)), + "-curves", strconv.Itoa(int(CurveX25519Kyber768)), "-curves", strconv.Itoa(int(CurveX25519)), - "-expect-curve-id", strconv.Itoa(int(CurveCECPQ2)), + // Cannot expect Kyber until we have a Go implementation of it. + // "-expect-curve-id", strconv.Itoa(int(CurveX25519Kyber768)), }, }) // ... and the other way around testCases = append(testCases, testCase{ - name: "CECPQ2KeyShareIncludedSecond", + name: "KyberKeyShareIncludedSecond", config: Config{ MinVersion: VersionTLS13, Bugs: ProtocolBugs{ - ExpectedKeyShares: []CurveID{CurveX25519, CurveCECPQ2}, + ExpectedKeyShares: []CurveID{CurveX25519, CurveX25519Kyber768}, }, }, flags: []string{ "-curves", strconv.Itoa(int(CurveX25519)), - "-curves", strconv.Itoa(int(CurveCECPQ2)), + "-curves", strconv.Itoa(int(CurveX25519Kyber768)), "-expect-curve-id", strconv.Itoa(int(CurveX25519)), }, }) @@ -11921,44 +11921,46 @@ func addCurveTests() { // first classical and first post-quantum "curves" that get key shares // included. testCases = append(testCases, testCase{ - name: "CECPQ2KeyShareIncludedThird", + name: "KyberKeyShareIncludedThird", config: Config{ MinVersion: VersionTLS13, Bugs: ProtocolBugs{ - ExpectedKeyShares: []CurveID{CurveX25519, CurveCECPQ2}, + ExpectedKeyShares: []CurveID{CurveX25519, CurveX25519Kyber768}, }, }, flags: []string{ "-curves", strconv.Itoa(int(CurveX25519)), "-curves", strconv.Itoa(int(CurveP256)), - "-curves", strconv.Itoa(int(CurveCECPQ2)), + "-curves", strconv.Itoa(int(CurveX25519Kyber768)), "-expect-curve-id", strconv.Itoa(int(CurveX25519)), }, }) - // If CECPQ2 is the only configured curve, the key share is sent. + // If Kyber is the only configured curve, the key share is sent. testCases = append(testCases, testCase{ - name: "JustConfiguringCECPQ2Works", + name: "JustConfiguringKyberWorks", config: Config{ MinVersion: VersionTLS13, Bugs: ProtocolBugs{ - ExpectedKeyShares: []CurveID{CurveCECPQ2}, + ExpectedKeyShares: []CurveID{CurveX25519Kyber768}, }, }, flags: []string{ - "-curves", strconv.Itoa(int(CurveCECPQ2)), - "-expect-curve-id", strconv.Itoa(int(CurveCECPQ2)), + "-curves", strconv.Itoa(int(CurveX25519Kyber768)), + "-expect-curve-id", strconv.Itoa(int(CurveX25519Kyber768)), }, + shouldFail: true, + expectedLocalError: "no curve supported by both client and server", }) - // As a server, CECPQ2 is not yet supported by default. + // As a server, Kyber is not yet supported by default. testCases = append(testCases, testCase{ testType: serverTest, - name: "CECPQ2NotEnabledByDefaultForAServer", + name: "KyberNotEnabledByDefaultForAServer", config: Config{ MinVersion: VersionTLS13, - CurvePreferences: []CurveID{CurveCECPQ2, CurveX25519}, - DefaultCurves: []CurveID{CurveCECPQ2}, + CurvePreferences: []CurveID{CurveX25519Kyber768, CurveX25519}, + DefaultCurves: []CurveID{CurveX25519Kyber768}, }, flags: []string{ "-server-preference", diff --git a/ssl/test/test_config.cc b/ssl/test/test_config.cc index 109c69ef4f..09faf04e1e 100644 --- a/ssl/test/test_config.cc +++ b/ssl/test/test_config.cc @@ -1909,8 +1909,8 @@ bssl::UniquePtr TestConfig::NewSSL( nids.push_back(NID_X25519); break; - case SSL_CURVE_CECPQ2: - nids.push_back(NID_CECPQ2); + case SSL_CURVE_X25519KYBER768: + nids.push_back(NID_X25519Kyber768); break; } if (!SSL_set1_curves(ssl.get(), &nids[0], nids.size())) { From d3acd45456450f7e8091f0f56084bc2da93e48fe Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Wed, 12 Apr 2023 23:03:11 +0000 Subject: [PATCH 10/56] Move HKDF into the FIPS module. Change-Id: I7c5b0a24c26b83779cf889d890e2c18ae13187c3 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58725 Commit-Queue: Adam Langley Reviewed-by: David Benjamin --- crypto/CMakeLists.txt | 3 +- crypto/fipsmodule/bcm.c | 1 + crypto/{ => fipsmodule}/hkdf/hkdf.c | 2 +- crypto/{ => fipsmodule}/hkdf/hkdf_test.cc | 6 +- crypto/fipsmodule/self_check/self_check.c | 30 +++++++++ .../acvp/acvptool/subprocess/hkdf.go | 3 + .../acvp/acvptool/test/expected/HKDF.bz2 | Bin 0 -> 2532 bytes util/fipstools/acvp/acvptool/test/tests.json | 1 + .../acvp/acvptool/test/vectors/HKDF.bz2 | Bin 0 -> 2965 bytes .../acvp/modulewrapper/modulewrapper.cc | 58 ++++++++++++++++++ util/fipstools/break-kat.go | 1 + 11 files changed, 99 insertions(+), 6 deletions(-) rename crypto/{ => fipsmodule}/hkdf/hkdf.c (99%) rename crypto/{ => fipsmodule}/hkdf/hkdf_test.cc (99%) create mode 100644 util/fipstools/acvp/acvptool/test/expected/HKDF.bz2 create mode 100644 util/fipstools/acvp/acvptool/test/vectors/HKDF.bz2 diff --git a/crypto/CMakeLists.txt b/crypto/CMakeLists.txt index b45256cf03..cdb5ddca19 100644 --- a/crypto/CMakeLists.txt +++ b/crypto/CMakeLists.txt @@ -168,7 +168,6 @@ add_library( evp/scrypt.c evp/sign.c ex_data.c - hkdf/hkdf.c hpke/hpke.c hrss/hrss.c kyber/keccak.c @@ -390,13 +389,13 @@ add_executable( fipsmodule/ec/ec_test.cc fipsmodule/ec/p256-nistz_test.cc fipsmodule/ecdsa/ecdsa_test.cc + fipsmodule/hkdf/hkdf_test.cc fipsmodule/md5/md5_test.cc fipsmodule/modes/gcm_test.cc fipsmodule/rand/ctrdrbg_test.cc fipsmodule/rand/fork_detect_test.cc fipsmodule/service_indicator/service_indicator_test.cc fipsmodule/sha/sha_test.cc - hkdf/hkdf_test.cc hpke/hpke_test.cc hmac_extra/hmac_test.cc hrss/hrss_test.cc diff --git a/crypto/fipsmodule/bcm.c b/crypto/fipsmodule/bcm.c index e2e4d90f63..8231eee630 100644 --- a/crypto/fipsmodule/bcm.c +++ b/crypto/fipsmodule/bcm.c @@ -80,6 +80,7 @@ #include "ec/simple_mul.c" #include "ec/util.c" #include "ec/wnaf.c" +#include "hkdf/hkdf.c" #include "hmac/hmac.c" #include "md4/md4.c" #include "md5/md5.c" diff --git a/crypto/hkdf/hkdf.c b/crypto/fipsmodule/hkdf/hkdf.c similarity index 99% rename from crypto/hkdf/hkdf.c rename to crypto/fipsmodule/hkdf/hkdf.c index 23b60afe0e..fa1cc7244c 100644 --- a/crypto/hkdf/hkdf.c +++ b/crypto/fipsmodule/hkdf/hkdf.c @@ -20,7 +20,7 @@ #include #include -#include "../internal.h" +#include "../../internal.h" int HKDF(uint8_t *out_key, size_t out_len, const EVP_MD *digest, diff --git a/crypto/hkdf/hkdf_test.cc b/crypto/fipsmodule/hkdf/hkdf_test.cc similarity index 99% rename from crypto/hkdf/hkdf_test.cc rename to crypto/fipsmodule/hkdf/hkdf_test.cc index 8aad6c8540..dd7dd58365 100644 --- a/crypto/hkdf/hkdf_test.cc +++ b/crypto/fipsmodule/hkdf/hkdf_test.cc @@ -20,9 +20,9 @@ #include -#include "../test/file_test.h" -#include "../test/test_util.h" -#include "../test/wycheproof_util.h" +#include "../../test/file_test.h" +#include "../../test/test_util.h" +#include "../../test/wycheproof_util.h" struct HKDFTestVector { diff --git a/crypto/fipsmodule/self_check/self_check.c b/crypto/fipsmodule/self_check/self_check.c index 08500e59a1..8dcc415249 100644 --- a/crypto/fipsmodule/self_check/self_check.c +++ b/crypto/fipsmodule/self_check/self_check.c @@ -946,6 +946,36 @@ static int boringssl_self_test_fast(void) { goto err; } + // HKDF + static const uint8_t kHKDFSecret[32] = { + 0x68, 0x67, 0x85, 0x04, 0xb9, 0xb3, 0xad, 0xd1, 0x7d, 0x59, 0x67, + 0xa1, 0xa7, 0xbd, 0x37, 0x99, 0x3f, 0xd8, 0xa3, 0x3c, 0xe7, 0x30, + 0x30, 0x71, 0xf3, 0x9c, 0x09, 0x6d, 0x16, 0x35, 0xb3, 0xc9, + }; + static const uint8_t kHKDFSalt[32] = { + 0x8a, 0xab, 0x18, 0xb4, 0x9b, 0x0a, 0x17, 0xf9, 0xe8, 0xe6, 0x97, + 0x1a, 0x3d, 0xff, 0xda, 0x9b, 0x26, 0x8b, 0x3d, 0x17, 0x78, 0x0a, + 0xb3, 0xea, 0x65, 0xdb, 0x2a, 0xc0, 0x29, 0x9c, 0xfa, 0x72, + }; + static const uint8_t kHKDFInfo[32] = { + 0xe5, 0x6f, 0xf9, 0xe1, 0x18, 0x5e, 0x64, 0x8c, 0x6c, 0x8f, 0xee, + 0xc6, 0x93, 0x5a, 0xc5, 0x14, 0x8c, 0xf3, 0xd9, 0x78, 0xd2, 0x3a, + 0x86, 0xdd, 0x01, 0xdf, 0xb9, 0xe9, 0x5e, 0xe5, 0x1a, 0x56, + }; + static const uint8_t kHKDFOutput[32] = { + 0xa6, 0x29, 0xb4, 0xd7, 0xf4, 0xc1, 0x16, 0x64, 0x71, 0x5e, 0xa4, + 0xa8, 0xe6, 0x60, 0x8c, 0xf3, 0xc1, 0xa5, 0x03, 0xe2, 0x22, 0xf9, + 0x89, 0xe2, 0x12, 0x18, 0xbe, 0xef, 0x16, 0x86, 0xe0, 0xec, + }; + uint8_t hkdf_output[sizeof(kHKDFOutput)]; + if (!HKDF(hkdf_output, sizeof(hkdf_output), EVP_sha256(), kHKDFSecret, + sizeof(kHKDFSecret), kHKDFSalt, sizeof(kHKDFSalt), kHKDFInfo, + sizeof(kHKDFInfo)) || + !check_test(kHKDFOutput, hkdf_output, sizeof(kHKDFOutput), "HKDF")) { + fprintf(stderr, "HKDF failed.\n"); + goto err; + } + ret = 1; err: diff --git a/util/fipstools/acvp/acvptool/subprocess/hkdf.go b/util/fipstools/acvp/acvptool/subprocess/hkdf.go index 3cd4c32ef3..b124d790e7 100644 --- a/util/fipstools/acvp/acvptool/subprocess/hkdf.go +++ b/util/fipstools/acvp/acvptool/subprocess/hkdf.go @@ -173,6 +173,9 @@ func (k *hkdf) Process(vectorSet []byte, m Transactable) (interface{}, error) { if err != nil { return nil, fmt.Errorf("HKDF operation failed: %s", err) } + if len(resp[0]) != int(outBytes) { + return nil, fmt.Errorf("HKDF operation resulted in %d bytes but wanted %d", len(resp[0]), outBytes) + } if isValidationTest { passed := bytes.Equal(expected, resp[0]) diff --git a/util/fipstools/acvp/acvptool/test/expected/HKDF.bz2 b/util/fipstools/acvp/acvptool/test/expected/HKDF.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..791fa7a072cd82ce6886bb76fbaab9aa05138e3f GIT binary patch literal 2532 zcmV2b(ex}rEHkt|P4^u;F=_HVrbZt|o0;C>77>J0hMPfL~ zw4ww=GDg{;5Q~xlc8Madu}z$Ds=eNuc3dxe8a>*z2<8cqF?j&SA`IFHfMUA#pu-K{ ze+}l$P3&WAbe!;4SbPq*JE3JOstz`pa<%^D8Cj8hJ=(E$Tz7Wp&Usd6>D{#YBR4eU zA+V+?gim$sy6yQcd4|{Y2hfh^`2RNDVO-E>%YBrv$;IsJ6klv9`459Ui)rE7mbNFh z;5C#Dd@`4X9}a*4^NrLpP;3{)#aKtiSMqvXltMEa)ss)*TXa5}TYun;gKbW^<+ z07FHI$8K9so~Ck#ndW8J_DrYC_!>QDn#Pd&?Ax`Z?v7CPf2$fj-GVQ|kJlm(yGS%h ztRQG7hsa^ZH&g0N?7{Xx3N>)1CvTFEnlzgPGOJ(oA{huebqvhNF9G-&@IpF4QA@&D z`Dq?=1xB<=`_TiLgE;GJt+nYKzaQh*e*}8-&o@2s+hlM@#szI8qcy2pq@wyHIQD{? zGx4~Ogatbg3{3gCNbE%9WW8q&eTIR-o-+cEC_W##Od@3UC{#FYy&n2rR`q*G!r}L1 zb|Xl$RW|10r@G5Z9^mFd`5{AXGx_qJ*Q|cY=*EgKRSO+^TA!6JGTtTYO+sllO1}0Y zNtcxmLQs9*AtTSTD~2LQQu$C{-+Sp^fpQ%k-!?*=NYD)XJpr@sArIId`BawrpVndN zj#A`IWU{ie>J_P^S9SQWhj~r0+!L)W5W?o%euX-oRIA&Su~)CpPQ4H&Z({SFVjYV# z4SU-~t3m1Ki+Gy&uC(^F~U zTm(L&0lFd>tkUIYZvx(<`27c^;l|1;(&ACuWw@%tZqREeC-(&b;P^F*)i>^@<+y=6 zpcjT@?Ry(pm%?=cTR(1#>MxRt!37~)@3KYLwx8Q@rapyWT(Tg0GdghY$@Hwk?b=?i zEl72-WcRY<99-r8o23>z#_AVl)APG!U zSmm(u+>tt*(yWM&Ml24!*o6-ts}g7;yk$Q!Xvtxv@*%2PWfw1y)hDOH3w4ofN~YwH zdrJ*IaT+zlZ-frD0;Vrsvf%JltKN0bZnTeA5}6W!qkBf6-qQ)T>Aa}7?RS#(?R!17 z2HRo9r_0@kcbGtx>X8<@3p=tXsiC}+e;OQ^yULy{rO#O_RO2}wzr3R$*&-#bqZmTe zaOr>mq`-MR2^Mm;IIY$=$(N zIN~|%x9fPAA>#|9uYQ|zx^|y@=ttF&1NTRIbM!0lADe3d#MD!V;$TL_&Xa%H3JxCyNMj6M+_qLSD|t@1+Yl`6eKQCihYe|XX3*jN{3)5 z6V^YNQ?>%UEta$c_T}l$y?ECXeQiH^jvrGSzrXCKyo($@Dv4UM6M>kQ0cPQYAv2;acV zUQ^kONVwEhmt~muWe(QK($M}RN_c#KfKM3G1=uz zTap=!{%7(~ANe*rVzMe-J|;>XlKm^whl z^gVdV=@4w^&r^?zT(iM2w|rPMO{`|6S6(VB1&vfg=V41Mw;#pb^;wDRTZBD4*$fo3 zQL!DK;y;OF$7X#tlb@^)W#V__1av@YHf+^%Jy)kxNP zoK-k5;9`wZ_;n?CnRW>KoVP%H-aSB6@OeR#kS!}Lsr;_^>f%yDgz;TDgSLHEdKSfa zUM_!EN!vEu$xU$ScX%$5!Wsi#^e1@On3(Iz$zC(CnuItMZ_;hc*1AOoY4HB|euLj2 zAxOOn(zAK6J~?peDFxnJF}M5ZR7LibL)Mi0kHoDIvP;#0Z{;beGg8Sbz@dH4jLYl| zgo6FJ4gkRqZD`J*>Ec!?^yGm7Pja&~n@bu;Zh?g}sBWi;f|i4vp|n;xx@98p%*O$3 zcH@tk+(q1wtmPu;Ukp9CL%2o5tg*VLItUic(%@822iI=LDq3O!GF4#wG}}P>vejO< zmy*oSYFhzT`FDaVv5`EJ3|`jEP;J;(zKdCKooX;W00aCG-J}hjj+s&sL#0L}K`zIE z5mESD%iyeH$)CXp^#-RjMsmigu-w8ND}H0!6Hshn>e~S>`smfblt`_x!9&WL)V@1$ zt=G32Z`f+7$H}1)<^q_^d_QFEUDdO#VEl35GkvJNsFZ1wR2i$&TiTwpJ}_ zfj`mGAZUC)mCj*z?3di42W2*&Z;Z4JG07q^eVl#k&Fl0$KeC&hKmIe}--Gn*k@FSpx#55d_p?4%xg$W2sn*rcf!0ajj literal 0 HcmV?d00001 diff --git a/util/fipstools/acvp/acvptool/test/tests.json b/util/fipstools/acvp/acvptool/test/tests.json index d1e8eb5bc4..36fdaad005 100644 --- a/util/fipstools/acvp/acvptool/test/tests.json +++ b/util/fipstools/acvp/acvptool/test/tests.json @@ -18,6 +18,7 @@ {"Wrapper": "modulewrapper", "In": "vectors/HMAC-SHA2-384.bz2", "Out": "expected/HMAC-SHA2-384.bz2"}, {"Wrapper": "modulewrapper", "In": "vectors/HMAC-SHA2-512.bz2", "Out": "expected/HMAC-SHA2-512.bz2"}, {"Wrapper": "modulewrapper", "In": "vectors/HMAC-SHA2-512-256.bz2", "Out": "expected/HMAC-SHA2-512-256.bz2"}, +{"Wrapper": "modulewrapper", "In": "vectors/HKDF.bz2", "Out": "expected/HKDF.bz2"}, {"Wrapper": "testmodulewrapper", "In": "vectors/hmacDRBG.bz2", "Out": "expected/hmacDRBG.bz2"}, {"Wrapper": "testmodulewrapper", "In": "vectors/KDA.bz2", "Out": "expected/KDA.bz2"}, {"Wrapper": "modulewrapper", "In": "vectors/KAS-ECC-SSC.bz2"}, diff --git a/util/fipstools/acvp/acvptool/test/vectors/HKDF.bz2 b/util/fipstools/acvp/acvptool/test/vectors/HKDF.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..f69a46191aaa61cf93a90dafbb50d96673b740ab GIT binary patch literal 2965 zcmV;G3u^R2T4*^jL0KkKS-JixD*z9eUw~CmPzL|-KkiQ&FYn)eU=9BT0`sieW@Hjc zK$My>Yiin(RN1NpW-kHq@_(T0SuUc!8F9k$&O$X zOaf#u022hj004@30T~oZjEo=v0B8*W4qy{Z0%R}%69m8j04YfdX`(b`Fh&rWshXO3 zN9vjxsiV|wPKfQws=xP9nRR^smdwifF7Djcn&g{_(43QG*sGFxIa!Rio3diA6=<4F zV=#~<(X%*Gv_yzTXUUEBSe^Ywjx&Zi%5pRcD{ z<(>{XYp3krkA8j+$bPBuPH$lT>C3^PAxQJ_XRjw#wCO%4dsN4dluAw$~OlEwO zT4k1YRX!N5_qjXMM8w#boA;*avT&G~o8dTG(riuBZWU(K#*-B=YD^QEU#fwM;I%KoHXZX~-*;HBn>w;GSCH2KgM0Pq)Sq;>V(;)WVd*V8-o zWTvwK?@mT5Tw&b6BTkj&k<&yd^k7h4rpXL7Whg41VOZLtzppC+di~Uo2Ld#E+8I+S z6L(~!p_PDb+fLb(A%=K12XOkRdqU)__PF#}7k_Qg4f(TWXFEb-=vShL=zQ zm2$h$CBiVUD}=K^X-F8vi)nDNS?Qd`U_kJ`0@udp!M;zlybo8F0_7hV?`?6Rm9Ku% zeeBv2;UztGR$z^ni8?g4Qd>BM*0K60Q%km2*TnN(ieaNlLk9E0&aa^kp{5kc{dzpB z@}rR~3ze@C<_vczyG3A~V?36hfEIo%wnT=l!rvKtf)gS@_1X+7ezbWn-B}< zW2V(jI4)#vq%y(;oq8u*>clKqf@0smA*SeQHOvAqL4Lr>ac;Gc`c81no~?~5u=vO+ zxCJl}G}}>1NloqD=OmgeloqssOK|S|ePgQ<)>-J=SV?GvT{bAbQ7c?O zB0AZ!-qQd)4H3EMblR5!d+4iEa%lI=E=D?eD_MGj?@teO^Px- zv~wO5ZrdY3kCFD0`Unjuo?>#r_0_6R@61( z5y3qSO+c2Bw^Or2RUde6WJiE`8iUpn9G$VyHJJj=wheNz>_F$GhC{&YKU)c~b=Xc$ z86XvVBO77}NuC^Zu!QUH`@(3HOlNpZ+0Jg4F{O^n zmTk?oVBWyr7LO})I+}-J3S9SnH}4&g`;d*^Fl3lyL7L9hK=x)DK217~oKbX*)&}g3 zSYDw{3|_!oI3aaulvf(8u3w=#1bsvS-WIwv5JzBurjHsoF7%x<0!(fD#K6sR(N=+S zr%+)!h)|WBOco6x@o*1LQuzGXtiCz!v9x=5+T}|ZGLGB_HdwNitqJocJnmy2OeLl# z4CsdvLeb+#i7VcC)M4TB-TSWVtm>7^PV*XiOgL@Kr+!OL%~5B5E`|%b>`n+EL`zid zl*Os;;dCx`=%LHsXy#kGnA?%i!1Q$@M2sWHWz7b2t0jtjtE&qq*L0C7x7F!F08wX9 zEi)Wpm80Jbr*%dNZMFp_*}RBG4Fv-Z0C*p5B~+I?3>X=@G~+5E)}2d?m<<*>1r4oB zS?fYYQQb|U(hk&MCJuAk9k_Rij6;hDgr-{yU0kKXR19Y>v4y$auVI!DmRa-z_9Gvrhb^oU~t1`EFSRQ*g^uF=ABh-}tz ziMtb`*qXRoc8E)QyFxlM-38oQqEC zd)5tx@-cYC*zpCG%gtyW9qO9yw}Nrr*v)PqCwJKAEv(n2)k?*yvuvTiO6UW~Is}F( zi*Q*h?SaiVyJOWO@zl~L)3aS^jDgpx#ZJsadenr>x+=CSpuF-+26RVog9FxO;)!H5(;qjqJY#CN zK`wZfipjj#qmZtLm~K$}L7F`)AGn+^F+HLgbN z=W=n^UHY^ILAiESS)Cg&Nb5L*0_gkVLqrudirU!T&v~rZi1ggGGj`S0+`OG9q%uxv z+`2AtDFM4`?_+s!mqDeMxs15EWIThe#BwCR<@Gv_m%WzCFV+>nr?)drq!YX`7F!k^mvZj77gGv*AjOmnpt)- zgn6qfJ9v&DvfWjb>O^^rqnPiy0~U78GdBp`_gZUJBdFAxacRDw@EbaWvB*VyP7xc4 zUuRdrxlH0YbA+$Gs|6GVyfg82N}HgOm`5>w-l~g7GU2Wd0!7D=^z8|37Kcve4XeB$ z6tr>NgT{`Icp;)gY6H?IqNqS&No+3FP1N*IUP&zE0Zf7lQOe7;?`X>XoQ>VQl}=wS zwA(?#G!@w$H+^o?o!)IlOzzru6T*Nw`UHb?fg#V@AYNT-F_|#gKcJYLdilAh_DoM& zdsFvMTCSAv^gjmPq20Q3CxtbM!`b``-}q*G(~^E^%iZBkb}G_(F@Mze69o3Br9U*` zH%{aHCxtjCT6ed6iRes|VKuq?m1#8SUA=?r#Xp~`*7=FS`lsxkG{oyoCsJa0nNu{M zx@*hQRoZxyq)aO8OipR7C(Slb8gNZwVtG?KQxoaL#{Ip00(i-|oSW#LWasy$xAGcQ zC&@8adDfm3 #include #include +#include #include #include #include @@ -885,6 +886,34 @@ static bool GetConfig(const Span args[], ReplyCallback write_repl "FB", "FC" ] + }, + { + "algorithm": "KDA", + "mode": "HKDF", + "revision": "Sp800-56Cr1", + "fixedInfoPattern": "uPartyInfo||vPartyInfo", + "encoding": [ + "concatenation" + ], + "hmacAlg": [ + "SHA2-224", + "SHA2-256", + "SHA2-384", + "SHA2-512", + "SHA2-512/256" + ], + "macSaltMethods": [ + "default", + "random" + ], + "l": 2048, + "z": [ + { + "min": 224, + "max": 65336, + "increment": 8 + } + ] } ])"; return write_reply({Span( @@ -1431,6 +1460,30 @@ static bool HMAC(const Span args[], ReplyCallback write_reply) { return write_reply({Span(digest, digest_len)}); } +template +static bool HKDF(const Span args[], ReplyCallback write_reply) { + const EVP_MD *const md = HashFunc(); + const auto key = args[0]; + const auto salt = args[1]; + const auto info = args[2]; + const auto out_len_bytes = args[3]; + + if (out_len_bytes.size() != sizeof(uint32_t)) { + return false; + } + const uint32_t out_len = CRYPTO_load_u32_le(out_len_bytes.data()); + if (out_len > (1 << 24)) { + return false; + } + + std::vector out(out_len); + if (!::HKDF(out.data(), out_len, md, key.data(), key.size(), salt.data(), + salt.size(), info.data(), info.size())) { + return false; + } + return write_reply({out}); +} + template static bool DRBG(const Span args[], ReplyCallback write_reply) { const auto out_len_bytes = args[0]; @@ -1971,6 +2024,11 @@ static constexpr struct { {"3DES-ECB/decrypt", 3, TDES}, {"3DES-CBC/encrypt", 4, TDES_CBC}, {"3DES-CBC/decrypt", 4, TDES_CBC}, + {"HKDF/SHA2-224", 4, HKDF}, + {"HKDF/SHA2-256", 4, HKDF}, + {"HKDF/SHA2-384", 4, HKDF}, + {"HKDF/SHA2-512", 4, HKDF}, + {"HKDF/SHA2-512/256", 4, HKDF}, {"HMAC-SHA-1", 2, HMAC}, {"HMAC-SHA2-224", 2, HMAC}, {"HMAC-SHA2-256", 2, HMAC}, diff --git a/util/fipstools/break-kat.go b/util/fipstools/break-kat.go index 6eace5b464..ed29bb3a49 100644 --- a/util/fipstools/break-kat.go +++ b/util/fipstools/break-kat.go @@ -21,6 +21,7 @@ var ( "AES-GCM-decrypt": "35f3058f875760ff09d3120f70c4bc9ed7a86872e13452202176f7371ae04faae1dd391920f5d13953d896785994823c", "DRBG": "c4da0740d505f1ee280b95e58c4931ac6de846a0152fbb4a3f174cf4787a4f1a40c2b50babe14aae530be5886d910a27", "DRBG-reseed": "c7161ca36c2309b716e9859bb96c6d49bdc8352103a18cd24ef42ec97ef46bf446eb1a4576c186e9351803763a7912fe", + "HKDF": "68678504b9b3add17d5967a1a7bd37993fd8a33ce7303071f39c096d1635b3c9", "SHA-1": "132fd9bad5c1826263bafbb699f707a5", "SHA-256": "ff3b857da7236a2baa0f396b51522217", "SHA-512": "212512f8d2ad8322781c6c4d69a9daa1", From 480344d4fa03319efa29cdca41f051c41f5bf95a Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Thu, 13 Apr 2023 02:09:12 +0000 Subject: [PATCH 11/56] Move TLS 1.3 KDF functions into the FIPS module. Change-Id: I32a40a73f96e029ac9096af826d15b22d9dcad28 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58745 Auto-Submit: Adam Langley Reviewed-by: David Benjamin Commit-Queue: David Benjamin --- crypto/fipsmodule/self_check/self_check.c | 40 +++ crypto/fipsmodule/tls/internal.h | 8 + crypto/fipsmodule/tls/kdf.c | 32 +++ ssl/tls13_enc.cc | 26 +- util/fipstools/acvp/ACVP.md | 2 + .../acvp/acvptool/subprocess/subprocess.go | 1 + .../acvp/acvptool/subprocess/tls13.go | 240 ++++++++++++++++++ .../acvp/acvptool/test/expected/TLS13.bz2 | Bin 0 -> 4044 bytes util/fipstools/acvp/acvptool/test/tests.json | 3 +- .../acvp/acvptool/test/vectors/TLS13.bz2 | Bin 0 -> 2556 bytes .../acvp/modulewrapper/modulewrapper.cc | 61 +++++ util/fipstools/break-kat.go | 1 + 12 files changed, 392 insertions(+), 22 deletions(-) create mode 100644 util/fipstools/acvp/acvptool/subprocess/tls13.go create mode 100644 util/fipstools/acvp/acvptool/test/expected/TLS13.bz2 create mode 100644 util/fipstools/acvp/acvptool/test/vectors/TLS13.bz2 diff --git a/crypto/fipsmodule/self_check/self_check.c b/crypto/fipsmodule/self_check/self_check.c index 8dcc415249..3b51e2fe22 100644 --- a/crypto/fipsmodule/self_check/self_check.c +++ b/crypto/fipsmodule/self_check/self_check.c @@ -946,6 +946,46 @@ static int boringssl_self_test_fast(void) { goto err; } + // TLS v1.3: derives a dummy client-early-traffic secret. + static const uint8_t kTLS13Secret[32] = { + 0x02, 0x4a, 0x0d, 0x80, 0xf3, 0x57, 0xf2, 0x49, 0x9a, 0x12, 0x44, + 0xda, 0xc2, 0x6d, 0xab, 0x66, 0xfc, 0x13, 0xed, 0x85, 0xfc, 0xa7, + 0x1d, 0xac, 0xe1, 0x46, 0x21, 0x11, 0x19, 0x52, 0x58, 0x74, + }; + static const uint8_t kTLS13Salt[16] = { + 0x54, 0x61, 0x11, 0x36, 0x75, 0x91, 0xf0, 0xf8, + 0x92, 0xec, 0x70, 0xbd, 0x78, 0x2a, 0xef, 0x61, + }; + static const uint8_t kTLS13Label[] = "c e traffic"; + static const uint8_t kTLS13ClientHelloHash[32] = { + 0x1d, 0xe8, 0x67, 0xed, 0x93, 0x6a, 0x73, 0x65, 0x9b, 0x05, 0xcf, + 0x8a, 0x22, 0x77, 0xb7, 0x37, 0x29, 0xf2, 0x44, 0x94, 0x81, 0x6a, + 0x83, 0x33, 0x7f, 0x09, 0xbb, 0x6c, 0xc2, 0x6f, 0x48, 0x9c, + }; + static const uint8_t kTLS13ExpandLabelOutput[32] = { + 0x62, 0x91, 0x52, 0x90, 0x2e, 0xc9, 0xcf, 0x9c, 0x5f, 0x1e, 0x0a, + 0xb7, 0x00, 0x33, 0x42, 0x24, 0xc4, 0xe3, 0xba, 0x01, 0x40, 0x32, + 0x06, 0xab, 0x09, 0x23, 0x8a, 0xdd, 0x01, 0xa4, 0x05, 0xcd, + }; + uint8_t tls13_extract_output[32]; + size_t tls13_extract_output_len; + uint8_t tls13_expand_label_output[32]; + if (!HKDF_extract(tls13_extract_output, &tls13_extract_output_len, + EVP_sha256(), kTLS13Secret, sizeof(kTLS13Secret), + kTLS13Salt, sizeof(kTLS13Salt)) || + tls13_extract_output_len != sizeof(tls13_extract_output) || + !CRYPTO_tls13_hkdf_expand_label( + tls13_expand_label_output, sizeof(tls13_expand_label_output), + EVP_sha256(), tls13_extract_output, sizeof(tls13_extract_output), + kTLS13Label, sizeof(kTLS13Label) - 1, kTLS13ClientHelloHash, + sizeof(kTLS13ClientHelloHash)) || + !check_test(kTLS13ExpandLabelOutput, tls13_expand_label_output, + sizeof(kTLS13ExpandLabelOutput), + "CRYPTO_tls13_hkdf_expand_label")) { + fprintf(stderr, "TLSv1.3 KDF failed.\n"); + goto err; + } + // HKDF static const uint8_t kHKDFSecret[32] = { 0x68, 0x67, 0x85, 0x04, 0xb9, 0xb3, 0xad, 0xd1, 0x7d, 0x59, 0x67, diff --git a/crypto/fipsmodule/tls/internal.h b/crypto/fipsmodule/tls/internal.h index ef642a6cd5..535b7ebe69 100644 --- a/crypto/fipsmodule/tls/internal.h +++ b/crypto/fipsmodule/tls/internal.h @@ -31,6 +31,14 @@ OPENSSL_EXPORT int CRYPTO_tls1_prf(const EVP_MD *digest, const uint8_t *seed1, size_t seed1_len, const uint8_t *seed2, size_t seed2_len); +// CRYPTO_tls13_hkdf_expand_label computes the TLS 1.3 KDF function of the same +// name. See https://www.rfc-editor.org/rfc/rfc8446#section-7.1. +OPENSSL_EXPORT int CRYPTO_tls13_hkdf_expand_label( + uint8_t *out, size_t out_len, const EVP_MD *digest, // + const uint8_t *secret, size_t secret_len, // + const uint8_t *label, size_t label_len, // + const uint8_t *hash, size_t hash_len); + #if defined(__cplusplus) } diff --git a/crypto/fipsmodule/tls/kdf.c b/crypto/fipsmodule/tls/kdf.c index 046cb526aa..9c6cfaf03c 100644 --- a/crypto/fipsmodule/tls/kdf.c +++ b/crypto/fipsmodule/tls/kdf.c @@ -52,6 +52,7 @@ #include +#include #include #include #include @@ -176,3 +177,34 @@ int CRYPTO_tls1_prf(const EVP_MD *digest, } return ret; } + +int CRYPTO_tls13_hkdf_expand_label(uint8_t *out, size_t out_len, + const EVP_MD *digest, // + const uint8_t *secret, size_t secret_len, + const uint8_t *label, size_t label_len, + const uint8_t *hash, size_t hash_len) { + static const uint8_t kProtocolLabel[] = "tls13 "; + CBB cbb, child; + uint8_t *hkdf_label = NULL; + size_t hkdf_label_len; + + CBB_zero(&cbb); + if (!CBB_init(&cbb, 2 + 1 + sizeof(kProtocolLabel) - 1 + label_len + 1 + + hash_len) || + !CBB_add_u16(&cbb, out_len) || + !CBB_add_u8_length_prefixed(&cbb, &child) || + !CBB_add_bytes(&child, kProtocolLabel, sizeof(kProtocolLabel) - 1) || + !CBB_add_bytes(&child, label, label_len) || + !CBB_add_u8_length_prefixed(&cbb, &child) || + !CBB_add_bytes(&child, hash, hash_len) || + !CBB_finish(&cbb, &hkdf_label, &hkdf_label_len)) { + CBB_cleanup(&cbb); + return 0; + } + + const int ret = HKDF_expand(out, out_len, digest, secret, secret_len, + hkdf_label, hkdf_label_len); + OPENSSL_free(hkdf_label); + return ret; +} + diff --git a/ssl/tls13_enc.cc b/ssl/tls13_enc.cc index ad023ef8eb..3de10f4802 100644 --- a/ssl/tls13_enc.cc +++ b/ssl/tls13_enc.cc @@ -27,6 +27,7 @@ #include #include +#include "../crypto/fipsmodule/tls/internal.h" #include "../crypto/internal.h" #include "internal.h" @@ -95,27 +96,10 @@ static bool hkdf_expand_label(Span out, const EVP_MD *digest, Span secret, Span label, Span hash) { - Span protocol_label = label_to_span("tls13 "); - ScopedCBB cbb; - CBB child; - Array hkdf_label; - if (!CBB_init(cbb.get(), 2 + 1 + protocol_label.size() + label.size() + 1 + - hash.size()) || - !CBB_add_u16(cbb.get(), out.size()) || - !CBB_add_u8_length_prefixed(cbb.get(), &child) || - !CBB_add_bytes(&child, - reinterpret_cast(protocol_label.data()), - protocol_label.size()) || - !CBB_add_bytes(&child, reinterpret_cast(label.data()), - label.size()) || - !CBB_add_u8_length_prefixed(cbb.get(), &child) || - !CBB_add_bytes(&child, hash.data(), hash.size()) || - !CBBFinishArray(cbb.get(), &hkdf_label)) { - return false; - } - - return HKDF_expand(out.data(), out.size(), digest, secret.data(), - secret.size(), hkdf_label.data(), hkdf_label.size()); + return CRYPTO_tls13_hkdf_expand_label( + out.data(), out.size(), digest, secret.data(), secret.size(), + reinterpret_cast(label.data()), label.size(), + hash.data(), hash.size()) == 1; } static const char kTLS13LabelDerived[] = "derived"; diff --git a/util/fipstools/acvp/ACVP.md b/util/fipstools/acvp/ACVP.md index d3578e206c..61c6f884b1 100644 --- a/util/fipstools/acvp/ACVP.md +++ b/util/fipstools/acvp/ACVP.md @@ -77,6 +77,8 @@ The other commands are as follows. (Note that you only need to implement the com | ECDSA/sigVer | Curve name, hash name, message, X, Y, R, S | Single-byte validity flag | | FFDH | p, q, g, peer public key, local private key (or empty), local public key (or empty) | Local public key, shared key | | HKDF/<HASH> | key, salt, info, num output bytes | Key | +| HKDFExtract | secret, salt | Key | +| HKDFExpandLabel | Output length, secret, label, transcript hash | Key | | HMAC-SHA-1 | Value to hash, key | Digest | | HMAC-SHA2-224 | Value to hash, key | Digest | | HMAC-SHA2-256 | Value to hash, key | Digest | diff --git a/util/fipstools/acvp/acvptool/subprocess/subprocess.go b/util/fipstools/acvp/acvptool/subprocess/subprocess.go index 48d708315a..b496982e7e 100644 --- a/util/fipstools/acvp/acvptool/subprocess/subprocess.go +++ b/util/fipstools/acvp/acvptool/subprocess/subprocess.go @@ -107,6 +107,7 @@ func NewWithIO(cmd *exec.Cmd, in io.WriteCloser, out io.ReadCloser) *Subprocess "hmacDRBG": &drbg{"hmacDRBG", map[string]bool{"SHA-1": true, "SHA2-224": true, "SHA2-256": true, "SHA2-384": true, "SHA2-512": true}}, "KDF": &kdfPrimitive{}, "KDA": &hkdf{}, + "TLS-v1.3": &tls13{}, "CMAC-AES": &keyedMACPrimitive{"CMAC-AES"}, "RSA": &rsa{}, "kdf-components": &tlsKDF{}, diff --git a/util/fipstools/acvp/acvptool/subprocess/tls13.go b/util/fipstools/acvp/acvptool/subprocess/tls13.go new file mode 100644 index 0000000000..b8b6e51a50 --- /dev/null +++ b/util/fipstools/acvp/acvptool/subprocess/tls13.go @@ -0,0 +1,240 @@ +// Copyright (c) 2023, Google Inc. +// +// Permission to use, copy, modify, and/or distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +package subprocess + +import ( + "crypto/sha256" + "crypto/sha512" + "encoding/hex" + "encoding/json" + "fmt" +) + +// The following structures reflect the JSON of TLS 1.3 tests. See +// https://pages.nist.gov/ACVP/draft-hammett-acvp-kdf-tls-v1.3.html + +type tls13TestVectorSet struct { + Groups []tls13TestGroup `json:"testGroups"` +} + +type tls13TestGroup struct { + ID uint64 `json:"tgId"` + HashFunc string `json:"hmacAlg"` + Tests []tls13Test `json:"tests"` +} + +type tls13Test struct { + ID uint64 `json:"tcId"` + // Although ACVP refers to these as client and server randoms, these + // fields are misnamed and really contain portions of the handshake + // transcript. Concatenated in order, they give the transcript up to + // the named message. In case of HelloRetryRequest, ClientHelloHex + // includes up to the second ClientHello. + ClientHelloHex string `json:"helloClientRandom"` + ServerHelloHex string `json:"helloServerRandom"` + ServerFinishedHex string `json:"finishedServerRandom"` + ClientFinishedHex string `json:"finishedClientRandom"` + DHEInputHex string `json:"dhe"` + PSKInputHex string `json:"psk"` +} + +type tls13TestGroupResponse struct { + ID uint64 `json:"tgId"` + Tests []tls13TestResponse `json:"tests"` +} + +type tls13TestResponse struct { + ID uint64 `json:"tcId"` + ClientEarlyTrafficSecretHex string `json:"clientEarlyTrafficSecret"` + EarlyExporterMasterSecretHex string `json:"earlyExporterMasterSecret"` + ClientHandshakeTrafficSecretHex string `json:"clientHandshakeTrafficSecret"` + ServerHandshakeTrafficSecretHex string `json:"serverHandshakeTrafficSecret"` + ClientApplicationTrafficSecretHex string `json:"clientApplicationTrafficSecret"` + ServerApplicationTrafficSecretHex string `json:"serverApplicationTrafficSecret"` + ExporterMasterSecretHex string `json:"exporterMasterSecret"` + ResumptionMasterSecretHex string `json:"resumptionMasterSecret"` +} + +type tls13 struct{} + +func (k *tls13) Process(vectorSet []byte, m Transactable) (interface{}, error) { + var parsed tls13TestVectorSet + if err := json.Unmarshal(vectorSet, &parsed); err != nil { + return nil, err + } + + var respGroups []tls13TestGroupResponse + for _, group := range parsed.Groups { + groupResp := tls13TestGroupResponse{ID: group.ID} + + for _, test := range group.Tests { + testResp := tls13TestResponse{ID: test.ID} + + clientHello, err := hex.DecodeString(test.ClientHelloHex) + if err != nil { + return nil, err + } + serverHello, err := hex.DecodeString(test.ServerHelloHex) + if err != nil { + return nil, err + } + serverFinished, err := hex.DecodeString(test.ServerFinishedHex) + if err != nil { + return nil, err + } + clientFinished, err := hex.DecodeString(test.ClientFinishedHex) + if err != nil { + return nil, err + } + + // See https://www.rfc-editor.org/rfc/rfc8446#section-7.1 + var hashLen int + var emptyHash []byte + switch group.HashFunc { + case "SHA2-256": + hashLen = 256 / 8 + digest := sha256.Sum256(nil) + emptyHash = digest[:] + case "SHA2-384": + hashLen = 384 / 8 + digest := sha512.Sum384(nil) + emptyHash = digest[:] + default: + return nil, fmt.Errorf("hash function %q is not supported for TLS v1.3", group.HashFunc) + } + hashLenBytes := uint32le(uint32(hashLen)) + + psk, err := hex.DecodeString(test.PSKInputHex) + if err != nil { + return nil, err + } + if len(psk) == 0 { + psk = make([]byte, hashLen) + } + + dhe, err := hex.DecodeString(test.DHEInputHex) + if err != nil { + return nil, err + } + if len(dhe) == 0 { + dhe = make([]byte, hashLen) + } + + zeros := make([]byte, hashLen) + earlySecret, err := m.Transact("HKDFExtract/"+group.HashFunc, 1, psk, zeros) + if err != nil { + return nil, fmt.Errorf("HKDFExtract operation failed: %s", err) + } + + hashedToClientHello, err := m.Transact(group.HashFunc, 1, clientHello) + if err != nil { + return nil, fmt.Errorf("%q operation failed: %s", group.HashFunc, err) + } + hashedToServerHello, err := m.Transact(group.HashFunc, 1, concat(clientHello, serverHello)) + if err != nil { + return nil, fmt.Errorf("%q operation failed: %s", group.HashFunc, err) + } + hashedToServerFinished, err := m.Transact(group.HashFunc, 1, concat(clientHello, serverHello, serverFinished)) + if err != nil { + return nil, fmt.Errorf("%q operation failed: %s", group.HashFunc, err) + } + hashedMessages, err := m.Transact(group.HashFunc, 1, concat(clientHello, serverHello, serverFinished, clientFinished)) + if err != nil { + return nil, fmt.Errorf("%q operation failed: %s", group.HashFunc, err) + } + + clientEarlyTrafficSecret, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, earlySecret[0], []byte("c e traffic"), hashedToClientHello[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + testResp.ClientEarlyTrafficSecretHex = hex.EncodeToString(clientEarlyTrafficSecret[0]) + + earlyExporter, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, earlySecret[0], []byte("e exp master"), hashedToClientHello[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + testResp.EarlyExporterMasterSecretHex = hex.EncodeToString(earlyExporter[0]) + + derivedSecret, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, earlySecret[0], []byte("derived"), emptyHash[:]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + + handshakeSecret, err := m.Transact("HKDFExtract/"+group.HashFunc, 1, dhe, derivedSecret[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExtract operation failed: %s", err) + } + + clientHandshakeTrafficSecret, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, handshakeSecret[0], []byte("c hs traffic"), hashedToServerHello[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + testResp.ClientHandshakeTrafficSecretHex = hex.EncodeToString(clientHandshakeTrafficSecret[0]) + + serverHandshakeTrafficSecret, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, handshakeSecret[0], []byte("s hs traffic"), hashedToServerHello[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + testResp.ServerHandshakeTrafficSecretHex = hex.EncodeToString(serverHandshakeTrafficSecret[0]) + + derivedSecret, err = m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, handshakeSecret[0], []byte("derived"), emptyHash[:]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + + masterSecret, err := m.Transact("HKDFExtract/"+group.HashFunc, 1, zeros, derivedSecret[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExtract operation failed: %s", err) + } + + clientAppTrafficSecret, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, masterSecret[0], []byte("c ap traffic"), hashedToServerFinished[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + testResp.ClientApplicationTrafficSecretHex = hex.EncodeToString(clientAppTrafficSecret[0]) + + serverAppTrafficSecret, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, masterSecret[0], []byte("s ap traffic"), hashedToServerFinished[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + testResp.ServerApplicationTrafficSecretHex = hex.EncodeToString(serverAppTrafficSecret[0]) + + exporterSecret, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, masterSecret[0], []byte("exp master"), hashedToServerFinished[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + testResp.ExporterMasterSecretHex = hex.EncodeToString(exporterSecret[0]) + + resumptionSecret, err := m.Transact("HKDFExpandLabel/"+group.HashFunc, 1, hashLenBytes, masterSecret[0], []byte("res master"), hashedMessages[0]) + if err != nil { + return nil, fmt.Errorf("HKDFExpandLabel operation failed: %s", err) + } + testResp.ResumptionMasterSecretHex = hex.EncodeToString(resumptionSecret[0]) + + groupResp.Tests = append(groupResp.Tests, testResp) + } + respGroups = append(respGroups, groupResp) + } + + return respGroups, nil +} + +func concat(slices ...[]byte) []byte { + var ret []byte + for _, slice := range slices { + ret = append(ret, slice...) + } + return ret +} diff --git a/util/fipstools/acvp/acvptool/test/expected/TLS13.bz2 b/util/fipstools/acvp/acvptool/test/expected/TLS13.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..7693c5f6c0e3a5cb63b68f5e47df2ebae36ad789 GIT binary patch literal 4044 zcmV;-4>RyWT4*^jL0KkKSxJC;)Bp?g|A0hPKmbq&|L`K_4jMo2-)dkIzdnn-51rfq z0025VpaAWFpaJ0bxLmiO4wM7X8QO*bz-RyfXaE2J01;IG0Wcy|sTc%c0000gr}}B5 zX*9}eqaYeEjDP?J6;IIgLsQdAY6C++00008s(*nrX^K>O5H!#LXaEBUlz?a^Q%t5w z=`k4@4F{xQl)Xjr%119habh0vAeRYfmWgndfF+__Z-NM+nh2hdMYHre_4q#--Dkoc z5S~7zQ=Tx@03Jm3Dq!OA&GW~ElZ&!5X!TP-ryC`?KmznM}y>v zJ^#%G2{E;C4BX!~I_~MyMjZ=2KoJ?gnnL>HdlQ|BZ$jRV+`Pv&_zrIu-ZZ|BA5$n@ zEjEUFTfFQ`VAalV7kJ&S!LY<{EH60Thf14Gtm9X@!5qzn>z^(*w7_H93Ce>S6GT!F zq>KshgTC0Lh!v~Nd<$IO^ngRBP%@fzHPp%B znUZT!=$XO7ui-+F*>8+3YbqB!qwOQn{;xCB`9DQ?^xIG;PkNiJ(@?DX3B2!F5%*P%DPJ#cu>*71BR^v+UX zi-r9loQr?E^gA#WGE42I%qj3C0A)K3tXzeO8%yl+ld+bFed*6c?~%3{v>ZAYEZr>F z4z}=z-g>d~$CRWCrUYZc0?XANm*)UQrbWolT@TX2p5N1qpm-W0+9P`y|2ZT(N-?Pu zn?%siM-GxGqf6=D0~gZcfnDWfsg5Diqyv_ZdO-yBB>>ybYdtdCWc4Ef?tQZS;JMTz zm24W7uj?1cB7C%-ge<4ytje6|YWcg`@N|J=U2@-S zdMf&2lyMs%n}%hBIIav-=Fn&z@B`rnQkl;ty0d8xHSrf6`x_#TS_Zr@Q5#_1sq=pB z*0n4lg;dHIxoIqVgpZ9Dl(^EjRNWC02q@ztTTtVKj%$c%?5I8pBZ^G}5yqjag%#tg z-&(PB3jmjfLS!?QF z9WCqUZk}d~I|Ny6J5?K7DIh{PmYL;M@anzN;FPnFggP9Cjud;I;?4TgAR@Y6y@}_8 zX_arDJ`)Eot#i54$TsGHnJe%m!WjwBBS`b|=@s-Y_Hj( z5-%1EI5IGG=C5~~$*i}PL%irLFmfS9aMaR(gT8am&!@BQCo~QL4udS%%U!Tq8)L0) z416i1Q!J+2(`|o(So$j}Z<(r?*@|7p=tJg#*g0Eq0}-h^+pLohfVYl&ftf`~y|QGm zVDY=Rk5+9c66VlsxswGja8lDrz7dIDz%89Mc07xy(Pox8rA94mkZ`Tc{-f>_AlUs#B+ix1ZJSTxhdZsi6!?5K-;wvS0(kFvg%s>LDJCaMQBK=G7EK)gK5m+uIGx^L}-4m+P_&`Mgy zq|Ut66RcHZIAA(A(W>(nV3H7bi>Fx=1;~XHy4l2d4V4cX2`h7V(U7j8LgCSeQ@f^x zcg~dT?Guaw!aOj}JgXjr4G(8*suTlDl()9CWanVQ6^qsltryO4=b~I77#mWN5pt!y zLIqLFt#_`Z91m!Mlq^Fv9fsWMFgoMZz85=)uXk*S^XfG(8kcK>Z6JK>_D(#qzQG0H z3{SVd*6$DoxL(5$^;>lBpHNqdKD4%l%3k&4lqK2JL9>23mL=s@->al)(HeLl@8IS) zICFITmXSnq-TImZz?YajM6%arzOtD|S43X(+G_52fjJ_|TfWic$4)s-PaTP{PakiF zR5Lj_MV+=dW)ARj+U%$em6tTr zjlv-_rLOy@erSho@+&*q4fP#$^#_w7uQ2JvnO#${Z5ETY5~~e3tEur(Zj#Bn8gD|g zP3Dg-$6;~TO=+Cl3o*RE95601+i*p$A7k1QNeKxdAf94MFkrx+>AC8q2?+@Z9v@=i zBnZg@5`5`#2^bO*F@Ye-AtWOR!bu|}jFK>kFd?>^XN-jgN>Yguk&=;tDM(2|U(dWB z+ukSV?>ctj-J$5?a^2lp;%BK032WBH5{Ct4ZFjrKtni(gFF=PAL@BMEXzrk5C39j_ zlt4@^qpT(mFlxb~AW=otwS(nO_o{3WhpGE&iN1jKBUKLwX4!70o2#1wwy7iuvpiou zMq?&>@jZfD!``0tGQ4SbYfBtdlt!DbIerNfvlTaCX_T9bRP^b6rNwNndh3ee60$XG zi=u`M6hV=oFhZ8ubNS~c?uJ~HmD@7ee^#$ajqy>clPQv{kXMCG?ADe`IkTfR%Q{<~ zhI4%Q;_g+~m6&77nfgQ@peBDXPQg4x|Alk}vp#%palP8@Z%nx2y(?}U@4pQ=#J2qM z%M491A9E)IKs|{>nK^EfW|0Lg@L)6z8vrc zRgjrnIk*j3T_@V4s-n7XQkd9U3DpSH!b=I@mETeIbEFbcIN89(B`7)w)Vi|3 zy8P`}H&Az?+*N6=iPYVT$#qEz2^IXDF)MChZqHaCmce9dsSwP3PEzgfSll(EACTC_ zRbwZ-8{AP0XL!21=w5Vz4k(`cSBsd!O?@tVsqYlvAXSl(`|(MEo4uQc@cG*q;)^@$ zSlxyfwzDlY%PQ&MC)7c|Z6(u#PA@XE4CW>{+kM;A61d_^^%s!#!_NEGHKS~zNf{8< z$mXOum=zBL2DGQb%VVqi8saY?kamDUREAeR?y zo|XC{Q%+ZHezsY6(qvK_Xk1(wKa5gE(6|QSG{?_*GG7y%bCFRjzhkAP9Oom%(ii z8q_Am36*|hI7T8jB|xnpRW~V9ju6oUlF)d(R`_vwU=d?8M$F*KgG_1fJ+`d&O#(*O zaZ&&~inGPMI&_;-7&59AadFfXt zQZCCs1$iZ$^qn&BI1xO$q+X^m5#5J08fd#nb@)#3%e}{gH9Tsmz5}l&k5u??-}wOi z1bA)K&fsIzdXW1bGWb6NpGo1Ryq)HKDn)Iqi%>D*=?=iGg=tt`MvH%F00-cIV1A7^ z>#`wKq@`fU`WZT&`hiwhF-{%O7<~!M*Nn{jEwfGR%I#}@xEI#SS1q!a<#(W0uoJjJ z_yTk&kK!VfHxn&3n|0TVt?Z|5G3hCW9eZveTPG&y-9j+*vS@Q!bmoDaS4^7D!0N<} zb$WAKpnSyi5|5eBB8Q->4Z#}L8U3SH;lT$NuACV9US{Y77FGC0mnIVvG8Y0WZKO$lT0i(Z<;ZZ+ti?VYc1O92fH?24JkYu_C{|>-4E5(tgH7mQ9QD}lr;+E z)o(@DJ$6jA$~Jyw-KF literal 0 HcmV?d00001 diff --git a/util/fipstools/acvp/acvptool/test/tests.json b/util/fipstools/acvp/acvptool/test/tests.json index 36fdaad005..3e7dbd0c36 100644 --- a/util/fipstools/acvp/acvptool/test/tests.json +++ b/util/fipstools/acvp/acvptool/test/tests.json @@ -30,5 +30,6 @@ {"Wrapper": "modulewrapper", "In": "vectors/SHA2-224.bz2", "Out": "expected/SHA2-224.bz2"}, {"Wrapper": "modulewrapper", "In": "vectors/SHA2-256.bz2", "Out": "expected/SHA2-256.bz2"}, {"Wrapper": "modulewrapper", "In": "vectors/SHA2-384.bz2", "Out": "expected/SHA2-384.bz2"}, -{"Wrapper": "modulewrapper", "In": "vectors/SHA2-512.bz2", "Out": "expected/SHA2-512.bz2"} +{"Wrapper": "modulewrapper", "In": "vectors/SHA2-512.bz2", "Out": "expected/SHA2-512.bz2"}, +{"Wrapper": "modulewrapper", "In": "vectors/TLS13.bz2", "Out": "expected/TLS13.bz2"} ] diff --git a/util/fipstools/acvp/acvptool/test/vectors/TLS13.bz2 b/util/fipstools/acvp/acvptool/test/vectors/TLS13.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..7e8ea080b1dc8f6a63f159456edc7f1e0fc1eaad GIT binary patch literal 2556 zcmV*T4*^jL0KkKS$N|DSO5!QUw~CmPzV3;Kki-{FYn(fU<;obH;#gZ0EtjV zR46G5riP~g1yk}!^Hb3@Pf!7-O#lD@07X4C#K4-BNMvZx111m|GzLM;0$>Ed044we zU;sr=z$QjXB%m??0BF-jngATYCICzT0$>0p00JbbiIil+RC<}H9!NA~XvoksW~Iua zc;FH^aO%k*8a3<3A2%+}US2^sz)a$2671xXNi7>m0x$ux&yjYNPy=Fun?zQE-CMJK zvR1f86L|ZBs7r6va(P#kUT_q z$c`v(yUVWX(hVWAirt8X9q6_p+&eO>Y(3B8ahyi^tz%LFg5qeT)D2%Vv) zZ6}0o_rk(Ee3>q)gHYm~>vUNKV8@*D7nt=q^7IEGzTZ$cQi1Jys|lsjTD&BWvx#OH zqn?wl7k%1Vf+i;H3dC&VP_Lk9Nf~(SV#urZ5f?7GPMN8q+RnSON z8f}+bM)&kt$D8vyur5GdzF;T`0LaCVw&rNlP2_f7-IX${IsA@CR#7a2A;y95Rz36RA+(WbsT=o!rD2fU)5szI?L zn5eWg);2IbOn2-Wk}ue6BaMhW$D9Oj<$suu5==IEP=e> zId~9no$YlWOcrs0R$OEnSJ;coGkv68dg$w30-2Z+8DgC>t?Ce-Ixv?Ub@BnQJR$DyBd%}7#NoRbUgcxJ26nXq&dcwV`XolXKigf##6sdOGyIg)Ffh>{ymJvEhMkuqi*$dRO2m2FpV7my_h zg@)oW+;1aW?*z@Pi^T>oWXT9MEw)sRUz5R5iP>{lcY76tIvLalC%`Z#5#YTPso?t= zZICI8+-43H9FAOD%a3|ylR8Gey~?WeHnhZ>WzOpo^)@{S#gQpf*=)Lvmr=dlyrgG( zio-dZYKR=gOy;r0xf+wd8GGh93N1n7_Bp<{iNN=6{7pgLj!J^G!dk>qojctW#@!VR zk&@nYm!P$t!;L3}({s0}X>KId+DinH5Dw#WPG!weM2Hh0r6P87xk?;g3Mg-nr6Wpbj#}KHh-J*)Xo5q){{i4B&$BJ*bUEJUy(nc) zFC*9jUq^2)K=7B(HCC<4rk*aZ+Cb^RoIn&rI+?PEZasqy`OqWQwk;u+_*P~-Ocm5f zfx{$2I>i{4bsm^ZRP8meMWzfResXEDr<1U|%yE76(31IkV%z~=Rvvj8XF-7*<+aUf z4uUOWZsD~;NbZr2&r4l(7Sryll=_a? zL#0CPu!yx{;2(kj)FBN!_j>NK2~jH0@i4dm z5f--NA!;)Un&}rOSqhb)y%QZ0-X_%*C$ZI`+~)Si^n4H#{7ge*PC-Mkl4%H{+5jvf zl1RbMSOdl|H7ro~JS2h{8yi^iCB)dSGzvU?luPy;P!)6BGy?W&CI@r5-uDr%l#Z8} z^~mAz(Q1oU_FHWPB#vtqc7ujzxYCq&Pba#a2sy}RF9qjr#9;}~MGprljMp3rRNMw6 zPWy%+Ns}coM8~uSWUOaCtuHov;}>Z+e0CnVHjssz3v>mghn=C+FKpaz9=o}gVS9d{ z5ePjI9CC0$0iXu=wL4I_%_eQ2Lz#C;-gdF^HgyD|<2(W$ppK$*sc;l~e%n1kp>ec8 zVt~b@H@EwJdT7urO5}9;JQA*imasy!Vgn9w-)?y{<;{KqcyAKX={B78M1+Kd3m0bm zf>0g>JzL?zWI+h3En3d zpE8fyB?4+wDE0uHU*PK!9#uPhex-mXh$RAP6ws*-Y`~X^V3~xjA=(LOC9q2YD$zVa zEp5mNh4w7Z&L%w|n1W^myATsnnzP?z0Wt}kNC~V<3;{3%@O+VR0W!Fo`7t;Ner*ew z6FE~S4jguga3+r}ifS`x6xdq1P-@Uf4PK|5g11k3y5TO?rklRl6)Xg{^3H)UJH+55 Sf>j|u;_gVN3K9<-U`qgWYOfan literal 0 HcmV?d00001 diff --git a/util/fipstools/acvp/modulewrapper/modulewrapper.cc b/util/fipstools/acvp/modulewrapper/modulewrapper.cc index 5c4f9b0a87..85622c19cd 100644 --- a/util/fipstools/acvp/modulewrapper/modulewrapper.cc +++ b/util/fipstools/acvp/modulewrapper/modulewrapper.cc @@ -914,6 +914,20 @@ static bool GetConfig(const Span args[], ReplyCallback write_repl "increment": 8 } ] + }, + { + "algorithm": "TLS-v1.3", + "mode": "KDF", + "revision": "RFC8446", + "hmacAlg": [ + "SHA2-256", + "SHA2-384" + ], + "runningMode": [ + "DHE", + "PSK", + "PSK-DHE" + ] } ])"; return write_reply({Span( @@ -1484,6 +1498,49 @@ static bool HKDF(const Span args[], ReplyCallback write_reply) { return write_reply({out}); } +template +static bool HKDFExtract(const Span args[], + ReplyCallback write_reply) { + const EVP_MD *const md = HashFunc(); + const auto secret = args[0]; + const auto salt = args[1]; + + std::vector out(EVP_MD_size(md)); + size_t out_len; + if (!HKDF_extract(out.data(), &out_len, md, secret.data(), secret.size(), + salt.data(), salt.size())) { + return false; + } + assert(out_len == out.size()); + return write_reply({out}); +} + +template +static bool HKDFExpandLabel(const Span args[], + ReplyCallback write_reply) { + const EVP_MD *const md = HashFunc(); + const auto out_len_bytes = args[0]; + const auto secret = args[1]; + const auto label = args[2]; + const auto hash = args[3]; + + if (out_len_bytes.size() != sizeof(uint32_t)) { + return false; + } + const uint32_t out_len = CRYPTO_load_u32_le(out_len_bytes.data()); + if (out_len > (1 << 24)) { + return false; + } + + std::vector out(out_len); + if (!CRYPTO_tls13_hkdf_expand_label(out.data(), out_len, md, secret.data(), + secret.size(), label.data(), label.size(), + hash.data(), hash.size())) { + return false; + } + return write_reply({out}); +} + template static bool DRBG(const Span args[], ReplyCallback write_reply) { const auto out_len_bytes = args[0]; @@ -2029,6 +2086,10 @@ static constexpr struct { {"HKDF/SHA2-384", 4, HKDF}, {"HKDF/SHA2-512", 4, HKDF}, {"HKDF/SHA2-512/256", 4, HKDF}, + {"HKDFExpandLabel/SHA2-256", 4, HKDFExpandLabel}, + {"HKDFExpandLabel/SHA2-384", 4, HKDFExpandLabel}, + {"HKDFExtract/SHA2-256", 2, HKDFExtract}, + {"HKDFExtract/SHA2-384", 2, HKDFExtract}, {"HMAC-SHA-1", 2, HMAC}, {"HMAC-SHA2-224", 2, HMAC}, {"HMAC-SHA2-256", 2, HMAC}, diff --git a/util/fipstools/break-kat.go b/util/fipstools/break-kat.go index ed29bb3a49..c412d0e28f 100644 --- a/util/fipstools/break-kat.go +++ b/util/fipstools/break-kat.go @@ -26,6 +26,7 @@ var ( "SHA-256": "ff3b857da7236a2baa0f396b51522217", "SHA-512": "212512f8d2ad8322781c6c4d69a9daa1", "TLS-KDF": "abc3657b094c7628a0b282996fe75a75f4984fd94d4ecc2fcf53a2c469a3f731", + "TLS13-KDF": "024a0d80f357f2499a1244dac26dab66fc13ed85fca71dace146211119525874", "RSA-sign": "d2b56e53306f720d7929d8708bf46f1c22300305582b115bedcac722d8aa5ab2", "RSA-verify": "abe2cbc13d6bd39d48db5334ddbf8d070a93bdcb104e2cc5d0ee486ee295f6b31bda126c41890b98b73e70e6b65d82f95c663121755a90744c8d1c21148a1960be0eca446e9ff497f1345c537ef8119b9a4398e95c5c6de2b1c955905c5299d8ce7a3b6ab76380d9babdd15f610237e1f3f2aa1c1f1e770b62fbb596381b2ebdd77ecef9c90d4c92f7b6b05fed2936285fa94826e62055322a33b6f04c74ce69e5d8d737fb838b79d2d48e3daf71387531882531a95ac964d02ea413bf85952982bbc089527daff5b845c9a0f4d14ef1956d9c3acae882d12da66da0f35794f5ee32232333517db9315232a183b991654dbea41615345c885325926744a53915", "ECDSA-sign": "1e35930be860d0942ca7bbd6f6ded87f157e4de24f81ed4b875c0e018e89a81f", From 404d98b6f7605c48e7f409141b1324bcc4cd931d Mon Sep 17 00:00:00 2001 From: Nabil Wadih Date: Fri, 14 Apr 2023 13:05:02 -0700 Subject: [PATCH 12/56] Include bindgen generated file via a build time env var, this plays nicer with other build systems like Soong and Gn. Change-Id: I42e40da22dd243796cd735e09a9821cc2d114200 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58785 Reviewed-by: Bob Beck Commit-Queue: Bob Beck --- rust/bssl-sys/CMakeLists.txt | 2 -- rust/bssl-sys/build.rs | 10 ++++++++++ rust/bssl-sys/src/lib.rs | 8 +++++--- 3 files changed, 15 insertions(+), 5 deletions(-) diff --git a/rust/bssl-sys/CMakeLists.txt b/rust/bssl-sys/CMakeLists.txt index 9b5c841229..05f03f45c6 100644 --- a/rust/bssl-sys/CMakeLists.txt +++ b/rust/bssl-sys/CMakeLists.txt @@ -20,8 +20,6 @@ set(COMMAND ${BINDGEN_EXECUTABLE} "wrapper.h" # https://doc.rust-lang.org/nightly/rustc/platform-support.html --target=${RUST_BINDINGS}) -set(INCLUDES "include!(\"wrapper_${RUST_BINDINGS}.rs\");\n") - add_custom_target( bindgen_rust_${RUST_BINDINGS} ALL diff --git a/rust/bssl-sys/build.rs b/rust/bssl-sys/build.rs index 955eae3c3a..c2b7358ad7 100644 --- a/rust/bssl-sys/build.rs +++ b/rust/bssl-sys/build.rs @@ -20,6 +20,16 @@ fn main() { let dir = env::var("CARGO_MANIFEST_DIR").unwrap(); let crate_path = Path::new(&dir); + // Find the bindgen generated target platform bindings file and set BINDGEN_RS_FILE + let bindgen_file = crate_path + .join("src") + .read_dir() + .unwrap() + .map(|file| file.unwrap().file_name().into_string().unwrap()) + .find(|file| file.starts_with("wrapper_")) + .unwrap(); + println!("cargo:rustc-env=BINDGEN_RS_FILE={}", bindgen_file); + // building bssl-sys with: `mkdir build && cd build && cmake -G Ninja .. -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja` // outputs this crate to /build/rust/bssl-sys/ so need to go up 3 levels to the root of the repo let repo_root = crate_path.parent().unwrap().parent().unwrap(); diff --git a/rust/bssl-sys/src/lib.rs b/rust/bssl-sys/src/lib.rs index d8c2c00039..51ba2cf39a 100644 --- a/rust/bssl-sys/src/lib.rs +++ b/rust/bssl-sys/src/lib.rs @@ -2,8 +2,8 @@ #![allow(non_camel_case_types)] #![allow(non_snake_case)] -// populated by cmake -${INCLUDES} +// Set in build.rs +include!(env!("BINDGEN_RS_FILE")); pub fn ERR_GET_LIB(packed_error: u32) -> i32 { unsafe { ERR_GET_LIB_RUST(packed_error) } @@ -18,5 +18,7 @@ pub fn ERR_GET_FUNC(packed_error: u32) -> i32 { } pub fn init() { - unsafe { CRYPTO_library_init(); } + unsafe { + CRYPTO_library_init(); + } } From fa7afff95a7e490afc50c8b554dbd24e8e30101c Mon Sep 17 00:00:00 2001 From: Nabil Wadih Date: Fri, 14 Apr 2023 13:21:48 -0700 Subject: [PATCH 13/56] add extra lints to align with Chromium rust toolchain Change-Id: Ib3372c2a4e0e6189402485e87963d8151ad29981 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58786 Reviewed-by: Adam Langley Reviewed-by: danakj Commit-Queue: Bob Beck --- rust/bssl-crypto/src/lib.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/rust/bssl-crypto/src/lib.rs b/rust/bssl-crypto/src/lib.rs index 9024ed4b96..6ccf09cbf6 100644 --- a/rust/bssl-crypto/src/lib.rs +++ b/rust/bssl-crypto/src/lib.rs @@ -15,6 +15,7 @@ #![deny( missing_docs, + unsafe_op_in_unsafe_fn, clippy::indexing_slicing, clippy::unwrap_used, clippy::panic, @@ -107,7 +108,7 @@ unsafe trait ForeignTypeRef: Sized { #[inline] unsafe fn from_ptr<'a>(ptr: *mut Self::CType) -> &'a Self { debug_assert!(!ptr.is_null()); - &*(ptr as *mut _) + unsafe { &*(ptr as *mut _) } } /// Constructs a mutable reference of this type from its raw type. @@ -118,7 +119,7 @@ unsafe trait ForeignTypeRef: Sized { #[inline] unsafe fn from_ptr_mut<'a>(ptr: *mut Self::CType) -> &'a mut Self { debug_assert!(!ptr.is_null()); - &mut *(ptr as *mut _) + unsafe { &mut *(ptr as *mut _) } } /// Returns a raw pointer to the wrapped value. From cee2dbb08cb3daf56995875207b5e947310697de Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Fri, 14 Apr 2023 16:47:59 -0400 Subject: [PATCH 14/56] Default SSL_set_enforce_rsa_key_usage to enabled. This relands https://boringssl-review.googlesource.com/c/boringssl/+/54606, which was temporarily reverted. Update-Note: By default, clients will now require RSA server certificates used in TLS 1.2 and earlier to include the keyEncipherment or digitalSignature bit. keyEncipherment is required if using RSA key exchange. digitalSignature is required if using ECDHE_RSA key exchange. If unsure, TLS RSA server signatures should include both, but some deployments may wish to include only one if separating keys, or simply disabling RSA key exchange. The latter is useful to mitigate either the Bleichenbacher attack (from 1998, most recently resurfaced in 2017 as ROBOT), or to strengthen TLS 1.3 downgrade protections, which is particularly important for enterprise environments using client certificates (aka "mTLS") because, prior to TLS 1.3, the TLS client certificate flow was insufficiently encrypted or authenticated. Without reflecting an RSA key exchange disable into key usage, and then the client checking it, an attacker can spoof a CertificateRequest as coming from some server. This aligns with standard security requirements for using X.509 certificates, specified in RFC 5280, section 4.2.1.3, and reiterated in TLS as early as TLS 1.0, RFC 2246, section 7.4.2, published 24 years ago on January 1999. Constraints on usage of keys are important to mitigate cross-protocol attacks, a class of cryptographic attacks that is well-studied in the literature. We already checked this for each of ECDSA, TLS 1.3, and servers verifying client certificates, so this just fills in the remaining hole. As a result, this change is also important for avoiding some weird behaviors when configuration changes transition a server in or out of this hole. (We've seen connection failures get misattributed to TLS 1.3 when it was really a certificate misconfiguration.) Chrome has also enforced this for some time with publicly-trusted certificates. As a temporary measure for callers that need more time, the SSL_set_enforce_rsa_key_usage API, added to BoringSSL in January 2019, still exists where we need to turn this off. Fixed: 519 Change-Id: I91bf2cfb04c92aec7875e640f90ba6f837146dc1 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58805 Commit-Queue: David Benjamin Reviewed-by: Bob Beck --- ssl/ssl_lib.cc | 2 +- ssl/test/runner/runner.go | 21 +++++---------------- ssl/test/test_config.cc | 6 +++--- ssl/test/test_config.h | 2 +- 4 files changed, 10 insertions(+), 21 deletions(-) diff --git a/ssl/ssl_lib.cc b/ssl/ssl_lib.cc index c035825133..6b45496335 100644 --- a/ssl/ssl_lib.cc +++ b/ssl/ssl_lib.cc @@ -703,7 +703,7 @@ SSL_CONFIG::SSL_CONFIG(SSL *ssl_arg) signed_cert_timestamps_enabled(false), ocsp_stapling_enabled(false), channel_id_enabled(false), - enforce_rsa_key_usage(false), + enforce_rsa_key_usage(true), retain_only_sha256_of_client_certs(false), handoff(false), shed_handshake_config(false), diff --git a/ssl/test/runner/runner.go b/ssl/test/runner/runner.go index 54bb7b4805..dde60dfdf1 100644 --- a/ssl/test/runner/runner.go +++ b/ssl/test/runner/runner.go @@ -15605,9 +15605,6 @@ func addRSAKeyUsageTests() { }, shouldFail: true, expectedError: ":KEY_USAGE_BIT_INCORRECT:", - flags: []string{ - "-enforce-rsa-key-usage", - }, }) testCases = append(testCases, testCase{ @@ -15619,9 +15616,6 @@ func addRSAKeyUsageTests() { Certificates: []Certificate{dsCert}, CipherSuites: dsSuites, }, - flags: []string{ - "-enforce-rsa-key-usage", - }, }) // TLS 1.3 removes the encipherment suites. @@ -15635,9 +15629,6 @@ func addRSAKeyUsageTests() { Certificates: []Certificate{encCert}, CipherSuites: encSuites, }, - flags: []string{ - "-enforce-rsa-key-usage", - }, }) testCases = append(testCases, testCase{ @@ -15651,9 +15642,6 @@ func addRSAKeyUsageTests() { }, shouldFail: true, expectedError: ":KEY_USAGE_BIT_INCORRECT:", - flags: []string{ - "-enforce-rsa-key-usage", - }, }) // In 1.2 and below, we should not enforce without the enforce-rsa-key-usage flag. @@ -15666,7 +15654,7 @@ func addRSAKeyUsageTests() { Certificates: []Certificate{dsCert}, CipherSuites: encSuites, }, - flags: []string{"-expect-key-usage-invalid"}, + flags: []string{"-expect-key-usage-invalid", "-ignore-rsa-key-usage"}, }) testCases = append(testCases, testCase{ @@ -15678,21 +15666,22 @@ func addRSAKeyUsageTests() { Certificates: []Certificate{encCert}, CipherSuites: dsSuites, }, - flags: []string{"-expect-key-usage-invalid"}, + flags: []string{"-expect-key-usage-invalid", "-ignore-rsa-key-usage"}, }) } if ver.version >= VersionTLS13 { - // In 1.3 and above, we enforce keyUsage even without the flag. + // In 1.3 and above, we enforce keyUsage even when disabled. testCases = append(testCases, testCase{ testType: clientTest, - name: "RSAKeyUsage-Client-WantSignature-GotEncipherment-Enforced-" + ver.name, + name: "RSAKeyUsage-Client-WantSignature-GotEncipherment-AlwaysEnforced-" + ver.name, config: Config{ MinVersion: ver.version, MaxVersion: ver.version, Certificates: []Certificate{encCert}, CipherSuites: dsSuites, }, + flags: []string{"-ignore-rsa-key-usage"}, shouldFail: true, expectedError: ":KEY_USAGE_BIT_INCORRECT:", }) diff --git a/ssl/test/test_config.cc b/ssl/test/test_config.cc index 09faf04e1e..ba10a33190 100644 --- a/ssl/test/test_config.cc +++ b/ssl/test/test_config.cc @@ -366,7 +366,7 @@ std::vector SortedFlags() { IntFlag("-install-one-cert-compression-alg", &TestConfig::install_one_cert_compression_alg), BoolFlag("-reverify-on-resume", &TestConfig::reverify_on_resume), - BoolFlag("-enforce-rsa-key-usage", &TestConfig::enforce_rsa_key_usage), + BoolFlag("-ignore-rsa-key-usage", &TestConfig::ignore_rsa_key_usage), BoolFlag("-expect-key-usage-invalid", &TestConfig::expect_key_usage_invalid), BoolFlag("-is-handshaker-supported", @@ -1741,8 +1741,8 @@ bssl::UniquePtr TestConfig::NewSSL( if (reverify_on_resume) { SSL_CTX_set_reverify_on_resume(ssl_ctx, 1); } - if (enforce_rsa_key_usage) { - SSL_set_enforce_rsa_key_usage(ssl.get(), 1); + if (ignore_rsa_key_usage) { + SSL_set_enforce_rsa_key_usage(ssl.get(), 0); } if (no_tls13) { SSL_set_options(ssl.get(), SSL_OP_NO_TLSv1_3); diff --git a/ssl/test/test_config.h b/ssl/test/test_config.h index 5608dabd03..5cc5926437 100644 --- a/ssl/test/test_config.h +++ b/ssl/test/test_config.h @@ -177,7 +177,7 @@ struct TestConfig { bool install_cert_compression_algs = false; int install_one_cert_compression_alg = 0; bool reverify_on_resume = false; - bool enforce_rsa_key_usage = false; + bool ignore_rsa_key_usage = false; bool expect_key_usage_invalid = false; bool is_handshaker_supported = false; bool handshaker_resume = false; From 6e1e367021faafc74647427cdc1605a4844c2f83 Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Sat, 15 Apr 2023 00:04:12 +0000 Subject: [PATCH 15/56] Switch to new ACVP test for TLS 1.2 KDF. NIST has deprecated the test that we were using and replaced it with the one that this change switches BoringSSL to using. Change-Id: Iff975cda33153f8db42d9c01457d104c502485b9 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58787 Commit-Queue: Adam Langley Reviewed-by: David Benjamin --- util/fipstools/acvp/ACVP.md | 2 +- .../acvp/acvptool/subprocess/subprocess.go | 2 +- .../acvp/acvptool/subprocess/tlskdf.go | 50 ++++-------------- .../acvp/acvptool/test/expected/TLS12.bz2 | Bin 0 -> 934 bytes util/fipstools/acvp/acvptool/test/tests.json | 2 +- .../acvp/acvptool/test/vectors/TLS12.bz2 | Bin 0 -> 999 bytes .../acvp/modulewrapper/modulewrapper.cc | 25 ++++----- 7 files changed, 24 insertions(+), 57 deletions(-) create mode 100644 util/fipstools/acvp/acvptool/test/expected/TLS12.bz2 create mode 100644 util/fipstools/acvp/acvptool/test/vectors/TLS12.bz2 diff --git a/util/fipstools/acvp/ACVP.md b/util/fipstools/acvp/ACVP.md index 61c6f884b1..1fd919f68d 100644 --- a/util/fipstools/acvp/ACVP.md +++ b/util/fipstools/acvp/ACVP.md @@ -106,7 +106,7 @@ The other commands are as follows. (Note that you only need to implement the com | SHA2-384/MCT | Initial seed¹ | Digest | | SHA2-512/MCT | Initial seed¹ | Digest | | SHA2-512/256/MCT | Initial seed¹ | Digest | -| TLSKDF/<1.0\|1.2>/<HASH> | Number output bytes, secret, label, seed1, seed2 | Output | +| TLSKDF/1.2/<HASH> | Number output bytes, secret, label, seed1, seed2 | Output | ¹ The iterated tests would result in excessive numbers of round trips if the module wrapper handled only basic operations. Thus some ACVP logic is pushed down for these tests so that the inner loop can be handled locally. Either read the NIST documentation ([block-ciphers](https://pages.nist.gov/ACVP/draft-celi-acvp-symmetric.html#name-monte-carlo-tests-for-block) [hashes](https://pages.nist.gov/ACVP/draft-celi-acvp-sha.html#name-monte-carlo-tests-for-sha-1)) to understand the iteration count and return values or, probably more fruitfully, see how these functions are handled in the `modulewrapper` directory. diff --git a/util/fipstools/acvp/acvptool/subprocess/subprocess.go b/util/fipstools/acvp/acvptool/subprocess/subprocess.go index b496982e7e..84152cf9af 100644 --- a/util/fipstools/acvp/acvptool/subprocess/subprocess.go +++ b/util/fipstools/acvp/acvptool/subprocess/subprocess.go @@ -107,10 +107,10 @@ func NewWithIO(cmd *exec.Cmd, in io.WriteCloser, out io.ReadCloser) *Subprocess "hmacDRBG": &drbg{"hmacDRBG", map[string]bool{"SHA-1": true, "SHA2-224": true, "SHA2-256": true, "SHA2-384": true, "SHA2-512": true}}, "KDF": &kdfPrimitive{}, "KDA": &hkdf{}, + "TLS-v1.2": &tlsKDF{}, "TLS-v1.3": &tls13{}, "CMAC-AES": &keyedMACPrimitive{"CMAC-AES"}, "RSA": &rsa{}, - "kdf-components": &tlsKDF{}, "KAS-ECC-SSC": &kas{}, "KAS-FFC-SSC": &kasDH{}, } diff --git a/util/fipstools/acvp/acvptool/subprocess/tlskdf.go b/util/fipstools/acvp/acvptool/subprocess/tlskdf.go index 2e2b65d3b1..ad27b542f3 100644 --- a/util/fipstools/acvp/acvptool/subprocess/tlskdf.go +++ b/util/fipstools/acvp/acvptool/subprocess/tlskdf.go @@ -35,17 +35,11 @@ type tlsKDFTestGroup struct { } type tlsKDFTest struct { - ID uint64 `json:"tcId"` - PMSHex string `json:"preMasterSecret"` - // ClientHelloRandomHex and ServerHelloRandomHex are used for deriving the - // master secret. ClientRandomHex and ServerRandomHex are used for deriving the - // key block. Having different values for these is not possible in a TLS - // handshake unless you squint at a resumption handshake and somehow rederive - // the master secret from the session information during resumption. - ClientHelloRandomHex string `json:"clientHelloRandom"` - ServerHelloRandomHex string `json:"serverHelloRandom"` - ClientRandomHex string `json:"clientRandom"` - ServerRandomHex string `json:"serverRandom"` + ID uint64 `json:"tcId"` + PMSHex string `json:"preMasterSecret"` + ClientRandomHex string `json:"clientRandom"` + ServerRandomHex string `json:"serverRandom"` + SessionHashHex string `json:"sessionHash"` } type tlsKDFTestGroupResponse struct { @@ -74,35 +68,18 @@ func (k *tlsKDF) Process(vectorSet []byte, m Transactable) (interface{}, error) ID: group.ID, } - var tlsVer string - switch group.TLSVersion { - case "v1.0/1.1": - tlsVer = "1.0" - case "v1.2": - tlsVer = "1.2" - default: - return nil, fmt.Errorf("unknown TLS version %q", group.TLSVersion) - } - - hashIsTLS10 := false switch group.Hash { - case "SHA-1": - hashIsTLS10 = true case "SHA2-256", "SHA2-384", "SHA2-512": break default: return nil, fmt.Errorf("unknown hash %q", group.Hash) } - if (tlsVer == "1.0") != hashIsTLS10 { - return nil, fmt.Errorf("hash %q not permitted with TLS version %q", group.Hash, group.TLSVersion) - } - if group.KeyBlockBits%8 != 0 { return nil, fmt.Errorf("requested key-block length (%d bits) is not a whole number of bytes", group.KeyBlockBits) } - method := "TLSKDF/" + tlsVer + "/" + group.Hash + method := "TLSKDF/1.2/" + group.Hash for _, test := range group.Tests { pms, err := hex.DecodeString(test.PMSHex) @@ -110,35 +87,30 @@ func (k *tlsKDF) Process(vectorSet []byte, m Transactable) (interface{}, error) return nil, err } - clientHelloRandom, err := hex.DecodeString(test.ClientHelloRandomHex) - if err != nil { - return nil, err - } - - serverHelloRandom, err := hex.DecodeString(test.ServerHelloRandomHex) + clientRandom, err := hex.DecodeString(test.ClientRandomHex) if err != nil { return nil, err } - clientRandom, err := hex.DecodeString(test.ClientRandomHex) + serverRandom, err := hex.DecodeString(test.ServerRandomHex) if err != nil { return nil, err } - serverRandom, err := hex.DecodeString(test.ServerRandomHex) + sessionHash, err := hex.DecodeString(test.SessionHashHex) if err != nil { return nil, err } const ( masterSecretLength = 48 - masterSecretLabel = "master secret" + masterSecretLabel = "extended master secret" keyBlockLabel = "key expansion" ) var outLenBytes [4]byte binary.LittleEndian.PutUint32(outLenBytes[:], uint32(masterSecretLength)) - result, err := m.Transact(method, 1, outLenBytes[:], pms, []byte(masterSecretLabel), clientHelloRandom, serverHelloRandom) + result, err := m.Transact(method, 1, outLenBytes[:], pms, []byte(masterSecretLabel), sessionHash, nil) if err != nil { return nil, err } diff --git a/util/fipstools/acvp/acvptool/test/expected/TLS12.bz2 b/util/fipstools/acvp/acvptool/test/expected/TLS12.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..d83b691619b9a4b97bd250490fa5642084680ae9 GIT binary patch literal 934 zcmV;X16lk+T4*^jL0KkKSr5iT&Hw^1e}F_(Kmbq&|L_o`4jMo2-zrc8zFzazfZcZw zP(ox(L;&?Rr-}igpn8A;r-ao{%`$4Isp4=lq!1bv^Zc~VRh}q@4lSmwcdRkv&oQ-%elgrrKVp!94X~Bvnw?ZZ=OeSHis!1 zV4#6^_R0cN#^Fm)YCu#}Ih#03639{=tgW3m?BmwZBnV2gB|3{OdDa?fFLBG}T(w%m z3#;Ke49sWMh}`a(f-3zh7KKVukhfhWQz2_A8ALLJ$_zm8L8}T*1e^tQ!Zse*SIa() z!E9;n&etq_hJjBNb)QwN5=-5#1EWnL+do=Dpr)1yqYI@9a6DNw3j-h$C1QV1jEak$R4EB~Xy418SCWwz{vewE6ZaBim)s`m1Z9(Af&oyCOL93_N;pZIn7WQYhK-{{Z?3hFX=hbsqV zfgF;QB~#2J2r0{A7Hww~^Ic7y)J)La1OQgj6Iav~NTkVDAD>++vudo&NZV#agP|aW zt6WIj?n98|Kv8#`EMFNyhRDMCXo8IDd9y(1_nD}ceq!1bmuMV3w%Y``xjPH2Y8wN&(4~qegR!+BwrZiGU%Hs)cUWIejRM30r=~N6YiN^J9 zS6`|Ubz@B7%CfcW5E;C}0uN>1Q9bHtTn`Kw%riz_BTzxmNqN4Jz(@ia!I2Q9DH~Z}nL~f%q5k6ime7|UU|(-6#0hsMYKEy*~=12rgvi8+fg;)mv$^Zh zy&adHLUMWCs37a=bL$R6y>}8mXH3RZ<-w0HC~s)B;6-^_ye1w&OGu%;>&%}e2z_3= z+#EF`zY^BRLdm+r%{QV*+bNWeWWpe48<51V!X-5t)YZ63)f6P?Lm*3H6=s zlYZw(i$g>`9TJhO$jgRaGo>3b3@?u@UP?FNhnG9jS(8UOKrB6x!3?I_JHfUCF7Plt zEtattsNP#=Qo;zGFiYcS;!r0__gO%w&SJ`pCj?B$W1|Ma%Pc~K&dk@6#L=fGe7jc! z^m)S*L!kyo5;G{!+Iwx0;Pfmg%+>{}OrJ8U!_Xebb5p(sQWiq>7Yh$JNJo2xnI{cY z7GIOPfSsKx=4~ahpu%M#%(Ym6JVw!8Yf5#o(4tWwabG~}`4KnYHex~0bR6O5BrU(g zu46XVWsA2toCW3(`HUK71SE@-LOE9K*?a5e>DkLvNhtWKx&_MMFUJ>~G>+&PgIA2z z1%%7Eg07)$mGtUA_d|$^Gc_uxCrG6YlrD zw?&jA#A@IVql=^Q#?DrnLw}txYNNi)NfMzbV~-t^Mzd#U-84zQo~|my?A`WgD2t;6 z-tf9dHJi=$oRg^5V(6_KXN679#_4kTToUfJ&7bVavK0w+v)40V?dx{CeEVdRo3DG3 z`3+}*5g*z&)M`PU>9V0ciQ%>*y|=nC>K%^9%y}LS&LDal*1o~<{5!mO^p0`xJ;TM9 z0r!oBp=ik+P3>6BHnbRVW~@+YlJA2?d3Cxhd)qV*Mi<>sfzmQV%JcJ$!-3hC1M=O- zJsD8sF&yJ%EaS&EM+@j0OxR@{Ms%g>P+(>oSxK>xjYJ`!Zk!IwTe-2fcc_@FW args[], ReplyCallback write_repl }] }] }, - { - "algorithm": "kdf-components", - "revision": "1.0", - "mode": "tls", - "tlsVersion": [ - "v1.0/1.1", - "v1.2" - ], - "hashAlg": [ - "SHA2-256", - "SHA2-384", - "SHA2-512" - ] - }, { "algorithm": "KAS-ECC-SSC", "revision": "Sp800-56Ar3", @@ -915,6 +901,16 @@ static bool GetConfig(const Span args[], ReplyCallback write_repl } ] }, + { + "algorithm": "TLS-v1.2", + "mode": "KDF", + "revision": "RFC7627", + "hashAlg": [ + "SHA2-256", + "SHA2-384", + "SHA2-512" + ] + }, { "algorithm": "TLS-v1.3", "mode": "KDF", @@ -2127,7 +2123,6 @@ static constexpr struct { {"RSA/sigVer/SHA2-512/pss", 4, RSASigVer}, {"RSA/sigVer/SHA2-512/256/pss", 4, RSASigVer}, {"RSA/sigVer/SHA-1/pss", 4, RSASigVer}, - {"TLSKDF/1.0/SHA-1", 5, TLSKDF}, {"TLSKDF/1.2/SHA2-256", 5, TLSKDF}, {"TLSKDF/1.2/SHA2-384", 5, TLSKDF}, {"TLSKDF/1.2/SHA2-512", 5, TLSKDF}, From c466222febf86ef8e12c7926d5544354c905fce5 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Mon, 17 Apr 2023 17:27:49 -0400 Subject: [PATCH 16/56] Skip some BIO_gets tests if tmpfile fails on Android On Android, when running from an APK, |tmpfile| does not work. See b/36991167#comment8. Change-Id: I1415471907e61da5e8c8d1530a2b915fcd991d53 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58845 Auto-Submit: David Benjamin Commit-Queue: David Benjamin Reviewed-by: Bob Beck Commit-Queue: Bob Beck --- crypto/bio/bio_test.cc | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/crypto/bio/bio_test.cc b/crypto/bio/bio_test.cc index 99cdcbf6d2..6610be9a28 100644 --- a/crypto/bio/bio_test.cc +++ b/crypto/bio/bio_test.cc @@ -427,7 +427,18 @@ TEST(BIOTest, Gets) { using ScopedFILE = std::unique_ptr; ScopedFILE file(tmpfile(), fclose); +#if defined(OPENSSL_ANDROID) + // On Android, when running from an APK, |tmpfile| does not work. See + // b/36991167#comment8. + if (!file) { + fprintf(stderr, "tmpfile failed: %s (%d). Skipping file-based tests.\n", + strerror(errno), errno); + continue; + } +#else ASSERT_TRUE(file); +#endif + if (!t.bio.empty()) { ASSERT_EQ(1u, fwrite(t.bio.data(), t.bio.size(), /*nitems=*/1, file.get())); From a4593cefebff2578ffef25db68d20f53a813de8e Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Thu, 4 Aug 2022 20:03:56 +0000 Subject: [PATCH 17/56] break-tests.sh: break run-time tests and use two test_fips binaries. (This change breaks running on Android. But it's close to what we used for non-Android FIPS testing so is useful to have on the record.) This change adds testing of the run-time break tests: the pair-wise consistency tests and the RNG test. It also switches to using two test_fips binaries: an unmodified one for showing a clean up and testing the integrity test, and a test_fips_break which makes integrity test failures non-fatal (for KAT testing) and which allows the run-time tests to be triggered. Change-Id: Id2787723059cfb17cc2d22013ad66b985ef86701 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/53885 Reviewed-by: David Benjamin Auto-Submit: Adam Langley Commit-Queue: David Benjamin --- util/fipstools/break-tests.sh | 186 +++++++++++++++++++--------------- 1 file changed, 102 insertions(+), 84 deletions(-) diff --git a/util/fipstools/break-tests.sh b/util/fipstools/break-tests.sh index f9ae2e8d13..695b62931b 100644 --- a/util/fipstools/break-tests.sh +++ b/util/fipstools/break-tests.sh @@ -25,139 +25,147 @@ set -e die () { - echo "ERROR: $@" - exit 1 + echo "ERROR: $@" + exit 1 } usage() { - echo "USAGE: $0 [local|device]" - exit 1 + echo "USAGE: $0 [local|device]" + exit 1 } inferred_mode() { - # Try and infer local or device mode based on makefiles and artifacts. - if [ -f Android.bp -o -f external/boringssl/Android.bp ] - then - echo device - elif [ -f CMakeLists.txt -a -d build/crypto -a -d build/ssl ] - then - echo local - else - echo "Unable to infer mode, please specify on the command line." - usage - fi + # Try and infer local or device mode based on makefiles and artifacts. + if [ -f Android.bp -o -f external/boringssl/Android.bp ]; then + echo device + elif [ -f CMakeLists.txt -a -d build/crypto -a -d build/ssl ]; then + echo local + else + echo "Unable to infer mode, please specify on the command line." + usage + fi } # Prefer mode from command line if present. case "$1" in - local|device) - MODE=$1 - ;; + local|device) + MODE=$1 + ;; - "") - MODE=`inferred_mode` - ;; + "") + MODE=`inferred_mode` + ;; - *) - usage - ;; + *) + usage + ;; esac check_directory() { - test -d $1 || die "Directory $1 not found." + test -d "$1" || die "Directory $1 not found." } check_file() { - test -f $1 || die "File $1 not found." + test -f "$1" || die "File $1 not found." } run_test_locally() { - eval "$1" || true + eval "$1" || true } run_test_on_device() { - EXECFILE="$1" - LIBRARY="$2" - adb shell rm -rf $DEVICE_TMP - adb shell mkdir -p $DEVICE_TMP - adb push $EXECFILE $DEVICE_TMP > /dev/null - EXECPATH=$(basename $EXECFILE) - adb push $LIBRARY $DEVICE_TMP > /dev/null - adb shell "LD_LIBRARY_PATH=$DEVICE_TMP $DEVICE_TMP/$EXECPATH" || true + EXECFILE="$1" + LIBRARY="$2" + adb shell rm -rf "$DEVICE_TMP" + adb shell mkdir -p "$DEVICE_TMP" + adb push "$EXECFILE" "$DEVICE_TMP" > /dev/null + EXECPATH=$(basename "$EXECFILE") + adb push "$LIBRARY" "$DEVICE_TMP" > /dev/null + adb shell "LD_LIBRARY_PATH=$DEVICE_TMP" "$DEVICE_TMP/$EXECPATH" || true } device_integrity_break_test() { - go run $BORINGSSL/util/fipstools/break-hash.go $LIBCRYPTO_BIN ./libcrypto.so - $RUN $TEST_FIPS_BIN ./libcrypto.so - rm ./libcrypto.so + go run "$BORINGSSL/util/fipstools/break-hash.go" "$LIBCRYPTO_BIN" ./libcrypto.so + $RUN "$TEST_FIPS_BIN" ./libcrypto.so + rm ./libcrypto.so } local_integrity_break_test() { - go run $BORINGSSL/util/fipstools/break-hash.go $TEST_FIPS_BIN ./break-bin - chmod u+x ./break-bin - $RUN ./break-bin - rm ./break-bin + go run $BORINGSSL/util/fipstools/break-hash.go "$TEST_FIPS_BIN" ./break-bin + chmod u+x ./break-bin + $RUN ./break-bin + rm ./break-bin +} + +local_runtime_break_test() { + BORINGSSL_FIPS_BREAK_TEST=$1 "$RUN" "$TEST_FIPS_BREAK_BIN" } # TODO(prb): make break-hash and break-kat take similar arguments to save having # separate functions for each. device_kat_break_test() { - KAT="$1" - go run $BORINGSSL/util/fipstools/break-kat.go $LIBCRYPTO_BIN $KAT > ./libcrypto.so - $RUN $TEST_FIPS_BIN ./libcrypto.so - rm ./libcrypto.so + KAT="$1" + go run "$BORINGSSL/util/fipstools/break-kat.go" "$LIBCRYPTO_BREAK_BIN" "$KAT" > ./libcrypto.so + $RUN "$TEST_FIPS_BIN" ./libcrypto.so + rm ./libcrypto.so } local_kat_break_test() { - KAT="$1" - go run $BORINGSSL/util/fipstools/break-kat.go $TEST_FIPS_BIN $KAT > ./break-bin - chmod u+x ./break-bin - $RUN ./break-bin - rm ./break-bin + KAT="$1" + go run "$BORINGSSL/util/fipstools/break-kat.go" "$TEST_FIPS_BREAK_BIN" "$KAT" > ./break-bin + chmod u+x ./break-bin + $RUN ./break-bin + rm ./break-bin } pause () { - echo -n "Press " - read + echo -n "Press " + read } -if [ "$MODE" = "local" ] -then - TEST_FIPS_BIN="build/util/fipstools/test_fips" - BORINGSSL=. - RUN=run_test_locally - BREAK_TEST=local_break_test - INTEGRITY_BREAK_TEST=local_integrity_break_test - KAT_BREAK_TEST=local_kat_break_test - if [ ! -f $TEST_FIPS_BIN ]; then - echo "$TEST_FIPS_BIN is missing. Run this script from the top level of a" - echo "BoringSSL checkout and ensure that BoringSSL has been built in" - echo "build/ with -DFIPS_BREAK_TEST=TESTS passed to CMake." - exit 1 - fi +if [ "$MODE" = "local" ]; then + TEST_FIPS_BIN=${TEST_FIPS_BIN:-build/util/fipstools/test_fips} + TEST_FIPS_BREAK_BIN=${TEST_FIPS_BREAK_BIN:-./test_fips_break} + check_file "$TEST_FIPS_BIN" + check_file "$TEST_FIPS_BREAK_BIN" + + BORINGSSL=. + RUN=run_test_locally + BREAK_TEST=local_break_test + INTEGRITY_BREAK_TEST=local_integrity_break_test + KAT_BREAK_TEST=local_kat_break_test + RUNTIME_BREAK_TEST=local_runtime_break_test + if [ ! -f "$TEST_FIPS_BIN" ]; then + echo "$TEST_FIPS_BIN is missing. Run this script from the top level of a" + echo "BoringSSL checkout and ensure that BoringSSL has been built in" + echo "build/ with -DFIPS_BREAK_TEST=TESTS passed to CMake." + exit 1 + fi else # Device mode - test "$ANDROID_BUILD_TOP" || die "'lunch aosp_arm64-eng' first" - check_directory "$ANDROID_PRODUCT_OUT" - - TEST_FIPS_BIN="$ANDROID_PRODUCT_OUT/system/bin/test_fips" - check_file "$TEST_FIPS_BIN" - LIBCRYPTO_BIN="$ANDROID_PRODUCT_OUT/system/lib64/libcrypto.so" - check_file "$LIBCRYPTO_BIN" - - test "$ANDROID_SERIAL" || die "ANDROID_SERIAL not set" - DEVICE_TMP=/data/local/tmp - - BORINGSSL="$ANDROID_BUILD_TOP/external/boringssl/src" - RUN=run_test_on_device - INTEGRITY_BREAK_TEST=device_integrity_break_test - KAT_BREAK_TEST=device_kat_break_test + test "$ANDROID_BUILD_TOP" || die "'lunch aosp_arm64-eng' first" + check_directory "$ANDROID_PRODUCT_OUT" + + TEST_FIPS_BIN="$ANDROID_PRODUCT_OUT/system/bin/test_fips" + check_file "$TEST_FIPS_BIN" + LIBCRYPTO_BIN="$ANDROID_PRODUCT_OUT/system/lib64/libcrypto.so" + LIBCRYPTO_BREAK_BIN="libcrypto.so" + check_file "$LIBCRYPTO_BIN" + check_file "$LIBCRYPTO_BREAK_BIN" + + test "$ANDROID_SERIAL" || die "ANDROID_SERIAL not set" + DEVICE_TMP=/data/local/tmp + + BORINGSSL="$ANDROID_BUILD_TOP/external/boringssl/src" + RUN=run_test_on_device + INTEGRITY_BREAK_TEST=device_integrity_break_test + KAT_BREAK_TEST=device_kat_break_test fi -KATS=$(go run $BORINGSSL/util/fipstools/break-kat.go --list-tests) +KATS=$(go run "$BORINGSSL/util/fipstools/break-kat.go" --list-tests) echo -e '\033[1mNormal output\033[0m' -$RUN $TEST_FIPS_BIN $LIBCRYPTO_BIN +$RUN "$TEST_FIPS_BIN" "$LIBCRYPTO_BIN" pause echo @@ -171,3 +179,13 @@ for kat in $KATS; do $KAT_BREAK_TEST $kat pause done + +if [ "$MODE" = "local" ]; then + # TODO(prb): add support for Android devices. + for runtime_test in ECDSA_PWCT RSA_PWCT CRNG; do + echo + echo -e "\033[1m${runtime_test} failure\033[0m" + $RUNTIME_BREAK_TEST ${runtime_test} + pause + done +fi From 6776d5cd8fcdf6c5e05bae2d655076dbeaa56103 Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Mon, 17 Apr 2023 22:13:39 +0000 Subject: [PATCH 18/56] Update test_fips.c with new functions added to FIPS module. Change-Id: Ibe428995fbc03669bf822296741574e2bbeb482d Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58865 Commit-Queue: Adam Langley Reviewed-by: David Benjamin --- util/fipstools/test_fips.c | 42 ++++++++++++++++++++++++++++++-------- 1 file changed, 34 insertions(+), 8 deletions(-) diff --git a/util/fipstools/test_fips.c b/util/fipstools/test_fips.c index ed95b8ccb6..3a1f7fcebb 100644 --- a/util/fipstools/test_fips.c +++ b/util/fipstools/test_fips.c @@ -24,8 +24,9 @@ #include #include #include -#include #include +#include +#include #include #include #include @@ -278,18 +279,43 @@ int main(int argc, char **argv) { hexdump(output, sizeof(output)); CTR_DRBG_clear(&drbg); - /* TLS KDF */ - printf("About to run TLS KDF\n"); - uint8_t tls_output[32]; - if (!CRYPTO_tls1_prf(EVP_sha256(), tls_output, sizeof(tls_output), kAESKey, - sizeof(kAESKey), "foo", 3, kPlaintextSHA256, + /* HKDF */ + printf("About to run HKDF\n"); + uint8_t hkdf_output[32]; + if (!HKDF(hkdf_output, sizeof(hkdf_output), EVP_sha256(), kAESKey, + sizeof(kAESKey), (const uint8_t *)"salt", 4, kPlaintextSHA256, + sizeof(kPlaintextSHA256))) { + fprintf(stderr, "HKDF failed.\n"); + goto err; + } + printf(" got "); + hexdump(hkdf_output, sizeof(hkdf_output)); + + /* TLS v1.2 KDF */ + printf("About to run TLS v1.2 KDF\n"); + uint8_t tls12_output[32]; + if (!CRYPTO_tls1_prf(EVP_sha256(), tls12_output, sizeof(tls12_output), + kAESKey, sizeof(kAESKey), "foo", 3, kPlaintextSHA256, sizeof(kPlaintextSHA256), kPlaintextSHA256, sizeof(kPlaintextSHA256))) { - fprintf(stderr, "TLS KDF failed.\n"); + fprintf(stderr, "TLS v1.2 KDF failed.\n"); + goto err; + } + printf(" got "); + hexdump(tls12_output, sizeof(tls12_output)); + + /* TLS v1.3 KDF */ + printf("About to run TLS v1.3 KDF\n"); + uint8_t tls13_output[32]; + if (!CRYPTO_tls13_hkdf_expand_label( + tls13_output, sizeof(tls13_output), EVP_sha256(), kAESKey, + sizeof(kAESKey), (const uint8_t *)"foo", 3, kPlaintextSHA256, + sizeof(kPlaintextSHA256))) { + fprintf(stderr, "TLS v1.3 KDF failed.\n"); goto err; } printf(" got "); - hexdump(tls_output, sizeof(tls_output)); + hexdump(tls13_output, sizeof(tls13_output)); /* FFDH */ printf("About to compute FFDH key-agreement:\n"); From 32b51305debe43e38e7bf2c2b13c4ebf3b474e80 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Sat, 25 Mar 2023 01:42:18 -0400 Subject: [PATCH 19/56] Widen ASN1_mbstring_copy and ASN1_mbstring_ncopy to ossl_ssize_t Bug: 516 Change-Id: I3f374f05188bebe7aa4cbf45c81a6f945d3ce97c Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58549 Commit-Queue: David Benjamin Reviewed-by: Bob Beck --- crypto/asn1/a_mbstr.c | 17 +++++++++-------- crypto/asn1/a_strnid.c | 2 +- crypto/x509/x509name.c | 25 +++++++++++-------------- include/openssl/asn1.h | 10 ++++++---- include/openssl/x509.h | 23 ++++++++++++++--------- 5 files changed, 41 insertions(+), 36 deletions(-) diff --git a/crypto/asn1/a_mbstr.c b/crypto/asn1/a_mbstr.c index 85a7b98a74..8fc82ab5ca 100644 --- a/crypto/asn1/a_mbstr.c +++ b/crypto/asn1/a_mbstr.c @@ -73,18 +73,19 @@ // horrible: it has to be :-( The 'ncopy' form checks minimum and maximum // size limits too. -int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, - int inform, unsigned long mask) { - return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0); +int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, + ossl_ssize_t len, int inform, unsigned long mask) { + return ASN1_mbstring_ncopy(out, in, len, inform, mask, /*minsize=*/0, + /*maxsize=*/0); } OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_BMPSTRING) OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_UNIVERSALSTRING) OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_UTF8STRING) -int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, - int inform, unsigned long mask, long minsize, - long maxsize) { +int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, + ossl_ssize_t len, int inform, unsigned long mask, + ossl_ssize_t minsize, ossl_ssize_t maxsize) { if (len == -1) { len = strlen((const char *)in); } @@ -164,14 +165,14 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, utf8_len += cbb_get_utf8_len(c); if (maxsize > 0 && nchar > (size_t)maxsize) { OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_LONG); - ERR_add_error_dataf("maxsize=%ld", maxsize); + ERR_add_error_dataf("maxsize=%zu", (size_t)maxsize); return -1; } } if (minsize > 0 && nchar < (size_t)minsize) { OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_SHORT); - ERR_add_error_dataf("minsize=%ld", minsize); + ERR_add_error_dataf("minsize=%zu", (size_t)minsize); return -1; } diff --git a/crypto/asn1/a_strnid.c b/crypto/asn1/a_strnid.c index 3be266e8d1..48c223d6ad 100644 --- a/crypto/asn1/a_strnid.c +++ b/crypto/asn1/a_strnid.c @@ -87,7 +87,7 @@ static const ASN1_STRING_TABLE *asn1_string_table_get(int nid); // a corresponding OID. For example certificates and certificate requests. ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in, - int len, int inform, int nid) { + ossl_ssize_t len, int inform, int nid) { ASN1_STRING *str = NULL; int ret; if (!out) { diff --git a/crypto/x509/x509name.c b/crypto/x509/x509name.c index cc86e289a6..25f7b8b350 100644 --- a/crypto/x509/x509name.c +++ b/crypto/x509/x509name.c @@ -178,8 +178,8 @@ X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc) { } int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, - int type, const unsigned char *bytes, int len, - int loc, int set) { + int type, const unsigned char *bytes, + ossl_ssize_t len, int loc, int set) { X509_NAME_ENTRY *ne = X509_NAME_ENTRY_create_by_OBJ(NULL, obj, type, bytes, len); if (!ne) { @@ -191,8 +191,8 @@ int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, } int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type, - const unsigned char *bytes, int len, int loc, - int set) { + const unsigned char *bytes, ossl_ssize_t len, + int loc, int set) { X509_NAME_ENTRY *ne = X509_NAME_ENTRY_create_by_NID(NULL, nid, type, bytes, len); if (!ne) { @@ -204,8 +204,8 @@ int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type, } int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type, - const unsigned char *bytes, int len, int loc, - int set) { + const unsigned char *bytes, ossl_ssize_t len, + int loc, int set) { X509_NAME_ENTRY *ne = X509_NAME_ENTRY_create_by_txt(NULL, field, type, bytes, len); if (!ne) { @@ -282,7 +282,7 @@ int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *entry, int loc, X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne, const char *field, int type, const unsigned char *bytes, - int len) { + ossl_ssize_t len) { ASN1_OBJECT *obj; X509_NAME_ENTRY *nentry; @@ -300,7 +300,7 @@ X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne, X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, int type, const unsigned char *bytes, - int len) { + ossl_ssize_t len) { const ASN1_OBJECT *obj = OBJ_nid2obj(nid); if (obj == NULL) { OPENSSL_PUT_ERROR(X509, X509_R_UNKNOWN_NID); @@ -312,7 +312,7 @@ X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne, const ASN1_OBJECT *obj, int type, const unsigned char *bytes, - int len) { + ossl_ssize_t len) { X509_NAME_ENTRY *ret; if ((ne == NULL) || (*ne == NULL)) { @@ -352,9 +352,7 @@ int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj) { } int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type, - const unsigned char *bytes, int len) { - int i; - + const unsigned char *bytes, ossl_ssize_t len) { if ((ne == NULL) || ((bytes == NULL) && (len != 0))) { return 0; } @@ -367,8 +365,7 @@ int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type, if (len < 0) { len = strlen((const char *)bytes); } - i = ASN1_STRING_set(ne->value, bytes, len); - if (!i) { + if (!ASN1_STRING_set(ne->value, bytes, len)) { return 0; } if (type != V_ASN1_UNDEF) { diff --git a/include/openssl/asn1.h b/include/openssl/asn1.h index 5df6816039..d128c8dfe0 100644 --- a/include/openssl/asn1.h +++ b/include/openssl/asn1.h @@ -740,15 +740,17 @@ OPENSSL_EXPORT int ASN1_STRING_to_UTF8(unsigned char **out, // the result. If |out| is NULL, it returns the selected output type without // constructing an |ASN1_STRING|. On error, this function returns -1. OPENSSL_EXPORT int ASN1_mbstring_copy(ASN1_STRING **out, const uint8_t *in, - int len, int inform, unsigned long mask); + ossl_ssize_t len, int inform, + unsigned long mask); // ASN1_mbstring_ncopy behaves like |ASN1_mbstring_copy| but returns an error if // the input is less than |minsize| or greater than |maxsize| codepoints long. A // |maxsize| value of zero is ignored. Note the sizes are measured in // codepoints, not output bytes. OPENSSL_EXPORT int ASN1_mbstring_ncopy(ASN1_STRING **out, const uint8_t *in, - int len, int inform, unsigned long mask, - long minsize, long maxsize); + ossl_ssize_t len, int inform, + unsigned long mask, ossl_ssize_t minsize, + ossl_ssize_t maxsize); // ASN1_STRING_set_by_NID behaves like |ASN1_mbstring_ncopy|, but determines // |mask|, |minsize|, and |maxsize| based on |nid|. When |nid| is a recognized @@ -774,7 +776,7 @@ OPENSSL_EXPORT int ASN1_mbstring_ncopy(ASN1_STRING **out, const uint8_t *in, // to call |ASN1_mbstring_ncopy| directly instead. OPENSSL_EXPORT ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in, - int len, int inform, + ossl_ssize_t len, int inform, int nid); // STABLE_NO_MASK causes |ASN1_STRING_TABLE_add| to allow types other than diff --git a/include/openssl/x509.h b/include/openssl/x509.h index 19d647d335..2ab7564b2d 100644 --- a/include/openssl/x509.h +++ b/include/openssl/x509.h @@ -940,22 +940,25 @@ OPENSSL_EXPORT int X509_NAME_add_entry(X509_NAME *name, // |set| as in |X509_NAME_add_entry|. OPENSSL_EXPORT int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type, - const uint8_t *bytes, int len, - int loc, int set); + const uint8_t *bytes, + ossl_ssize_t len, int loc, + int set); // X509_NAME_add_entry_by_NID behaves like |X509_NAME_add_entry_by_OBJ| but sets // the entry's attribute type to |nid|, which should be one of the |NID_*| // constants. OPENSSL_EXPORT int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type, const uint8_t *bytes, - int len, int loc, int set); + ossl_ssize_t len, int loc, + int set); // X509_NAME_add_entry_by_txt behaves like |X509_NAME_add_entry_by_OBJ| but sets // the entry's attribute type to |field|, which is passed to |OBJ_txt2obj|. OPENSSL_EXPORT int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type, - const uint8_t *bytes, int len, - int loc, int set); + const uint8_t *bytes, + ossl_ssize_t len, int loc, + int set); // X509_NAME_ENTRY is an |ASN1_ITEM| whose ASN.1 type is AttributeTypeAndValue // (RFC 5280) and C type is |X509_NAME_ENTRY*|. @@ -1021,7 +1024,8 @@ OPENSSL_EXPORT ASN1_STRING *X509_NAME_ENTRY_get_data( // See |ASN1_STRING| for how to format ASN.1 types as an |ASN1_STRING|. If // |type| is |V_ASN1_UNDEF| the previous |ASN1_STRING| type is reused. OPENSSL_EXPORT int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *entry, int type, - const uint8_t *bytes, int len); + const uint8_t *bytes, + ossl_ssize_t len); // X509_NAME_ENTRY_set returns the zero-based index of the RDN which contains // |entry|. Consecutive entries with the same index are part of the same RDN. @@ -1037,19 +1041,20 @@ OPENSSL_EXPORT int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *entry); // object at |*out| instead of allocating a new one. OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ( X509_NAME_ENTRY **out, const ASN1_OBJECT *obj, int type, - const uint8_t *bytes, int len); + const uint8_t *bytes, ossl_ssize_t len); // X509_NAME_ENTRY_create_by_NID behaves like |X509_NAME_ENTRY_create_by_OBJ| // except the attribute type is |nid|, which should be one of the |NID_*| // constants. OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID( - X509_NAME_ENTRY **out, int nid, int type, const uint8_t *bytes, int len); + X509_NAME_ENTRY **out, int nid, int type, const uint8_t *bytes, + ossl_ssize_t len); // X509_NAME_ENTRY_create_by_txt behaves like |X509_NAME_ENTRY_create_by_OBJ| // except the attribute type is |field|, which is passed to |OBJ_txt2obj|. OPENSSL_EXPORT X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt( X509_NAME_ENTRY **out, const char *field, int type, const uint8_t *bytes, - int len); + ossl_ssize_t len); // Extensions. From aa31748bc84f0cd499e4b0337bf929b132aab1cc Mon Sep 17 00:00:00 2001 From: Andres Erbsen Date: Mon, 27 Feb 2023 17:08:23 +0000 Subject: [PATCH 20/56] Generate 64-bit Curve25519 and P256 code for MSVC Change-Id: I2218807c6bfe445460a01f6c86712640915e87df Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/57666 Reviewed-by: David Benjamin Commit-Queue: David Benjamin --- crypto/curve25519/curve25519.c | 10 +- crypto/curve25519/curve25519_tables.h | 1590 +++++++-------- crypto/curve25519/internal.h | 6 +- crypto/curve25519/make_curve25519_tables.py | 2 +- crypto/fipsmodule/ec/make_tables.go | 2 +- crypto/fipsmodule/ec/p256.c | 7 +- crypto/fipsmodule/ec/p256_table.h | 2 +- third_party/fiat/curve25519_64_msvc.h | 1281 ++++++++++++ third_party/fiat/p256_64_msvc.h | 2002 +++++++++++++++++++ 9 files changed, 4091 insertions(+), 811 deletions(-) create mode 100644 third_party/fiat/curve25519_64_msvc.h create mode 100644 third_party/fiat/p256_64_msvc.h diff --git a/crypto/curve25519/curve25519.c b/crypto/curve25519/curve25519.c index 6a0af2d9f9..c0289ffe78 100644 --- a/crypto/curve25519/curve25519.c +++ b/crypto/curve25519/curve25519.c @@ -35,11 +35,13 @@ // Various pre-computed constants. #include "./curve25519_tables.h" -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(BORINGSSL_HAS_UINT128) #include "../../third_party/fiat/curve25519_64.h" +#elif defined(OPENSSL_64_BIT) +#include "../../third_party/fiat/curve25519_64_msvc.h" #else #include "../../third_party/fiat/curve25519_32.h" -#endif // BORINGSSL_CURVE25519_64BIT +#endif // Low-level intrinsic operations @@ -64,7 +66,7 @@ static uint64_t load_4(const uint8_t *in) { // Field operations. -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) typedef uint64_t fe_limb_t; #define FE_NUM_LIMBS 5 @@ -144,7 +146,7 @@ typedef uint32_t fe_limb_t; } \ } while (0) -#endif // BORINGSSL_CURVE25519_64BIT +#endif // OPENSSL_64_BIT static_assert(sizeof(fe) == sizeof(fe_limb_t) * FE_NUM_LIMBS, "fe_limb_t[FE_NUM_LIMBS] is inconsistent with fe"); diff --git a/crypto/curve25519/curve25519_tables.h b/crypto/curve25519/curve25519_tables.h index 310581cf3b..ad1f036a44 100644 --- a/crypto/curve25519/curve25519_tables.h +++ b/crypto/curve25519/curve25519_tables.h @@ -17,7 +17,7 @@ static const fe d = {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 929955233495203, 466365720129213, 1662059464998953, 2033849074728123, 1442794654840575 #else @@ -27,7 +27,7 @@ static const fe d = {{ }}; static const fe sqrtm1 = {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1718705420411056, 234908883556509, 2233514472574048, 2117202627021982, 765476049583133 #else @@ -37,7 +37,7 @@ static const fe sqrtm1 = {{ }}; static const fe d2 = {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1859910466990425, 932731440258426, 1072319116312658, 1815898335770999, 633789495995903 #else @@ -146,7 +146,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1288382639258501, 245678601348599, 269427782077623, 1462984067271730, 137412439391563 #else @@ -155,7 +155,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 62697248952638, 204681361388450, 631292143396476, 338455783676468, 1213667448819585 #else @@ -164,7 +164,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 301289933810280, 1259582250014073, 1422107436869536, 796239922652654, 1953934009299142 #else @@ -175,7 +175,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1380971894829527, 790832306631236, 2067202295274102, 1995808275510000, 1566530869037010 #else @@ -184,7 +184,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 463307831301544, 432984605774163, 1610641361907204, 750899048855000, 1894842303421586 #else @@ -193,7 +193,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 748439484463711, 1033211726465151, 1396005112841647, 1611506220286469, 1972177495910992 #else @@ -204,7 +204,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1601611775252272, 1720807796594148, 1132070835939856, 1260455018889551, 2147779492816911 #else @@ -213,7 +213,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 316559037616741, 2177824224946892, 1459442586438991, 1461528397712656, 751590696113597 #else @@ -222,7 +222,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1850748884277385, 1200145853858453, 1068094770532492, 672251375690438, 1586055907191707 #else @@ -233,7 +233,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 934282339813791, 1846903124198670, 1172395437954843, 1007037127761661, 1830588347719256 #else @@ -242,7 +242,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1694390458783935, 1735906047636159, 705069562067493, 648033061693059, 696214010414170 #else @@ -251,7 +251,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1121406372216585, 192876649532226, 190294192191717, 1994165897297032, 2245000007398739 #else @@ -262,7 +262,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 769950342298419, 132954430919746, 844085933195555, 974092374476333, 726076285546016 #else @@ -271,7 +271,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 425251763115706, 608463272472562, 442562545713235, 837766094556764, 374555092627893 #else @@ -280,7 +280,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1086255230780037, 274979815921559, 1960002765731872, 929474102396301, 1190409889297339 #else @@ -291,7 +291,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1388594989461809, 316767091099457, 394298842192982, 1230079486801005, 1440737038838979 #else @@ -300,7 +300,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 7380825640100, 146210432690483, 304903576448906, 1198869323871120, 997689833219095 #else @@ -309,7 +309,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1181317918772081, 114573476638901, 262805072233344, 265712217171332, 294181933805782 #else @@ -320,7 +320,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 665000864555967, 2065379846933859, 370231110385876, 350988370788628, 1233371373142985 #else @@ -329,7 +329,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2019367628972465, 676711900706637, 110710997811333, 1108646842542025, 517791959672113 #else @@ -338,7 +338,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 965130719900578, 247011430587952, 526356006571389, 91986625355052, 2157223321444601 #else @@ -349,7 +349,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2068619540119183, 1966274918058806, 957728544705549, 729906502578991, 159834893065166 #else @@ -358,7 +358,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2073601412052185, 31021124762708, 264500969797082, 248034690651703, 1030252227928288 #else @@ -367,7 +367,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 551790716293402, 1989538725166328, 801169423371717, 2052451893578887, 678432056995012 #else @@ -380,7 +380,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1368953770187805, 790347636712921, 437508475667162, 2142576377050580, 1932081720066286 #else @@ -389,7 +389,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 953638594433374, 1092333936795051, 1419774766716690, 805677984380077, 859228993502513 #else @@ -398,7 +398,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1200766035879111, 20142053207432, 1465634435977050, 1645256912097844, 295121984874596 #else @@ -409,7 +409,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1735718747031557, 1248237894295956, 1204753118328107, 976066523550493, 65943769534592 #else @@ -418,7 +418,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1060098822528990, 1586825862073490, 212301317240126, 1975302711403555, 666724059764335 #else @@ -427,7 +427,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1091990273418756, 1572899409348578, 80968014455247, 306009358661350, 1520450739132526 #else @@ -438,7 +438,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1480517209436112, 1511153322193952, 1244343858991172, 304788150493241, 369136856496443 #else @@ -447,7 +447,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2151330273626164, 762045184746182, 1688074332551515, 823046109005759, 907602769079491 #else @@ -456,7 +456,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2047386910586836, 168470092900250, 1552838872594810, 340951180073789, 360819374702533 #else @@ -467,7 +467,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1982622644432056, 2014393600336956, 128909208804214, 1617792623929191, 105294281913815 #else @@ -476,7 +476,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 980234343912898, 1712256739246056, 588935272190264, 204298813091998, 841798321043288 #else @@ -485,7 +485,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 197561292938973, 454817274782871, 1963754960082318, 2113372252160468, 971377527342673 #else @@ -496,7 +496,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 164699448829328, 3127451757672, 1199504971548753, 1766155447043652, 1899238924683527 #else @@ -505,7 +505,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 732262946680281, 1674412764227063, 2182456405662809, 1350894754474250, 558458873295247 #else @@ -514,7 +514,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2103305098582922, 1960809151316468, 715134605001343, 1454892949167181, 40827143824949 #else @@ -525,7 +525,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1239289043050212, 1744654158124578, 758702410031698, 1796762995074688, 1603056663766 #else @@ -534,7 +534,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2232056027107988, 987343914584615, 2115594492994461, 1819598072792159, 1119305654014850 #else @@ -543,7 +543,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 320153677847348, 939613871605645, 641883205761567, 1930009789398224, 329165806634126 #else @@ -554,7 +554,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 980930490474130, 1242488692177893, 1251446316964684, 1086618677993530, 1961430968465772 #else @@ -563,7 +563,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 276821765317453, 1536835591188030, 1305212741412361, 61473904210175, 2051377036983058 #else @@ -572,7 +572,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 833449923882501, 1750270368490475, 1123347002068295, 185477424765687, 278090826653186 #else @@ -583,7 +583,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 794524995833413, 1849907304548286, 53348672473145, 1272368559505217, 1147304168324779 #else @@ -592,7 +592,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1504846112759364, 1203096289004681, 562139421471418, 274333017451844, 1284344053775441 #else @@ -601,7 +601,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 483048732424432, 2116063063343382, 30120189902313, 292451576741007, 1156379271702225 #else @@ -614,7 +614,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 928372153029038, 2147692869914564, 1455665844462196, 1986737809425946, 185207050258089 #else @@ -623,7 +623,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 137732961814206, 706670923917341, 1387038086865771, 1965643813686352, 1384777115696347 #else @@ -632,7 +632,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 481144981981577, 2053319313589856, 2065402289827512, 617954271490316, 1106602634668125 #else @@ -643,7 +643,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 696298019648792, 893299659040895, 1148636718636009, 26734077349617, 2203955659340681 #else @@ -652,7 +652,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 657390353372855, 998499966885562, 991893336905797, 810470207106761, 343139804608786 #else @@ -661,7 +661,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 791736669492960, 934767652997115, 824656780392914, 1759463253018643, 361530362383518 #else @@ -672,7 +672,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2022541353055597, 2094700262587466, 1551008075025686, 242785517418164, 695985404963562 #else @@ -681,7 +681,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1287487199965223, 2215311941380308, 1552928390931986, 1664859529680196, 1125004975265243 #else @@ -690,7 +690,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 677434665154918, 989582503122485, 1817429540898386, 1052904935475344, 1143826298169798 #else @@ -701,7 +701,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 367266328308408, 318431188922404, 695629353755355, 634085657580832, 24581612564426 #else @@ -710,7 +710,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 773360688841258, 1815381330538070, 363773437667376, 539629987070205, 783280434248437 #else @@ -719,7 +719,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 180820816194166, 168937968377394, 748416242794470, 1227281252254508, 1567587861004268 #else @@ -730,7 +730,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 478775558583645, 2062896624554807, 699391259285399, 358099408427873, 1277310261461761 #else @@ -739,7 +739,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1984740906540026, 1079164179400229, 1056021349262661, 1659958556483663, 1088529069025527 #else @@ -748,7 +748,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 580736401511151, 1842931091388998, 1177201471228238, 2075460256527244, 1301133425678027 #else @@ -759,7 +759,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1515728832059182, 1575261009617579, 1510246567196186, 191078022609704, 116661716289141 #else @@ -768,7 +768,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1295295738269652, 1714742313707026, 545583042462581, 2034411676262552, 1513248090013606 #else @@ -777,7 +777,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 230710545179830, 30821514358353, 760704303452229, 390668103790604, 573437871383156 #else @@ -788,7 +788,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1169380107545646, 263167233745614, 2022901299054448, 819900753251120, 2023898464874585 #else @@ -797,7 +797,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2102254323485823, 1570832666216754, 34696906544624, 1993213739807337, 70638552271463 #else @@ -806,7 +806,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 894132856735058, 548675863558441, 845349339503395, 1942269668326667, 1615682209874691 #else @@ -817,7 +817,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1287670217537834, 1222355136884920, 1846481788678694, 1150426571265110, 1613523400722047 #else @@ -826,7 +826,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 793388516527298, 1315457083650035, 1972286999342417, 1901825953052455, 338269477222410 #else @@ -835,7 +835,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 550201530671806, 778605267108140, 2063911101902983, 115500557286349, 2041641272971022 #else @@ -848,7 +848,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 717255318455100, 519313764361315, 2080406977303708, 541981206705521, 774328150311600 #else @@ -857,7 +857,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 261715221532238, 1795354330069993, 1496878026850283, 499739720521052, 389031152673770 #else @@ -866,7 +866,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1997217696294013, 1717306351628065, 1684313917746180, 1644426076011410, 1857378133465451 #else @@ -877,7 +877,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1475434724792648, 76931896285979, 1116729029771667, 2002544139318042, 725547833803938 #else @@ -886,7 +886,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2022306639183567, 726296063571875, 315345054448644, 1058733329149221, 1448201136060677 #else @@ -895,7 +895,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1710065158525665, 1895094923036397, 123988286168546, 1145519900776355, 1607510767693874 #else @@ -906,7 +906,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 561605375422540, 1071733543815037, 131496498800990, 1946868434569999, 828138133964203 #else @@ -915,7 +915,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1548495173745801, 442310529226540, 998072547000384, 553054358385281, 644824326376171 #else @@ -924,7 +924,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1445526537029440, 2225519789662536, 914628859347385, 1064754194555068, 1660295614401091 #else @@ -935,7 +935,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1199690223111956, 24028135822341, 66638289244341, 57626156285975, 565093967979607 #else @@ -944,7 +944,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 876926774220824, 554618976488214, 1012056309841565, 839961821554611, 1414499340307677 #else @@ -953,7 +953,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 703047626104145, 1266841406201770, 165556500219173, 486991595001879, 1011325891650656 #else @@ -964,7 +964,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1622861044480487, 1156394801573634, 1869132565415504, 327103985777730, 2095342781472284 #else @@ -973,7 +973,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 334886927423922, 489511099221528, 129160865966726, 1720809113143481, 619700195649254 #else @@ -982,7 +982,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1646545795166119, 1758370782583567, 714746174550637, 1472693650165135, 898994790308209 #else @@ -993,7 +993,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 333403773039279, 295772542452938, 1693106465353610, 912330357530760, 471235657950362 #else @@ -1002,7 +1002,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1811196219982022, 1068969825533602, 289602974833439, 1988956043611592, 863562343398367 #else @@ -1011,7 +1011,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 906282429780072, 2108672665779781, 432396390473936, 150625823801893, 1708930497638539 #else @@ -1022,7 +1022,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 925664675702328, 21416848568684, 1831436641861340, 601157008940113, 371818055044496 #else @@ -1031,7 +1031,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1479786007267725, 1738881859066675, 68646196476567, 2146507056100328, 1247662817535471 #else @@ -1040,7 +1040,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 52035296774456, 939969390708103, 312023458773250, 59873523517659, 1231345905848899 #else @@ -1051,7 +1051,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 643355106415761, 290186807495774, 2013561737429023, 319648069511546, 393736678496162 #else @@ -1060,7 +1060,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 129358342392716, 1932811617704777, 1176749390799681, 398040349861790, 1170779668090425 #else @@ -1069,7 +1069,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2051980782668029, 121859921510665, 2048329875753063, 1235229850149665, 519062146124755 #else @@ -1082,7 +1082,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1608170971973096, 415809060360428, 1350468408164766, 2038620059057678, 1026904485989112 #else @@ -1091,7 +1091,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1837656083115103, 1510134048812070, 906263674192061, 1821064197805734, 565375124676301 #else @@ -1100,7 +1100,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 578027192365650, 2034800251375322, 2128954087207123, 478816193810521, 2196171989962750 #else @@ -1111,7 +1111,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1633188840273139, 852787172373708, 1548762607215796, 1266275218902681, 1107218203325133 #else @@ -1120,7 +1120,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 462189358480054, 1784816734159228, 1611334301651368, 1303938263943540, 707589560319424 #else @@ -1129,7 +1129,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1038829280972848, 38176604650029, 753193246598573, 1136076426528122, 595709990562434 #else @@ -1140,7 +1140,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1408451820859834, 2194984964010833, 2198361797561729, 1061962440055713, 1645147963442934 #else @@ -1149,7 +1149,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 4701053362120, 1647641066302348, 1047553002242085, 1923635013395977, 206970314902065 #else @@ -1158,7 +1158,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1750479161778571, 1362553355169293, 1891721260220598, 966109370862782, 1024913988299801 #else @@ -1169,7 +1169,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 212699049131723, 1117950018299775, 1873945661751056, 1403802921984058, 130896082652698 #else @@ -1178,7 +1178,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 636808533673210, 1262201711667560, 390951380330599, 1663420692697294, 561951321757406 #else @@ -1187,7 +1187,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 520731594438141, 1446301499955692, 273753264629267, 1565101517999256, 1019411827004672 #else @@ -1198,7 +1198,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 926527492029409, 1191853477411379, 734233225181171, 184038887541270, 1790426146325343 #else @@ -1207,7 +1207,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1464651961852572, 1483737295721717, 1519450561335517, 1161429831763785, 405914998179977 #else @@ -1216,7 +1216,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 996126634382301, 796204125879525, 127517800546509, 344155944689303, 615279846169038 #else @@ -1227,7 +1227,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 738724080975276, 2188666632415296, 1961313708559162, 1506545807547587, 1151301638969740 #else @@ -1236,7 +1236,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 622917337413835, 1218989177089035, 1284857712846592, 970502061709359, 351025208117090 #else @@ -1245,7 +1245,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2067814584765580, 1677855129927492, 2086109782475197, 235286517313238, 1416314046739645 #else @@ -1256,7 +1256,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 586844262630358, 307444381952195, 458399356043426, 602068024507062, 1028548203415243 #else @@ -1265,7 +1265,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 678489922928203, 2016657584724032, 90977383049628, 1026831907234582, 615271492942522 #else @@ -1274,7 +1274,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 301225714012278, 1094837270268560, 1202288391010439, 644352775178361, 1647055902137983 #else @@ -1285,7 +1285,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1210746697896478, 1416608304244708, 686487477217856, 1245131191434135, 1051238336855737 #else @@ -1294,7 +1294,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1135604073198207, 1683322080485474, 769147804376683, 2086688130589414, 900445683120379 #else @@ -1303,7 +1303,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1971518477615628, 401909519527336, 448627091057375, 1409486868273821, 1214789035034363 #else @@ -1316,7 +1316,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1364039144731711, 1897497433586190, 2203097701135459, 145461396811251, 1349844460790699 #else @@ -1325,7 +1325,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1045230323257973, 818206601145807, 630513189076103, 1672046528998132, 807204017562437 #else @@ -1334,7 +1334,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 439961968385997, 386362664488986, 1382706320807688, 309894000125359, 2207801346498567 #else @@ -1345,7 +1345,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1229004686397588, 920643968530863, 123975893911178, 681423993215777, 1400559197080973 #else @@ -1354,7 +1354,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2003766096898049, 170074059235165, 1141124258967971, 1485419893480973, 1573762821028725 #else @@ -1363,7 +1363,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 729905708611432, 1270323270673202, 123353058984288, 426460209632942, 2195574535456672 #else @@ -1374,7 +1374,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1271140255321235, 2044363183174497, 52125387634689, 1445120246694705, 942541986339084 #else @@ -1383,7 +1383,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1761608437466135, 583360847526804, 1586706389685493, 2157056599579261, 1170692369685772 #else @@ -1392,7 +1392,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 871476219910823, 1878769545097794, 2241832391238412, 548957640601001, 690047440233174 #else @@ -1403,7 +1403,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 297194732135507, 1366347803776820, 1301185512245601, 561849853336294, 1533554921345731 #else @@ -1412,7 +1412,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 999628998628371, 1132836708493400, 2084741674517453, 469343353015612, 678782988708035 #else @@ -1421,7 +1421,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2189427607417022, 699801937082607, 412764402319267, 1478091893643349, 2244675696854460 #else @@ -1432,7 +1432,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1712292055966563, 204413590624874, 1405738637332841, 408981300829763, 861082219276721 #else @@ -1441,7 +1441,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 508561155940631, 966928475686665, 2236717801150132, 424543858577297, 2089272956986143 #else @@ -1450,7 +1450,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 221245220129925, 1156020201681217, 491145634799213, 542422431960839, 828100817819207 #else @@ -1461,7 +1461,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 153756971240384, 1299874139923977, 393099165260502, 1058234455773022, 996989038681183 #else @@ -1470,7 +1470,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 559086812798481, 573177704212711, 1629737083816402, 1399819713462595, 1646954378266038 #else @@ -1479,7 +1479,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1887963056288059, 228507035730124, 1468368348640282, 930557653420194, 613513962454686 #else @@ -1490,7 +1490,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1224529808187553, 1577022856702685, 2206946542980843, 625883007765001, 279930793512158 #else @@ -1499,7 +1499,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1076287717051609, 1114455570543035, 187297059715481, 250446884292121, 1885187512550540 #else @@ -1508,7 +1508,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 902497362940219, 76749815795675, 1657927525633846, 1420238379745202, 1340321636548352 #else @@ -1519,7 +1519,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1129576631190784, 1281994010027327, 996844254743018, 257876363489249, 1150850742055018 #else @@ -1528,7 +1528,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 628740660038789, 1943038498527841, 467786347793886, 1093341428303375, 235413859513003 #else @@ -1537,7 +1537,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 237425418909360, 469614029179605, 1512389769174935, 1241726368345357, 441602891065214 #else @@ -1550,7 +1550,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1736417953058555, 726531315520508, 1833335034432527, 1629442561574747, 624418919286085 #else @@ -1559,7 +1559,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1960754663920689, 497040957888962, 1909832851283095, 1271432136996826, 2219780368020940 #else @@ -1568,7 +1568,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1537037379417136, 1358865369268262, 2130838645654099, 828733687040705, 1999987652890901 #else @@ -1579,7 +1579,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 629042105241814, 1098854999137608, 887281544569320, 1423102019874777, 7911258951561 #else @@ -1588,7 +1588,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1811562332665373, 1501882019007673, 2213763501088999, 359573079719636, 36370565049116 #else @@ -1597,7 +1597,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 218907117361280, 1209298913016966, 1944312619096112, 1130690631451061, 1342327389191701 #else @@ -1608,7 +1608,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1369976867854704, 1396479602419169, 1765656654398856, 2203659200586299, 998327836117241 #else @@ -1617,7 +1617,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2230701885562825, 1348173180338974, 2172856128624598, 1426538746123771, 444193481326151 #else @@ -1626,7 +1626,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 784210426627951, 918204562375674, 1284546780452985, 1324534636134684, 1872449409642708 #else @@ -1637,7 +1637,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 319638829540294, 596282656808406, 2037902696412608, 1557219121643918, 341938082688094 #else @@ -1646,7 +1646,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1901860206695915, 2004489122065736, 1625847061568236, 973529743399879, 2075287685312905 #else @@ -1655,7 +1655,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1371853944110545, 1042332820512553, 1949855697918254, 1791195775521505, 37487364849293 #else @@ -1666,7 +1666,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 687200189577855, 1082536651125675, 644224940871546, 340923196057951, 343581346747396 #else @@ -1675,7 +1675,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2082717129583892, 27829425539422, 145655066671970, 1690527209845512, 1865260509673478 #else @@ -1684,7 +1684,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1059729620568824, 2163709103470266, 1440302280256872, 1769143160546397, 869830310425069 #else @@ -1695,7 +1695,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1609516219779025, 777277757338817, 2101121130363987, 550762194946473, 1905542338659364 #else @@ -1704,7 +1704,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2024821921041576, 426948675450149, 595133284085473, 471860860885970, 600321679413000 #else @@ -1713,7 +1713,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 598474602406721, 1468128276358244, 1191923149557635, 1501376424093216, 1281662691293476 #else @@ -1724,7 +1724,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1721138489890707, 1264336102277790, 433064545421287, 1359988423149466, 1561871293409447 #else @@ -1733,7 +1733,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 719520245587143, 393380711632345, 132350400863381, 1543271270810729, 1819543295798660 #else @@ -1742,7 +1742,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 396397949784152, 1811354474471839, 1362679985304303, 2117033964846756, 498041172552279 #else @@ -1753,7 +1753,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1812471844975748, 1856491995543149, 126579494584102, 1036244859282620, 1975108050082550 #else @@ -1762,7 +1762,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 650623932407995, 1137551288410575, 2125223403615539, 1725658013221271, 2134892965117796 #else @@ -1771,7 +1771,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 522584000310195, 1241762481390450, 1743702789495384, 2227404127826575, 1686746002148897 #else @@ -1784,7 +1784,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 427904865186312, 1703211129693455, 1585368107547509, 1436984488744336, 761188534613978 #else @@ -1793,7 +1793,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 318101947455002, 248138407995851, 1481904195303927, 309278454311197, 1258516760217879 #else @@ -1802,7 +1802,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1275068538599310, 513726919533379, 349926553492294, 688428871968420, 1702400196000666 #else @@ -1813,7 +1813,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1061864036265233, 961611260325381, 321859632700838, 1045600629959517, 1985130202504038 #else @@ -1822,7 +1822,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1558816436882417, 1962896332636523, 1337709822062152, 1501413830776938, 294436165831932 #else @@ -1831,7 +1831,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 818359826554971, 1862173000996177, 626821592884859, 573655738872376, 1749691246745455 #else @@ -1842,7 +1842,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1988022651432119, 1082111498586040, 1834020786104821, 1454826876423687, 692929915223122 #else @@ -1851,7 +1851,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2146513703733331, 584788900394667, 464965657279958, 2183973639356127, 238371159456790 #else @@ -1860,7 +1860,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1129007025494441, 2197883144413266, 265142755578169, 971864464758890, 1983715884903702 #else @@ -1871,7 +1871,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1291366624493075, 381456718189114, 1711482489312444, 1815233647702022, 892279782992467 #else @@ -1880,7 +1880,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 444548969917454, 1452286453853356, 2113731441506810, 645188273895859, 810317625309512 #else @@ -1889,7 +1889,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2242724082797924, 1373354730327868, 1006520110883049, 2147330369940688, 1151816104883620 #else @@ -1900,7 +1900,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1745720200383796, 1911723143175317, 2056329390702074, 355227174309849, 879232794371100 #else @@ -1909,7 +1909,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 163723479936298, 115424889803150, 1156016391581227, 1894942220753364, 1970549419986329 #else @@ -1918,7 +1918,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 681981452362484, 267208874112496, 1374683991933094, 638600984916117, 646178654558546 #else @@ -1929,7 +1929,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 13378654854251, 106237307029567, 1944412051589651, 1841976767925457, 230702819835573 #else @@ -1938,7 +1938,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 260683893467075, 854060306077237, 913639551980112, 4704576840123, 280254810808712 #else @@ -1947,7 +1947,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 715374893080287, 1173334812210491, 1806524662079626, 1894596008000979, 398905715033393 #else @@ -1958,7 +1958,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 500026409727661, 1596431288195371, 1420380351989370, 985211561521489, 392444930785633 #else @@ -1967,7 +1967,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2096421546958141, 1922523000950363, 789831022876840, 427295144688779, 320923973161730 #else @@ -1976,7 +1976,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1927770723575450, 1485792977512719, 1850996108474547, 551696031508956, 2126047405475647 #else @@ -1987,7 +1987,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2112099158080148, 742570803909715, 6484558077432, 1951119898618916, 93090382703416 #else @@ -1996,7 +1996,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 383905201636970, 859946997631870, 855623867637644, 1017125780577795, 794250831877809 #else @@ -2005,7 +2005,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 77571826285752, 999304298101753, 487841111777762, 1038031143212339, 339066367948762 #else @@ -2018,7 +2018,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 674994775520533, 266035846330789, 826951213393478, 1405007746162285, 1781791018620876 #else @@ -2027,7 +2027,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1001412661522686, 348196197067298, 1666614366723946, 888424995032760, 580747687801357 #else @@ -2036,7 +2036,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1939560076207777, 1409892634407635, 552574736069277, 383854338280405, 190706709864139 #else @@ -2047,7 +2047,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2177087163428741, 1439255351721944, 1208070840382793, 2230616362004769, 1396886392021913 #else @@ -2056,7 +2056,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 676962063230039, 1880275537148808, 2046721011602706, 888463247083003, 1318301552024067 #else @@ -2065,7 +2065,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1466980508178206, 617045217998949, 652303580573628, 757303753529064, 207583137376902 #else @@ -2076,7 +2076,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1511056752906902, 105403126891277, 493434892772846, 1091943425335976, 1802717338077427 #else @@ -2085,7 +2085,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1853982405405128, 1878664056251147, 1528011020803992, 1019626468153565, 1128438412189035 #else @@ -2094,7 +2094,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1963939888391106, 293456433791664, 697897559513649, 985882796904380, 796244541237972 #else @@ -2105,7 +2105,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 416770998629779, 389655552427054, 1314476859406756, 1749382513022778, 1161905598739491 #else @@ -2114,7 +2114,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1428358296490651, 1027115282420478, 304840698058337, 441410174026628, 1819358356278573 #else @@ -2123,7 +2123,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 204943430200135, 1554861433819175, 216426658514651, 264149070665950, 2047097371738319 #else @@ -2134,7 +2134,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1934415182909034, 1393285083565062, 516409331772960, 1157690734993892, 121039666594268 #else @@ -2143,7 +2143,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 662035583584445, 286736105093098, 1131773000510616, 818494214211439, 472943792054479 #else @@ -2152,7 +2152,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 665784778135882, 1893179629898606, 808313193813106, 276797254706413, 1563426179676396 #else @@ -2163,7 +2163,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 945205108984232, 526277562959295, 1324180513733566, 1666970227868664, 153547609289173 #else @@ -2172,7 +2172,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2031433403516252, 203996615228162, 170487168837083, 981513604791390, 843573964916831 #else @@ -2181,7 +2181,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1476570093962618, 838514669399805, 1857930577281364, 2017007352225784, 317085545220047 #else @@ -2192,7 +2192,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1461557121912842, 1600674043318359, 2157134900399597, 1670641601940616, 127765583803283 #else @@ -2201,7 +2201,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1293543509393474, 2143624609202546, 1058361566797508, 214097127393994, 946888515472729 #else @@ -2210,7 +2210,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 357067959932916, 1290876214345711, 521245575443703, 1494975468601005, 800942377643885 #else @@ -2221,7 +2221,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 566116659100033, 820247422481740, 994464017954148, 327157611686365, 92591318111744 #else @@ -2230,7 +2230,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 617256647603209, 1652107761099439, 1857213046645471, 1085597175214970, 817432759830522 #else @@ -2239,7 +2239,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 771808161440705, 1323510426395069, 680497615846440, 851580615547985, 1320806384849017 #else @@ -2252,7 +2252,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1219260086131915, 647169006596815, 79601124759706, 2161724213426748, 404861897060198 #else @@ -2261,7 +2261,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1327968293887866, 1335500852943256, 1401587164534264, 558137311952440, 1551360549268902 #else @@ -2270,7 +2270,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 417621685193956, 1429953819744454, 396157358457099, 1940470778873255, 214000046234152 #else @@ -2281,7 +2281,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1268047918491973, 2172375426948536, 1533916099229249, 1761293575457130, 1590622667026765 #else @@ -2290,7 +2290,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1627072914981959, 2211603081280073, 1912369601616504, 1191770436221309, 2187309757525860 #else @@ -2299,7 +2299,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1149147819689533, 378692712667677, 828475842424202, 2218619146419342, 70688125792186 #else @@ -2310,7 +2310,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1299739417079761, 1438616663452759, 1536729078504412, 2053896748919838, 1008421032591246 #else @@ -2319,7 +2319,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2040723824657366, 399555637875075, 632543375452995, 872649937008051, 1235394727030233 #else @@ -2328,7 +2328,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2211311599327900, 2139787259888175, 938706616835350, 12609661139114, 2081897930719789 #else @@ -2339,7 +2339,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1324994503390450, 336982330582631, 1183998925654177, 1091654665913274, 48727673971319 #else @@ -2348,7 +2348,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1845522914617879, 1222198248335542, 150841072760134, 1927029069940982, 1189913404498011 #else @@ -2357,7 +2357,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1079559557592645, 2215338383666441, 1903569501302605, 49033973033940, 305703433934152 #else @@ -2368,7 +2368,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 94653405416909, 1386121349852999, 1062130477891762, 36553947479274, 833669648948846 #else @@ -2377,7 +2377,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1432015813136298, 440364795295369, 1395647062821501, 1976874522764578, 934452372723352 #else @@ -2386,7 +2386,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1296625309219774, 2068273464883862, 1858621048097805, 1492281814208508, 2235868981918946 #else @@ -2397,7 +2397,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1490330266465570, 1858795661361448, 1436241134969763, 294573218899647, 1208140011028933 #else @@ -2406,7 +2406,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1282462923712748, 741885683986255, 2027754642827561, 518989529541027, 1826610009555945 #else @@ -2415,7 +2415,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1525827120027511, 723686461809551, 1597702369236987, 244802101764964, 1502833890372311 #else @@ -2426,7 +2426,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 113622036244513, 1233740067745854, 674109952278496, 2114345180342965, 166764512856263 #else @@ -2435,7 +2435,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2041668749310338, 2184405322203901, 1633400637611036, 2110682505536899, 2048144390084644 #else @@ -2444,7 +2444,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 503058759232932, 760293024620937, 2027152777219493, 666858468148475, 1539184379870952 #else @@ -2455,7 +2455,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1916168475367211, 915626432541343, 883217071712575, 363427871374304, 1976029821251593 #else @@ -2464,7 +2464,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 678039535434506, 570587290189340, 1605302676614120, 2147762562875701, 1706063797091704 #else @@ -2473,7 +2473,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1439489648586438, 2194580753290951, 832380563557396, 561521973970522, 584497280718389 #else @@ -2486,7 +2486,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 187989455492609, 681223515948275, 1933493571072456, 1872921007304880, 488162364135671 #else @@ -2495,7 +2495,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1413466089534451, 410844090765630, 1397263346404072, 408227143123410, 1594561803147811 #else @@ -2504,7 +2504,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2102170800973153, 719462588665004, 1479649438510153, 1097529543970028, 1302363283777685 #else @@ -2515,7 +2515,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 942065717847195, 1069313679352961, 2007341951411051, 70973416446291, 1419433790163706 #else @@ -2524,7 +2524,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1146565545556377, 1661971299445212, 406681704748893, 564452436406089, 1109109865829139 #else @@ -2533,7 +2533,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2214421081775077, 1165671861210569, 1890453018796184, 3556249878661, 442116172656317 #else @@ -2544,7 +2544,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 753830546620811, 1666955059895019, 1530775289309243, 1119987029104146, 2164156153857580 #else @@ -2553,7 +2553,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 615171919212796, 1523849404854568, 854560460547503, 2067097370290715, 1765325848586042 #else @@ -2562,7 +2562,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1094538949313667, 1796592198908825, 870221004284388, 2025558921863561, 1699010892802384 #else @@ -2573,7 +2573,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1951351290725195, 1916457206844795, 198025184438026, 1909076887557595, 1938542290318919 #else @@ -2582,7 +2582,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1014323197538413, 869150639940606, 1756009942696599, 1334952557375672, 1544945379082874 #else @@ -2591,7 +2591,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 764055910920305, 1603590757375439, 146805246592357, 1843313433854297, 954279890114939 #else @@ -2602,7 +2602,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 80113526615750, 764536758732259, 1055139345100233, 469252651759390, 617897512431515 #else @@ -2611,7 +2611,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 74497112547268, 740094153192149, 1745254631717581, 727713886503130, 1283034364416928 #else @@ -2620,7 +2620,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 525892105991110, 1723776830270342, 1476444848991936, 573789489857760, 133864092632978 #else @@ -2631,7 +2631,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 542611720192581, 1986812262899321, 1162535242465837, 481498966143464, 544600533583622 #else @@ -2640,7 +2640,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 64123227344372, 1239927720647794, 1360722983445904, 222610813654661, 62429487187991 #else @@ -2649,7 +2649,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1793193323953132, 91096687857833, 70945970938921, 2158587638946380, 1537042406482111 #else @@ -2660,7 +2660,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1895854577604609, 1394895708949416, 1728548428495944, 1140864900240149, 563645333603061 #else @@ -2669,7 +2669,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 141358280486863, 91435889572504, 1087208572552643, 1829599652522921, 1193307020643647 #else @@ -2678,7 +2678,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1611230858525381, 950720175540785, 499589887488610, 2001656988495019, 88977313255908 #else @@ -2689,7 +2689,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1189080501479658, 2184348804772597, 1040818725742319, 2018318290311834, 1712060030915354 #else @@ -2698,7 +2698,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 873966876953756, 1090638350350440, 1708559325189137, 672344594801910, 1320437969700239 #else @@ -2707,7 +2707,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1508590048271766, 1131769479776094, 101550868699323, 428297785557897, 561791648661744 #else @@ -2720,7 +2720,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 756417570499462, 237882279232602, 2136263418594016, 1701968045454886, 703713185137472 #else @@ -2729,7 +2729,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1781187809325462, 1697624151492346, 1381393690939988, 175194132284669, 1483054666415238 #else @@ -2738,7 +2738,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2175517777364616, 708781536456029, 955668231122942, 1967557500069555, 2021208005604118 #else @@ -2749,7 +2749,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1115135966606887, 224217372950782, 915967306279222, 593866251291540, 561747094208006 #else @@ -2758,7 +2758,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1443163092879439, 391875531646162, 2180847134654632, 464538543018753, 1594098196837178 #else @@ -2767,7 +2767,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 850858855888869, 319436476624586, 327807784938441, 740785849558761, 17128415486016 #else @@ -2778,7 +2778,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2132756334090067, 536247820155645, 48907151276867, 608473197600695, 1261689545022784 #else @@ -2787,7 +2787,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1525176236978354, 974205476721062, 293436255662638, 148269621098039, 137961998433963 #else @@ -2796,7 +2796,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1121075518299410, 2071745529082111, 1265567917414828, 1648196578317805, 496232102750820 #else @@ -2807,7 +2807,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 122321229299801, 1022922077493685, 2001275453369484, 2017441881607947, 993205880778002 #else @@ -2816,7 +2816,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 654925550560074, 1168810995576858, 575655959430926, 905758704861388, 496774564663534 #else @@ -2825,7 +2825,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1954109525779738, 2117022646152485, 338102630417180, 1194140505732026, 107881734943492 #else @@ -2836,7 +2836,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1714785840001267, 2036500018681589, 1876380234251966, 2056717182974196, 1645855254384642 #else @@ -2845,7 +2845,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 106431476499341, 62482972120563, 1513446655109411, 807258751769522, 538491469114 #else @@ -2854,7 +2854,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2002850762893643, 1243624520538135, 1486040410574605, 2184752338181213, 378495998083531 #else @@ -2865,7 +2865,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 922510868424903, 1089502620807680, 402544072617374, 1131446598479839, 1290278588136533 #else @@ -2874,7 +2874,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1867998812076769, 715425053580701, 39968586461416, 2173068014586163, 653822651801304 #else @@ -2883,7 +2883,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 162892278589453, 182585796682149, 75093073137630, 497037941226502, 133871727117371 #else @@ -2894,7 +2894,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1914596576579670, 1608999621851578, 1987629837704609, 1519655314857977, 1819193753409464 #else @@ -2903,7 +2903,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1949315551096831, 1069003344994464, 1939165033499916, 1548227205730856, 1933767655861407 #else @@ -2912,7 +2912,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1730519386931635, 1393284965610134, 1597143735726030, 416032382447158, 1429665248828629 #else @@ -2923,7 +2923,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 360275475604565, 547835731063078, 215360904187529, 596646739879007, 332709650425085 #else @@ -2932,7 +2932,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 47602113726801, 1522314509708010, 437706261372925, 814035330438027, 335930650933545 #else @@ -2941,7 +2941,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1291597595523886, 1058020588994081, 402837842324045, 1363323695882781, 2105763393033193 #else @@ -2954,7 +2954,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 109521982566564, 1715257748585139, 1112231216891516, 2046641005101484, 134249157157013 #else @@ -2963,7 +2963,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2156991030936798, 2227544497153325, 1869050094431622, 754875860479115, 1754242344267058 #else @@ -2972,7 +2972,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1846089562873800, 98894784984326, 1412430299204844, 171351226625762, 1100604760929008 #else @@ -2983,7 +2983,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 84172382130492, 499710970700046, 425749630620778, 1762872794206857, 612842602127960 #else @@ -2992,7 +2992,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 868309334532756, 1703010512741873, 1952690008738057, 4325269926064, 2071083554962116 #else @@ -3001,7 +3001,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 523094549451158, 401938899487815, 1407690589076010, 2022387426254453, 158660516411257 #else @@ -3012,7 +3012,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 612867287630009, 448212612103814, 571629077419196, 1466796750919376, 1728478129663858 #else @@ -3021,7 +3021,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1723848973783452, 2208822520534681, 1718748322776940, 1974268454121942, 1194212502258141 #else @@ -3030,7 +3030,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1254114807944608, 977770684047110, 2010756238954993, 1783628927194099, 1525962994408256 #else @@ -3041,7 +3041,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 232464058235826, 1948628555342434, 1835348780427694, 1031609499437291, 64472106918373 #else @@ -3050,7 +3050,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 767338676040683, 754089548318405, 1523192045639075, 435746025122062, 512692508440385 #else @@ -3059,7 +3059,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1255955808701983, 1700487367990941, 1166401238800299, 1175121994891534, 1190934801395380 #else @@ -3070,7 +3070,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 349144008168292, 1337012557669162, 1475912332999108, 1321618454900458, 47611291904320 #else @@ -3079,7 +3079,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 877519947135419, 2172838026132651, 272304391224129, 1655143327559984, 886229406429814 #else @@ -3088,7 +3088,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 375806028254706, 214463229793940, 572906353144089, 572168269875638, 697556386112979 #else @@ -3099,7 +3099,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1168827102357844, 823864273033637, 2071538752104697, 788062026895924, 599578340743362 #else @@ -3108,7 +3108,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1948116082078088, 2054898304487796, 2204939184983900, 210526805152138, 786593586607626 #else @@ -3117,7 +3117,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1915320147894736, 156481169009469, 655050471180417, 592917090415421, 2165897438660879 #else @@ -3128,7 +3128,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1726336468579724, 1119932070398949, 1929199510967666, 33918788322959, 1836837863503150 #else @@ -3137,7 +3137,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 829996854845988, 217061778005138, 1686565909803640, 1346948817219846, 1723823550730181 #else @@ -3146,7 +3146,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 384301494966394, 687038900403062, 2211195391021739, 254684538421383, 1245698430589680 #else @@ -3157,7 +3157,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1247567493562688, 1978182094455847, 183871474792955, 806570235643435, 288461518067916 #else @@ -3166,7 +3166,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1449077384734201, 38285445457996, 2136537659177832, 2146493000841573, 725161151123125 #else @@ -3175,7 +3175,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1201928866368855, 800415690605445, 1703146756828343, 997278587541744, 1858284414104014 #else @@ -3188,7 +3188,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 356468809648877, 782373916933152, 1718002439402870, 1392222252219254, 663171266061951 #else @@ -3197,7 +3197,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 759628738230460, 1012693474275852, 353780233086498, 246080061387552, 2030378857679162 #else @@ -3206,7 +3206,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2040672435071076, 888593182036908, 1298443657189359, 1804780278521327, 354070726137060 #else @@ -3217,7 +3217,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1894938527423184, 1463213041477277, 474410505497651, 247294963033299, 877975941029128 #else @@ -3226,7 +3226,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 207937160991127, 12966911039119, 820997788283092, 1010440472205286, 1701372890140810 #else @@ -3235,7 +3235,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 218882774543183, 533427444716285, 1233243976733245, 435054256891319, 1509568989549904 #else @@ -3246,7 +3246,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1888838535711826, 1052177758340622, 1213553803324135, 169182009127332, 463374268115872 #else @@ -3255,7 +3255,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 299137589460312, 1594371588983567, 868058494039073, 257771590636681, 1805012993142921 #else @@ -3264,7 +3264,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1806842755664364, 2098896946025095, 1356630998422878, 1458279806348064, 347755825962072 #else @@ -3275,7 +3275,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1402334161391744, 1560083671046299, 1008585416617747, 1147797150908892, 1420416683642459 #else @@ -3284,7 +3284,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 665506704253369, 273770475169863, 799236974202630, 848328990077558, 1811448782807931 #else @@ -3293,7 +3293,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1468412523962641, 771866649897997, 1931766110147832, 799561180078482, 524837559150077 #else @@ -3304,7 +3304,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2223212657821850, 630416247363666, 2144451165500328, 816911130947791, 1024351058410032 #else @@ -3313,7 +3313,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1266603897524861, 156378408858100, 1275649024228779, 447738405888420, 253186462063095 #else @@ -3322,7 +3322,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2022215964509735, 136144366993649, 1800716593296582, 1193970603800203, 871675847064218 #else @@ -3333,7 +3333,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1862751661970328, 851596246739884, 1519315554814041, 1542798466547449, 1417975335901520 #else @@ -3342,7 +3342,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1228168094547481, 334133883362894, 587567568420081, 433612590281181, 603390400373205 #else @@ -3351,7 +3351,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 121893973206505, 1843345804916664, 1703118377384911, 497810164760654, 101150811654673 #else @@ -3362,7 +3362,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 458346255946468, 290909935619344, 1452768413850679, 550922875254215, 1537286854336538 #else @@ -3371,7 +3371,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 584322311184395, 380661238802118, 114839394528060, 655082270500073, 2111856026034852 #else @@ -3380,7 +3380,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 996965581008991, 2148998626477022, 1012273164934654, 1073876063914522, 1688031788934939 #else @@ -3391,7 +3391,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 923487018849600, 2085106799623355, 528082801620136, 1606206360876188, 735907091712524 #else @@ -3400,7 +3400,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1697697887804317, 1335343703828273, 831288615207040, 949416685250051, 288760277392022 #else @@ -3409,7 +3409,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1419122478109648, 1325574567803701, 602393874111094, 2107893372601700, 1314159682671307 #else @@ -3422,7 +3422,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2201150872731804, 2180241023425241, 97663456423163, 1633405770247824, 848945042443986 #else @@ -3431,7 +3431,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1173339555550611, 818605084277583, 47521504364289, 924108720564965, 735423405754506 #else @@ -3440,7 +3440,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 830104860549448, 1886653193241086, 1600929509383773, 1475051275443631, 286679780900937 #else @@ -3451,7 +3451,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1577111294832995, 1030899169768747, 144900916293530, 1964672592979567, 568390100955250 #else @@ -3460,7 +3460,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 278388655910247, 487143369099838, 927762205508727, 181017540174210, 1616886700741287 #else @@ -3469,7 +3469,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1191033906638969, 940823957346562, 1606870843663445, 861684761499847, 658674867251089 #else @@ -3480,7 +3480,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1875032594195546, 1427106132796197, 724736390962158, 901860512044740, 635268497268760 #else @@ -3489,7 +3489,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 622869792298357, 1903919278950367, 1922588621661629, 1520574711600434, 1087100760174640 #else @@ -3498,7 +3498,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 25465949416618, 1693639527318811, 1526153382657203, 125943137857169, 145276964043999 #else @@ -3509,7 +3509,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 214739857969358, 920212862967915, 1939901550972269, 1211862791775221, 85097515720120 #else @@ -3518,7 +3518,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2006245852772938, 734762734836159, 254642929763427, 1406213292755966, 239303749517686 #else @@ -3527,7 +3527,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1619678837192149, 1919424032779215, 1357391272956794, 1525634040073113, 1310226789796241 #else @@ -3538,7 +3538,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1040763709762123, 1704449869235352, 605263070456329, 1998838089036355, 1312142911487502 #else @@ -3547,7 +3547,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1996723311435669, 1844342766567060, 985455700466044, 1165924681400960, 311508689870129 #else @@ -3556,7 +3556,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 43173156290518, 2202883069785309, 1137787467085917, 1733636061944606, 1394992037553852 #else @@ -3567,7 +3567,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 670078326344559, 555655025059356, 471959386282438, 2141455487356409, 849015953823125 #else @@ -3576,7 +3576,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2197214573372804, 794254097241315, 1030190060513737, 267632515541902, 2040478049202624 #else @@ -3585,7 +3585,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1812516004670529, 1609256702920783, 1706897079364493, 258549904773295, 996051247540686 #else @@ -3596,7 +3596,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1540374301420584, 1764656898914615, 1810104162020396, 923808779163088, 664390074196579 #else @@ -3605,7 +3605,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1323460699404750, 1262690757880991, 871777133477900, 1060078894988977, 1712236889662886 #else @@ -3614,7 +3614,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1696163952057966, 1391710137550823, 608793846867416, 1034391509472039, 1780770894075012 #else @@ -3625,7 +3625,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1367603834210841, 2131988646583224, 890353773628144, 1908908219165595, 270836895252891 #else @@ -3634,7 +3634,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 597536315471731, 40375058742586, 1942256403956049, 1185484645495932, 312666282024145 #else @@ -3643,7 +3643,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1919411405316294, 1234508526402192, 1066863051997083, 1008444703737597, 1348810787701552 #else @@ -3656,7 +3656,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2102881477513865, 1570274565945361, 1573617900503708, 18662635732583, 2232324307922098 #else @@ -3665,7 +3665,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1853931367696942, 8107973870707, 350214504129299, 775206934582587, 1752317649166792 #else @@ -3674,7 +3674,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1417148368003523, 721357181628282, 505725498207811, 373232277872983, 261634707184480 #else @@ -3685,7 +3685,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2186733281493267, 2250694917008620, 1014829812957440, 479998161452389, 83566193876474 #else @@ -3694,7 +3694,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1268116367301224, 560157088142809, 802626839600444, 2210189936605713, 1129993785579988 #else @@ -3703,7 +3703,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 615183387352312, 917611676109240, 878893615973325, 978940963313282, 938686890583575 #else @@ -3714,7 +3714,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 522024729211672, 1045059315315808, 1892245413707790, 1907891107684253, 2059998109500714 #else @@ -3723,7 +3723,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1799679152208884, 912132775900387, 25967768040979, 432130448590461, 274568990261996 #else @@ -3732,7 +3732,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 98698809797682, 2144627600856209, 1907959298569602, 811491302610148, 1262481774981493 #else @@ -3743,7 +3743,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1791451399743152, 1713538728337276, 118349997257490, 1882306388849954, 158235232210248 #else @@ -3752,7 +3752,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1217809823321928, 2173947284933160, 1986927836272325, 1388114931125539, 12686131160169 #else @@ -3761,7 +3761,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1650875518872272, 1136263858253897, 1732115601395988, 734312880662190, 1252904681142109 #else @@ -3772,7 +3772,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 372986456113865, 525430915458171, 2116279931702135, 501422713587815, 1907002872974925 #else @@ -3781,7 +3781,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 803147181835288, 868941437997146, 316299302989663, 943495589630550, 571224287904572 #else @@ -3790,7 +3790,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 227742695588364, 1776969298667369, 628602552821802, 457210915378118, 2041906378111140 #else @@ -3801,7 +3801,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 815000523470260, 913085688728307, 1052060118271173, 1345536665214223, 541623413135555 #else @@ -3810,7 +3810,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1580216071604333, 1877997504342444, 857147161260913, 703522726778478, 2182763974211603 #else @@ -3819,7 +3819,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1870080310923419, 71988220958492, 1783225432016732, 615915287105016, 1035570475990230 #else @@ -3830,7 +3830,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 730987750830150, 857613889540280, 1083813157271766, 1002817255970169, 1719228484436074 #else @@ -3839,7 +3839,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 377616581647602, 1581980403078513, 804044118130621, 2034382823044191, 643844048472185 #else @@ -3848,7 +3848,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 176957326463017, 1573744060478586, 528642225008045, 1816109618372371, 1515140189765006 #else @@ -3859,7 +3859,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1888911448245718, 1387110895611080, 1924503794066429, 1731539523700949, 2230378382645454 #else @@ -3868,7 +3868,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 443392177002051, 233793396845137, 2199506622312416, 1011858706515937, 974676837063129 #else @@ -3877,7 +3877,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1846351103143623, 1949984838808427, 671247021915253, 1946756846184401, 1929296930380217 #else @@ -3890,7 +3890,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 849646212452002, 1410198775302919, 73767886183695, 1641663456615812, 762256272452411 #else @@ -3899,7 +3899,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 692017667358279, 723305578826727, 1638042139863265, 748219305990306, 334589200523901 #else @@ -3908,7 +3908,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 22893968530686, 2235758574399251, 1661465835630252, 925707319443452, 1203475116966621 #else @@ -3919,7 +3919,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 801299035785166, 1733292596726131, 1664508947088596, 467749120991922, 1647498584535623 #else @@ -3928,7 +3928,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 903105258014366, 427141894933047, 561187017169777, 1884330244401954, 1914145708422219 #else @@ -3937,7 +3937,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1344191060517578, 1960935031767890, 1518838929955259, 1781502350597190, 1564784025565682 #else @@ -3948,7 +3948,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 673723351748086, 1979969272514923, 1175287312495508, 1187589090978666, 1881897672213940 #else @@ -3957,7 +3957,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1917185587363432, 1098342571752737, 5935801044414, 2000527662351839, 1538640296181569 #else @@ -3966,7 +3966,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2495540013192, 678856913479236, 224998292422872, 219635787698590, 1972465269000940 #else @@ -3977,7 +3977,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 271413961212179, 1353052061471651, 344711291283483, 2014925838520662, 2006221033113941 #else @@ -3986,7 +3986,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 194583029968109, 514316781467765, 829677956235672, 1676415686873082, 810104584395840 #else @@ -3995,7 +3995,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1980510813313589, 1948645276483975, 152063780665900, 129968026417582, 256984195613935 #else @@ -4006,7 +4006,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1860190562533102, 1936576191345085, 461100292705964, 1811043097042830, 957486749306835 #else @@ -4015,7 +4015,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 796664815624365, 1543160838872951, 1500897791837765, 1667315977988401, 599303877030711 #else @@ -4024,7 +4024,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1151480509533204, 2136010406720455, 738796060240027, 319298003765044, 1150614464349587 #else @@ -4035,7 +4035,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1731069268103150, 735642447616087, 1364750481334268, 417232839982871, 927108269127661 #else @@ -4044,7 +4044,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1017222050227968, 1987716148359, 2234319589635701, 621282683093392, 2132553131763026 #else @@ -4053,7 +4053,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1567828528453324, 1017807205202360, 565295260895298, 829541698429100, 307243822276582 #else @@ -4064,7 +4064,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 249079270936248, 1501514259790706, 947909724204848, 944551802437487, 552658763982480 #else @@ -4073,7 +4073,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2089966982947227, 1854140343916181, 2151980759220007, 2139781292261749, 158070445864917 #else @@ -4082,7 +4082,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1338766321464554, 1906702607371284, 1519569445519894, 115384726262267, 1393058953390992 #else @@ -4093,7 +4093,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1364621558265400, 1512388234908357, 1926731583198686, 2041482526432505, 920401122333774 #else @@ -4102,7 +4102,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1884844597333588, 601480070269079, 620203503079537, 1079527400117915, 1202076693132015 #else @@ -4111,7 +4111,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 840922919763324, 727955812569642, 1303406629750194, 522898432152867, 294161410441865 #else @@ -4124,7 +4124,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 353760790835310, 1598361541848743, 1122905698202299, 1922533590158905, 419107700666580 #else @@ -4133,7 +4133,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 359856369838236, 180914355488683, 861726472646627, 218807937262986, 575626773232501 #else @@ -4142,7 +4142,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 755467689082474, 909202735047934, 730078068932500, 936309075711518, 2007798262842972 #else @@ -4153,7 +4153,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1609384177904073, 362745185608627, 1335318541768201, 800965770436248, 547877979267412 #else @@ -4162,7 +4162,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 984339177776787, 815727786505884, 1645154585713747, 1659074964378553, 1686601651984156 #else @@ -4171,7 +4171,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1697863093781930, 599794399429786, 1104556219769607, 830560774794755, 12812858601017 #else @@ -4182,7 +4182,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1168737550514982, 897832437380552, 463140296333799, 302564600022547, 2008360505135501 #else @@ -4191,7 +4191,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1856930662813910, 678090852002597, 1920179140755167, 1259527833759868, 55540971895511 #else @@ -4200,7 +4200,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1158643631044921, 476554103621892, 178447851439725, 1305025542653569, 103433927680625 #else @@ -4211,7 +4211,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2176793111709008, 1576725716350391, 2009350167273523, 2012390194631546, 2125297410909580 #else @@ -4220,7 +4220,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 825403285195098, 2144208587560784, 1925552004644643, 1915177840006985, 1015952128947864 #else @@ -4229,7 +4229,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1807108316634472, 1534392066433717, 347342975407218, 1153820745616376, 7375003497471 #else @@ -4240,7 +4240,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 983061001799725, 431211889901241, 2201903782961093, 817393911064341, 2214616493042167 #else @@ -4249,7 +4249,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 228567918409756, 865093958780220, 358083886450556, 159617889659320, 1360637926292598 #else @@ -4258,7 +4258,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 234147501399755, 2229469128637390, 2175289352258889, 1397401514549353, 1885288963089922 #else @@ -4269,7 +4269,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1111762412951562, 252849572507389, 1048714233823341, 146111095601446, 1237505378776770 #else @@ -4278,7 +4278,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1113790697840279, 1051167139966244, 1045930658550944, 2011366241542643, 1686166824620755 #else @@ -4287,7 +4287,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1054097349305049, 1872495070333352, 182121071220717, 1064378906787311, 100273572924182 #else @@ -4298,7 +4298,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1306410853171605, 1627717417672447, 50983221088417, 1109249951172250, 870201789081392 #else @@ -4307,7 +4307,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 104233794644221, 1548919791188248, 2224541913267306, 2054909377116478, 1043803389015153 #else @@ -4316,7 +4316,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 216762189468802, 707284285441622, 190678557969733, 973969342604308, 1403009538434867 #else @@ -4327,7 +4327,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1279024291038477, 344776835218310, 273722096017199, 1834200436811442, 634517197663804 #else @@ -4336,7 +4336,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 343805853118335, 1302216857414201, 566872543223541, 2051138939539004, 321428858384280 #else @@ -4345,7 +4345,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 470067171324852, 1618629234173951, 2000092177515639, 7307679772789, 1117521120249968 #else @@ -4358,7 +4358,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 278151578291475, 1810282338562947, 1771599529530998, 1383659409671631, 685373414471841 #else @@ -4367,7 +4367,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 577009397403102, 1791440261786291, 2177643735971638, 174546149911960, 1412505077782326 #else @@ -4376,7 +4376,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 893719721537457, 1201282458018197, 1522349501711173, 58011597740583, 1130406465887139 #else @@ -4387,7 +4387,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 412607348255453, 1280455764199780, 2233277987330768, 14180080401665, 331584698417165 #else @@ -4396,7 +4396,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 262483770854550, 990511055108216, 526885552771698, 571664396646158, 354086190278723 #else @@ -4405,7 +4405,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1820352417585487, 24495617171480, 1547899057533253, 10041836186225, 480457105094042 #else @@ -4416,7 +4416,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2023310314989233, 637905337525881, 2106474638900687, 557820711084072, 1687858215057826 #else @@ -4425,7 +4425,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1144168702609745, 604444390410187, 1544541121756138, 1925315550126027, 626401428894002 #else @@ -4434,7 +4434,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1922168257351784, 2018674099908659, 1776454117494445, 956539191509034, 36031129147635 #else @@ -4445,7 +4445,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 544644538748041, 1039872944430374, 876750409130610, 710657711326551, 1216952687484972 #else @@ -4454,7 +4454,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 58242421545916, 2035812695641843, 2118491866122923, 1191684463816273, 46921517454099 #else @@ -4463,7 +4463,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 272268252444639, 1374166457774292, 2230115177009552, 1053149803909880, 1354288411641016 #else @@ -4474,7 +4474,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1857910905368338, 1754729879288912, 885945464109877, 1516096106802166, 1602902393369811 #else @@ -4483,7 +4483,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1193437069800958, 901107149704790, 999672920611411, 477584824802207, 364239578697845 #else @@ -4492,7 +4492,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 886299989548838, 1538292895758047, 1590564179491896, 1944527126709657, 837344427345298 #else @@ -4503,7 +4503,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 754558365378305, 1712186480903618, 1703656826337531, 750310918489786, 518996040250900 #else @@ -4512,7 +4512,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1309847803895382, 1462151862813074, 211370866671570, 1544595152703681, 1027691798954090 #else @@ -4521,7 +4521,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 803217563745370, 1884799722343599, 1357706345069218, 2244955901722095, 730869460037413 #else @@ -4532,7 +4532,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 689299471295966, 1831210565161071, 1375187341585438, 1106284977546171, 1893781834054269 #else @@ -4541,7 +4541,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 696351368613042, 1494385251239250, 738037133616932, 636385507851544, 927483222611406 #else @@ -4550,7 +4550,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1949114198209333, 1104419699537997, 783495707664463, 1747473107602770, 2002634765788641 #else @@ -4561,7 +4561,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1607325776830197, 530883941415333, 1451089452727895, 1581691157083423, 496100432831154 #else @@ -4570,7 +4570,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1068900648804224, 2006891997072550, 1134049269345549, 1638760646180091, 2055396084625778 #else @@ -4579,7 +4579,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2222475519314561, 1870703901472013, 1884051508440561, 1344072275216753, 1318025677799069 #else @@ -4592,7 +4592,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 155711679280656, 681100400509288, 389811735211209, 2135723811340709, 408733211204125 #else @@ -4601,7 +4601,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 7813206966729, 194444201427550, 2071405409526507, 1065605076176312, 1645486789731291 #else @@ -4610,7 +4610,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 16625790644959, 1647648827778410, 1579910185572704, 436452271048548, 121070048451050 #else @@ -4621,7 +4621,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1037263028552531, 568385780377829, 297953104144430, 1558584511931211, 2238221839292471 #else @@ -4630,7 +4630,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 190565267697443, 672855706028058, 338796554369226, 337687268493904, 853246848691734 #else @@ -4639,7 +4639,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1763863028400139, 766498079432444, 1321118624818005, 69494294452268, 858786744165651 #else @@ -4650,7 +4650,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1292056768563024, 1456632109855638, 1100631247050184, 1386133165675321, 1232898350193752 #else @@ -4659,7 +4659,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 366253102478259, 525676242508811, 1449610995265438, 1183300845322183, 185960306491545 #else @@ -4668,7 +4668,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 28315355815982, 460422265558930, 1799675876678724, 1969256312504498, 1051823843138725 #else @@ -4679,7 +4679,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 156914999361983, 1606148405719949, 1665208410108430, 317643278692271, 1383783705665320 #else @@ -4688,7 +4688,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 54684536365732, 2210010038536222, 1194984798155308, 535239027773705, 1516355079301361 #else @@ -4697,7 +4697,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1484387703771650, 198537510937949, 2186282186359116, 617687444857508, 647477376402122 #else @@ -4708,7 +4708,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2147715541830533, 500032538445817, 646380016884826, 352227855331122, 1488268620408052 #else @@ -4717,7 +4717,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 159386186465542, 1877626593362941, 618737197060512, 1026674284330807, 1158121760792685 #else @@ -4726,7 +4726,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1744544377739822, 1964054180355661, 1685781755873170, 2169740670377448, 1286112621104591 #else @@ -4737,7 +4737,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 81977249784993, 1667943117713086, 1668983819634866, 1605016835177615, 1353960708075544 #else @@ -4746,7 +4746,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1602253788689063, 439542044889886, 2220348297664483, 657877410752869, 157451572512238 #else @@ -4755,7 +4755,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1029287186166717, 65860128430192, 525298368814832, 1491902500801986, 1461064796385400 #else @@ -4766,7 +4766,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 408216988729246, 2121095722306989, 913562102267595, 1879708920318308, 241061448436731 #else @@ -4775,7 +4775,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1185483484383269, 1356339572588553, 584932367316448, 102132779946470, 1792922621116791 #else @@ -4784,7 +4784,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1966196870701923, 2230044620318636, 1425982460745905, 261167817826569, 46517743394330 #else @@ -4795,7 +4795,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 107077591595359, 884959942172345, 27306869797400, 2224911448949390, 964352058245223 #else @@ -4804,7 +4804,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1730194207717538, 431790042319772, 1831515233279467, 1372080552768581, 1074513929381760 #else @@ -4813,7 +4813,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1450880638731607, 1019861580989005, 1229729455116861, 1174945729836143, 826083146840706 #else @@ -4826,7 +4826,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1899935429242705, 1602068751520477, 940583196550370, 82431069053859, 1540863155745696 #else @@ -4835,7 +4835,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2136688454840028, 2099509000964294, 1690800495246475, 1217643678575476, 828720645084218 #else @@ -4844,7 +4844,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 765548025667841, 462473984016099, 998061409979798, 546353034089527, 2212508972466858 #else @@ -4855,7 +4855,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 46575283771160, 892570971573071, 1281983193144090, 1491520128287375, 75847005908304 #else @@ -4864,7 +4864,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1801436127943107, 1734436817907890, 1268728090345068, 167003097070711, 2233597765834956 #else @@ -4873,7 +4873,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1997562060465113, 1048700225534011, 7615603985628, 1855310849546841, 2242557647635213 #else @@ -4884,7 +4884,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1161017320376250, 492624580169043, 2169815802355237, 976496781732542, 1770879511019629 #else @@ -4893,7 +4893,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1357044908364776, 729130645262438, 1762469072918979, 1365633616878458, 181282906404941 #else @@ -4902,7 +4902,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1080413443139865, 1155205815510486, 1848782073549786, 622566975152580, 124965574467971 #else @@ -4913,7 +4913,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1184526762066993, 247622751762817, 692129017206356, 820018689412496, 2188697339828085 #else @@ -4922,7 +4922,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2020536369003019, 202261491735136, 1053169669150884, 2056531979272544, 778165514694311 #else @@ -4931,7 +4931,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 237404399610207, 1308324858405118, 1229680749538400, 720131409105291, 1958958863624906 #else @@ -4942,7 +4942,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 515583508038846, 17656978857189, 1717918437373989, 1568052070792483, 46975803123923 #else @@ -4951,7 +4951,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 281527309158085, 36970532401524, 866906920877543, 2222282602952734, 1289598729589882 #else @@ -4960,7 +4960,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1278207464902042, 494742455008756, 1262082121427081, 1577236621659884, 1888786707293291 #else @@ -4971,7 +4971,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 353042527954210, 1830056151907359, 1111731275799225, 174960955838824, 404312815582675 #else @@ -4980,7 +4980,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2064251142068628, 1666421603389706, 1419271365315441, 468767774902855, 191535130366583 #else @@ -4989,7 +4989,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1716987058588002, 1859366439773457, 1767194234188234, 64476199777924, 1117233614485261 #else @@ -5000,7 +5000,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 984292135520292, 135138246951259, 2220652137473167, 1722843421165029, 190482558012909 #else @@ -5009,7 +5009,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 298845952651262, 1166086588952562, 1179896526238434, 1347812759398693, 1412945390096208 #else @@ -5018,7 +5018,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1143239552672925, 906436640714209, 2177000572812152, 2075299936108548, 325186347798433 #else @@ -5029,7 +5029,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 721024854374772, 684487861263316, 1373438744094159, 2193186935276995, 1387043709851261 #else @@ -5038,7 +5038,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 418098668140962, 715065997721283, 1471916138376055, 2168570337288357, 937812682637044 #else @@ -5047,7 +5047,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1043584187226485, 2143395746619356, 2209558562919611, 482427979307092, 847556718384018 #else @@ -5060,7 +5060,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1248731221520759, 1465200936117687, 540803492710140, 52978634680892, 261434490176109 #else @@ -5069,7 +5069,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1057329623869501, 620334067429122, 461700859268034, 2012481616501857, 297268569108938 #else @@ -5078,7 +5078,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1055352180870759, 1553151421852298, 1510903185371259, 1470458349428097, 1226259419062731 #else @@ -5089,7 +5089,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1492988790301668, 790326625573331, 1190107028409745, 1389394752159193, 1620408196604194 #else @@ -5098,7 +5098,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 47000654413729, 1004754424173864, 1868044813557703, 173236934059409, 588771199737015 #else @@ -5107,7 +5107,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 30498470091663, 1082245510489825, 576771653181956, 806509986132686, 1317634017056939 #else @@ -5118,7 +5118,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 420308055751555, 1493354863316002, 165206721528088, 1884845694919786, 2065456951573059 #else @@ -5127,7 +5127,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1115636332012334, 1854340990964155, 83792697369514, 1972177451994021, 457455116057587 #else @@ -5136,7 +5136,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1698968457310898, 1435137169051090, 1083661677032510, 938363267483709, 340103887207182 #else @@ -5147,7 +5147,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1995325341336574, 911500251774648, 164010755403692, 855378419194762, 1573601397528842 #else @@ -5156,7 +5156,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 241719380661528, 310028521317150, 1215881323380194, 1408214976493624, 2141142156467363 #else @@ -5165,7 +5165,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1315157046163473, 727368447885818, 1363466668108618, 1668921439990361, 1398483384337907 #else @@ -5176,7 +5176,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 75029678299646, 1015388206460473, 1849729037055212, 1939814616452984, 444404230394954 #else @@ -5185,7 +5185,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2053597130993710, 2024431685856332, 2233550957004860, 2012407275509545, 872546993104440 #else @@ -5194,7 +5194,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1217269667678610, 599909351968693, 1390077048548598, 1471879360694802, 739586172317596 #else @@ -5205,7 +5205,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1718318639380794, 1560510726633958, 904462881159922, 1418028351780052, 94404349451937 #else @@ -5214,7 +5214,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2132502667405250, 214379346175414, 1502748313768060, 1960071701057800, 1353971822643138 #else @@ -5223,7 +5223,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 319394212043702, 2127459436033571, 717646691535162, 663366796076914, 318459064945314 #else @@ -5234,7 +5234,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 405989424923593, 1960452633787083, 667349034401665, 1492674260767112, 1451061489880787 #else @@ -5243,7 +5243,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 947085906234007, 323284730494107, 1485778563977200, 728576821512394, 901584347702286 #else @@ -5252,7 +5252,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1575783124125742, 2126210792434375, 1569430791264065, 1402582372904727, 1891780248341114 #else @@ -5263,7 +5263,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 838432205560695, 1997703511451664, 1018791879907867, 1662001808174331, 78328132957753 #else @@ -5272,7 +5272,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 739152638255629, 2074935399403557, 505483666745895, 1611883356514088, 628654635394878 #else @@ -5281,7 +5281,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1822054032121349, 643057948186973, 7306757352712, 577249257962099, 284735863382083 #else @@ -5294,7 +5294,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1366558556363930, 1448606567552086, 1478881020944768, 165803179355898, 1115718458123498 #else @@ -5303,7 +5303,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 204146226972102, 1630511199034723, 2215235214174763, 174665910283542, 956127674017216 #else @@ -5312,7 +5312,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1562934578796716, 1070893489712745, 11324610642270, 958989751581897, 2172552325473805 #else @@ -5323,7 +5323,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1770564423056027, 735523631664565, 1326060113795289, 1509650369341127, 65892421582684 #else @@ -5332,7 +5332,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 623682558650637, 1337866509471512, 990313350206649, 1314236615762469, 1164772974270275 #else @@ -5341,7 +5341,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 223256821462517, 723690150104139, 1000261663630601, 933280913953265, 254872671543046 #else @@ -5352,7 +5352,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1969087237026041, 624795725447124, 1335555107635969, 2069986355593023, 1712100149341902 #else @@ -5361,7 +5361,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1236103475266979, 1837885883267218, 1026072585230455, 1025865513954973, 1801964901432134 #else @@ -5370,7 +5370,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1115241013365517, 1712251818829143, 2148864332502771, 2096001471438138, 2235017246626125 #else @@ -5381,7 +5381,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1299268198601632, 2047148477845621, 2165648650132450, 1612539282026145, 514197911628890 #else @@ -5390,7 +5390,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 118352772338543, 1067608711804704, 1434796676193498, 1683240170548391, 230866769907437 #else @@ -5399,7 +5399,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1850689576796636, 1601590730430274, 1139674615958142, 1954384401440257, 76039205311 #else @@ -5410,7 +5410,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1723387471374172, 997301467038410, 533927635123657, 20928644693965, 1756575222802513 #else @@ -5419,7 +5419,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2146711623855116, 503278928021499, 625853062251406, 1109121378393107, 1033853809911861 #else @@ -5428,7 +5428,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 571005965509422, 2005213373292546, 1016697270349626, 56607856974274, 914438579435146 #else @@ -5439,7 +5439,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1346698876211176, 2076651707527589, 1084761571110205, 265334478828406, 1068954492309671 #else @@ -5448,7 +5448,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1769967932677654, 1695893319756416, 1151863389675920, 1781042784397689, 400287774418285 #else @@ -5457,7 +5457,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1851867764003121, 403841933237558, 820549523771987, 761292590207581, 1743735048551143 #else @@ -5468,7 +5468,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 410915148140008, 2107072311871739, 1004367461876503, 99684895396761, 1180818713503224 #else @@ -5477,7 +5477,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 285945406881439, 648174397347453, 1098403762631981, 1366547441102991, 1505876883139217 #else @@ -5486,7 +5486,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 672095903120153, 1675918957959872, 636236529315028, 1569297300327696, 2164144194785875 #else @@ -5497,7 +5497,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1902708175321798, 1035343530915438, 1178560808893263, 301095684058146, 1280977479761118 #else @@ -5506,7 +5506,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1615357281742403, 404257611616381, 2160201349780978, 1160947379188955, 1578038619549541 #else @@ -5515,7 +5515,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2013087639791217, 822734930507457, 1785668418619014, 1668650702946164, 389450875221715 #else @@ -5528,7 +5528,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 453918449698368, 106406819929001, 2072540975937135, 308588860670238, 1304394580755385 #else @@ -5537,7 +5537,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1295082798350326, 2091844511495996, 1851348972587817, 3375039684596, 789440738712837 #else @@ -5546,7 +5546,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2083069137186154, 848523102004566, 993982213589257, 1405313299916317, 1532824818698468 #else @@ -5557,7 +5557,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1495961298852430, 1397203457344779, 1774950217066942, 139302743555696, 66603584342787 #else @@ -5566,7 +5566,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1782411379088302, 1096724939964781, 27593390721418, 542241850291353, 1540337798439873 #else @@ -5575,7 +5575,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 693543956581437, 171507720360750, 1557908942697227, 1074697073443438, 1104093109037196 #else @@ -5586,7 +5586,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 345288228393419, 1099643569747172, 134881908403743, 1740551994106740, 248212179299770 #else @@ -5595,7 +5595,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 231429562203065, 1526290236421172, 2021375064026423, 1520954495658041, 806337791525116 #else @@ -5604,7 +5604,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1079623667189886, 872403650198613, 766894200588288, 2163700860774109, 2023464507911816 #else @@ -5615,7 +5615,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 854645372543796, 1936406001954827, 151460662541253, 825325739271555, 1554306377287556 #else @@ -5624,7 +5624,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1497138821904622, 1044820250515590, 1742593886423484, 1237204112746837, 849047450816987 #else @@ -5633,7 +5633,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 667962773375330, 1897271816877105, 1399712621683474, 1143302161683099, 2081798441209593 #else @@ -5644,7 +5644,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 127147851567005, 1936114012888110, 1704424366552046, 856674880716312, 716603621335359 #else @@ -5653,7 +5653,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1072409664800960, 2146937497077528, 1508780108920651, 935767602384853, 1112800433544068 #else @@ -5662,7 +5662,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 333549023751292, 280219272863308, 2104176666454852, 1036466864875785, 536135186520207 #else @@ -5673,7 +5673,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 373666279883137, 146457241530109, 304116267127857, 416088749147715, 1258577131183391 #else @@ -5682,7 +5682,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1186115062588401, 2251609796968486, 1098944457878953, 1153112761201374, 1791625503417267 #else @@ -5691,7 +5691,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1870078460219737, 2129630962183380, 852283639691142, 292865602592851, 401904317342226 #else @@ -5702,7 +5702,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1361070124828035, 815664541425524, 1026798897364671, 1951790935390647, 555874891834790 #else @@ -5711,7 +5711,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1546301003424277, 459094500062839, 1097668518375311, 1780297770129643, 720763293687608 #else @@ -5720,7 +5720,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1212405311403990, 1536693382542438, 61028431067459, 1863929423417129, 1223219538638038 #else @@ -5731,7 +5731,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1294303766540260, 1183557465955093, 882271357233093, 63854569425375, 2213283684565087 #else @@ -5740,7 +5740,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 339050984211414, 601386726509773, 413735232134068, 966191255137228, 1839475899458159 #else @@ -5749,7 +5749,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 235605972169408, 2174055643032978, 1538335001838863, 1281866796917192, 1815940222628465 #else @@ -5762,7 +5762,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1632352921721536, 1833328609514701, 2092779091951987, 1923956201873226, 2210068022482919 #else @@ -5771,7 +5771,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 35271216625062, 1712350667021807, 983664255668860, 98571260373038, 1232645608559836 #else @@ -5780,7 +5780,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1998172393429622, 1798947921427073, 784387737563581, 1589352214827263, 1589861734168180 #else @@ -5791,7 +5791,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1733739258725305, 31715717059538, 201969945218860, 992093044556990, 1194308773174556 #else @@ -5800,7 +5800,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 846415389605137, 746163495539180, 829658752826080, 592067705956946, 957242537821393 #else @@ -5809,7 +5809,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1758148849754419, 619249044817679, 168089007997045, 1371497636330523, 1867101418880350 #else @@ -5820,7 +5820,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 326633984209635, 261759506071016, 1700682323676193, 1577907266349064, 1217647663383016 #else @@ -5829,7 +5829,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1714182387328607, 1477856482074168, 574895689942184, 2159118410227270, 1555532449716575 #else @@ -5838,7 +5838,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 853828206885131, 998498946036955, 1835887550391235, 207627336608048, 258363815956050 #else @@ -5849,7 +5849,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 141141474651677, 1236728744905256, 643101419899887, 1646615130509173, 1208239602291765 #else @@ -5858,7 +5858,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1501663228068911, 1354879465566912, 1444432675498247, 897812463852601, 855062598754348 #else @@ -5867,7 +5867,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 714380763546606, 1032824444965790, 1774073483745338, 1063840874947367, 1738680636537158 #else @@ -5878,7 +5878,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1640635546696252, 633168953192112, 2212651044092396, 30590958583852, 368515260889378 #else @@ -5887,7 +5887,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1171650314802029, 1567085444565577, 1453660792008405, 757914533009261, 1619511342778196 #else @@ -5896,7 +5896,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 420958967093237, 971103481109486, 2169549185607107, 1301191633558497, 1661514101014240 #else @@ -5907,7 +5907,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 907123651818302, 1332556122804146, 1824055253424487, 1367614217442959, 1982558335973172 #else @@ -5916,7 +5916,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1121533090144639, 1021251337022187, 110469995947421, 1511059774758394, 2110035908131662 #else @@ -5925,7 +5925,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 303213233384524, 2061932261128138, 352862124777736, 40828818670255, 249879468482660 #else @@ -5936,7 +5936,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 856559257852200, 508517664949010, 1378193767894916, 1723459126947129, 1962275756614521 #else @@ -5945,7 +5945,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1445691340537320, 40614383122127, 402104303144865, 485134269878232, 1659439323587426 #else @@ -5954,7 +5954,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 20057458979482, 1183363722525800, 2140003847237215, 2053873950687614, 2112017736174909 #else @@ -5965,7 +5965,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2228654250927986, 1483591363415267, 1368661293910956, 1076511285177291, 526650682059608 #else @@ -5974,7 +5974,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 709481497028540, 531682216165724, 316963769431931, 1814315888453765, 258560242424104 #else @@ -5983,7 +5983,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1053447823660455, 1955135194248683, 1010900954918985, 1182614026976701, 1240051576966610 #else @@ -5996,7 +5996,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1957943897155497, 1788667368028035, 137692910029106, 1039519607062, 826404763313028 #else @@ -6005,7 +6005,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1848942433095597, 1582009882530495, 1849292741020143, 1068498323302788, 2001402229799484 #else @@ -6014,7 +6014,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1528282417624269, 2142492439828191, 2179662545816034, 362568973150328, 1591374675250271 #else @@ -6025,7 +6025,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 160026679434388, 232341189218716, 2149181472355545, 598041771119831, 183859001910173 #else @@ -6034,7 +6034,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2013278155187349, 662660471354454, 793981225706267, 411706605985744, 804490933124791 #else @@ -6043,7 +6043,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2051892037280204, 488391251096321, 2230187337030708, 930221970662692, 679002758255210 #else @@ -6054,7 +6054,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1530723630438670, 875873929577927, 341560134269988, 449903119530753, 1055551308214179 #else @@ -6063,7 +6063,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1461835919309432, 1955256480136428, 180866187813063, 1551979252664528, 557743861963950 #else @@ -6072,7 +6072,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 359179641731115, 1324915145732949, 902828372691474, 294254275669987, 1887036027752957 #else @@ -6083,7 +6083,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2043271609454323, 2038225437857464, 1317528426475850, 1398989128982787, 2027639881006861 #else @@ -6092,7 +6092,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2072902725256516, 312132452743412, 309930885642209, 996244312618453, 1590501300352303 #else @@ -6101,7 +6101,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1397254305160710, 695734355138021, 2233992044438756, 1776180593969996, 1085588199351115 #else @@ -6112,7 +6112,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 440567051331029, 254894786356681, 493869224930222, 1556322069683366, 1567456540319218 #else @@ -6121,7 +6121,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1950722461391320, 1907845598854797, 1822757481635527, 2121567704750244, 73811931471221 #else @@ -6130,7 +6130,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 387139307395758, 2058036430315676, 1220915649965325, 1794832055328951, 1230009312169328 #else @@ -6141,7 +6141,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1765973779329517, 659344059446977, 19821901606666, 1301928341311214, 1116266004075885 #else @@ -6150,7 +6150,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1127572801181483, 1224743760571696, 1276219889847274, 1529738721702581, 1589819666871853 #else @@ -6159,7 +6159,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2181229378964934, 2190885205260020, 1511536077659137, 1246504208580490, 668883326494241 #else @@ -6170,7 +6170,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 437866655573314, 669026411194768, 81896997980338, 523874406393178, 245052060935236 #else @@ -6179,7 +6179,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1975438052228868, 1071801519999806, 594652299224319, 1877697652668809, 1489635366987285 #else @@ -6188,7 +6188,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 958592545673770, 233048016518599, 851568750216589, 567703851596087, 1740300006094761 #else @@ -6199,7 +6199,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2014540178270324, 192672779514432, 213877182641530, 2194819933853411, 1716422829364835 #else @@ -6208,7 +6208,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1540769606609725, 2148289943846077, 1597804156127445, 1230603716683868, 815423458809453 #else @@ -6217,7 +6217,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1738560251245018, 1779576754536888, 1783765347671392, 1880170990446751, 1088225159617541 #else @@ -6230,7 +6230,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 659303913929492, 1956447718227573, 1830568515922666, 841069049744408, 1669607124206368 #else @@ -6239,7 +6239,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1143465490433355, 1532194726196059, 1093276745494697, 481041706116088, 2121405433561163 #else @@ -6248,7 +6248,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1686424298744462, 1451806974487153, 266296068846582, 1834686947542675, 1720762336132256 #else @@ -6259,7 +6259,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 889217026388959, 1043290623284660, 856125087551909, 1669272323124636, 1603340330827879 #else @@ -6268,7 +6268,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1206396181488998, 333158148435054, 1402633492821422, 1120091191722026, 1945474114550509 #else @@ -6277,7 +6277,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 766720088232571, 1512222781191002, 1189719893490790, 2091302129467914, 2141418006894941 #else @@ -6288,7 +6288,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 419663647306612, 1998875112167987, 1426599870253707, 1154928355379510, 486538532138187 #else @@ -6297,7 +6297,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 938160078005954, 1421776319053174, 1941643234741774, 180002183320818, 1414380336750546 #else @@ -6306,7 +6306,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 398001940109652, 1577721237663248, 1012748649830402, 1540516006905144, 1011684812884559 #else @@ -6317,7 +6317,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1653276489969630, 6081825167624, 1921777941170836, 1604139841794531, 861211053640641 #else @@ -6326,7 +6326,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 996661541407379, 1455877387952927, 744312806857277, 139213896196746, 1000282908547789 #else @@ -6335,7 +6335,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1450817495603008, 1476865707053229, 1030490562252053, 620966950353376, 1744760161539058 #else @@ -6346,7 +6346,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 559728410002599, 37056661641185, 2038622963352006, 1637244893271723, 1026565352238948 #else @@ -6355,7 +6355,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 962165956135846, 1116599660248791, 182090178006815, 1455605467021751, 196053588803284 #else @@ -6364,7 +6364,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 796863823080135, 1897365583584155, 420466939481601, 2165972651724672, 932177357788289 #else @@ -6375,7 +6375,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 877047233620632, 1375632631944375, 643773611882121, 660022738847877, 19353932331831 #else @@ -6384,7 +6384,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2216943882299338, 394841323190322, 2222656898319671, 558186553950529, 1077236877025190 #else @@ -6393,7 +6393,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 801118384953213, 1914330175515892, 574541023311511, 1471123787903705, 1526158900256288 #else @@ -6404,7 +6404,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 949617889087234, 2207116611267331, 912920039141287, 501158539198789, 62362560771472 #else @@ -6413,7 +6413,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1474518386765335, 1760793622169197, 1157399790472736, 1622864308058898, 165428294422792 #else @@ -6422,7 +6422,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1961673048027128, 102619413083113, 1051982726768458, 1603657989805485, 1941613251499678 #else @@ -6433,7 +6433,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1401939116319266, 335306339903072, 72046196085786, 862423201496006, 850518754531384 #else @@ -6442,7 +6442,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1234706593321979, 1083343891215917, 898273974314935, 1640859118399498, 157578398571149 #else @@ -6451,7 +6451,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1143483057726416, 1992614991758919, 674268662140796, 1773370048077526, 674318359920189 #else @@ -6464,7 +6464,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1835401379538542, 173900035308392, 818247630716732, 1762100412152786, 1021506399448291 #else @@ -6473,7 +6473,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1506632088156630, 2127481795522179, 513812919490255, 140643715928370, 442476620300318 #else @@ -6482,7 +6482,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2056683376856736, 219094741662735, 2193541883188309, 1841182310235800, 556477468664293 #else @@ -6493,7 +6493,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1315019427910827, 1049075855992603, 2066573052986543, 266904467185534, 2040482348591520 #else @@ -6502,7 +6502,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 94096246544434, 922482381166992, 24517828745563, 2139430508542503, 2097139044231004 #else @@ -6511,7 +6511,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 537697207950515, 1399352016347350, 1563663552106345, 2148749520888918, 549922092988516 #else @@ -6522,7 +6522,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1747985413252434, 680511052635695, 1809559829982725, 594274250930054, 201673170745982 #else @@ -6531,7 +6531,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 323583936109569, 1973572998577657, 1192219029966558, 79354804385273, 1374043025560347 #else @@ -6540,7 +6540,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 213277331329947, 416202017849623, 1950535221091783, 1313441578103244, 2171386783823658 #else @@ -6551,7 +6551,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 189088804229831, 993969372859110, 895870121536987, 1547301535298256, 1477373024911350 #else @@ -6560,7 +6560,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1620578418245010, 541035331188469, 2235785724453865, 2154865809088198, 1974627268751826 #else @@ -6569,7 +6569,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1346805451740245, 1350981335690626, 942744349501813, 2155094562545502, 1012483751693409 #else @@ -6580,7 +6580,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2107080134091762, 1132567062788208, 1824935377687210, 769194804343737, 1857941799971888 #else @@ -6589,7 +6589,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1074666112436467, 249279386739593, 1174337926625354, 1559013532006480, 1472287775519121 #else @@ -6598,7 +6598,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1872620123779532, 1892932666768992, 1921559078394978, 1270573311796160, 1438913646755037 #else @@ -6609,7 +6609,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 837390187648199, 1012253300223599, 989780015893987, 1351393287739814, 328627746545550 #else @@ -6618,7 +6618,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1028328827183114, 1711043289969857, 1350832470374933, 1923164689604327, 1495656368846911 #else @@ -6627,7 +6627,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1900828492104143, 430212361082163, 687437570852799, 832514536673512, 1685641495940794 #else @@ -6638,7 +6638,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 842632847936398, 605670026766216, 290836444839585, 163210774892356, 2213815011799645 #else @@ -6647,7 +6647,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1176336383453996, 1725477294339771, 12700622672454, 678015708818208, 162724078519879 #else @@ -6656,7 +6656,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1448049969043497, 1789411762943521, 385587766217753, 90201620913498, 832999441066823 #else @@ -6667,7 +6667,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 516086333293313, 2240508292484616, 1351669528166508, 1223255565316488, 750235824427138 #else @@ -6676,7 +6676,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1263624896582495, 1102602401673328, 526302183714372, 2152015839128799, 1483839308490010 #else @@ -6685,7 +6685,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 442991718646863, 1599275157036458, 1925389027579192, 899514691371390, 350263251085160 #else @@ -6698,7 +6698,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1689713572022143, 593854559254373, 978095044791970, 1985127338729499, 1676069120347625 #else @@ -6707,7 +6707,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1557207018622683, 340631692799603, 1477725909476187, 614735951619419, 2033237123746766 #else @@ -6716,7 +6716,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 968764929340557, 1225534776710944, 662967304013036, 1155521416178595, 791142883466590 #else @@ -6727,7 +6727,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1487081286167458, 993039441814934, 1792378982844640, 698652444999874, 2153908693179754 #else @@ -6736,7 +6736,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1123181311102823, 685575944875442, 507605465509927, 1412590462117473, 568017325228626 #else @@ -6745,7 +6745,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 560258797465417, 2193971151466401, 1824086900849026, 579056363542056, 1690063960036441 #else @@ -6756,7 +6756,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1918407319222416, 353767553059963, 1930426334528099, 1564816146005724, 1861342381708096 #else @@ -6765,7 +6765,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2131325168777276, 1176636658428908, 1756922641512981, 1390243617176012, 1966325177038383 #else @@ -6774,7 +6774,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2063958120364491, 2140267332393533, 699896251574968, 273268351312140, 375580724713232 #else @@ -6785,7 +6785,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2024297515263178, 416959329722687, 1079014235017302, 171612225573183, 1031677520051053 #else @@ -6794,7 +6794,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2033900009388450, 1744902869870788, 2190580087917640, 1949474984254121, 231049754293748 #else @@ -6803,7 +6803,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 343868674606581, 550155864008088, 1450580864229630, 481603765195050, 896972360018042 #else @@ -6814,7 +6814,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2151139328380127, 314745882084928, 59756825775204, 1676664391494651, 2048348075599360 #else @@ -6823,7 +6823,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1528930066340597, 1605003907059576, 1055061081337675, 1458319101947665, 1234195845213142 #else @@ -6832,7 +6832,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 830430507734812, 1780282976102377, 1425386760709037, 362399353095425, 2168861579799910 #else @@ -6843,7 +6843,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1155762232730333, 980662895504006, 2053766700883521, 490966214077606, 510405877041357 #else @@ -6852,7 +6852,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1683750316716132, 652278688286128, 1221798761193539, 1897360681476669, 319658166027343 #else @@ -6861,7 +6861,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 618808732869972, 72755186759744, 2060379135624181, 1730731526741822, 48862757828238 #else @@ -6872,7 +6872,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1463171970593505, 1143040711767452, 614590986558883, 1409210575145591, 1882816996436803 #else @@ -6881,7 +6881,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2230133264691131, 563950955091024, 2042915975426398, 827314356293472, 672028980152815 #else @@ -6890,7 +6890,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 264204366029760, 1654686424479449, 2185050199932931, 2207056159091748, 506015669043634 #else @@ -6901,7 +6901,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1784446333136569, 1973746527984364, 334856327359575, 1156769775884610, 1023950124675478 #else @@ -6910,7 +6910,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2065270940578383, 31477096270353, 306421879113491, 181958643936686, 1907105536686083 #else @@ -6919,7 +6919,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1496516440779464, 1748485652986458, 872778352227340, 818358834654919, 97932669284220 #else @@ -6932,7 +6932,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 471636015770351, 672455402793577, 1804995246884103, 1842309243470804, 1501862504981682 #else @@ -6941,7 +6941,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1013216974933691, 538921919682598, 1915776722521558, 1742822441583877, 1886550687916656 #else @@ -6950,7 +6950,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2094270000643336, 303971879192276, 40801275554748, 649448917027930, 1818544418535447 #else @@ -6961,7 +6961,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2241737709499165, 549397817447461, 838180519319392, 1725686958520781, 1705639080897747 #else @@ -6970,7 +6970,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1216074541925116, 50120933933509, 1565829004133810, 721728156134580, 349206064666188 #else @@ -6979,7 +6979,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 948617110470858, 346222547451945, 1126511960599975, 1759386906004538, 493053284802266 #else @@ -6990,7 +6990,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1454933046815146, 874696014266362, 1467170975468588, 1432316382418897, 2111710746366763 #else @@ -6999,7 +6999,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2105387117364450, 1996463405126433, 1303008614294500, 851908115948209, 1353742049788635 #else @@ -7008,7 +7008,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 750300956351719, 1487736556065813, 15158817002104, 1511998221598392, 971739901354129 #else @@ -7019,7 +7019,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1874648163531693, 2124487685930551, 1810030029384882, 918400043048335, 586348627300650 #else @@ -7028,7 +7028,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1235084464747900, 1166111146432082, 1745394857881591, 1405516473883040, 4463504151617 #else @@ -7037,7 +7037,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1663810156463827, 327797390285791, 1341846161759410, 1964121122800605, 1747470312055380 #else @@ -7048,7 +7048,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 660005247548233, 2071860029952887, 1358748199950107, 911703252219107, 1014379923023831 #else @@ -7057,7 +7057,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2206641276178231, 1690587809721504, 1600173622825126, 2156096097634421, 1106822408548216 #else @@ -7066,7 +7066,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1344788193552206, 1949552134239140, 1735915881729557, 675891104100469, 1834220014427292 #else @@ -7077,7 +7077,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1920949492387964, 158885288387530, 70308263664033, 626038464897817, 1468081726101009 #else @@ -7086,7 +7086,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 622221042073383, 1210146474039168, 1742246422343683, 1403839361379025, 417189490895736 #else @@ -7095,7 +7095,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 22727256592983, 168471543384997, 1324340989803650, 1839310709638189, 504999476432775 #else @@ -7106,7 +7106,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1313240518756327, 1721896294296942, 52263574587266, 2065069734239232, 804910473424630 #else @@ -7115,7 +7115,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1337466662091884, 1287645354669772, 2018019646776184, 652181229374245, 898011753211715 #else @@ -7124,7 +7124,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1969792547910734, 779969968247557, 2011350094423418, 1823964252907487, 1058949448296945 #else @@ -7135,7 +7135,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 207343737062002, 1118176942430253, 758894594548164, 806764629546266, 1157700123092949 #else @@ -7144,7 +7144,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1273565321399022, 1638509681964574, 759235866488935, 666015124346707, 897983460943405 #else @@ -7153,7 +7153,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1717263794012298, 1059601762860786, 1837819172257618, 1054130665797229, 680893204263559 #else @@ -7166,7 +7166,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2237039662793603, 2249022333361206, 2058613546633703, 149454094845279, 2215176649164582 #else @@ -7175,7 +7175,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 79472182719605, 1851130257050174, 1825744808933107, 821667333481068, 781795293511946 #else @@ -7184,7 +7184,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 755822026485370, 152464789723500, 1178207602290608, 410307889503239, 156581253571278 #else @@ -7195,7 +7195,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1418185496130297, 484520167728613, 1646737281442950, 1401487684670265, 1349185550126961 #else @@ -7204,7 +7204,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1495380034400429, 325049476417173, 46346894893933, 1553408840354856, 828980101835683 #else @@ -7213,7 +7213,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1280337889310282, 2070832742866672, 1640940617225222, 2098284908289951, 450929509534434 #else @@ -7224,7 +7224,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 407703353998781, 126572141483652, 286039827513621, 1999255076709338, 2030511179441770 #else @@ -7233,7 +7233,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1254958221100483, 1153235960999843, 942907704968834, 637105404087392, 1149293270147267 #else @@ -7242,7 +7242,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 894249020470196, 400291701616810, 406878712230981, 1599128793487393, 1145868722604026 #else @@ -7253,7 +7253,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1497955250203334, 110116344653260, 1128535642171976, 1900106496009660, 129792717460909 #else @@ -7262,7 +7262,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 452487513298665, 1352120549024569, 1173495883910956, 1999111705922009, 367328130454226 #else @@ -7271,7 +7271,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1717539401269642, 1475188995688487, 891921989653942, 836824441505699, 1885988485608364 #else @@ -7282,7 +7282,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1241784121422547, 187337051947583, 1118481812236193, 428747751936362, 30358898927325 #else @@ -7291,7 +7291,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2022432361201842, 1088816090685051, 1977843398539868, 1854834215890724, 564238862029357 #else @@ -7300,7 +7300,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 938868489100585, 1100285072929025, 1017806255688848, 1957262154788833, 152787950560442 #else @@ -7311,7 +7311,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 867319417678923, 620471962942542, 226032203305716, 342001443957629, 1761675818237336 #else @@ -7320,7 +7320,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1295072362439987, 931227904689414, 1355731432641687, 922235735834035, 892227229410209 #else @@ -7329,7 +7329,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1680989767906154, 535362787031440, 2136691276706570, 1942228485381244, 1267350086882274 #else @@ -7340,7 +7340,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 366018233770527, 432660629755596, 126409707644535, 1973842949591662, 645627343442376 #else @@ -7349,7 +7349,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 535509430575217, 546885533737322, 1524675609547799, 2138095752851703, 1260738089896827 #else @@ -7358,7 +7358,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1159906385590467, 2198530004321610, 714559485023225, 81880727882151, 1484020820037082 #else @@ -7369,7 +7369,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1377485731340769, 2046328105512000, 1802058637158797, 62146136768173, 1356993908853901 #else @@ -7378,7 +7378,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2013612215646735, 1830770575920375, 536135310219832, 609272325580394, 270684344495013 #else @@ -7387,7 +7387,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1237542585982777, 2228682050256790, 1385281931622824, 593183794882890, 493654978552689 #else @@ -7400,7 +7400,7 @@ static const ge_precomp k25519Precomp[32][8] = { { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 47341488007760, 1891414891220257, 983894663308928, 176161768286818, 1126261115179708 #else @@ -7409,7 +7409,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1694030170963455, 502038567066200, 1691160065225467, 949628319562187, 275110186693066 #else @@ -7418,7 +7418,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1124515748676336, 1661673816593408, 1499640319059718, 1584929449166988, 558148594103306 #else @@ -7429,7 +7429,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1784525599998356, 1619698033617383, 2097300287550715, 258265458103756, 1905684794832758 #else @@ -7438,7 +7438,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1288941072872766, 931787902039402, 190731008859042, 2006859954667190, 1005931482221702 #else @@ -7447,7 +7447,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1465551264822703, 152905080555927, 680334307368453, 173227184634745, 666407097159852 #else @@ -7458,7 +7458,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2111017076203943, 1378760485794347, 1248583954016456, 1352289194864422, 1895180776543896 #else @@ -7467,7 +7467,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 171348223915638, 662766099800389, 462338943760497, 466917763340314, 656911292869115 #else @@ -7476,7 +7476,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 488623681976577, 866497561541722, 1708105560937768, 1673781214218839, 1506146329818807 #else @@ -7487,7 +7487,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 160425464456957, 950394373239689, 430497123340934, 711676555398832, 320964687779005 #else @@ -7496,7 +7496,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 988979367990485, 1359729327576302, 1301834257246029, 294141160829308, 29348272277475 #else @@ -7505,7 +7505,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1434382743317910, 100082049942065, 221102347892623, 186982837860588, 1305765053501834 #else @@ -7516,7 +7516,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2205916462268190, 499863829790820, 961960554686616, 158062762756985, 1841471168298305 #else @@ -7525,7 +7525,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1191737341426592, 1847042034978363, 1382213545049056, 1039952395710448, 788812858896859 #else @@ -7534,7 +7534,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1346965964571152, 1291881610839830, 2142916164336056, 786821641205979, 1571709146321039 #else @@ -7545,7 +7545,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 787164375951248, 202869205373189, 1356590421032140, 1431233331032510, 786341368775957 #else @@ -7554,7 +7554,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 492448143532951, 304105152670757, 1761767168301056, 233782684697790, 1981295323106089 #else @@ -7563,7 +7563,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 665807507761866, 1343384868355425, 895831046139653, 439338948736892, 1986828765695105 #else @@ -7574,7 +7574,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 756096210874553, 1721699973539149, 258765301727885, 1390588532210645, 1212530909934781 #else @@ -7583,7 +7583,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 852891097972275, 1816988871354562, 1543772755726524, 1174710635522444, 202129090724628 #else @@ -7592,7 +7592,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1205281565824323, 22430498399418, 992947814485516, 1392458699738672, 688441466734558 #else @@ -7603,7 +7603,7 @@ static const ge_precomp k25519Precomp[32][8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1050627428414972, 1955849529137135, 2171162376368357, 91745868298214, 447733118757826 #else @@ -7612,7 +7612,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1287181461435438, 622722465530711, 880952150571872, 741035693459198, 311565274989772 #else @@ -7621,7 +7621,7 @@ static const ge_precomp k25519Precomp[32][8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1003649078149734, 545233927396469, 1849786171789880, 1318943684880434, 280345687170552 #else @@ -7639,7 +7639,7 @@ static const ge_precomp k25519Precomp[32][8] = { static const ge_precomp Bi[8] = { { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1288382639258501, 245678601348599, 269427782077623, 1462984067271730, 137412439391563 #else @@ -7648,7 +7648,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 62697248952638, 204681361388450, 631292143396476, 338455783676468, 1213667448819585 #else @@ -7657,7 +7657,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 301289933810280, 1259582250014073, 1422107436869536, 796239922652654, 1953934009299142 #else @@ -7668,7 +7668,7 @@ static const ge_precomp Bi[8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1601611775252272, 1720807796594148, 1132070835939856, 1260455018889551, 2147779492816911 #else @@ -7677,7 +7677,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 316559037616741, 2177824224946892, 1459442586438991, 1461528397712656, 751590696113597 #else @@ -7686,7 +7686,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1850748884277385, 1200145853858453, 1068094770532492, 672251375690438, 1586055907191707 #else @@ -7697,7 +7697,7 @@ static const ge_precomp Bi[8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 769950342298419, 132954430919746, 844085933195555, 974092374476333, 726076285546016 #else @@ -7706,7 +7706,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 425251763115706, 608463272472562, 442562545713235, 837766094556764, 374555092627893 #else @@ -7715,7 +7715,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1086255230780037, 274979815921559, 1960002765731872, 929474102396301, 1190409889297339 #else @@ -7726,7 +7726,7 @@ static const ge_precomp Bi[8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 665000864555967, 2065379846933859, 370231110385876, 350988370788628, 1233371373142985 #else @@ -7735,7 +7735,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2019367628972465, 676711900706637, 110710997811333, 1108646842542025, 517791959672113 #else @@ -7744,7 +7744,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 965130719900578, 247011430587952, 526356006571389, 91986625355052, 2157223321444601 #else @@ -7755,7 +7755,7 @@ static const ge_precomp Bi[8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1802695059465007, 1664899123557221, 593559490740857, 2160434469266659, 927570450755031 #else @@ -7764,7 +7764,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1725674970513508, 1933645953859181, 1542344539275782, 1767788773573747, 1297447965928905 #else @@ -7773,7 +7773,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1381809363726107, 1430341051343062, 2061843536018959, 1551778050872521, 2036394857967624 #else @@ -7784,7 +7784,7 @@ static const ge_precomp Bi[8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1970894096313054, 528066325833207, 1619374932191227, 2207306624415883, 1169170329061080 #else @@ -7793,7 +7793,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 2070390218572616, 1458919061857835, 624171843017421, 1055332792707765, 433987520732508 #else @@ -7802,7 +7802,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 893653801273833, 1168026499324677, 1242553501121234, 1306366254304474, 1086752658510815 #else @@ -7813,7 +7813,7 @@ static const ge_precomp Bi[8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 213454002618221, 939771523987438, 1159882208056014, 317388369627517, 621213314200687 #else @@ -7822,7 +7822,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1971678598905747, 338026507889165, 762398079972271, 655096486107477, 42299032696322 #else @@ -7831,7 +7831,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 177130678690680, 1754759263300204, 1864311296286618, 1180675631479880, 1292726903152791 #else @@ -7842,7 +7842,7 @@ static const ge_precomp Bi[8] = { }, { {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1913163449625248, 460779200291993, 2193883288642314, 1008900146920800, 1721983679009502 #else @@ -7851,7 +7851,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 1070401523076875, 1272492007800961, 1910153608563310, 2075579521696771, 1191169788841221 #else @@ -7860,7 +7860,7 @@ static const ge_precomp Bi[8] = { #endif }}, {{ -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) 692896803108118, 500174642072499, 2068223309439677, 1162190621851337, 1426986007309901 #else diff --git a/crypto/curve25519/internal.h b/crypto/curve25519/internal.h index 76ff78faf4..1420601bb7 100644 --- a/crypto/curve25519/internal.h +++ b/crypto/curve25519/internal.h @@ -32,11 +32,7 @@ void x25519_NEON(uint8_t out[32], const uint8_t scalar[32], const uint8_t point[32]); #endif -#if defined(BORINGSSL_HAS_UINT128) -#define BORINGSSL_CURVE25519_64BIT -#endif - -#if defined(BORINGSSL_CURVE25519_64BIT) +#if defined(OPENSSL_64_BIT) // fe means field element. Here the field is \Z/(2^255-19). An element t, // entries t[0]...t[4], represents the integer t[0]+2^51 t[1]+2^102 t[2]+2^153 // t[3]+2^204 t[4]. diff --git a/crypto/curve25519/make_curve25519_tables.py b/crypto/curve25519/make_curve25519_tables.py index 50dee2a98a..c3cf12ab09 100755 --- a/crypto/curve25519/make_curve25519_tables.py +++ b/crypto/curve25519/make_curve25519_tables.py @@ -110,7 +110,7 @@ def to_base_51(x): return ret def to_literal(x): - ret = "{{\n#if defined(BORINGSSL_CURVE25519_64BIT)\n" + ret = "{{\n#if defined(OPENSSL_64_BIT)\n" ret += ", ".join(map(str, to_base_51(x))) ret += "\n#else\n" ret += ", ".join(map(str, to_base_25_5(x))) diff --git a/crypto/fipsmodule/ec/make_tables.go b/crypto/fipsmodule/ec/make_tables.go index 7fb9041c68..b60712b009 100644 --- a/crypto/fipsmodule/ec/make_tables.go +++ b/crypto/fipsmodule/ec/make_tables.go @@ -151,7 +151,7 @@ func writeP256Table(path string) error { // Tables for other points have table[i] = iG for i in 0 .. 16. // fiat_p256_g_pre_comp is the table of precomputed base points -#if defined(BORINGSSL_NISTP256_64BIT) +#if defined(OPENSSL_64_BIT) static const fiat_p256_felem fiat_p256_g_pre_comp[2][15][2] = ` if _, err := f.WriteString(fileHeader); err != nil { return err diff --git a/crypto/fipsmodule/ec/p256.c b/crypto/fipsmodule/ec/p256.c index d67f6c08b1..cd2b6fc0ee 100644 --- a/crypto/fipsmodule/ec/p256.c +++ b/crypto/fipsmodule/ec/p256.c @@ -31,8 +31,9 @@ #include "./internal.h" #if defined(BORINGSSL_HAS_UINT128) -#define BORINGSSL_NISTP256_64BIT 1 #include "../../../third_party/fiat/p256_64.h" +#elif defined(OPENSSL_64_BIT) +#include "../../../third_party/fiat/p256_64_msvc.h" #else #include "../../../third_party/fiat/p256_32.h" #endif @@ -40,7 +41,7 @@ // utility functions, handwritten -#if defined(BORINGSSL_NISTP256_64BIT) +#if defined(OPENSSL_64_BIT) #define FIAT_P256_NLIMBS 4 typedef uint64_t fiat_p256_limb_t; typedef uint64_t fiat_p256_felem[FIAT_P256_NLIMBS]; @@ -748,5 +749,3 @@ DEFINE_METHOD_FUNCTION(EC_METHOD, EC_GFp_nistp256_method) { ec_simple_scalar_to_montgomery_inv_vartime; out->cmp_x_coordinate = ec_GFp_nistp256_cmp_x_coordinate; } - -#undef BORINGSSL_NISTP256_64BIT diff --git a/crypto/fipsmodule/ec/p256_table.h b/crypto/fipsmodule/ec/p256_table.h index 14129a36f3..d823d37ff0 100644 --- a/crypto/fipsmodule/ec/p256_table.h +++ b/crypto/fipsmodule/ec/p256_table.h @@ -50,7 +50,7 @@ // Tables for other points have table[i] = iG for i in 0 .. 16. // fiat_p256_g_pre_comp is the table of precomputed base points -#if defined(BORINGSSL_NISTP256_64BIT) +#if defined(OPENSSL_64_BIT) static const fiat_p256_felem fiat_p256_g_pre_comp[2][15][2] = { {{{0x79e730d418a9143c, 0x75ba95fc5fedb601, 0x79fb732b77622510, 0x18905f76a53755c6}, diff --git a/third_party/fiat/curve25519_64_msvc.h b/third_party/fiat/curve25519_64_msvc.h new file mode 100644 index 0000000000..d20ec8538a --- /dev/null +++ b/third_party/fiat/curve25519_64_msvc.h @@ -0,0 +1,1281 @@ +/* Autogenerated: 'src/ExtractionOCaml/unsaturated_solinas' --inline --static --use-value-barrier --no-wide-int 25519 64 '(auto)' '2^255 - 19' carry_mul carry_square carry add sub opp selectznz to_bytes from_bytes relax carry_scmul121666 */ +/* curve description: 25519 */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: carry_mul, carry_square, carry, add, sub, opp, selectznz, to_bytes, from_bytes, relax, carry_scmul121666 */ +/* n = 5 (from "(auto)") */ +/* s-c = 2^255 - [(1, 19)] (from "2^255 - 19") */ +/* tight_bounds_multiplier = 1 (from "") */ +/* */ +/* Computed values: */ +/* carry_chain = [0, 1, 2, 3, 4, 0, 1] */ +/* eval z = z[0] + (z[1] << 51) + (z[2] << 102) + (z[3] << 153) + (z[4] << 204) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* balance = [0xfffffffffffda, 0xffffffffffffe, 0xffffffffffffe, 0xffffffffffffe, 0xffffffffffffe] */ + +#include +#include +#if defined(_M_X64) +#include +#endif + +typedef unsigned char fiat_25519_uint1; +typedef signed char fiat_25519_int1; + +#define FIAT_25519_FIAT_INLINE inline + +/* The type fiat_25519_loose_field_element is a field element with loose bounds. */ +/* Bounds: [[0x0 ~> 0x18000000000000], [0x0 ~> 0x18000000000000], [0x0 ~> 0x18000000000000], [0x0 ~> 0x18000000000000], [0x0 ~> 0x18000000000000]] */ +typedef uint64_t fiat_25519_loose_field_element[5]; + +/* The type fiat_25519_tight_field_element is a field element with tight bounds. */ +/* Bounds: [[0x0 ~> 0x8000000000000], [0x0 ~> 0x8000000000000], [0x0 ~> 0x8000000000000], [0x0 ~> 0x8000000000000], [0x0 ~> 0x8000000000000]] */ +typedef uint64_t fiat_25519_tight_field_element[5]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#define fiat_25519_value_barrier_u64(x) (x) + +/* + * The function fiat_25519_addcarryx_u64 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^64 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_addcarryx_u64(uint64_t* out1, fiat_25519_uint1* out2, fiat_25519_uint1 arg1, uint64_t arg2, uint64_t arg3) { +// NOTE: edited after generation +#if defined(_M_X64) + *out2 = _addcarry_u64(arg1, arg2, arg3, out1); +#else + arg2 += arg1; + arg1 = arg2 < arg1; + arg3 += arg2; + arg1 += arg3 < arg2; + *out1 = arg3; + *out2 = arg1; +#endif +} + +/* + * The function fiat_25519_subborrowx_u64 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^64 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_subborrowx_u64(uint64_t* out1, fiat_25519_uint1* out2, fiat_25519_uint1 arg1, uint64_t arg2, uint64_t arg3) { +#if defined(_M_X64) + *out2 = _subborrow_u64(arg1, arg2, arg3, out1); // NOTE: edited after generation +#else + *out1 = arg2 - arg3 - arg1; + *out2 = (arg2 < arg3) | ((arg2 == arg3) & arg1); +#endif +} + +/* + * The function fiat_25519_addcarryx_u51 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^51 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^51⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0x7ffffffffffff] + * arg3: [0x0 ~> 0x7ffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0x7ffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_addcarryx_u51(uint64_t* out1, fiat_25519_uint1* out2, fiat_25519_uint1 arg1, uint64_t arg2, uint64_t arg3) { + uint64_t x1; + uint64_t x2; + fiat_25519_uint1 x3; + x1 = ((arg1 + arg2) + arg3); + x2 = (x1 & UINT64_C(0x7ffffffffffff)); + x3 = (fiat_25519_uint1)(x1 >> 51); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_25519_subborrowx_u51 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^51 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^51⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0x7ffffffffffff] + * arg3: [0x0 ~> 0x7ffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0x7ffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_subborrowx_u51(uint64_t* out1, fiat_25519_uint1* out2, fiat_25519_uint1 arg1, uint64_t arg2, uint64_t arg3) { + int64_t x1; + fiat_25519_int1 x2; + uint64_t x3; + x1 = ((int64_t)(arg2 - (int64_t)arg1) - (int64_t)arg3); + x2 = (fiat_25519_int1)(x1 >> 51); + x3 = (x1 & UINT64_C(0x7ffffffffffff)); + *out1 = x3; + *out2 = (fiat_25519_uint1)(0x0 - x2); +} + +/* + * The function fiat_25519_mulx_u64 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^64 + * out2 = ⌊arg1 * arg2 / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) { +// NOTE: edited after generation +#if defined(_M_X64) + *out1 = _umul128(arg1, arg2, out2); +#elif defined(_M_ARM64) + *out1 = arg1 * arg2; + *out2 = __umulh(arg1, arg2); +#else +#error "This file is intended for MSVC on X64 or ARM64" +#endif +} + +/* + * The function fiat_25519_cmovznz_u64 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_cmovznz_u64(uint64_t* out1, fiat_25519_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_25519_uint1 x1; + uint64_t x2; + uint64_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_25519_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff)); + x3 = ((fiat_25519_value_barrier_u64(x2) & arg3) | (fiat_25519_value_barrier_u64((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_25519_carry_mul multiplies two field elements and reduces the result. + * + * Postconditions: + * eval out1 mod m = (eval arg1 * eval arg2) mod m + * + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_carry_mul(fiat_25519_tight_field_element out1, const fiat_25519_loose_field_element arg1, const fiat_25519_loose_field_element arg2) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint64_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + fiat_25519_uint1 x52; + uint64_t x53; + fiat_25519_uint1 x54; + uint64_t x55; + fiat_25519_uint1 x56; + uint64_t x57; + fiat_25519_uint1 x58; + uint64_t x59; + fiat_25519_uint1 x60; + uint64_t x61; + fiat_25519_uint1 x62; + uint64_t x63; + fiat_25519_uint1 x64; + uint64_t x65; + fiat_25519_uint1 x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + fiat_25519_uint1 x70; + uint64_t x71; + fiat_25519_uint1 x72; + uint64_t x73; + fiat_25519_uint1 x74; + uint64_t x75; + fiat_25519_uint1 x76; + uint64_t x77; + fiat_25519_uint1 x78; + uint64_t x79; + fiat_25519_uint1 x80; + uint64_t x81; + fiat_25519_uint1 x82; + uint64_t x83; + fiat_25519_uint1 x84; + uint64_t x85; + fiat_25519_uint1 x86; + uint64_t x87; + fiat_25519_uint1 x88; + uint64_t x89; + fiat_25519_uint1 x90; + uint64_t x91; + fiat_25519_uint1 x92; + uint64_t x93; + fiat_25519_uint1 x94; + uint64_t x95; + fiat_25519_uint1 x96; + uint64_t x97; + fiat_25519_uint1 x98; + uint64_t x99; + fiat_25519_uint1 x100; + uint64_t x101; + fiat_25519_uint1 x102; + uint64_t x103; + fiat_25519_uint1 x104; + uint64_t x105; + fiat_25519_uint1 x106; + uint64_t x107; + fiat_25519_uint1 x108; + uint64_t x109; + fiat_25519_uint1 x110; + uint64_t x111; + fiat_25519_uint1 x112; + uint64_t x113; + fiat_25519_uint1 x114; + uint64_t x115; + fiat_25519_uint1 x116; + uint64_t x117; + fiat_25519_uint1 x118; + uint64_t x119; + fiat_25519_uint1 x120; + uint64_t x121; + fiat_25519_uint1 x122; + uint64_t x123; + fiat_25519_uint1 x124; + uint64_t x125; + fiat_25519_uint1 x126; + uint64_t x127; + fiat_25519_uint1 x128; + uint64_t x129; + fiat_25519_uint1 x130; + uint64_t x131; + fiat_25519_uint1 x132; + uint64_t x133; + fiat_25519_uint1 x134; + uint64_t x135; + uint64_t x136; + uint64_t x137; + uint64_t x138; + fiat_25519_uint1 x139; + uint64_t x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + fiat_25519_uint1 x144; + uint64_t x145; + uint64_t x146; + uint64_t x147; + uint64_t x148; + fiat_25519_uint1 x149; + uint64_t x150; + uint64_t x151; + uint64_t x152; + uint64_t x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + fiat_25519_uint1 x158; + uint64_t x159; + uint64_t x160; + fiat_25519_mulx_u64(&x1, &x2, (arg1[4]), ((arg2[4]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x3, &x4, (arg1[4]), ((arg2[3]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x5, &x6, (arg1[4]), ((arg2[2]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x7, &x8, (arg1[4]), ((arg2[1]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x9, &x10, (arg1[3]), ((arg2[4]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x11, &x12, (arg1[3]), ((arg2[3]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x13, &x14, (arg1[3]), ((arg2[2]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x15, &x16, (arg1[2]), ((arg2[4]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x17, &x18, (arg1[2]), ((arg2[3]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x19, &x20, (arg1[1]), ((arg2[4]) * UINT8_C(0x13))); + fiat_25519_mulx_u64(&x21, &x22, (arg1[4]), (arg2[0])); + fiat_25519_mulx_u64(&x23, &x24, (arg1[3]), (arg2[1])); + fiat_25519_mulx_u64(&x25, &x26, (arg1[3]), (arg2[0])); + fiat_25519_mulx_u64(&x27, &x28, (arg1[2]), (arg2[2])); + fiat_25519_mulx_u64(&x29, &x30, (arg1[2]), (arg2[1])); + fiat_25519_mulx_u64(&x31, &x32, (arg1[2]), (arg2[0])); + fiat_25519_mulx_u64(&x33, &x34, (arg1[1]), (arg2[3])); + fiat_25519_mulx_u64(&x35, &x36, (arg1[1]), (arg2[2])); + fiat_25519_mulx_u64(&x37, &x38, (arg1[1]), (arg2[1])); + fiat_25519_mulx_u64(&x39, &x40, (arg1[1]), (arg2[0])); + fiat_25519_mulx_u64(&x41, &x42, (arg1[0]), (arg2[4])); + fiat_25519_mulx_u64(&x43, &x44, (arg1[0]), (arg2[3])); + fiat_25519_mulx_u64(&x45, &x46, (arg1[0]), (arg2[2])); + fiat_25519_mulx_u64(&x47, &x48, (arg1[0]), (arg2[1])); + fiat_25519_mulx_u64(&x49, &x50, (arg1[0]), (arg2[0])); + fiat_25519_addcarryx_u64(&x51, &x52, 0x0, x13, x7); + fiat_25519_addcarryx_u64(&x53, &x54, x52, x14, x8); + fiat_25519_addcarryx_u64(&x55, &x56, 0x0, x17, x51); + fiat_25519_addcarryx_u64(&x57, &x58, x56, x18, x53); + fiat_25519_addcarryx_u64(&x59, &x60, 0x0, x19, x55); + fiat_25519_addcarryx_u64(&x61, &x62, x60, x20, x57); + fiat_25519_addcarryx_u64(&x63, &x64, 0x0, x49, x59); + fiat_25519_addcarryx_u64(&x65, &x66, x64, x50, x61); + x67 = ((x63 >> 51) | ((x65 << 13) & UINT64_C(0xffffffffffffffff))); + x68 = (x63 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x69, &x70, 0x0, x23, x21); + fiat_25519_addcarryx_u64(&x71, &x72, x70, x24, x22); + fiat_25519_addcarryx_u64(&x73, &x74, 0x0, x27, x69); + fiat_25519_addcarryx_u64(&x75, &x76, x74, x28, x71); + fiat_25519_addcarryx_u64(&x77, &x78, 0x0, x33, x73); + fiat_25519_addcarryx_u64(&x79, &x80, x78, x34, x75); + fiat_25519_addcarryx_u64(&x81, &x82, 0x0, x41, x77); + fiat_25519_addcarryx_u64(&x83, &x84, x82, x42, x79); + fiat_25519_addcarryx_u64(&x85, &x86, 0x0, x25, x1); + fiat_25519_addcarryx_u64(&x87, &x88, x86, x26, x2); + fiat_25519_addcarryx_u64(&x89, &x90, 0x0, x29, x85); + fiat_25519_addcarryx_u64(&x91, &x92, x90, x30, x87); + fiat_25519_addcarryx_u64(&x93, &x94, 0x0, x35, x89); + fiat_25519_addcarryx_u64(&x95, &x96, x94, x36, x91); + fiat_25519_addcarryx_u64(&x97, &x98, 0x0, x43, x93); + fiat_25519_addcarryx_u64(&x99, &x100, x98, x44, x95); + fiat_25519_addcarryx_u64(&x101, &x102, 0x0, x9, x3); + fiat_25519_addcarryx_u64(&x103, &x104, x102, x10, x4); + fiat_25519_addcarryx_u64(&x105, &x106, 0x0, x31, x101); + fiat_25519_addcarryx_u64(&x107, &x108, x106, x32, x103); + fiat_25519_addcarryx_u64(&x109, &x110, 0x0, x37, x105); + fiat_25519_addcarryx_u64(&x111, &x112, x110, x38, x107); + fiat_25519_addcarryx_u64(&x113, &x114, 0x0, x45, x109); + fiat_25519_addcarryx_u64(&x115, &x116, x114, x46, x111); + fiat_25519_addcarryx_u64(&x117, &x118, 0x0, x11, x5); + fiat_25519_addcarryx_u64(&x119, &x120, x118, x12, x6); + fiat_25519_addcarryx_u64(&x121, &x122, 0x0, x15, x117); + fiat_25519_addcarryx_u64(&x123, &x124, x122, x16, x119); + fiat_25519_addcarryx_u64(&x125, &x126, 0x0, x39, x121); + fiat_25519_addcarryx_u64(&x127, &x128, x126, x40, x123); + fiat_25519_addcarryx_u64(&x129, &x130, 0x0, x47, x125); + fiat_25519_addcarryx_u64(&x131, &x132, x130, x48, x127); + fiat_25519_addcarryx_u64(&x133, &x134, 0x0, x67, x129); + x135 = (x134 + x131); + x136 = ((x133 >> 51) | ((x135 << 13) & UINT64_C(0xffffffffffffffff))); + x137 = (x133 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x138, &x139, 0x0, x136, x113); + x140 = (x139 + x115); + x141 = ((x138 >> 51) | ((x140 << 13) & UINT64_C(0xffffffffffffffff))); + x142 = (x138 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x143, &x144, 0x0, x141, x97); + x145 = (x144 + x99); + x146 = ((x143 >> 51) | ((x145 << 13) & UINT64_C(0xffffffffffffffff))); + x147 = (x143 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x148, &x149, 0x0, x146, x81); + x150 = (x149 + x83); + x151 = ((x148 >> 51) | ((x150 << 13) & UINT64_C(0xffffffffffffffff))); + x152 = (x148 & UINT64_C(0x7ffffffffffff)); + x153 = (x151 * UINT8_C(0x13)); + x154 = (x68 + x153); + x155 = (x154 >> 51); + x156 = (x154 & UINT64_C(0x7ffffffffffff)); + x157 = (x155 + x137); + x158 = (fiat_25519_uint1)(x157 >> 51); + x159 = (x157 & UINT64_C(0x7ffffffffffff)); + x160 = (x158 + x142); + out1[0] = x156; + out1[1] = x159; + out1[2] = x160; + out1[3] = x147; + out1[4] = x152; +} + +/* + * The function fiat_25519_carry_square squares a field element and reduces the result. + * + * Postconditions: + * eval out1 mod m = (eval arg1 * eval arg1) mod m + * + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_carry_square(fiat_25519_tight_field_element out1, const fiat_25519_loose_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint64_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + fiat_25519_uint1 x40; + uint64_t x41; + fiat_25519_uint1 x42; + uint64_t x43; + fiat_25519_uint1 x44; + uint64_t x45; + fiat_25519_uint1 x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + fiat_25519_uint1 x50; + uint64_t x51; + fiat_25519_uint1 x52; + uint64_t x53; + fiat_25519_uint1 x54; + uint64_t x55; + fiat_25519_uint1 x56; + uint64_t x57; + fiat_25519_uint1 x58; + uint64_t x59; + fiat_25519_uint1 x60; + uint64_t x61; + fiat_25519_uint1 x62; + uint64_t x63; + fiat_25519_uint1 x64; + uint64_t x65; + fiat_25519_uint1 x66; + uint64_t x67; + fiat_25519_uint1 x68; + uint64_t x69; + fiat_25519_uint1 x70; + uint64_t x71; + fiat_25519_uint1 x72; + uint64_t x73; + fiat_25519_uint1 x74; + uint64_t x75; + fiat_25519_uint1 x76; + uint64_t x77; + fiat_25519_uint1 x78; + uint64_t x79; + fiat_25519_uint1 x80; + uint64_t x81; + fiat_25519_uint1 x82; + uint64_t x83; + uint64_t x84; + uint64_t x85; + uint64_t x86; + fiat_25519_uint1 x87; + uint64_t x88; + uint64_t x89; + uint64_t x90; + uint64_t x91; + fiat_25519_uint1 x92; + uint64_t x93; + uint64_t x94; + uint64_t x95; + uint64_t x96; + fiat_25519_uint1 x97; + uint64_t x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + fiat_25519_uint1 x106; + uint64_t x107; + uint64_t x108; + x1 = ((arg1[4]) * UINT8_C(0x13)); + x2 = (x1 * 0x2); + x3 = ((arg1[4]) * 0x2); + x4 = ((arg1[3]) * UINT8_C(0x13)); + x5 = (x4 * 0x2); + x6 = ((arg1[3]) * 0x2); + x7 = ((arg1[2]) * 0x2); + x8 = ((arg1[1]) * 0x2); + fiat_25519_mulx_u64(&x9, &x10, (arg1[4]), x1); + fiat_25519_mulx_u64(&x11, &x12, (arg1[3]), x2); + fiat_25519_mulx_u64(&x13, &x14, (arg1[3]), x4); + fiat_25519_mulx_u64(&x15, &x16, (arg1[2]), x2); + fiat_25519_mulx_u64(&x17, &x18, (arg1[2]), x5); + fiat_25519_mulx_u64(&x19, &x20, (arg1[2]), (arg1[2])); + fiat_25519_mulx_u64(&x21, &x22, (arg1[1]), x2); + fiat_25519_mulx_u64(&x23, &x24, (arg1[1]), x6); + fiat_25519_mulx_u64(&x25, &x26, (arg1[1]), x7); + fiat_25519_mulx_u64(&x27, &x28, (arg1[1]), (arg1[1])); + fiat_25519_mulx_u64(&x29, &x30, (arg1[0]), x3); + fiat_25519_mulx_u64(&x31, &x32, (arg1[0]), x6); + fiat_25519_mulx_u64(&x33, &x34, (arg1[0]), x7); + fiat_25519_mulx_u64(&x35, &x36, (arg1[0]), x8); + fiat_25519_mulx_u64(&x37, &x38, (arg1[0]), (arg1[0])); + fiat_25519_addcarryx_u64(&x39, &x40, 0x0, x21, x17); + fiat_25519_addcarryx_u64(&x41, &x42, x40, x22, x18); + fiat_25519_addcarryx_u64(&x43, &x44, 0x0, x37, x39); + fiat_25519_addcarryx_u64(&x45, &x46, x44, x38, x41); + x47 = ((x43 >> 51) | ((x45 << 13) & UINT64_C(0xffffffffffffffff))); + x48 = (x43 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x49, &x50, 0x0, x23, x19); + fiat_25519_addcarryx_u64(&x51, &x52, x50, x24, x20); + fiat_25519_addcarryx_u64(&x53, &x54, 0x0, x29, x49); + fiat_25519_addcarryx_u64(&x55, &x56, x54, x30, x51); + fiat_25519_addcarryx_u64(&x57, &x58, 0x0, x25, x9); + fiat_25519_addcarryx_u64(&x59, &x60, x58, x26, x10); + fiat_25519_addcarryx_u64(&x61, &x62, 0x0, x31, x57); + fiat_25519_addcarryx_u64(&x63, &x64, x62, x32, x59); + fiat_25519_addcarryx_u64(&x65, &x66, 0x0, x27, x11); + fiat_25519_addcarryx_u64(&x67, &x68, x66, x28, x12); + fiat_25519_addcarryx_u64(&x69, &x70, 0x0, x33, x65); + fiat_25519_addcarryx_u64(&x71, &x72, x70, x34, x67); + fiat_25519_addcarryx_u64(&x73, &x74, 0x0, x15, x13); + fiat_25519_addcarryx_u64(&x75, &x76, x74, x16, x14); + fiat_25519_addcarryx_u64(&x77, &x78, 0x0, x35, x73); + fiat_25519_addcarryx_u64(&x79, &x80, x78, x36, x75); + fiat_25519_addcarryx_u64(&x81, &x82, 0x0, x47, x77); + x83 = (x82 + x79); + x84 = ((x81 >> 51) | ((x83 << 13) & UINT64_C(0xffffffffffffffff))); + x85 = (x81 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x86, &x87, 0x0, x84, x69); + x88 = (x87 + x71); + x89 = ((x86 >> 51) | ((x88 << 13) & UINT64_C(0xffffffffffffffff))); + x90 = (x86 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x91, &x92, 0x0, x89, x61); + x93 = (x92 + x63); + x94 = ((x91 >> 51) | ((x93 << 13) & UINT64_C(0xffffffffffffffff))); + x95 = (x91 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x96, &x97, 0x0, x94, x53); + x98 = (x97 + x55); + x99 = ((x96 >> 51) | ((x98 << 13) & UINT64_C(0xffffffffffffffff))); + x100 = (x96 & UINT64_C(0x7ffffffffffff)); + x101 = (x99 * UINT8_C(0x13)); + x102 = (x48 + x101); + x103 = (x102 >> 51); + x104 = (x102 & UINT64_C(0x7ffffffffffff)); + x105 = (x103 + x85); + x106 = (fiat_25519_uint1)(x105 >> 51); + x107 = (x105 & UINT64_C(0x7ffffffffffff)); + x108 = (x106 + x90); + out1[0] = x104; + out1[1] = x107; + out1[2] = x108; + out1[3] = x95; + out1[4] = x100; +} + +/* + * The function fiat_25519_carry reduces a field element. + * + * Postconditions: + * eval out1 mod m = eval arg1 mod m + * + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_carry(fiat_25519_tight_field_element out1, const fiat_25519_loose_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + x1 = (arg1[0]); + x2 = ((x1 >> 51) + (arg1[1])); + x3 = ((x2 >> 51) + (arg1[2])); + x4 = ((x3 >> 51) + (arg1[3])); + x5 = ((x4 >> 51) + (arg1[4])); + x6 = ((x1 & UINT64_C(0x7ffffffffffff)) + ((x5 >> 51) * UINT8_C(0x13))); + x7 = ((fiat_25519_uint1)(x6 >> 51) + (x2 & UINT64_C(0x7ffffffffffff))); + x8 = (x6 & UINT64_C(0x7ffffffffffff)); + x9 = (x7 & UINT64_C(0x7ffffffffffff)); + x10 = ((fiat_25519_uint1)(x7 >> 51) + (x3 & UINT64_C(0x7ffffffffffff))); + x11 = (x4 & UINT64_C(0x7ffffffffffff)); + x12 = (x5 & UINT64_C(0x7ffffffffffff)); + out1[0] = x8; + out1[1] = x9; + out1[2] = x10; + out1[3] = x11; + out1[4] = x12; +} + +/* + * The function fiat_25519_add adds two field elements. + * + * Postconditions: + * eval out1 mod m = (eval arg1 + eval arg2) mod m + * + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_add(fiat_25519_loose_field_element out1, const fiat_25519_tight_field_element arg1, const fiat_25519_tight_field_element arg2) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + x1 = ((arg1[0]) + (arg2[0])); + x2 = ((arg1[1]) + (arg2[1])); + x3 = ((arg1[2]) + (arg2[2])); + x4 = ((arg1[3]) + (arg2[3])); + x5 = ((arg1[4]) + (arg2[4])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; +} + +/* + * The function fiat_25519_sub subtracts two field elements. + * + * Postconditions: + * eval out1 mod m = (eval arg1 - eval arg2) mod m + * + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_sub(fiat_25519_loose_field_element out1, const fiat_25519_tight_field_element arg1, const fiat_25519_tight_field_element arg2) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + x1 = ((UINT64_C(0xfffffffffffda) + (arg1[0])) - (arg2[0])); + x2 = ((UINT64_C(0xffffffffffffe) + (arg1[1])) - (arg2[1])); + x3 = ((UINT64_C(0xffffffffffffe) + (arg1[2])) - (arg2[2])); + x4 = ((UINT64_C(0xffffffffffffe) + (arg1[3])) - (arg2[3])); + x5 = ((UINT64_C(0xffffffffffffe) + (arg1[4])) - (arg2[4])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; +} + +/* + * The function fiat_25519_opp negates a field element. + * + * Postconditions: + * eval out1 mod m = -eval arg1 mod m + * + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_opp(fiat_25519_loose_field_element out1, const fiat_25519_tight_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + x1 = (UINT64_C(0xfffffffffffda) - (arg1[0])); + x2 = (UINT64_C(0xffffffffffffe) - (arg1[1])); + x3 = (UINT64_C(0xffffffffffffe) - (arg1[2])); + x4 = (UINT64_C(0xffffffffffffe) - (arg1[3])); + x5 = (UINT64_C(0xffffffffffffe) - (arg1[4])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; +} + +/* + * The function fiat_25519_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_selectznz(uint64_t out1[5], fiat_25519_uint1 arg1, const uint64_t arg2[5], const uint64_t arg3[5]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + fiat_25519_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_25519_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_25519_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_25519_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3])); + fiat_25519_cmovznz_u64(&x5, arg1, (arg2[4]), (arg3[4])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; +} + +/* + * The function fiat_25519_to_bytes serializes a field element to bytes in little-endian order. + * + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] + * + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x7f]] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_to_bytes(uint8_t out1[32], const fiat_25519_tight_field_element arg1) { + uint64_t x1; + fiat_25519_uint1 x2; + uint64_t x3; + fiat_25519_uint1 x4; + uint64_t x5; + fiat_25519_uint1 x6; + uint64_t x7; + fiat_25519_uint1 x8; + uint64_t x9; + fiat_25519_uint1 x10; + uint64_t x11; + uint64_t x12; + fiat_25519_uint1 x13; + uint64_t x14; + fiat_25519_uint1 x15; + uint64_t x16; + fiat_25519_uint1 x17; + uint64_t x18; + fiat_25519_uint1 x19; + uint64_t x20; + fiat_25519_uint1 x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint8_t x26; + uint64_t x27; + uint8_t x28; + uint64_t x29; + uint8_t x30; + uint64_t x31; + uint8_t x32; + uint64_t x33; + uint8_t x34; + uint64_t x35; + uint8_t x36; + uint8_t x37; + uint64_t x38; + uint8_t x39; + uint64_t x40; + uint8_t x41; + uint64_t x42; + uint8_t x43; + uint64_t x44; + uint8_t x45; + uint64_t x46; + uint8_t x47; + uint64_t x48; + uint8_t x49; + uint8_t x50; + uint64_t x51; + uint8_t x52; + uint64_t x53; + uint8_t x54; + uint64_t x55; + uint8_t x56; + uint64_t x57; + uint8_t x58; + uint64_t x59; + uint8_t x60; + uint64_t x61; + uint8_t x62; + uint64_t x63; + uint8_t x64; + fiat_25519_uint1 x65; + uint64_t x66; + uint8_t x67; + uint64_t x68; + uint8_t x69; + uint64_t x70; + uint8_t x71; + uint64_t x72; + uint8_t x73; + uint64_t x74; + uint8_t x75; + uint64_t x76; + uint8_t x77; + uint8_t x78; + uint64_t x79; + uint8_t x80; + uint64_t x81; + uint8_t x82; + uint64_t x83; + uint8_t x84; + uint64_t x85; + uint8_t x86; + uint64_t x87; + uint8_t x88; + uint64_t x89; + uint8_t x90; + uint8_t x91; + fiat_25519_subborrowx_u51(&x1, &x2, 0x0, (arg1[0]), UINT64_C(0x7ffffffffffed)); + fiat_25519_subborrowx_u51(&x3, &x4, x2, (arg1[1]), UINT64_C(0x7ffffffffffff)); + fiat_25519_subborrowx_u51(&x5, &x6, x4, (arg1[2]), UINT64_C(0x7ffffffffffff)); + fiat_25519_subborrowx_u51(&x7, &x8, x6, (arg1[3]), UINT64_C(0x7ffffffffffff)); + fiat_25519_subborrowx_u51(&x9, &x10, x8, (arg1[4]), UINT64_C(0x7ffffffffffff)); + fiat_25519_cmovznz_u64(&x11, x10, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_25519_addcarryx_u51(&x12, &x13, 0x0, x1, (x11 & UINT64_C(0x7ffffffffffed))); + fiat_25519_addcarryx_u51(&x14, &x15, x13, x3, (x11 & UINT64_C(0x7ffffffffffff))); + fiat_25519_addcarryx_u51(&x16, &x17, x15, x5, (x11 & UINT64_C(0x7ffffffffffff))); + fiat_25519_addcarryx_u51(&x18, &x19, x17, x7, (x11 & UINT64_C(0x7ffffffffffff))); + fiat_25519_addcarryx_u51(&x20, &x21, x19, x9, (x11 & UINT64_C(0x7ffffffffffff))); + x22 = (x20 << 4); + x23 = (x18 * (uint64_t)0x2); + x24 = (x16 << 6); + x25 = (x14 << 3); + x26 = (uint8_t)(x12 & UINT8_C(0xff)); + x27 = (x12 >> 8); + x28 = (uint8_t)(x27 & UINT8_C(0xff)); + x29 = (x27 >> 8); + x30 = (uint8_t)(x29 & UINT8_C(0xff)); + x31 = (x29 >> 8); + x32 = (uint8_t)(x31 & UINT8_C(0xff)); + x33 = (x31 >> 8); + x34 = (uint8_t)(x33 & UINT8_C(0xff)); + x35 = (x33 >> 8); + x36 = (uint8_t)(x35 & UINT8_C(0xff)); + x37 = (uint8_t)(x35 >> 8); + x38 = (x25 + (uint64_t)x37); + x39 = (uint8_t)(x38 & UINT8_C(0xff)); + x40 = (x38 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (x42 >> 8); + x45 = (uint8_t)(x44 & UINT8_C(0xff)); + x46 = (x44 >> 8); + x47 = (uint8_t)(x46 & UINT8_C(0xff)); + x48 = (x46 >> 8); + x49 = (uint8_t)(x48 & UINT8_C(0xff)); + x50 = (uint8_t)(x48 >> 8); + x51 = (x24 + (uint64_t)x50); + x52 = (uint8_t)(x51 & UINT8_C(0xff)); + x53 = (x51 >> 8); + x54 = (uint8_t)(x53 & UINT8_C(0xff)); + x55 = (x53 >> 8); + x56 = (uint8_t)(x55 & UINT8_C(0xff)); + x57 = (x55 >> 8); + x58 = (uint8_t)(x57 & UINT8_C(0xff)); + x59 = (x57 >> 8); + x60 = (uint8_t)(x59 & UINT8_C(0xff)); + x61 = (x59 >> 8); + x62 = (uint8_t)(x61 & UINT8_C(0xff)); + x63 = (x61 >> 8); + x64 = (uint8_t)(x63 & UINT8_C(0xff)); + x65 = (fiat_25519_uint1)(x63 >> 8); + x66 = (x23 + (uint64_t)x65); + x67 = (uint8_t)(x66 & UINT8_C(0xff)); + x68 = (x66 >> 8); + x69 = (uint8_t)(x68 & UINT8_C(0xff)); + x70 = (x68 >> 8); + x71 = (uint8_t)(x70 & UINT8_C(0xff)); + x72 = (x70 >> 8); + x73 = (uint8_t)(x72 & UINT8_C(0xff)); + x74 = (x72 >> 8); + x75 = (uint8_t)(x74 & UINT8_C(0xff)); + x76 = (x74 >> 8); + x77 = (uint8_t)(x76 & UINT8_C(0xff)); + x78 = (uint8_t)(x76 >> 8); + x79 = (x22 + (uint64_t)x78); + x80 = (uint8_t)(x79 & UINT8_C(0xff)); + x81 = (x79 >> 8); + x82 = (uint8_t)(x81 & UINT8_C(0xff)); + x83 = (x81 >> 8); + x84 = (uint8_t)(x83 & UINT8_C(0xff)); + x85 = (x83 >> 8); + x86 = (uint8_t)(x85 & UINT8_C(0xff)); + x87 = (x85 >> 8); + x88 = (uint8_t)(x87 & UINT8_C(0xff)); + x89 = (x87 >> 8); + x90 = (uint8_t)(x89 & UINT8_C(0xff)); + x91 = (uint8_t)(x89 >> 8); + out1[0] = x26; + out1[1] = x28; + out1[2] = x30; + out1[3] = x32; + out1[4] = x34; + out1[5] = x36; + out1[6] = x39; + out1[7] = x41; + out1[8] = x43; + out1[9] = x45; + out1[10] = x47; + out1[11] = x49; + out1[12] = x52; + out1[13] = x54; + out1[14] = x56; + out1[15] = x58; + out1[16] = x60; + out1[17] = x62; + out1[18] = x64; + out1[19] = x67; + out1[20] = x69; + out1[21] = x71; + out1[22] = x73; + out1[23] = x75; + out1[24] = x77; + out1[25] = x80; + out1[26] = x82; + out1[27] = x84; + out1[28] = x86; + out1[29] = x88; + out1[30] = x90; + out1[31] = x91; +} + +/* + * The function fiat_25519_from_bytes deserializes a field element from bytes in little-endian order. + * + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x7f]] + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_from_bytes(fiat_25519_tight_field_element out1, const uint8_t arg1[32]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint8_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint8_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint8_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + uint64_t x56; + uint8_t x57; + uint64_t x58; + uint64_t x59; + uint64_t x60; + uint64_t x61; + uint64_t x62; + uint64_t x63; + uint64_t x64; + uint8_t x65; + uint64_t x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + uint64_t x71; + x1 = ((uint64_t)(arg1[31]) << 44); + x2 = ((uint64_t)(arg1[30]) << 36); + x3 = ((uint64_t)(arg1[29]) << 28); + x4 = ((uint64_t)(arg1[28]) << 20); + x5 = ((uint64_t)(arg1[27]) << 12); + x6 = ((uint64_t)(arg1[26]) << 4); + x7 = ((uint64_t)(arg1[25]) << 47); + x8 = ((uint64_t)(arg1[24]) << 39); + x9 = ((uint64_t)(arg1[23]) << 31); + x10 = ((uint64_t)(arg1[22]) << 23); + x11 = ((uint64_t)(arg1[21]) << 15); + x12 = ((uint64_t)(arg1[20]) << 7); + x13 = ((uint64_t)(arg1[19]) << 50); + x14 = ((uint64_t)(arg1[18]) << 42); + x15 = ((uint64_t)(arg1[17]) << 34); + x16 = ((uint64_t)(arg1[16]) << 26); + x17 = ((uint64_t)(arg1[15]) << 18); + x18 = ((uint64_t)(arg1[14]) << 10); + x19 = ((uint64_t)(arg1[13]) << 2); + x20 = ((uint64_t)(arg1[12]) << 45); + x21 = ((uint64_t)(arg1[11]) << 37); + x22 = ((uint64_t)(arg1[10]) << 29); + x23 = ((uint64_t)(arg1[9]) << 21); + x24 = ((uint64_t)(arg1[8]) << 13); + x25 = ((uint64_t)(arg1[7]) << 5); + x26 = ((uint64_t)(arg1[6]) << 48); + x27 = ((uint64_t)(arg1[5]) << 40); + x28 = ((uint64_t)(arg1[4]) << 32); + x29 = ((uint64_t)(arg1[3]) << 24); + x30 = ((uint64_t)(arg1[2]) << 16); + x31 = ((uint64_t)(arg1[1]) << 8); + x32 = (arg1[0]); + x33 = (x31 + (uint64_t)x32); + x34 = (x30 + x33); + x35 = (x29 + x34); + x36 = (x28 + x35); + x37 = (x27 + x36); + x38 = (x26 + x37); + x39 = (x38 & UINT64_C(0x7ffffffffffff)); + x40 = (uint8_t)(x38 >> 51); + x41 = (x25 + (uint64_t)x40); + x42 = (x24 + x41); + x43 = (x23 + x42); + x44 = (x22 + x43); + x45 = (x21 + x44); + x46 = (x20 + x45); + x47 = (x46 & UINT64_C(0x7ffffffffffff)); + x48 = (uint8_t)(x46 >> 51); + x49 = (x19 + (uint64_t)x48); + x50 = (x18 + x49); + x51 = (x17 + x50); + x52 = (x16 + x51); + x53 = (x15 + x52); + x54 = (x14 + x53); + x55 = (x13 + x54); + x56 = (x55 & UINT64_C(0x7ffffffffffff)); + x57 = (uint8_t)(x55 >> 51); + x58 = (x12 + (uint64_t)x57); + x59 = (x11 + x58); + x60 = (x10 + x59); + x61 = (x9 + x60); + x62 = (x8 + x61); + x63 = (x7 + x62); + x64 = (x63 & UINT64_C(0x7ffffffffffff)); + x65 = (uint8_t)(x63 >> 51); + x66 = (x6 + (uint64_t)x65); + x67 = (x5 + x66); + x68 = (x4 + x67); + x69 = (x3 + x68); + x70 = (x2 + x69); + x71 = (x1 + x70); + out1[0] = x39; + out1[1] = x47; + out1[2] = x56; + out1[3] = x64; + out1[4] = x71; +} + +/* + * The function fiat_25519_relax is the identity function converting from tight field elements to loose field elements. + * + * Postconditions: + * out1 = arg1 + * + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_relax(fiat_25519_loose_field_element out1, const fiat_25519_tight_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + x1 = (arg1[0]); + x2 = (arg1[1]); + x3 = (arg1[2]); + x4 = (arg1[3]); + x5 = (arg1[4]); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; + out1[4] = x5; +} + +/* + * The function fiat_25519_carry_scmul_121666 multiplies a field element by 121666 and reduces the result. + * + * Postconditions: + * eval out1 mod m = (121666 * eval arg1) mod m + * + */ +static FIAT_25519_FIAT_INLINE void fiat_25519_carry_scmul_121666(fiat_25519_tight_field_element out1, const fiat_25519_loose_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_25519_uint1 x14; + uint64_t x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + fiat_25519_uint1 x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + fiat_25519_uint1 x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + fiat_25519_uint1 x29; + uint64_t x30; + uint64_t x31; + uint64_t x32; + uint64_t x33; + uint64_t x34; + fiat_25519_uint1 x35; + uint64_t x36; + uint64_t x37; + fiat_25519_uint1 x38; + uint64_t x39; + uint64_t x40; + fiat_25519_mulx_u64(&x1, &x2, UINT32_C(0x1db42), (arg1[4])); + fiat_25519_mulx_u64(&x3, &x4, UINT32_C(0x1db42), (arg1[3])); + fiat_25519_mulx_u64(&x5, &x6, UINT32_C(0x1db42), (arg1[2])); + fiat_25519_mulx_u64(&x7, &x8, UINT32_C(0x1db42), (arg1[1])); + fiat_25519_mulx_u64(&x9, &x10, UINT32_C(0x1db42), (arg1[0])); + x11 = ((x9 >> 51) | ((x10 << 13) & UINT64_C(0xffffffffffffffff))); + x12 = (x9 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x13, &x14, 0x0, x11, x7); + x15 = (x14 + x8); + x16 = ((x13 >> 51) | ((x15 << 13) & UINT64_C(0xffffffffffffffff))); + x17 = (x13 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x18, &x19, 0x0, x16, x5); + x20 = (x19 + x6); + x21 = ((x18 >> 51) | ((x20 << 13) & UINT64_C(0xffffffffffffffff))); + x22 = (x18 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x23, &x24, 0x0, x21, x3); + x25 = (x24 + x4); + x26 = ((x23 >> 51) | ((x25 << 13) & UINT64_C(0xffffffffffffffff))); + x27 = (x23 & UINT64_C(0x7ffffffffffff)); + fiat_25519_addcarryx_u64(&x28, &x29, 0x0, x26, x1); + x30 = (x29 + x2); + x31 = ((x28 >> 51) | ((x30 << 13) & UINT64_C(0xffffffffffffffff))); + x32 = (x28 & UINT64_C(0x7ffffffffffff)); + x33 = (x31 * UINT8_C(0x13)); + x34 = (x12 + x33); + x35 = (fiat_25519_uint1)(x34 >> 51); + x36 = (x34 & UINT64_C(0x7ffffffffffff)); + x37 = (x35 + x17); + x38 = (fiat_25519_uint1)(x37 >> 51); + x39 = (x37 & UINT64_C(0x7ffffffffffff)); + x40 = (x38 + x22); + out1[0] = x36; + out1[1] = x39; + out1[2] = x40; + out1[3] = x27; + out1[4] = x32; +} diff --git a/third_party/fiat/p256_64_msvc.h b/third_party/fiat/p256_64_msvc.h new file mode 100644 index 0000000000..8b65a37342 --- /dev/null +++ b/third_party/fiat/p256_64_msvc.h @@ -0,0 +1,2002 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier --no-wide-int p256 64 '2^256 - 2^224 + 2^192 + 2^96 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: p256 */ +/* machine_wordsize = 64 (from "64") */ +/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes, one, msat, divstep, divstep_precomp */ +/* m = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff (from "2^256 - 2^224 + 2^192 + 2^96 - 1") */ +/* */ +/* NOTE: In addition to the bounds specified above each function, all */ +/* functions synthesized for this Montgomery arithmetic require the */ +/* input to be strictly less than the prime modulus (m), and also */ +/* require the input to be in the unique saturated representation. */ +/* All functions also ensure that these two properties are true of */ +/* return values. */ +/* */ +/* Computed values: */ +/* eval z = z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) */ +/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) */ +/* twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) in */ +/* if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256 */ + +#include +#include +#if defined(_M_X64) +#include +#endif + +typedef unsigned char fiat_p256_uint1; +typedef signed char fiat_p256_int1; + +#define FIAT_P256_FIAT_INLINE inline + +/* The type fiat_p256_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_p256_montgomery_domain_field_element[4]; + +/* The type fiat_p256_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/* Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +typedef uint64_t fiat_p256_non_montgomery_domain_field_element[4]; + +#if (-1 & 3) != 3 +#error "This code only works on a two's complement system" +#endif + +#define fiat_p256_value_barrier_u64(x) (x) + + +/* + * The function fiat_p256_addcarryx_u64 is an addition with carry. + * + * Postconditions: + * out1 = (arg1 + arg2 + arg3) mod 2^64 + * out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_addcarryx_u64(uint64_t* out1, fiat_p256_uint1* out2, fiat_p256_uint1 arg1, uint64_t arg2, uint64_t arg3) { +#if defined(_M_X64) + *out2 = _addcarry_u64(arg1, arg2, arg3, out1); +#else + arg2 += arg1; + arg1 = arg2 < arg1; + arg3 += arg2; + arg1 += arg3 < arg2; + *out1 = arg3; + *out2 = arg1; +#endif +} + +/* + * The function fiat_p256_subborrowx_u64 is a subtraction with borrow. + * + * Postconditions: + * out1 = (-arg1 + arg2 + -arg3) mod 2^64 + * out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0x1] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_subborrowx_u64(uint64_t* out1, fiat_p256_uint1* out2, fiat_p256_uint1 arg1, uint64_t arg2, uint64_t arg3) { +#if defined(_M_X64) + *out2 = _subborrow_u64(arg1, arg2, arg3, out1); // NOTE: edited after generation +#else + *out1 = arg2 - arg3 - arg1; + *out2 = (arg2 < arg3) | ((arg2 == arg3) & arg1); +#endif +} + +/* + * The function fiat_p256_mulx_u64 is a multiplication, returning the full double-width result. + * + * Postconditions: + * out1 = (arg1 * arg2) mod 2^64 + * out2 = ⌊arg1 * arg2 / 2^64⌋ + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) { +// NOTE: edited after generation +#if defined(_M_X64) + *out1 = _umul128(arg1, arg2, out2); +#elif defined(_M_ARM64) + *out1 = arg1 * arg2; + *out2 = __umulh(arg1, arg2); +#else +#error "This file is intended for MSVC on X64 or ARM64" +#endif +} + +/* + * The function fiat_p256_cmovznz_u64 is a single-word conditional move. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [0x0 ~> 0xffffffffffffffff] + * arg3: [0x0 ~> 0xffffffffffffffff] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_cmovznz_u64(uint64_t* out1, fiat_p256_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_p256_uint1 x1; + uint64_t x2; + uint64_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_p256_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff)); + x3 = ((fiat_p256_value_barrier_u64(x2) & arg3) | (fiat_p256_value_barrier_u64((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_p256_mul multiplies two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_mul(fiat_p256_montgomery_domain_field_element out1, const fiat_p256_montgomery_domain_field_element arg1, const fiat_p256_montgomery_domain_field_element arg2) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_p256_uint1 x14; + uint64_t x15; + fiat_p256_uint1 x16; + uint64_t x17; + fiat_p256_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + fiat_p256_uint1 x27; + uint64_t x28; + uint64_t x29; + fiat_p256_uint1 x30; + uint64_t x31; + fiat_p256_uint1 x32; + uint64_t x33; + fiat_p256_uint1 x34; + uint64_t x35; + fiat_p256_uint1 x36; + uint64_t x37; + fiat_p256_uint1 x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + fiat_p256_uint1 x48; + uint64_t x49; + fiat_p256_uint1 x50; + uint64_t x51; + fiat_p256_uint1 x52; + uint64_t x53; + uint64_t x54; + fiat_p256_uint1 x55; + uint64_t x56; + fiat_p256_uint1 x57; + uint64_t x58; + fiat_p256_uint1 x59; + uint64_t x60; + fiat_p256_uint1 x61; + uint64_t x62; + fiat_p256_uint1 x63; + uint64_t x64; + uint64_t x65; + uint64_t x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + fiat_p256_uint1 x71; + uint64_t x72; + uint64_t x73; + fiat_p256_uint1 x74; + uint64_t x75; + fiat_p256_uint1 x76; + uint64_t x77; + fiat_p256_uint1 x78; + uint64_t x79; + fiat_p256_uint1 x80; + uint64_t x81; + fiat_p256_uint1 x82; + uint64_t x83; + uint64_t x84; + uint64_t x85; + uint64_t x86; + uint64_t x87; + uint64_t x88; + uint64_t x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + fiat_p256_uint1 x93; + uint64_t x94; + fiat_p256_uint1 x95; + uint64_t x96; + fiat_p256_uint1 x97; + uint64_t x98; + uint64_t x99; + fiat_p256_uint1 x100; + uint64_t x101; + fiat_p256_uint1 x102; + uint64_t x103; + fiat_p256_uint1 x104; + uint64_t x105; + fiat_p256_uint1 x106; + uint64_t x107; + fiat_p256_uint1 x108; + uint64_t x109; + uint64_t x110; + uint64_t x111; + uint64_t x112; + uint64_t x113; + uint64_t x114; + uint64_t x115; + fiat_p256_uint1 x116; + uint64_t x117; + uint64_t x118; + fiat_p256_uint1 x119; + uint64_t x120; + fiat_p256_uint1 x121; + uint64_t x122; + fiat_p256_uint1 x123; + uint64_t x124; + fiat_p256_uint1 x125; + uint64_t x126; + fiat_p256_uint1 x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + uint64_t x131; + uint64_t x132; + uint64_t x133; + uint64_t x134; + uint64_t x135; + uint64_t x136; + uint64_t x137; + fiat_p256_uint1 x138; + uint64_t x139; + fiat_p256_uint1 x140; + uint64_t x141; + fiat_p256_uint1 x142; + uint64_t x143; + uint64_t x144; + fiat_p256_uint1 x145; + uint64_t x146; + fiat_p256_uint1 x147; + uint64_t x148; + fiat_p256_uint1 x149; + uint64_t x150; + fiat_p256_uint1 x151; + uint64_t x152; + fiat_p256_uint1 x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + uint64_t x159; + uint64_t x160; + fiat_p256_uint1 x161; + uint64_t x162; + uint64_t x163; + fiat_p256_uint1 x164; + uint64_t x165; + fiat_p256_uint1 x166; + uint64_t x167; + fiat_p256_uint1 x168; + uint64_t x169; + fiat_p256_uint1 x170; + uint64_t x171; + fiat_p256_uint1 x172; + uint64_t x173; + uint64_t x174; + fiat_p256_uint1 x175; + uint64_t x176; + fiat_p256_uint1 x177; + uint64_t x178; + fiat_p256_uint1 x179; + uint64_t x180; + fiat_p256_uint1 x181; + uint64_t x182; + fiat_p256_uint1 x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_p256_mulx_u64(&x5, &x6, x4, (arg2[3])); + fiat_p256_mulx_u64(&x7, &x8, x4, (arg2[2])); + fiat_p256_mulx_u64(&x9, &x10, x4, (arg2[1])); + fiat_p256_mulx_u64(&x11, &x12, x4, (arg2[0])); + fiat_p256_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_p256_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_p256_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_p256_mulx_u64(&x20, &x21, x11, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x22, &x23, x11, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x24, &x25, x11, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x26, &x27, 0x0, x25, x22); + x28 = (x27 + x23); + fiat_p256_addcarryx_u64(&x29, &x30, 0x0, x11, x24); + fiat_p256_addcarryx_u64(&x31, &x32, x30, x13, x26); + fiat_p256_addcarryx_u64(&x33, &x34, x32, x15, x28); + fiat_p256_addcarryx_u64(&x35, &x36, x34, x17, x20); + fiat_p256_addcarryx_u64(&x37, &x38, x36, x19, x21); + fiat_p256_mulx_u64(&x39, &x40, x1, (arg2[3])); + fiat_p256_mulx_u64(&x41, &x42, x1, (arg2[2])); + fiat_p256_mulx_u64(&x43, &x44, x1, (arg2[1])); + fiat_p256_mulx_u64(&x45, &x46, x1, (arg2[0])); + fiat_p256_addcarryx_u64(&x47, &x48, 0x0, x46, x43); + fiat_p256_addcarryx_u64(&x49, &x50, x48, x44, x41); + fiat_p256_addcarryx_u64(&x51, &x52, x50, x42, x39); + x53 = (x52 + x40); + fiat_p256_addcarryx_u64(&x54, &x55, 0x0, x31, x45); + fiat_p256_addcarryx_u64(&x56, &x57, x55, x33, x47); + fiat_p256_addcarryx_u64(&x58, &x59, x57, x35, x49); + fiat_p256_addcarryx_u64(&x60, &x61, x59, x37, x51); + fiat_p256_addcarryx_u64(&x62, &x63, x61, x38, x53); + fiat_p256_mulx_u64(&x64, &x65, x54, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x66, &x67, x54, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x68, &x69, x54, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x70, &x71, 0x0, x69, x66); + x72 = (x71 + x67); + fiat_p256_addcarryx_u64(&x73, &x74, 0x0, x54, x68); + fiat_p256_addcarryx_u64(&x75, &x76, x74, x56, x70); + fiat_p256_addcarryx_u64(&x77, &x78, x76, x58, x72); + fiat_p256_addcarryx_u64(&x79, &x80, x78, x60, x64); + fiat_p256_addcarryx_u64(&x81, &x82, x80, x62, x65); + x83 = ((uint64_t)x82 + x63); + fiat_p256_mulx_u64(&x84, &x85, x2, (arg2[3])); + fiat_p256_mulx_u64(&x86, &x87, x2, (arg2[2])); + fiat_p256_mulx_u64(&x88, &x89, x2, (arg2[1])); + fiat_p256_mulx_u64(&x90, &x91, x2, (arg2[0])); + fiat_p256_addcarryx_u64(&x92, &x93, 0x0, x91, x88); + fiat_p256_addcarryx_u64(&x94, &x95, x93, x89, x86); + fiat_p256_addcarryx_u64(&x96, &x97, x95, x87, x84); + x98 = (x97 + x85); + fiat_p256_addcarryx_u64(&x99, &x100, 0x0, x75, x90); + fiat_p256_addcarryx_u64(&x101, &x102, x100, x77, x92); + fiat_p256_addcarryx_u64(&x103, &x104, x102, x79, x94); + fiat_p256_addcarryx_u64(&x105, &x106, x104, x81, x96); + fiat_p256_addcarryx_u64(&x107, &x108, x106, x83, x98); + fiat_p256_mulx_u64(&x109, &x110, x99, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x111, &x112, x99, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x113, &x114, x99, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x115, &x116, 0x0, x114, x111); + x117 = (x116 + x112); + fiat_p256_addcarryx_u64(&x118, &x119, 0x0, x99, x113); + fiat_p256_addcarryx_u64(&x120, &x121, x119, x101, x115); + fiat_p256_addcarryx_u64(&x122, &x123, x121, x103, x117); + fiat_p256_addcarryx_u64(&x124, &x125, x123, x105, x109); + fiat_p256_addcarryx_u64(&x126, &x127, x125, x107, x110); + x128 = ((uint64_t)x127 + x108); + fiat_p256_mulx_u64(&x129, &x130, x3, (arg2[3])); + fiat_p256_mulx_u64(&x131, &x132, x3, (arg2[2])); + fiat_p256_mulx_u64(&x133, &x134, x3, (arg2[1])); + fiat_p256_mulx_u64(&x135, &x136, x3, (arg2[0])); + fiat_p256_addcarryx_u64(&x137, &x138, 0x0, x136, x133); + fiat_p256_addcarryx_u64(&x139, &x140, x138, x134, x131); + fiat_p256_addcarryx_u64(&x141, &x142, x140, x132, x129); + x143 = (x142 + x130); + fiat_p256_addcarryx_u64(&x144, &x145, 0x0, x120, x135); + fiat_p256_addcarryx_u64(&x146, &x147, x145, x122, x137); + fiat_p256_addcarryx_u64(&x148, &x149, x147, x124, x139); + fiat_p256_addcarryx_u64(&x150, &x151, x149, x126, x141); + fiat_p256_addcarryx_u64(&x152, &x153, x151, x128, x143); + fiat_p256_mulx_u64(&x154, &x155, x144, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x156, &x157, x144, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x158, &x159, x144, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x160, &x161, 0x0, x159, x156); + x162 = (x161 + x157); + fiat_p256_addcarryx_u64(&x163, &x164, 0x0, x144, x158); + fiat_p256_addcarryx_u64(&x165, &x166, x164, x146, x160); + fiat_p256_addcarryx_u64(&x167, &x168, x166, x148, x162); + fiat_p256_addcarryx_u64(&x169, &x170, x168, x150, x154); + fiat_p256_addcarryx_u64(&x171, &x172, x170, x152, x155); + x173 = ((uint64_t)x172 + x153); + fiat_p256_subborrowx_u64(&x174, &x175, 0x0, x165, UINT64_C(0xffffffffffffffff)); + fiat_p256_subborrowx_u64(&x176, &x177, x175, x167, UINT32_C(0xffffffff)); + fiat_p256_subborrowx_u64(&x178, &x179, x177, x169, 0x0); + fiat_p256_subborrowx_u64(&x180, &x181, x179, x171, UINT64_C(0xffffffff00000001)); + fiat_p256_subborrowx_u64(&x182, &x183, x181, x173, 0x0); + fiat_p256_cmovznz_u64(&x184, x183, x174, x165); + fiat_p256_cmovznz_u64(&x185, x183, x176, x167); + fiat_p256_cmovznz_u64(&x186, x183, x178, x169); + fiat_p256_cmovznz_u64(&x187, x183, x180, x171); + out1[0] = x184; + out1[1] = x185; + out1[2] = x186; + out1[3] = x187; +} + +/* + * The function fiat_p256_square squares a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_square(fiat_p256_montgomery_domain_field_element out1, const fiat_p256_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_p256_uint1 x14; + uint64_t x15; + fiat_p256_uint1 x16; + uint64_t x17; + fiat_p256_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + fiat_p256_uint1 x27; + uint64_t x28; + uint64_t x29; + fiat_p256_uint1 x30; + uint64_t x31; + fiat_p256_uint1 x32; + uint64_t x33; + fiat_p256_uint1 x34; + uint64_t x35; + fiat_p256_uint1 x36; + uint64_t x37; + fiat_p256_uint1 x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + fiat_p256_uint1 x48; + uint64_t x49; + fiat_p256_uint1 x50; + uint64_t x51; + fiat_p256_uint1 x52; + uint64_t x53; + uint64_t x54; + fiat_p256_uint1 x55; + uint64_t x56; + fiat_p256_uint1 x57; + uint64_t x58; + fiat_p256_uint1 x59; + uint64_t x60; + fiat_p256_uint1 x61; + uint64_t x62; + fiat_p256_uint1 x63; + uint64_t x64; + uint64_t x65; + uint64_t x66; + uint64_t x67; + uint64_t x68; + uint64_t x69; + uint64_t x70; + fiat_p256_uint1 x71; + uint64_t x72; + uint64_t x73; + fiat_p256_uint1 x74; + uint64_t x75; + fiat_p256_uint1 x76; + uint64_t x77; + fiat_p256_uint1 x78; + uint64_t x79; + fiat_p256_uint1 x80; + uint64_t x81; + fiat_p256_uint1 x82; + uint64_t x83; + uint64_t x84; + uint64_t x85; + uint64_t x86; + uint64_t x87; + uint64_t x88; + uint64_t x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + fiat_p256_uint1 x93; + uint64_t x94; + fiat_p256_uint1 x95; + uint64_t x96; + fiat_p256_uint1 x97; + uint64_t x98; + uint64_t x99; + fiat_p256_uint1 x100; + uint64_t x101; + fiat_p256_uint1 x102; + uint64_t x103; + fiat_p256_uint1 x104; + uint64_t x105; + fiat_p256_uint1 x106; + uint64_t x107; + fiat_p256_uint1 x108; + uint64_t x109; + uint64_t x110; + uint64_t x111; + uint64_t x112; + uint64_t x113; + uint64_t x114; + uint64_t x115; + fiat_p256_uint1 x116; + uint64_t x117; + uint64_t x118; + fiat_p256_uint1 x119; + uint64_t x120; + fiat_p256_uint1 x121; + uint64_t x122; + fiat_p256_uint1 x123; + uint64_t x124; + fiat_p256_uint1 x125; + uint64_t x126; + fiat_p256_uint1 x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + uint64_t x131; + uint64_t x132; + uint64_t x133; + uint64_t x134; + uint64_t x135; + uint64_t x136; + uint64_t x137; + fiat_p256_uint1 x138; + uint64_t x139; + fiat_p256_uint1 x140; + uint64_t x141; + fiat_p256_uint1 x142; + uint64_t x143; + uint64_t x144; + fiat_p256_uint1 x145; + uint64_t x146; + fiat_p256_uint1 x147; + uint64_t x148; + fiat_p256_uint1 x149; + uint64_t x150; + fiat_p256_uint1 x151; + uint64_t x152; + fiat_p256_uint1 x153; + uint64_t x154; + uint64_t x155; + uint64_t x156; + uint64_t x157; + uint64_t x158; + uint64_t x159; + uint64_t x160; + fiat_p256_uint1 x161; + uint64_t x162; + uint64_t x163; + fiat_p256_uint1 x164; + uint64_t x165; + fiat_p256_uint1 x166; + uint64_t x167; + fiat_p256_uint1 x168; + uint64_t x169; + fiat_p256_uint1 x170; + uint64_t x171; + fiat_p256_uint1 x172; + uint64_t x173; + uint64_t x174; + fiat_p256_uint1 x175; + uint64_t x176; + fiat_p256_uint1 x177; + uint64_t x178; + fiat_p256_uint1 x179; + uint64_t x180; + fiat_p256_uint1 x181; + uint64_t x182; + fiat_p256_uint1 x183; + uint64_t x184; + uint64_t x185; + uint64_t x186; + uint64_t x187; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_p256_mulx_u64(&x5, &x6, x4, (arg1[3])); + fiat_p256_mulx_u64(&x7, &x8, x4, (arg1[2])); + fiat_p256_mulx_u64(&x9, &x10, x4, (arg1[1])); + fiat_p256_mulx_u64(&x11, &x12, x4, (arg1[0])); + fiat_p256_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_p256_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_p256_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_p256_mulx_u64(&x20, &x21, x11, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x22, &x23, x11, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x24, &x25, x11, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x26, &x27, 0x0, x25, x22); + x28 = (x27 + x23); + fiat_p256_addcarryx_u64(&x29, &x30, 0x0, x11, x24); + fiat_p256_addcarryx_u64(&x31, &x32, x30, x13, x26); + fiat_p256_addcarryx_u64(&x33, &x34, x32, x15, x28); + fiat_p256_addcarryx_u64(&x35, &x36, x34, x17, x20); + fiat_p256_addcarryx_u64(&x37, &x38, x36, x19, x21); + fiat_p256_mulx_u64(&x39, &x40, x1, (arg1[3])); + fiat_p256_mulx_u64(&x41, &x42, x1, (arg1[2])); + fiat_p256_mulx_u64(&x43, &x44, x1, (arg1[1])); + fiat_p256_mulx_u64(&x45, &x46, x1, (arg1[0])); + fiat_p256_addcarryx_u64(&x47, &x48, 0x0, x46, x43); + fiat_p256_addcarryx_u64(&x49, &x50, x48, x44, x41); + fiat_p256_addcarryx_u64(&x51, &x52, x50, x42, x39); + x53 = (x52 + x40); + fiat_p256_addcarryx_u64(&x54, &x55, 0x0, x31, x45); + fiat_p256_addcarryx_u64(&x56, &x57, x55, x33, x47); + fiat_p256_addcarryx_u64(&x58, &x59, x57, x35, x49); + fiat_p256_addcarryx_u64(&x60, &x61, x59, x37, x51); + fiat_p256_addcarryx_u64(&x62, &x63, x61, x38, x53); + fiat_p256_mulx_u64(&x64, &x65, x54, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x66, &x67, x54, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x68, &x69, x54, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x70, &x71, 0x0, x69, x66); + x72 = (x71 + x67); + fiat_p256_addcarryx_u64(&x73, &x74, 0x0, x54, x68); + fiat_p256_addcarryx_u64(&x75, &x76, x74, x56, x70); + fiat_p256_addcarryx_u64(&x77, &x78, x76, x58, x72); + fiat_p256_addcarryx_u64(&x79, &x80, x78, x60, x64); + fiat_p256_addcarryx_u64(&x81, &x82, x80, x62, x65); + x83 = ((uint64_t)x82 + x63); + fiat_p256_mulx_u64(&x84, &x85, x2, (arg1[3])); + fiat_p256_mulx_u64(&x86, &x87, x2, (arg1[2])); + fiat_p256_mulx_u64(&x88, &x89, x2, (arg1[1])); + fiat_p256_mulx_u64(&x90, &x91, x2, (arg1[0])); + fiat_p256_addcarryx_u64(&x92, &x93, 0x0, x91, x88); + fiat_p256_addcarryx_u64(&x94, &x95, x93, x89, x86); + fiat_p256_addcarryx_u64(&x96, &x97, x95, x87, x84); + x98 = (x97 + x85); + fiat_p256_addcarryx_u64(&x99, &x100, 0x0, x75, x90); + fiat_p256_addcarryx_u64(&x101, &x102, x100, x77, x92); + fiat_p256_addcarryx_u64(&x103, &x104, x102, x79, x94); + fiat_p256_addcarryx_u64(&x105, &x106, x104, x81, x96); + fiat_p256_addcarryx_u64(&x107, &x108, x106, x83, x98); + fiat_p256_mulx_u64(&x109, &x110, x99, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x111, &x112, x99, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x113, &x114, x99, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x115, &x116, 0x0, x114, x111); + x117 = (x116 + x112); + fiat_p256_addcarryx_u64(&x118, &x119, 0x0, x99, x113); + fiat_p256_addcarryx_u64(&x120, &x121, x119, x101, x115); + fiat_p256_addcarryx_u64(&x122, &x123, x121, x103, x117); + fiat_p256_addcarryx_u64(&x124, &x125, x123, x105, x109); + fiat_p256_addcarryx_u64(&x126, &x127, x125, x107, x110); + x128 = ((uint64_t)x127 + x108); + fiat_p256_mulx_u64(&x129, &x130, x3, (arg1[3])); + fiat_p256_mulx_u64(&x131, &x132, x3, (arg1[2])); + fiat_p256_mulx_u64(&x133, &x134, x3, (arg1[1])); + fiat_p256_mulx_u64(&x135, &x136, x3, (arg1[0])); + fiat_p256_addcarryx_u64(&x137, &x138, 0x0, x136, x133); + fiat_p256_addcarryx_u64(&x139, &x140, x138, x134, x131); + fiat_p256_addcarryx_u64(&x141, &x142, x140, x132, x129); + x143 = (x142 + x130); + fiat_p256_addcarryx_u64(&x144, &x145, 0x0, x120, x135); + fiat_p256_addcarryx_u64(&x146, &x147, x145, x122, x137); + fiat_p256_addcarryx_u64(&x148, &x149, x147, x124, x139); + fiat_p256_addcarryx_u64(&x150, &x151, x149, x126, x141); + fiat_p256_addcarryx_u64(&x152, &x153, x151, x128, x143); + fiat_p256_mulx_u64(&x154, &x155, x144, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x156, &x157, x144, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x158, &x159, x144, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x160, &x161, 0x0, x159, x156); + x162 = (x161 + x157); + fiat_p256_addcarryx_u64(&x163, &x164, 0x0, x144, x158); + fiat_p256_addcarryx_u64(&x165, &x166, x164, x146, x160); + fiat_p256_addcarryx_u64(&x167, &x168, x166, x148, x162); + fiat_p256_addcarryx_u64(&x169, &x170, x168, x150, x154); + fiat_p256_addcarryx_u64(&x171, &x172, x170, x152, x155); + x173 = ((uint64_t)x172 + x153); + fiat_p256_subborrowx_u64(&x174, &x175, 0x0, x165, UINT64_C(0xffffffffffffffff)); + fiat_p256_subborrowx_u64(&x176, &x177, x175, x167, UINT32_C(0xffffffff)); + fiat_p256_subborrowx_u64(&x178, &x179, x177, x169, 0x0); + fiat_p256_subborrowx_u64(&x180, &x181, x179, x171, UINT64_C(0xffffffff00000001)); + fiat_p256_subborrowx_u64(&x182, &x183, x181, x173, 0x0); + fiat_p256_cmovznz_u64(&x184, x183, x174, x165); + fiat_p256_cmovznz_u64(&x185, x183, x176, x167); + fiat_p256_cmovznz_u64(&x186, x183, x178, x169); + fiat_p256_cmovznz_u64(&x187, x183, x180, x171); + out1[0] = x184; + out1[1] = x185; + out1[2] = x186; + out1[3] = x187; +} + +/* + * The function fiat_p256_add adds two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_add(fiat_p256_montgomery_domain_field_element out1, const fiat_p256_montgomery_domain_field_element arg1, const fiat_p256_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_p256_uint1 x2; + uint64_t x3; + fiat_p256_uint1 x4; + uint64_t x5; + fiat_p256_uint1 x6; + uint64_t x7; + fiat_p256_uint1 x8; + uint64_t x9; + fiat_p256_uint1 x10; + uint64_t x11; + fiat_p256_uint1 x12; + uint64_t x13; + fiat_p256_uint1 x14; + uint64_t x15; + fiat_p256_uint1 x16; + uint64_t x17; + fiat_p256_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + fiat_p256_addcarryx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p256_addcarryx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p256_addcarryx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p256_addcarryx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p256_subborrowx_u64(&x9, &x10, 0x0, x1, UINT64_C(0xffffffffffffffff)); + fiat_p256_subborrowx_u64(&x11, &x12, x10, x3, UINT32_C(0xffffffff)); + fiat_p256_subborrowx_u64(&x13, &x14, x12, x5, 0x0); + fiat_p256_subborrowx_u64(&x15, &x16, x14, x7, UINT64_C(0xffffffff00000001)); + fiat_p256_subborrowx_u64(&x17, &x18, x16, x8, 0x0); + fiat_p256_cmovznz_u64(&x19, x18, x9, x1); + fiat_p256_cmovznz_u64(&x20, x18, x11, x3); + fiat_p256_cmovznz_u64(&x21, x18, x13, x5); + fiat_p256_cmovznz_u64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/* + * The function fiat_p256_sub subtracts two field elements in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * 0 ≤ eval arg2 < m + * Postconditions: + * eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_sub(fiat_p256_montgomery_domain_field_element out1, const fiat_p256_montgomery_domain_field_element arg1, const fiat_p256_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_p256_uint1 x2; + uint64_t x3; + fiat_p256_uint1 x4; + uint64_t x5; + fiat_p256_uint1 x6; + uint64_t x7; + fiat_p256_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_p256_uint1 x11; + uint64_t x12; + fiat_p256_uint1 x13; + uint64_t x14; + fiat_p256_uint1 x15; + uint64_t x16; + fiat_p256_uint1 x17; + fiat_p256_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_p256_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_p256_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_p256_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_p256_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x10, &x11, 0x0, x1, x9); + fiat_p256_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT32_C(0xffffffff))); + fiat_p256_addcarryx_u64(&x14, &x15, x13, x5, 0x0); + fiat_p256_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0xffffffff00000001))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_p256_opp negates a field element in the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_opp(fiat_p256_montgomery_domain_field_element out1, const fiat_p256_montgomery_domain_field_element arg1) { + uint64_t x1; + fiat_p256_uint1 x2; + uint64_t x3; + fiat_p256_uint1 x4; + uint64_t x5; + fiat_p256_uint1 x6; + uint64_t x7; + fiat_p256_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_p256_uint1 x11; + uint64_t x12; + fiat_p256_uint1 x13; + uint64_t x14; + fiat_p256_uint1 x15; + uint64_t x16; + fiat_p256_uint1 x17; + fiat_p256_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_p256_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_p256_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_p256_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_p256_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x10, &x11, 0x0, x1, x9); + fiat_p256_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT32_C(0xffffffff))); + fiat_p256_addcarryx_u64(&x14, &x15, x13, x5, 0x0); + fiat_p256_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0xffffffff00000001))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_p256_from_montgomery translates a field element out of the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval out1 mod m = (eval arg1 * ((2^64)⁻¹ mod m)^4) mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_from_montgomery(fiat_p256_non_montgomery_domain_field_element out1, const fiat_p256_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + fiat_p256_uint1 x9; + uint64_t x10; + fiat_p256_uint1 x11; + uint64_t x12; + fiat_p256_uint1 x13; + uint64_t x14; + fiat_p256_uint1 x15; + uint64_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + fiat_p256_uint1 x23; + uint64_t x24; + fiat_p256_uint1 x25; + uint64_t x26; + fiat_p256_uint1 x27; + uint64_t x28; + fiat_p256_uint1 x29; + uint64_t x30; + fiat_p256_uint1 x31; + uint64_t x32; + fiat_p256_uint1 x33; + uint64_t x34; + fiat_p256_uint1 x35; + uint64_t x36; + fiat_p256_uint1 x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + fiat_p256_uint1 x45; + uint64_t x46; + fiat_p256_uint1 x47; + uint64_t x48; + fiat_p256_uint1 x49; + uint64_t x50; + fiat_p256_uint1 x51; + uint64_t x52; + fiat_p256_uint1 x53; + uint64_t x54; + fiat_p256_uint1 x55; + uint64_t x56; + fiat_p256_uint1 x57; + uint64_t x58; + fiat_p256_uint1 x59; + uint64_t x60; + uint64_t x61; + uint64_t x62; + uint64_t x63; + uint64_t x64; + uint64_t x65; + uint64_t x66; + fiat_p256_uint1 x67; + uint64_t x68; + fiat_p256_uint1 x69; + uint64_t x70; + fiat_p256_uint1 x71; + uint64_t x72; + fiat_p256_uint1 x73; + uint64_t x74; + fiat_p256_uint1 x75; + uint64_t x76; + uint64_t x77; + fiat_p256_uint1 x78; + uint64_t x79; + fiat_p256_uint1 x80; + uint64_t x81; + fiat_p256_uint1 x82; + uint64_t x83; + fiat_p256_uint1 x84; + uint64_t x85; + fiat_p256_uint1 x86; + uint64_t x87; + uint64_t x88; + uint64_t x89; + uint64_t x90; + x1 = (arg1[0]); + fiat_p256_mulx_u64(&x2, &x3, x1, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x4, &x5, x1, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x6, &x7, x1, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x8, &x9, 0x0, x7, x4); + fiat_p256_addcarryx_u64(&x10, &x11, 0x0, x1, x6); + fiat_p256_addcarryx_u64(&x12, &x13, x11, 0x0, x8); + fiat_p256_addcarryx_u64(&x14, &x15, 0x0, x12, (arg1[1])); + fiat_p256_mulx_u64(&x16, &x17, x14, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x18, &x19, x14, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x20, &x21, x14, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x22, &x23, 0x0, x21, x18); + fiat_p256_addcarryx_u64(&x24, &x25, 0x0, x14, x20); + fiat_p256_addcarryx_u64(&x26, &x27, x25, (x15 + (x13 + (x9 + x5))), x22); + fiat_p256_addcarryx_u64(&x28, &x29, x27, x2, (x23 + x19)); + fiat_p256_addcarryx_u64(&x30, &x31, x29, x3, x16); + fiat_p256_addcarryx_u64(&x32, &x33, 0x0, x26, (arg1[2])); + fiat_p256_addcarryx_u64(&x34, &x35, x33, x28, 0x0); + fiat_p256_addcarryx_u64(&x36, &x37, x35, x30, 0x0); + fiat_p256_mulx_u64(&x38, &x39, x32, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x40, &x41, x32, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x42, &x43, x32, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x44, &x45, 0x0, x43, x40); + fiat_p256_addcarryx_u64(&x46, &x47, 0x0, x32, x42); + fiat_p256_addcarryx_u64(&x48, &x49, x47, x34, x44); + fiat_p256_addcarryx_u64(&x50, &x51, x49, x36, (x45 + x41)); + fiat_p256_addcarryx_u64(&x52, &x53, x51, (x37 + (x31 + x17)), x38); + fiat_p256_addcarryx_u64(&x54, &x55, 0x0, x48, (arg1[3])); + fiat_p256_addcarryx_u64(&x56, &x57, x55, x50, 0x0); + fiat_p256_addcarryx_u64(&x58, &x59, x57, x52, 0x0); + fiat_p256_mulx_u64(&x60, &x61, x54, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x62, &x63, x54, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x64, &x65, x54, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x66, &x67, 0x0, x65, x62); + fiat_p256_addcarryx_u64(&x68, &x69, 0x0, x54, x64); + fiat_p256_addcarryx_u64(&x70, &x71, x69, x56, x66); + fiat_p256_addcarryx_u64(&x72, &x73, x71, x58, (x67 + x63)); + fiat_p256_addcarryx_u64(&x74, &x75, x73, (x59 + (x53 + x39)), x60); + x76 = (x75 + x61); + fiat_p256_subborrowx_u64(&x77, &x78, 0x0, x70, UINT64_C(0xffffffffffffffff)); + fiat_p256_subborrowx_u64(&x79, &x80, x78, x72, UINT32_C(0xffffffff)); + fiat_p256_subborrowx_u64(&x81, &x82, x80, x74, 0x0); + fiat_p256_subborrowx_u64(&x83, &x84, x82, x76, UINT64_C(0xffffffff00000001)); + fiat_p256_subborrowx_u64(&x85, &x86, x84, 0x0, 0x0); + fiat_p256_cmovznz_u64(&x87, x86, x77, x70); + fiat_p256_cmovznz_u64(&x88, x86, x79, x72); + fiat_p256_cmovznz_u64(&x89, x86, x81, x74); + fiat_p256_cmovznz_u64(&x90, x86, x83, x76); + out1[0] = x87; + out1[1] = x88; + out1[2] = x89; + out1[3] = x90; +} + +/* + * The function fiat_p256_to_montgomery translates a field element into the Montgomery domain. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * eval (from_montgomery out1) mod m = eval arg1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_to_montgomery(fiat_p256_montgomery_domain_field_element out1, const fiat_p256_non_montgomery_domain_field_element arg1) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + fiat_p256_uint1 x14; + uint64_t x15; + fiat_p256_uint1 x16; + uint64_t x17; + fiat_p256_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + fiat_p256_uint1 x26; + uint64_t x27; + fiat_p256_uint1 x28; + uint64_t x29; + fiat_p256_uint1 x30; + uint64_t x31; + fiat_p256_uint1 x32; + uint64_t x33; + fiat_p256_uint1 x34; + uint64_t x35; + fiat_p256_uint1 x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + fiat_p256_uint1 x46; + uint64_t x47; + fiat_p256_uint1 x48; + uint64_t x49; + fiat_p256_uint1 x50; + uint64_t x51; + fiat_p256_uint1 x52; + uint64_t x53; + fiat_p256_uint1 x54; + uint64_t x55; + fiat_p256_uint1 x56; + uint64_t x57; + fiat_p256_uint1 x58; + uint64_t x59; + uint64_t x60; + uint64_t x61; + uint64_t x62; + uint64_t x63; + uint64_t x64; + uint64_t x65; + fiat_p256_uint1 x66; + uint64_t x67; + fiat_p256_uint1 x68; + uint64_t x69; + fiat_p256_uint1 x70; + uint64_t x71; + fiat_p256_uint1 x72; + uint64_t x73; + fiat_p256_uint1 x74; + uint64_t x75; + fiat_p256_uint1 x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + uint64_t x81; + uint64_t x82; + uint64_t x83; + uint64_t x84; + uint64_t x85; + fiat_p256_uint1 x86; + uint64_t x87; + fiat_p256_uint1 x88; + uint64_t x89; + fiat_p256_uint1 x90; + uint64_t x91; + fiat_p256_uint1 x92; + uint64_t x93; + fiat_p256_uint1 x94; + uint64_t x95; + fiat_p256_uint1 x96; + uint64_t x97; + fiat_p256_uint1 x98; + uint64_t x99; + uint64_t x100; + uint64_t x101; + uint64_t x102; + uint64_t x103; + uint64_t x104; + uint64_t x105; + fiat_p256_uint1 x106; + uint64_t x107; + fiat_p256_uint1 x108; + uint64_t x109; + fiat_p256_uint1 x110; + uint64_t x111; + fiat_p256_uint1 x112; + uint64_t x113; + fiat_p256_uint1 x114; + uint64_t x115; + fiat_p256_uint1 x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + fiat_p256_uint1 x126; + uint64_t x127; + fiat_p256_uint1 x128; + uint64_t x129; + fiat_p256_uint1 x130; + uint64_t x131; + fiat_p256_uint1 x132; + uint64_t x133; + fiat_p256_uint1 x134; + uint64_t x135; + fiat_p256_uint1 x136; + uint64_t x137; + fiat_p256_uint1 x138; + uint64_t x139; + uint64_t x140; + uint64_t x141; + uint64_t x142; + uint64_t x143; + uint64_t x144; + uint64_t x145; + fiat_p256_uint1 x146; + uint64_t x147; + fiat_p256_uint1 x148; + uint64_t x149; + fiat_p256_uint1 x150; + uint64_t x151; + fiat_p256_uint1 x152; + uint64_t x153; + fiat_p256_uint1 x154; + uint64_t x155; + fiat_p256_uint1 x156; + uint64_t x157; + fiat_p256_uint1 x158; + uint64_t x159; + fiat_p256_uint1 x160; + uint64_t x161; + fiat_p256_uint1 x162; + uint64_t x163; + fiat_p256_uint1 x164; + uint64_t x165; + fiat_p256_uint1 x166; + uint64_t x167; + uint64_t x168; + uint64_t x169; + uint64_t x170; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_p256_mulx_u64(&x5, &x6, x4, UINT64_C(0x4fffffffd)); + fiat_p256_mulx_u64(&x7, &x8, x4, UINT64_C(0xfffffffffffffffe)); + fiat_p256_mulx_u64(&x9, &x10, x4, UINT64_C(0xfffffffbffffffff)); + fiat_p256_mulx_u64(&x11, &x12, x4, 0x3); + fiat_p256_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_p256_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_p256_addcarryx_u64(&x17, &x18, x16, x8, x5); + fiat_p256_mulx_u64(&x19, &x20, x11, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x21, &x22, x11, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x23, &x24, x11, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x25, &x26, 0x0, x24, x21); + fiat_p256_addcarryx_u64(&x27, &x28, 0x0, x11, x23); + fiat_p256_addcarryx_u64(&x29, &x30, x28, x13, x25); + fiat_p256_addcarryx_u64(&x31, &x32, x30, x15, (x26 + x22)); + fiat_p256_addcarryx_u64(&x33, &x34, x32, x17, x19); + fiat_p256_addcarryx_u64(&x35, &x36, x34, (x18 + x6), x20); + fiat_p256_mulx_u64(&x37, &x38, x1, UINT64_C(0x4fffffffd)); + fiat_p256_mulx_u64(&x39, &x40, x1, UINT64_C(0xfffffffffffffffe)); + fiat_p256_mulx_u64(&x41, &x42, x1, UINT64_C(0xfffffffbffffffff)); + fiat_p256_mulx_u64(&x43, &x44, x1, 0x3); + fiat_p256_addcarryx_u64(&x45, &x46, 0x0, x44, x41); + fiat_p256_addcarryx_u64(&x47, &x48, x46, x42, x39); + fiat_p256_addcarryx_u64(&x49, &x50, x48, x40, x37); + fiat_p256_addcarryx_u64(&x51, &x52, 0x0, x29, x43); + fiat_p256_addcarryx_u64(&x53, &x54, x52, x31, x45); + fiat_p256_addcarryx_u64(&x55, &x56, x54, x33, x47); + fiat_p256_addcarryx_u64(&x57, &x58, x56, x35, x49); + fiat_p256_mulx_u64(&x59, &x60, x51, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x61, &x62, x51, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x63, &x64, x51, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x65, &x66, 0x0, x64, x61); + fiat_p256_addcarryx_u64(&x67, &x68, 0x0, x51, x63); + fiat_p256_addcarryx_u64(&x69, &x70, x68, x53, x65); + fiat_p256_addcarryx_u64(&x71, &x72, x70, x55, (x66 + x62)); + fiat_p256_addcarryx_u64(&x73, &x74, x72, x57, x59); + fiat_p256_addcarryx_u64(&x75, &x76, x74, (((uint64_t)x58 + x36) + (x50 + x38)), x60); + fiat_p256_mulx_u64(&x77, &x78, x2, UINT64_C(0x4fffffffd)); + fiat_p256_mulx_u64(&x79, &x80, x2, UINT64_C(0xfffffffffffffffe)); + fiat_p256_mulx_u64(&x81, &x82, x2, UINT64_C(0xfffffffbffffffff)); + fiat_p256_mulx_u64(&x83, &x84, x2, 0x3); + fiat_p256_addcarryx_u64(&x85, &x86, 0x0, x84, x81); + fiat_p256_addcarryx_u64(&x87, &x88, x86, x82, x79); + fiat_p256_addcarryx_u64(&x89, &x90, x88, x80, x77); + fiat_p256_addcarryx_u64(&x91, &x92, 0x0, x69, x83); + fiat_p256_addcarryx_u64(&x93, &x94, x92, x71, x85); + fiat_p256_addcarryx_u64(&x95, &x96, x94, x73, x87); + fiat_p256_addcarryx_u64(&x97, &x98, x96, x75, x89); + fiat_p256_mulx_u64(&x99, &x100, x91, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x101, &x102, x91, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x103, &x104, x91, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x105, &x106, 0x0, x104, x101); + fiat_p256_addcarryx_u64(&x107, &x108, 0x0, x91, x103); + fiat_p256_addcarryx_u64(&x109, &x110, x108, x93, x105); + fiat_p256_addcarryx_u64(&x111, &x112, x110, x95, (x106 + x102)); + fiat_p256_addcarryx_u64(&x113, &x114, x112, x97, x99); + fiat_p256_addcarryx_u64(&x115, &x116, x114, (((uint64_t)x98 + x76) + (x90 + x78)), x100); + fiat_p256_mulx_u64(&x117, &x118, x3, UINT64_C(0x4fffffffd)); + fiat_p256_mulx_u64(&x119, &x120, x3, UINT64_C(0xfffffffffffffffe)); + fiat_p256_mulx_u64(&x121, &x122, x3, UINT64_C(0xfffffffbffffffff)); + fiat_p256_mulx_u64(&x123, &x124, x3, 0x3); + fiat_p256_addcarryx_u64(&x125, &x126, 0x0, x124, x121); + fiat_p256_addcarryx_u64(&x127, &x128, x126, x122, x119); + fiat_p256_addcarryx_u64(&x129, &x130, x128, x120, x117); + fiat_p256_addcarryx_u64(&x131, &x132, 0x0, x109, x123); + fiat_p256_addcarryx_u64(&x133, &x134, x132, x111, x125); + fiat_p256_addcarryx_u64(&x135, &x136, x134, x113, x127); + fiat_p256_addcarryx_u64(&x137, &x138, x136, x115, x129); + fiat_p256_mulx_u64(&x139, &x140, x131, UINT64_C(0xffffffff00000001)); + fiat_p256_mulx_u64(&x141, &x142, x131, UINT32_C(0xffffffff)); + fiat_p256_mulx_u64(&x143, &x144, x131, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x145, &x146, 0x0, x144, x141); + fiat_p256_addcarryx_u64(&x147, &x148, 0x0, x131, x143); + fiat_p256_addcarryx_u64(&x149, &x150, x148, x133, x145); + fiat_p256_addcarryx_u64(&x151, &x152, x150, x135, (x146 + x142)); + fiat_p256_addcarryx_u64(&x153, &x154, x152, x137, x139); + fiat_p256_addcarryx_u64(&x155, &x156, x154, (((uint64_t)x138 + x116) + (x130 + x118)), x140); + fiat_p256_subborrowx_u64(&x157, &x158, 0x0, x149, UINT64_C(0xffffffffffffffff)); + fiat_p256_subborrowx_u64(&x159, &x160, x158, x151, UINT32_C(0xffffffff)); + fiat_p256_subborrowx_u64(&x161, &x162, x160, x153, 0x0); + fiat_p256_subborrowx_u64(&x163, &x164, x162, x155, UINT64_C(0xffffffff00000001)); + fiat_p256_subborrowx_u64(&x165, &x166, x164, x156, 0x0); + fiat_p256_cmovznz_u64(&x167, x166, x157, x149); + fiat_p256_cmovznz_u64(&x168, x166, x159, x151); + fiat_p256_cmovznz_u64(&x169, x166, x161, x153); + fiat_p256_cmovznz_u64(&x170, x166, x163, x155); + out1[0] = x167; + out1[1] = x168; + out1[2] = x169; + out1[3] = x170; +} + +/* + * The function fiat_p256_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0 + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + uint64_t x1; + x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/* + * The function fiat_p256_selectznz is a multi-limb conditional select. + * + * Postconditions: + * out1 = (if arg1 = 0 then arg2 else arg3) + * + * Input Bounds: + * arg1: [0x0 ~> 0x1] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_selectznz(uint64_t out1[4], fiat_p256_uint1 arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + fiat_p256_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_p256_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_p256_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_p256_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/* + * The function fiat_p256_to_bytes serializes a field element NOT in the Montgomery domain to bytes in little-endian order. + * + * Preconditions: + * 0 ≤ eval arg1 < m + * Postconditions: + * out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..31] + * + * Input Bounds: + * arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint8_t x5; + uint64_t x6; + uint8_t x7; + uint64_t x8; + uint8_t x9; + uint64_t x10; + uint8_t x11; + uint64_t x12; + uint8_t x13; + uint64_t x14; + uint8_t x15; + uint64_t x16; + uint8_t x17; + uint8_t x18; + uint8_t x19; + uint64_t x20; + uint8_t x21; + uint64_t x22; + uint8_t x23; + uint64_t x24; + uint8_t x25; + uint64_t x26; + uint8_t x27; + uint64_t x28; + uint8_t x29; + uint64_t x30; + uint8_t x31; + uint8_t x32; + uint8_t x33; + uint64_t x34; + uint8_t x35; + uint64_t x36; + uint8_t x37; + uint64_t x38; + uint8_t x39; + uint64_t x40; + uint8_t x41; + uint64_t x42; + uint8_t x43; + uint64_t x44; + uint8_t x45; + uint8_t x46; + uint8_t x47; + uint64_t x48; + uint8_t x49; + uint64_t x50; + uint8_t x51; + uint64_t x52; + uint8_t x53; + uint64_t x54; + uint8_t x55; + uint64_t x56; + uint8_t x57; + uint64_t x58; + uint8_t x59; + uint8_t x60; + x1 = (arg1[3]); + x2 = (arg1[2]); + x3 = (arg1[1]); + x4 = (arg1[0]); + x5 = (uint8_t)(x4 & UINT8_C(0xff)); + x6 = (x4 >> 8); + x7 = (uint8_t)(x6 & UINT8_C(0xff)); + x8 = (x6 >> 8); + x9 = (uint8_t)(x8 & UINT8_C(0xff)); + x10 = (x8 >> 8); + x11 = (uint8_t)(x10 & UINT8_C(0xff)); + x12 = (x10 >> 8); + x13 = (uint8_t)(x12 & UINT8_C(0xff)); + x14 = (x12 >> 8); + x15 = (uint8_t)(x14 & UINT8_C(0xff)); + x16 = (x14 >> 8); + x17 = (uint8_t)(x16 & UINT8_C(0xff)); + x18 = (uint8_t)(x16 >> 8); + x19 = (uint8_t)(x3 & UINT8_C(0xff)); + x20 = (x3 >> 8); + x21 = (uint8_t)(x20 & UINT8_C(0xff)); + x22 = (x20 >> 8); + x23 = (uint8_t)(x22 & UINT8_C(0xff)); + x24 = (x22 >> 8); + x25 = (uint8_t)(x24 & UINT8_C(0xff)); + x26 = (x24 >> 8); + x27 = (uint8_t)(x26 & UINT8_C(0xff)); + x28 = (x26 >> 8); + x29 = (uint8_t)(x28 & UINT8_C(0xff)); + x30 = (x28 >> 8); + x31 = (uint8_t)(x30 & UINT8_C(0xff)); + x32 = (uint8_t)(x30 >> 8); + x33 = (uint8_t)(x2 & UINT8_C(0xff)); + x34 = (x2 >> 8); + x35 = (uint8_t)(x34 & UINT8_C(0xff)); + x36 = (x34 >> 8); + x37 = (uint8_t)(x36 & UINT8_C(0xff)); + x38 = (x36 >> 8); + x39 = (uint8_t)(x38 & UINT8_C(0xff)); + x40 = (x38 >> 8); + x41 = (uint8_t)(x40 & UINT8_C(0xff)); + x42 = (x40 >> 8); + x43 = (uint8_t)(x42 & UINT8_C(0xff)); + x44 = (x42 >> 8); + x45 = (uint8_t)(x44 & UINT8_C(0xff)); + x46 = (uint8_t)(x44 >> 8); + x47 = (uint8_t)(x1 & UINT8_C(0xff)); + x48 = (x1 >> 8); + x49 = (uint8_t)(x48 & UINT8_C(0xff)); + x50 = (x48 >> 8); + x51 = (uint8_t)(x50 & UINT8_C(0xff)); + x52 = (x50 >> 8); + x53 = (uint8_t)(x52 & UINT8_C(0xff)); + x54 = (x52 >> 8); + x55 = (uint8_t)(x54 & UINT8_C(0xff)); + x56 = (x54 >> 8); + x57 = (uint8_t)(x56 & UINT8_C(0xff)); + x58 = (x56 >> 8); + x59 = (uint8_t)(x58 & UINT8_C(0xff)); + x60 = (uint8_t)(x58 >> 8); + out1[0] = x5; + out1[1] = x7; + out1[2] = x9; + out1[3] = x11; + out1[4] = x13; + out1[5] = x15; + out1[6] = x17; + out1[7] = x18; + out1[8] = x19; + out1[9] = x21; + out1[10] = x23; + out1[11] = x25; + out1[12] = x27; + out1[13] = x29; + out1[14] = x31; + out1[15] = x32; + out1[16] = x33; + out1[17] = x35; + out1[18] = x37; + out1[19] = x39; + out1[20] = x41; + out1[21] = x43; + out1[22] = x45; + out1[23] = x46; + out1[24] = x47; + out1[25] = x49; + out1[26] = x51; + out1[27] = x53; + out1[28] = x55; + out1[29] = x57; + out1[30] = x59; + out1[31] = x60; +} + +/* + * The function fiat_p256_from_bytes deserializes a field element NOT in the Montgomery domain from bytes in little-endian order. + * + * Preconditions: + * 0 ≤ bytes_eval arg1 < m + * Postconditions: + * eval out1 mod m = bytes_eval arg1 mod m + * 0 ≤ eval out1 < m + * + * Input Bounds: + * arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]] + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + uint64_t x1; + uint64_t x2; + uint64_t x3; + uint64_t x4; + uint64_t x5; + uint64_t x6; + uint64_t x7; + uint8_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + uint64_t x13; + uint64_t x14; + uint64_t x15; + uint8_t x16; + uint64_t x17; + uint64_t x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + uint64_t x23; + uint8_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + uint8_t x32; + uint64_t x33; + uint64_t x34; + uint64_t x35; + uint64_t x36; + uint64_t x37; + uint64_t x38; + uint64_t x39; + uint64_t x40; + uint64_t x41; + uint64_t x42; + uint64_t x43; + uint64_t x44; + uint64_t x45; + uint64_t x46; + uint64_t x47; + uint64_t x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + uint64_t x54; + uint64_t x55; + uint64_t x56; + uint64_t x57; + uint64_t x58; + uint64_t x59; + uint64_t x60; + x1 = ((uint64_t)(arg1[31]) << 56); + x2 = ((uint64_t)(arg1[30]) << 48); + x3 = ((uint64_t)(arg1[29]) << 40); + x4 = ((uint64_t)(arg1[28]) << 32); + x5 = ((uint64_t)(arg1[27]) << 24); + x6 = ((uint64_t)(arg1[26]) << 16); + x7 = ((uint64_t)(arg1[25]) << 8); + x8 = (arg1[24]); + x9 = ((uint64_t)(arg1[23]) << 56); + x10 = ((uint64_t)(arg1[22]) << 48); + x11 = ((uint64_t)(arg1[21]) << 40); + x12 = ((uint64_t)(arg1[20]) << 32); + x13 = ((uint64_t)(arg1[19]) << 24); + x14 = ((uint64_t)(arg1[18]) << 16); + x15 = ((uint64_t)(arg1[17]) << 8); + x16 = (arg1[16]); + x17 = ((uint64_t)(arg1[15]) << 56); + x18 = ((uint64_t)(arg1[14]) << 48); + x19 = ((uint64_t)(arg1[13]) << 40); + x20 = ((uint64_t)(arg1[12]) << 32); + x21 = ((uint64_t)(arg1[11]) << 24); + x22 = ((uint64_t)(arg1[10]) << 16); + x23 = ((uint64_t)(arg1[9]) << 8); + x24 = (arg1[8]); + x25 = ((uint64_t)(arg1[7]) << 56); + x26 = ((uint64_t)(arg1[6]) << 48); + x27 = ((uint64_t)(arg1[5]) << 40); + x28 = ((uint64_t)(arg1[4]) << 32); + x29 = ((uint64_t)(arg1[3]) << 24); + x30 = ((uint64_t)(arg1[2]) << 16); + x31 = ((uint64_t)(arg1[1]) << 8); + x32 = (arg1[0]); + x33 = (x31 + (uint64_t)x32); + x34 = (x30 + x33); + x35 = (x29 + x34); + x36 = (x28 + x35); + x37 = (x27 + x36); + x38 = (x26 + x37); + x39 = (x25 + x38); + x40 = (x23 + (uint64_t)x24); + x41 = (x22 + x40); + x42 = (x21 + x41); + x43 = (x20 + x42); + x44 = (x19 + x43); + x45 = (x18 + x44); + x46 = (x17 + x45); + x47 = (x15 + (uint64_t)x16); + x48 = (x14 + x47); + x49 = (x13 + x48); + x50 = (x12 + x49); + x51 = (x11 + x50); + x52 = (x10 + x51); + x53 = (x9 + x52); + x54 = (x7 + (uint64_t)x8); + x55 = (x6 + x54); + x56 = (x5 + x55); + x57 = (x4 + x56); + x58 = (x3 + x57); + x59 = (x2 + x58); + x60 = (x1 + x59); + out1[0] = x39; + out1[1] = x46; + out1[2] = x53; + out1[3] = x60; +} + +/* + * The function fiat_p256_set_one returns the field element one in the Montgomery domain. + * + * Postconditions: + * eval (from_montgomery out1) mod m = 1 mod m + * 0 ≤ eval out1 < m + * + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_set_one(fiat_p256_montgomery_domain_field_element out1) { + out1[0] = 0x1; + out1[1] = UINT64_C(0xffffffff00000000); + out1[2] = UINT64_C(0xffffffffffffffff); + out1[3] = UINT32_C(0xfffffffe); +} + +/* + * The function fiat_p256_msat returns the saturated representation of the prime modulus. + * + * Postconditions: + * twos_complement_eval out1 = m + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_msat(uint64_t out1[5]) { + out1[0] = UINT64_C(0xffffffffffffffff); + out1[1] = UINT32_C(0xffffffff); + out1[2] = 0x0; + out1[3] = UINT64_C(0xffffffff00000001); + out1[4] = 0x0; +} + +/* + * The function fiat_p256_divstep computes a divstep. + * + * Preconditions: + * 0 ≤ eval arg4 < m + * 0 ≤ eval arg5 < m + * Postconditions: + * out1 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then 1 - arg1 else 1 + arg1) + * twos_complement_eval out2 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then twos_complement_eval arg3 else twos_complement_eval arg2) + * twos_complement_eval out3 = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then ⌊(twos_complement_eval arg3 - twos_complement_eval arg2) / 2⌋ else ⌊(twos_complement_eval arg3 + (twos_complement_eval arg3 mod 2) * twos_complement_eval arg2) / 2⌋) + * eval (from_montgomery out4) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (2 * eval (from_montgomery arg5)) mod m else (2 * eval (from_montgomery arg4)) mod m) + * eval (from_montgomery out5) mod m = (if 0 < arg1 ∧ (twos_complement_eval arg3) is odd then (eval (from_montgomery arg4) - eval (from_montgomery arg4)) mod m else (eval (from_montgomery arg5) + (twos_complement_eval arg3 mod 2) * eval (from_montgomery arg4)) mod m) + * 0 ≤ eval out5 < m + * 0 ≤ eval out5 < m + * 0 ≤ eval out2 < m + * 0 ≤ eval out3 < m + * + * Input Bounds: + * arg1: [0x0 ~> 0xffffffffffffffff] + * arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * arg5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * Output Bounds: + * out1: [0x0 ~> 0xffffffffffffffff] + * out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + * out5: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_divstep(uint64_t* out1, uint64_t out2[5], uint64_t out3[5], uint64_t out4[4], uint64_t out5[4], uint64_t arg1, const uint64_t arg2[5], const uint64_t arg3[5], const uint64_t arg4[4], const uint64_t arg5[4]) { + uint64_t x1; + fiat_p256_uint1 x2; + fiat_p256_uint1 x3; + uint64_t x4; + fiat_p256_uint1 x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + fiat_p256_uint1 x13; + uint64_t x14; + fiat_p256_uint1 x15; + uint64_t x16; + fiat_p256_uint1 x17; + uint64_t x18; + fiat_p256_uint1 x19; + uint64_t x20; + fiat_p256_uint1 x21; + uint64_t x22; + uint64_t x23; + uint64_t x24; + uint64_t x25; + uint64_t x26; + uint64_t x27; + uint64_t x28; + uint64_t x29; + uint64_t x30; + uint64_t x31; + fiat_p256_uint1 x32; + uint64_t x33; + fiat_p256_uint1 x34; + uint64_t x35; + fiat_p256_uint1 x36; + uint64_t x37; + fiat_p256_uint1 x38; + uint64_t x39; + fiat_p256_uint1 x40; + uint64_t x41; + fiat_p256_uint1 x42; + uint64_t x43; + fiat_p256_uint1 x44; + uint64_t x45; + fiat_p256_uint1 x46; + uint64_t x47; + fiat_p256_uint1 x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + fiat_p256_uint1 x54; + uint64_t x55; + fiat_p256_uint1 x56; + uint64_t x57; + fiat_p256_uint1 x58; + uint64_t x59; + fiat_p256_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_p256_uint1 x63; + uint64_t x64; + fiat_p256_uint1 x65; + uint64_t x66; + fiat_p256_uint1 x67; + uint64_t x68; + fiat_p256_uint1 x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + fiat_p256_uint1 x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + fiat_p256_uint1 x81; + uint64_t x82; + fiat_p256_uint1 x83; + uint64_t x84; + fiat_p256_uint1 x85; + uint64_t x86; + fiat_p256_uint1 x87; + uint64_t x88; + fiat_p256_uint1 x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + fiat_p256_uint1 x95; + uint64_t x96; + fiat_p256_uint1 x97; + uint64_t x98; + fiat_p256_uint1 x99; + uint64_t x100; + fiat_p256_uint1 x101; + uint64_t x102; + fiat_p256_uint1 x103; + uint64_t x104; + fiat_p256_uint1 x105; + uint64_t x106; + fiat_p256_uint1 x107; + uint64_t x108; + fiat_p256_uint1 x109; + uint64_t x110; + fiat_p256_uint1 x111; + uint64_t x112; + fiat_p256_uint1 x113; + uint64_t x114; + uint64_t x115; + uint64_t x116; + uint64_t x117; + uint64_t x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + uint64_t x126; + fiat_p256_addcarryx_u64(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_p256_uint1)((fiat_p256_uint1)(x1 >> 63) & (fiat_p256_uint1)((arg3[0]) & 0x1)); + fiat_p256_addcarryx_u64(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_p256_cmovznz_u64(&x6, x3, arg1, x4); + fiat_p256_cmovznz_u64(&x7, x3, (arg2[0]), (arg3[0])); + fiat_p256_cmovznz_u64(&x8, x3, (arg2[1]), (arg3[1])); + fiat_p256_cmovznz_u64(&x9, x3, (arg2[2]), (arg3[2])); + fiat_p256_cmovznz_u64(&x10, x3, (arg2[3]), (arg3[3])); + fiat_p256_cmovznz_u64(&x11, x3, (arg2[4]), (arg3[4])); + fiat_p256_addcarryx_u64(&x12, &x13, 0x0, 0x1, (~(arg2[0]))); + fiat_p256_addcarryx_u64(&x14, &x15, x13, 0x0, (~(arg2[1]))); + fiat_p256_addcarryx_u64(&x16, &x17, x15, 0x0, (~(arg2[2]))); + fiat_p256_addcarryx_u64(&x18, &x19, x17, 0x0, (~(arg2[3]))); + fiat_p256_addcarryx_u64(&x20, &x21, x19, 0x0, (~(arg2[4]))); + fiat_p256_cmovznz_u64(&x22, x3, (arg3[0]), x12); + fiat_p256_cmovznz_u64(&x23, x3, (arg3[1]), x14); + fiat_p256_cmovznz_u64(&x24, x3, (arg3[2]), x16); + fiat_p256_cmovznz_u64(&x25, x3, (arg3[3]), x18); + fiat_p256_cmovznz_u64(&x26, x3, (arg3[4]), x20); + fiat_p256_cmovznz_u64(&x27, x3, (arg4[0]), (arg5[0])); + fiat_p256_cmovznz_u64(&x28, x3, (arg4[1]), (arg5[1])); + fiat_p256_cmovznz_u64(&x29, x3, (arg4[2]), (arg5[2])); + fiat_p256_cmovznz_u64(&x30, x3, (arg4[3]), (arg5[3])); + fiat_p256_addcarryx_u64(&x31, &x32, 0x0, x27, x27); + fiat_p256_addcarryx_u64(&x33, &x34, x32, x28, x28); + fiat_p256_addcarryx_u64(&x35, &x36, x34, x29, x29); + fiat_p256_addcarryx_u64(&x37, &x38, x36, x30, x30); + fiat_p256_subborrowx_u64(&x39, &x40, 0x0, x31, UINT64_C(0xffffffffffffffff)); + fiat_p256_subborrowx_u64(&x41, &x42, x40, x33, UINT32_C(0xffffffff)); + fiat_p256_subborrowx_u64(&x43, &x44, x42, x35, 0x0); + fiat_p256_subborrowx_u64(&x45, &x46, x44, x37, UINT64_C(0xffffffff00000001)); + fiat_p256_subborrowx_u64(&x47, &x48, x46, x38, 0x0); + x49 = (arg4[3]); + x50 = (arg4[2]); + x51 = (arg4[1]); + x52 = (arg4[0]); + fiat_p256_subborrowx_u64(&x53, &x54, 0x0, 0x0, x52); + fiat_p256_subborrowx_u64(&x55, &x56, x54, 0x0, x51); + fiat_p256_subborrowx_u64(&x57, &x58, x56, 0x0, x50); + fiat_p256_subborrowx_u64(&x59, &x60, x58, 0x0, x49); + fiat_p256_cmovznz_u64(&x61, x60, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_p256_addcarryx_u64(&x62, &x63, 0x0, x53, x61); + fiat_p256_addcarryx_u64(&x64, &x65, x63, x55, (x61 & UINT32_C(0xffffffff))); + fiat_p256_addcarryx_u64(&x66, &x67, x65, x57, 0x0); + fiat_p256_addcarryx_u64(&x68, &x69, x67, x59, (x61 & UINT64_C(0xffffffff00000001))); + fiat_p256_cmovznz_u64(&x70, x3, (arg5[0]), x62); + fiat_p256_cmovznz_u64(&x71, x3, (arg5[1]), x64); + fiat_p256_cmovznz_u64(&x72, x3, (arg5[2]), x66); + fiat_p256_cmovznz_u64(&x73, x3, (arg5[3]), x68); + x74 = (fiat_p256_uint1)(x22 & 0x1); + fiat_p256_cmovznz_u64(&x75, x74, 0x0, x7); + fiat_p256_cmovznz_u64(&x76, x74, 0x0, x8); + fiat_p256_cmovznz_u64(&x77, x74, 0x0, x9); + fiat_p256_cmovznz_u64(&x78, x74, 0x0, x10); + fiat_p256_cmovznz_u64(&x79, x74, 0x0, x11); + fiat_p256_addcarryx_u64(&x80, &x81, 0x0, x22, x75); + fiat_p256_addcarryx_u64(&x82, &x83, x81, x23, x76); + fiat_p256_addcarryx_u64(&x84, &x85, x83, x24, x77); + fiat_p256_addcarryx_u64(&x86, &x87, x85, x25, x78); + fiat_p256_addcarryx_u64(&x88, &x89, x87, x26, x79); + fiat_p256_cmovznz_u64(&x90, x74, 0x0, x27); + fiat_p256_cmovznz_u64(&x91, x74, 0x0, x28); + fiat_p256_cmovznz_u64(&x92, x74, 0x0, x29); + fiat_p256_cmovznz_u64(&x93, x74, 0x0, x30); + fiat_p256_addcarryx_u64(&x94, &x95, 0x0, x70, x90); + fiat_p256_addcarryx_u64(&x96, &x97, x95, x71, x91); + fiat_p256_addcarryx_u64(&x98, &x99, x97, x72, x92); + fiat_p256_addcarryx_u64(&x100, &x101, x99, x73, x93); + fiat_p256_subborrowx_u64(&x102, &x103, 0x0, x94, UINT64_C(0xffffffffffffffff)); + fiat_p256_subborrowx_u64(&x104, &x105, x103, x96, UINT32_C(0xffffffff)); + fiat_p256_subborrowx_u64(&x106, &x107, x105, x98, 0x0); + fiat_p256_subborrowx_u64(&x108, &x109, x107, x100, UINT64_C(0xffffffff00000001)); + fiat_p256_subborrowx_u64(&x110, &x111, x109, x101, 0x0); + fiat_p256_addcarryx_u64(&x112, &x113, 0x0, x6, 0x1); + x114 = ((x80 >> 1) | ((x82 << 63) & UINT64_C(0xffffffffffffffff))); + x115 = ((x82 >> 1) | ((x84 << 63) & UINT64_C(0xffffffffffffffff))); + x116 = ((x84 >> 1) | ((x86 << 63) & UINT64_C(0xffffffffffffffff))); + x117 = ((x86 >> 1) | ((x88 << 63) & UINT64_C(0xffffffffffffffff))); + x118 = ((x88 & UINT64_C(0x8000000000000000)) | (x88 >> 1)); + fiat_p256_cmovznz_u64(&x119, x48, x39, x31); + fiat_p256_cmovznz_u64(&x120, x48, x41, x33); + fiat_p256_cmovznz_u64(&x121, x48, x43, x35); + fiat_p256_cmovznz_u64(&x122, x48, x45, x37); + fiat_p256_cmovznz_u64(&x123, x111, x102, x94); + fiat_p256_cmovznz_u64(&x124, x111, x104, x96); + fiat_p256_cmovznz_u64(&x125, x111, x106, x98); + fiat_p256_cmovznz_u64(&x126, x111, x108, x100); + *out1 = x112; + out2[0] = x7; + out2[1] = x8; + out2[2] = x9; + out2[3] = x10; + out2[4] = x11; + out3[0] = x114; + out3[1] = x115; + out3[2] = x116; + out3[3] = x117; + out3[4] = x118; + out4[0] = x119; + out4[1] = x120; + out4[2] = x121; + out4[3] = x122; + out5[0] = x123; + out5[1] = x124; + out5[2] = x125; + out5[3] = x126; +} + +/* + * The function fiat_p256_divstep_precomp returns the precomputed value for Bernstein-Yang-inversion (in montgomery form). + * + * Postconditions: + * eval (from_montgomery out1) = ⌊(m - 1) / 2⌋^(if ⌊log2 m⌋ + 1 < 46 then ⌊(49 * (⌊log2 m⌋ + 1) + 80) / 17⌋ else ⌊(49 * (⌊log2 m⌋ + 1) + 57) / 17⌋) + * 0 ≤ eval out1 < m + * + * Output Bounds: + * out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static FIAT_P256_FIAT_INLINE void fiat_p256_divstep_precomp(uint64_t out1[4]) { + out1[0] = UINT64_C(0x67ffffffb8000000); + out1[1] = UINT64_C(0xc000000038000000); + out1[2] = UINT64_C(0xd80000007fffffff); + out1[3] = UINT64_C(0x2fffffffffffffff); +} From d9f209baaf21b5865c5cce0e9a43f59b32650fa8 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 01:08:04 -0400 Subject: [PATCH 21/56] Document a pile of X509 print functions I had a branch lying around to rewrite X509_NAME_print(_ex) because those functions are a disaster, but it needs more work and probably isn't high priority. In the meantime, document what we've got. Also tidy up X509_print_ex slightly. m was completely unused and some variable declarations could be moved closer to their definition. Bug: 426 Change-Id: I24295048c36268c745f579ad66f34736cfe6830f Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58925 Reviewed-by: Bob Beck Commit-Queue: David Benjamin Auto-Submit: David Benjamin --- crypto/x509/t_x509.c | 87 ++++++------ include/openssl/x509.h | 298 +++++++++++++++++++++++++++++------------ 2 files changed, 249 insertions(+), 136 deletions(-) diff --git a/crypto/x509/t_x509.c b/crypto/x509/t_x509.c index 6694e3d127..1d71576ccd 100644 --- a/crypto/x509/t_x509.c +++ b/crypto/x509/t_x509.c @@ -91,14 +91,8 @@ int X509_print(BIO *bp, X509 *x) { int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, unsigned long cflag) { - long l; - int ret = 0, i; - char *m = NULL, mlch = ' '; + char mlch = ' '; int nmindent = 0; - X509_CINF *ci; - EVP_PKEY *pkey = NULL; - const char *neg; - if ((nmflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) { mlch = '\n'; nmindent = 12; @@ -108,26 +102,26 @@ int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, nmindent = 16; } - ci = x->cert_info; + const X509_CINF *ci = x->cert_info; if (!(cflag & X509_FLAG_NO_HEADER)) { if (BIO_write(bp, "Certificate:\n", 13) <= 0) { - goto err; + return 0; } if (BIO_write(bp, " Data:\n", 10) <= 0) { - goto err; + return 0; } } if (!(cflag & X509_FLAG_NO_VERSION)) { - l = X509_get_version(x); + long l = X509_get_version(x); assert(X509_VERSION_1 <= l && l <= X509_VERSION_3); if (BIO_printf(bp, "%8sVersion: %ld (0x%lx)\n", "", l + 1, (unsigned long)l) <= 0) { - goto err; + return 0; } } if (!(cflag & X509_FLAG_NO_SERIAL)) { if (BIO_write(bp, " Serial Number:", 22) <= 0) { - goto err; + return 0; } const ASN1_INTEGER *serial = X509_get0_serialNumber(x); @@ -136,19 +130,20 @@ int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, assert(serial->type != V_ASN1_NEG_INTEGER); if (BIO_printf(bp, " %" PRIu64 " (0x%" PRIx64 ")\n", serial_u64, serial_u64) <= 0) { - goto err; + return 0; } } else { ERR_clear_error(); // Clear |ASN1_INTEGER_get_uint64|'s error. - neg = (serial->type == V_ASN1_NEG_INTEGER) ? " (Negative)" : ""; + const char *neg = + (serial->type == V_ASN1_NEG_INTEGER) ? " (Negative)" : ""; if (BIO_printf(bp, "\n%12s%s", "", neg) <= 0) { - goto err; + return 0; } - for (i = 0; i < serial->length; i++) { + for (int i = 0; i < serial->length; i++) { if (BIO_printf(bp, "%02x%c", serial->data[i], ((i + 1 == serial->length) ? '\n' : ':')) <= 0) { - goto err; + return 0; } } } @@ -156,69 +151,69 @@ int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, if (!(cflag & X509_FLAG_NO_SIGNAME)) { if (X509_signature_print(bp, ci->signature, NULL) <= 0) { - goto err; + return 0; } } if (!(cflag & X509_FLAG_NO_ISSUER)) { if (BIO_printf(bp, " Issuer:%c", mlch) <= 0) { - goto err; + return 0; } if (X509_NAME_print_ex(bp, X509_get_issuer_name(x), nmindent, nmflags) < 0) { - goto err; + return 0; } if (BIO_write(bp, "\n", 1) <= 0) { - goto err; + return 0; } } if (!(cflag & X509_FLAG_NO_VALIDITY)) { if (BIO_write(bp, " Validity\n", 17) <= 0) { - goto err; + return 0; } if (BIO_write(bp, " Not Before: ", 24) <= 0) { - goto err; + return 0; } if (!ASN1_TIME_print(bp, X509_get_notBefore(x))) { - goto err; + return 0; } if (BIO_write(bp, "\n Not After : ", 25) <= 0) { - goto err; + return 0; } if (!ASN1_TIME_print(bp, X509_get_notAfter(x))) { - goto err; + return 0; } if (BIO_write(bp, "\n", 1) <= 0) { - goto err; + return 0; } } if (!(cflag & X509_FLAG_NO_SUBJECT)) { if (BIO_printf(bp, " Subject:%c", mlch) <= 0) { - goto err; + return 0; } if (X509_NAME_print_ex(bp, X509_get_subject_name(x), nmindent, nmflags) < 0) { - goto err; + return 0; } if (BIO_write(bp, "\n", 1) <= 0) { - goto err; + return 0; } } if (!(cflag & X509_FLAG_NO_PUBKEY)) { if (BIO_write(bp, " Subject Public Key Info:\n", 33) <= 0) { - goto err; + return 0; } if (BIO_printf(bp, "%12sPublic Key Algorithm: ", "") <= 0) { - goto err; + return 0; } if (i2a_ASN1_OBJECT(bp, ci->key->algor->algorithm) <= 0) { - goto err; + return 0; } if (BIO_puts(bp, "\n") <= 0) { - goto err; + return 0; } - pkey = X509_get_pubkey(x); + EVP_PKEY *pkey = X509_get_pubkey(x); if (pkey == NULL) { BIO_printf(bp, "%12sUnable to load Public Key\n", ""); ERR_print_errors(bp); @@ -231,18 +226,18 @@ int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, if (!(cflag & X509_FLAG_NO_IDS)) { if (ci->issuerUID) { if (BIO_printf(bp, "%8sIssuer Unique ID: ", "") <= 0) { - goto err; + return 0; } if (!X509_signature_dump(bp, ci->issuerUID, 12)) { - goto err; + return 0; } } if (ci->subjectUID) { if (BIO_printf(bp, "%8sSubject Unique ID: ", "") <= 0) { - goto err; + return 0; } if (!X509_signature_dump(bp, ci->subjectUID, 12)) { - goto err; + return 0; } } } @@ -253,20 +248,16 @@ int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, if (!(cflag & X509_FLAG_NO_SIGDUMP)) { if (X509_signature_print(bp, x->sig_alg, x->signature) <= 0) { - goto err; + return 0; } } if (!(cflag & X509_FLAG_NO_AUX)) { if (!X509_CERT_AUX_print(bp, x->aux, 0)) { - goto err; + return 0; } } - ret = 1; -err: - if (m != NULL) { - OPENSSL_free(m); - } - return ret; + + return 1; } int X509_signature_print(BIO *bp, const X509_ALGOR *sigalg, diff --git a/include/openssl/x509.h b/include/openssl/x509.h index 2ab7564b2d..8f32149b80 100644 --- a/include/openssl/x509.h +++ b/include/openssl/x509.h @@ -1300,7 +1300,216 @@ OPENSSL_EXPORT int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b); // // The following functions output human-readable representations of // X.509-related structures. They should only be used for debugging or logging -// and not parsed programmatically. +// and not parsed programmatically. In many cases, the outputs are ambiguous, so +// attempting to parse them can lead to string injection vulnerabilities. + +// The following flags control |X509_print_ex| and |X509_REQ_print_ex|. + +// X509_FLAG_COMPAT disables all flags. It additionally causes names to be +// printed with a 16-byte indent. +#define X509_FLAG_COMPAT 0 + +// X509_FLAG_NO_HEADER skips a header identifying the type of object printed. +#define X509_FLAG_NO_HEADER 1L + +// X509_FLAG_NO_VERSION skips printing the X.509 version number. +#define X509_FLAG_NO_VERSION (1L << 1) + +// X509_FLAG_NO_SERIAL skips printing the serial number. It is ignored in +// |X509_REQ_print_fp|. +#define X509_FLAG_NO_SERIAL (1L << 2) + +// X509_FLAG_NO_SIGNAME skips printing the signature algorithm in the +// TBSCertificate. It is ignored in |X509_REQ_print_fp|. +#define X509_FLAG_NO_SIGNAME (1L << 3) + +// X509_FLAG_NO_ISSUER skips printing the issuer. +#define X509_FLAG_NO_ISSUER (1L << 4) + +// X509_FLAG_NO_ISSUER skips printing the notBefore and notAfter times. It is +// ignored in |X509_REQ_print_fp|. +#define X509_FLAG_NO_VALIDITY (1L << 5) + +// X509_FLAG_NO_ISSUER skips printing the subject. +#define X509_FLAG_NO_SUBJECT (1L << 6) + +// X509_FLAG_NO_PUBKEY skips printing the public key. +#define X509_FLAG_NO_PUBKEY (1L << 7) + +// X509_FLAG_NO_EXTENSIONS skips printing the extension list. It is ignored in +// |X509_REQ_print_fp|. CSRs instead have attributes, which is controlled by +// |X509_FLAG_NO_ATTRIBUTES|. +#define X509_FLAG_NO_EXTENSIONS (1L << 8) + +// X509_FLAG_NO_SIGDUMP skips printing the signature and outer signature +// algorithm. +#define X509_FLAG_NO_SIGDUMP (1L << 9) + +// X509_FLAG_NO_AUX skips printing auxiliary properties. (See |d2i_X509_AUX| and +// related functions.) +#define X509_FLAG_NO_AUX (1L << 10) + +// X509_FLAG_NO_ATTRIBUTES skips printing CSR attributes. It does nothing for +// certificates and CRLs. +#define X509_FLAG_NO_ATTRIBUTES (1L << 11) + +// X509_FLAG_NO_IDS skips printing the issuerUniqueID and subjectUniqueID in a +// certificate. It is ignored in |X509_REQ_print_fp|. +#define X509_FLAG_NO_IDS (1L << 12) + +// X509_print_ex writes a human-readable representation of |x| to |bp|. It +// returns one on success and zero on error. |nmflags| is the flags parameter +// for |X509_NAME_print_ex| when printing the subject and issuer. |cflag| should +// be some combination of the |X509_FLAG_*| constants. +OPENSSL_EXPORT int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag, + unsigned long cflag); + +// X509_print_ex_fp behaves like |X509_print_ex| but writes to |fp|. +OPENSSL_EXPORT int X509_print_ex_fp(FILE *fp, X509 *x, unsigned long nmflag, + unsigned long cflag); + +// X509_print calls |X509_print_ex| with |XN_FLAG_COMPAT| and |X509_FLAG_COMPAT| +// flags. +OPENSSL_EXPORT int X509_print(BIO *bp, X509 *x); + +// X509_print_fp behaves like |X509_print| but writes to |fp|. +OPENSSL_EXPORT int X509_print_fp(FILE *fp, X509 *x); + +// X509_CRL_print writes a human-readable representation of |x| to |bp|. It +// returns one on success and zero on error. +OPENSSL_EXPORT int X509_CRL_print(BIO *bp, X509_CRL *x); + +// X509_CRL_print_fp behaves like |X509_CRL_print| but writes to |fp|. +OPENSSL_EXPORT int X509_CRL_print_fp(FILE *fp, X509_CRL *x); + +// X509_REQ_print_ex writes a human-readable representation of |x| to |bp|. It +// returns one on success and zero on error. |nmflags| is the flags parameter +// for |X509_NAME_print_ex|, when printing the subject. |cflag| should be some +// combination of the |X509_FLAG_*| constants. +OPENSSL_EXPORT int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag, + unsigned long cflag); + +// X509_REQ_print calls |X509_REQ_print_ex| with |XN_FLAG_COMPAT| and +// |X509_FLAG_COMPAT| flags. +OPENSSL_EXPORT int X509_REQ_print(BIO *bp, X509_REQ *req); + +// X509_REQ_print_fp behaves like |X509_REQ_print| but writes to |fp|. +OPENSSL_EXPORT int X509_REQ_print_fp(FILE *fp, X509_REQ *req); + +// The following flags are control |X509_NAME_print_ex|. They must not collide +// with |ASN1_STRFLGS_*|. +// +// TODO(davidben): This is far, far too many options and most of them are +// useless. Trim this down. + +// XN_FLAG_COMPAT prints with |X509_NAME_print|'s format and return value +// convention. +#define XN_FLAG_COMPAT 0 + +// XN_FLAG_SEP_MASK determines the separators to use between attributes. +#define XN_FLAG_SEP_MASK (0xf << 16) + +// XN_FLAG_SEP_COMMA_PLUS separates RDNs with "," and attributes within an RDN +// with "+", as in RFC 2253. +#define XN_FLAG_SEP_COMMA_PLUS (1 << 16) + +// XN_FLAG_SEP_CPLUS_SPC behaves like |XN_FLAG_SEP_COMMA_PLUS| but adds spaces +// between the separators. +#define XN_FLAG_SEP_CPLUS_SPC (2 << 16) + +// XN_FLAG_SEP_SPLUS_SPC separates RDNs with "; " and attributes within an RDN +// with " + ". +#define XN_FLAG_SEP_SPLUS_SPC (3 << 16) + +// XN_FLAG_SEP_MULTILINE prints each attribute on one line. +#define XN_FLAG_SEP_MULTILINE (4 << 16) + +// XN_FLAG_DN_REV prints RDNs in reverse, from least significant to most +// significant, as RFC 2253. +#define XN_FLAG_DN_REV (1 << 20) + +// XN_FLAG_FN_MASK determines how attribute types are displayed. +#define XN_FLAG_FN_MASK (0x3 << 21) + +// XN_FLAG_FN_SN uses the attribute type's short name, when available. +#define XN_FLAG_FN_SN 0 + +// XN_FLAG_FN_LN uses the attribute type's long name, when available. +#define XN_FLAG_FN_LN (1 << 21) + +// XN_FLAG_FN_OID always prints attribute types as OIDs. +#define XN_FLAG_FN_OID (2 << 21) + +// XN_FLAG_FN_NONE skips printing field names. +#define XN_FLAG_FN_NONE (3 << 21) + +// XN_FLAG_SPC_EQ wraps the "=" operator with spaces when printing attributes. +#define XN_FLAG_SPC_EQ (1 << 23) + +// XN_FLAG_DUMP_UNKNOWN_FIELDS causes unknown attribute types to be printed in +// hex, as in RFC 2253. +#define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24) + +// XN_FLAG_FN_ALIGN aligns attribute names to 10 characters if using short +// names, and 25 characters if using long names. +#define XN_FLAG_FN_ALIGN (1 << 25) + +// XN_FLAG_RFC2253 prints like RFC 2253. +#define XN_FLAG_RFC2253 \ + (ASN1_STRFLGS_RFC2253 | XN_FLAG_SEP_COMMA_PLUS | XN_FLAG_DN_REV | \ + XN_FLAG_FN_SN | XN_FLAG_DUMP_UNKNOWN_FIELDS) + +// XN_FLAG_ONELINE prints a one-line representation of the name. +#define XN_FLAG_ONELINE \ + (ASN1_STRFLGS_RFC2253 | ASN1_STRFLGS_ESC_QUOTE | XN_FLAG_SEP_CPLUS_SPC | \ + XN_FLAG_SPC_EQ | XN_FLAG_FN_SN) + +// XN_FLAG_MULTILINE prints a multi-line representation of the name. +#define XN_FLAG_MULTILINE \ + (ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | XN_FLAG_SEP_MULTILINE | \ + XN_FLAG_SPC_EQ | XN_FLAG_FN_LN | XN_FLAG_FN_ALIGN) + +// X509_NAME_print_ex writes a human-readable representation of |nm| to |out|. +// Each line of output is indented by |indent| spaces. It returns the number of +// bytes written on success, and -1 on error. If |out| is NULL, it returns the +// number of bytes it would have written but does not write anything. |flags| +// should be some combination of |XN_FLAG_*| and |ASN1_STRFLGS_*| values and +// determines the output. If unsure, use |XN_FLAG_RFC2253|. +// +// If |flags| is |XN_FLAG_COMPAT|, or zero, this function calls +// |X509_NAME_print| instead. In that case, it returns one on success, rather +// than the output length. +OPENSSL_EXPORT int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent, + unsigned long flags); + +// X509_NAME_print prints a human-readable representation of |name| to |bp|. It +// returns one on success and zero on error. |obase| is ignored. +// +// This function outputs a legacy format that does not correctly handle string +// encodings and other cases. Prefer |X509_NAME_print_ex| if printing a name for +// debugging purposes. +OPENSSL_EXPORT int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase); + +// X509_NAME_oneline writes a human-readable representation to |name| to a +// buffer as a NUL-terminated C string. +// +// If |buf| is NULL, returns a newly-allocated buffer containing the result on +// success, or NULL on error. The buffer must be released with |OPENSSL_free| +// when done. +// +// If |buf| is non-NULL, at most |size| bytes of output are written to |buf| +// instead. |size| includes the trailing NUL. The function then returns |buf| on +// success or NULL on error. If the output does not fit in |size| bytes, the +// output is silently truncated at an attribute boundary. +// +// This function outputs a legacy format that does not correctly handle string +// encodings and other cases. Prefer |X509_NAME_print_ex| if printing a name for +// debugging purposes. +OPENSSL_EXPORT char *X509_NAME_oneline(const X509_NAME *name, char *buf, int size); + +// X509_NAME_print_ex_fp behaves like |X509_NAME_print_ex| but writes to |fp|. +OPENSSL_EXPORT int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, + int indent, unsigned long flags); // X509_signature_dump writes a human-readable representation of |sig| to |bio|, // indented with |indent| spaces. It returns one on success and zero on error. @@ -1631,74 +1840,6 @@ DEFINE_STACK_OF(X509_TRUST) #define X509_TRUST_REJECTED 2 #define X509_TRUST_UNTRUSTED 3 -// Flags for X509_print_ex() - -#define X509_FLAG_COMPAT 0 -#define X509_FLAG_NO_HEADER 1L -#define X509_FLAG_NO_VERSION (1L << 1) -#define X509_FLAG_NO_SERIAL (1L << 2) -#define X509_FLAG_NO_SIGNAME (1L << 3) -#define X509_FLAG_NO_ISSUER (1L << 4) -#define X509_FLAG_NO_VALIDITY (1L << 5) -#define X509_FLAG_NO_SUBJECT (1L << 6) -#define X509_FLAG_NO_PUBKEY (1L << 7) -#define X509_FLAG_NO_EXTENSIONS (1L << 8) -#define X509_FLAG_NO_SIGDUMP (1L << 9) -#define X509_FLAG_NO_AUX (1L << 10) -#define X509_FLAG_NO_ATTRIBUTES (1L << 11) -#define X509_FLAG_NO_IDS (1L << 12) - -// Flags specific to X509_NAME_print_ex(). These flags must not collide with -// |ASN1_STRFLGS_*|. - -// The field separator information - -#define XN_FLAG_SEP_MASK (0xf << 16) - -#define XN_FLAG_COMPAT 0 // Traditional SSLeay: use old X509_NAME_print -#define XN_FLAG_SEP_COMMA_PLUS (1 << 16) // RFC 2253 ,+ -#define XN_FLAG_SEP_CPLUS_SPC (2 << 16) // ,+ spaced: more readable -#define XN_FLAG_SEP_SPLUS_SPC (3 << 16) // ;+ spaced -#define XN_FLAG_SEP_MULTILINE (4 << 16) // One line per field - -#define XN_FLAG_DN_REV (1 << 20) // Reverse DN order - -// How the field name is shown - -#define XN_FLAG_FN_MASK (0x3 << 21) - -#define XN_FLAG_FN_SN 0 // Object short name -#define XN_FLAG_FN_LN (1 << 21) // Object long name -#define XN_FLAG_FN_OID (2 << 21) // Always use OIDs -#define XN_FLAG_FN_NONE (3 << 21) // No field names - -#define XN_FLAG_SPC_EQ (1 << 23) // Put spaces round '=' - -// This determines if we dump fields we don't recognise: -// RFC 2253 requires this. - -#define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24) - -#define XN_FLAG_FN_ALIGN (1 << 25) // Align field names to 20 characters - -// Complete set of RFC 2253 flags - -#define XN_FLAG_RFC2253 \ - (ASN1_STRFLGS_RFC2253 | XN_FLAG_SEP_COMMA_PLUS | XN_FLAG_DN_REV | \ - XN_FLAG_FN_SN | XN_FLAG_DUMP_UNKNOWN_FIELDS) - -// readable oneline form - -#define XN_FLAG_ONELINE \ - (ASN1_STRFLGS_RFC2253 | ASN1_STRFLGS_ESC_QUOTE | XN_FLAG_SEP_CPLUS_SPC | \ - XN_FLAG_SPC_EQ | XN_FLAG_FN_SN) - -// readable multiline form - -#define XN_FLAG_MULTILINE \ - (ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | XN_FLAG_SEP_MULTILINE | \ - XN_FLAG_SPC_EQ | XN_FLAG_FN_LN | XN_FLAG_FN_ALIGN) - DEFINE_STACK_OF(X509_REVOKED) DECLARE_STACK_OF(GENERAL_NAMES) @@ -1921,7 +2062,6 @@ DECLARE_ASN1_FUNCTIONS_const(NETSCAPE_SPKAC) OPENSSL_EXPORT X509_INFO *X509_INFO_new(void); OPENSSL_EXPORT void X509_INFO_free(X509_INFO *a); -OPENSSL_EXPORT char *X509_NAME_oneline(const X509_NAME *a, char *buf, int size); OPENSSL_EXPORT int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data, unsigned char *md, unsigned int *len); @@ -2082,24 +2222,6 @@ OPENSSL_EXPORT unsigned long X509_NAME_hash_old(X509_NAME *x); OPENSSL_EXPORT int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b); OPENSSL_EXPORT int X509_CRL_match(const X509_CRL *a, const X509_CRL *b); -OPENSSL_EXPORT int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag, - unsigned long cflag); -OPENSSL_EXPORT int X509_print_fp(FILE *bp, X509 *x); -OPENSSL_EXPORT int X509_CRL_print_fp(FILE *bp, X509_CRL *x); -OPENSSL_EXPORT int X509_REQ_print_fp(FILE *bp, X509_REQ *req); -OPENSSL_EXPORT int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, - int indent, unsigned long flags); - -OPENSSL_EXPORT int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase); -OPENSSL_EXPORT int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent, - unsigned long flags); -OPENSSL_EXPORT int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag, - unsigned long cflag); -OPENSSL_EXPORT int X509_print(BIO *bp, X509 *x); -OPENSSL_EXPORT int X509_CRL_print(BIO *bp, X509_CRL *x); -OPENSSL_EXPORT int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag, - unsigned long cflag); -OPENSSL_EXPORT int X509_REQ_print(BIO *bp, X509_REQ *req); // X509_get_ext_d2i behaves like |X509V3_get_d2i| but looks for the extension in // |x509|'s extension list. From 787713b2ff9fc4480b9506db2ed1617adf0bba70 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 10:28:13 -0400 Subject: [PATCH 22/56] Organize X509_ATTRIBUTE functions into sections. Also organize the low-level signature verification functions. I missed those in the first pass. Bug: 426 Change-Id: I9c93d643d8f0f77a35ee132f31377ba447f2f2f1 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58926 Commit-Queue: David Benjamin Reviewed-by: Bob Beck --- include/openssl/x509.h | 683 +++++++++++++++++++++-------------------- 1 file changed, 356 insertions(+), 327 deletions(-) diff --git a/include/openssl/x509.h b/include/openssl/x509.h index 8f32149b80..a7e20b4f86 100644 --- a/include/openssl/x509.h +++ b/include/openssl/x509.h @@ -277,6 +277,12 @@ OPENSSL_EXPORT int X509_get_signature_nid(const X509 *x509); // |i2d_re_X509_tbs| instead. OPENSSL_EXPORT int i2d_X509_tbs(X509 *x509, unsigned char **outp); +// X509_verify checks that |x509| has a valid signature by |pkey|. It returns +// one if the signature is valid and zero otherwise. Note this function only +// checks the signature itself and does not perform a full certificate +// validation. +OPENSSL_EXPORT int X509_verify(X509 *x509, EVP_PKEY *pkey); + // Issuing certificates. // @@ -576,6 +582,10 @@ OPENSSL_EXPORT int X509_CRL_get_signature_nid(const X509_CRL *crl); // instead. OPENSSL_EXPORT int i2d_X509_CRL_tbs(X509_CRL *crl, unsigned char **outp); +// X509_CRL_verify checks that |crl| has a valid signature by |pkey|. It returns +// one if the signature is valid and zero otherwise. +OPENSSL_EXPORT int X509_CRL_verify(X509_CRL *crl, EVP_PKEY *pkey); + // Issuing certificate revocation lists. // @@ -710,7 +720,6 @@ OPENSSL_EXPORT X509_REQ *d2i_X509_REQ(X509_REQ **out, const uint8_t **inp, // mutated. OPENSSL_EXPORT int i2d_X509_REQ(X509_REQ *req, uint8_t **outp); - // X509_REQ_VERSION_1 is the version constant for |X509_REQ| objects. No other // versions are defined. #define X509_REQ_VERSION_1 0 @@ -731,6 +740,46 @@ OPENSSL_EXPORT X509_NAME *X509_REQ_get_subject_name(const X509_REQ *req); // |EVP_PKEY_free| when done. OPENSSL_EXPORT EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req); +// X509_REQ_get_attr_count returns the number of attributes in |req|. +OPENSSL_EXPORT int X509_REQ_get_attr_count(const X509_REQ *req); + +// X509_REQ_get_attr returns the attribute at index |loc| in |req|, or NULL if +// out of bounds. +OPENSSL_EXPORT X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc); + +// X509_REQ_get_attr_by_NID returns the index of the attribute in |req| of type +// |nid|, or a negative number if not found. If found, callers can use +// |X509_REQ_get_attr| to look up the attribute by index. +// +// If |lastpos| is non-negative, it begins searching at |lastpos| + 1. Callers +// can thus loop over all matching attributes by first passing -1 and then +// passing the previously-returned value until no match is returned. +OPENSSL_EXPORT int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, + int lastpos); + +// X509_REQ_get_attr_by_OBJ behaves like |X509_REQ_get_attr_by_NID| but looks +// for attributes of type |obj|. +OPENSSL_EXPORT int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, + const ASN1_OBJECT *obj, + int lastpos); + +// X509_REQ_extension_nid returns one if |nid| is a supported CSR attribute type +// for carrying extensions and zero otherwise. The supported types are +// |NID_ext_req| (pkcs-9-at-extensionRequest from RFC 2985) and |NID_ms_ext_req| +// (a Microsoft szOID_CERT_EXTENSIONS variant). +OPENSSL_EXPORT int X509_REQ_extension_nid(int nid); + +// X509_REQ_get_extensions decodes the list of requested extensions in |req| and +// returns a newly-allocated |STACK_OF(X509_EXTENSION)| containing the result. +// It returns NULL on error, or if |req| did not request extensions. +// +// CSRs do not store extensions directly. Instead there are attribute types +// which are defined to hold extensions. See |X509_REQ_extension_nid|. This +// function supports both pkcs-9-at-extensionRequest from RFC 2985 and the +// Microsoft szOID_CERT_EXTENSIONS variant. If both are present, +// pkcs-9-at-extensionRequest is preferred. +OPENSSL_EXPORT STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req); + // X509_REQ_get0_signature sets |*out_sig| and |*out_alg| to the signature and // signature algorithm of |req|, respectively. Either output pointer may be NULL // to ignore the value. @@ -743,6 +792,10 @@ OPENSSL_EXPORT void X509_REQ_get0_signature(const X509_REQ *req, // a known NID. OPENSSL_EXPORT int X509_REQ_get_signature_nid(const X509_REQ *req); +// X509_REQ_verify checks that |req| has a valid signature by |pkey|. It returns +// one if the signature is valid and zero otherwise. +OPENSSL_EXPORT int X509_REQ_verify(X509_REQ *req, EVP_PKEY *pkey); + // Issuing certificate requests. // @@ -770,6 +823,56 @@ OPENSSL_EXPORT int X509_REQ_set_subject_name(X509_REQ *req, X509_NAME *name); // and internally copies and updates reference counts as needed. OPENSSL_EXPORT int X509_REQ_set_pubkey(X509_REQ *req, EVP_PKEY *pkey); +// X509_REQ_delete_attr removes the attribute at index |loc| in |req|. It +// returns the removed attribute to the caller, or NULL if |loc| was out of +// bounds. If non-NULL, the caller must release the result with +// |X509_ATTRIBUTE_free| when done. It is also safe, but not necessary, to call +// |X509_ATTRIBUTE_free| if the result is NULL. +OPENSSL_EXPORT X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc); + +// X509_REQ_add1_attr appends a copy of |attr| to |req|'s list of attributes. It +// returns one on success and zero on error. +// +// TODO(https://crbug.com/boringssl/407): |attr| should be const. +OPENSSL_EXPORT int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr); + +// X509_REQ_add1_attr_by_OBJ appends a new attribute to |req| with type |obj|. +// It returns one on success and zero on error. The value is determined by +// |X509_ATTRIBUTE_set1_data|. +// +// WARNING: The interpretation of |attrtype|, |data|, and |len| is complex and +// error-prone. See |X509_ATTRIBUTE_set1_data| for details. +OPENSSL_EXPORT int X509_REQ_add1_attr_by_OBJ(X509_REQ *req, + const ASN1_OBJECT *obj, + int attrtype, + const unsigned char *data, + int len); + +// X509_REQ_add1_attr_by_NID behaves like |X509_REQ_add1_attr_by_OBJ| except the +// attribute type is determined by |nid|. +OPENSSL_EXPORT int X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, + int attrtype, + const unsigned char *data, + int len); + +// X509_REQ_add1_attr_by_txt behaves like |X509_REQ_add1_attr_by_OBJ| except the +// attribute type is determined by calling |OBJ_txt2obj| with |attrname|. +OPENSSL_EXPORT int X509_REQ_add1_attr_by_txt(X509_REQ *req, + const char *attrname, int attrtype, + const unsigned char *data, + int len); + +// X509_REQ_add_extensions_nid adds an attribute to |req| of type |nid|, to +// request the certificate extensions in |exts|. It returns one on success and +// zero on error. |nid| should be |NID_ext_req| or |NID_ms_ext_req|. +OPENSSL_EXPORT int X509_REQ_add_extensions_nid( + X509_REQ *req, const STACK_OF(X509_EXTENSION) *exts, int nid); + +// X509_REQ_add_extensions behaves like |X509_REQ_add_extensions_nid|, using the +// standard |NID_ext_req| for the attribute type. +OPENSSL_EXPORT int X509_REQ_add_extensions( + X509_REQ *req, const STACK_OF(X509_EXTENSION) *exts); + // X509_REQ_sign signs |req| with |pkey| and replaces the signature algorithm // and signature fields. It returns one on success and zero on error. This // function uses digest algorithm |md|, or |pkey|'s default if NULL. Other @@ -1296,88 +1399,278 @@ OPENSSL_EXPORT void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md); OPENSSL_EXPORT int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b); -// Printing functions. +// Attributes. // -// The following functions output human-readable representations of -// X.509-related structures. They should only be used for debugging or logging -// and not parsed programmatically. In many cases, the outputs are ambiguous, so -// attempting to parse them can lead to string injection vulnerabilities. - -// The following flags control |X509_print_ex| and |X509_REQ_print_ex|. +// Unlike certificates and CRLs, CSRs use a separate Attribute structure (RFC +// 2985, RFC 2986) for extensibility. This is represented by the library as +// |X509_ATTRIBUTE|. -// X509_FLAG_COMPAT disables all flags. It additionally causes names to be -// printed with a 16-byte indent. -#define X509_FLAG_COMPAT 0 +DEFINE_STACK_OF(X509_ATTRIBUTE) -// X509_FLAG_NO_HEADER skips a header identifying the type of object printed. -#define X509_FLAG_NO_HEADER 1L +// X509_ATTRIBUTE is an |ASN1_ITEM| whose ASN.1 type is Attribute (RFC 2986) and +// C type is |X509_ATTRIBUTE*|. +DECLARE_ASN1_ITEM(X509_ATTRIBUTE) -// X509_FLAG_NO_VERSION skips printing the X.509 version number. -#define X509_FLAG_NO_VERSION (1L << 1) +// X509_ATTRIBUTE_new returns a newly-allocated, empty |X509_ATTRIBUTE| object, +// or NULL on error. |X509_ATTRIBUTE_set1_*| may be used to finish initializing +// it. +OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_new(void); -// X509_FLAG_NO_SERIAL skips printing the serial number. It is ignored in -// |X509_REQ_print_fp|. -#define X509_FLAG_NO_SERIAL (1L << 2) +// X509_ATTRIBUTE_dup returns a newly-allocated copy of |attr|, or NULL on +// error. This function works by serializing the structure, so if |attr| is +// incomplete, it may fail. +OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_dup(const X509_ATTRIBUTE *attr); -// X509_FLAG_NO_SIGNAME skips printing the signature algorithm in the -// TBSCertificate. It is ignored in |X509_REQ_print_fp|. -#define X509_FLAG_NO_SIGNAME (1L << 3) +// X509_ATTRIBUTE_free releases memory associated with |attr|. +OPENSSL_EXPORT void X509_ATTRIBUTE_free(X509_ATTRIBUTE *attr); -// X509_FLAG_NO_ISSUER skips printing the issuer. -#define X509_FLAG_NO_ISSUER (1L << 4) +// d2i_X509_ATTRIBUTE parses up to |len| bytes from |*inp| as a DER-encoded +// Attribute (RFC 2986), as described in |d2i_SAMPLE|. +OPENSSL_EXPORT X509_ATTRIBUTE *d2i_X509_ATTRIBUTE(X509_ATTRIBUTE **out, + const uint8_t **inp, + long len); -// X509_FLAG_NO_ISSUER skips printing the notBefore and notAfter times. It is -// ignored in |X509_REQ_print_fp|. -#define X509_FLAG_NO_VALIDITY (1L << 5) +// i2d_X509_ATTRIBUTE marshals |alg| as a DER-encoded Attribute (RFC 2986), as +// described in |i2d_SAMPLE|. +OPENSSL_EXPORT int i2d_X509_ATTRIBUTE(const X509_ATTRIBUTE *alg, + uint8_t **outp); -// X509_FLAG_NO_ISSUER skips printing the subject. -#define X509_FLAG_NO_SUBJECT (1L << 6) +// X509_ATTRIBUTE_create returns a newly-allocated |X509_ATTRIBUTE|, or NULL on +// error. The attribute has type |nid| and contains a single value determined by +// |attrtype| and |value|, which are interpreted as in |ASN1_TYPE_set|. Note +// this function takes ownership of |value|. +OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int attrtype, + void *value); -// X509_FLAG_NO_PUBKEY skips printing the public key. -#define X509_FLAG_NO_PUBKEY (1L << 7) +// X509_ATTRIBUTE_create_by_NID returns a newly-allocated |X509_ATTRIBUTE| of +// type |nid|, or NULL on error. The value is determined as in +// |X509_ATTRIBUTE_set1_data|. +// +// If |attr| is non-NULL, the resulting |X509_ATTRIBUTE| is also written to +// |*attr|. If |*attr| was non-NULL when the function was called, |*attr| is +// reused instead of creating a new object. +// +// WARNING: The interpretation of |attrtype|, |data|, and |len| is complex and +// error-prone. See |X509_ATTRIBUTE_set1_data| for details. +// +// WARNING: The object reuse form is deprecated and may be removed in the +// future. It also currently incorrectly appends to the reused object's value +// set rather than overwriting it. +OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID( + X509_ATTRIBUTE **attr, int nid, int attrtype, const void *data, int len); -// X509_FLAG_NO_EXTENSIONS skips printing the extension list. It is ignored in -// |X509_REQ_print_fp|. CSRs instead have attributes, which is controlled by -// |X509_FLAG_NO_ATTRIBUTES|. -#define X509_FLAG_NO_EXTENSIONS (1L << 8) +// X509_ATTRIBUTE_create_by_OBJ behaves like |X509_ATTRIBUTE_create_by_NID| +// except the attribute's type is determined by |obj|. +OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ( + X509_ATTRIBUTE **attr, const ASN1_OBJECT *obj, int attrtype, + const void *data, int len); -// X509_FLAG_NO_SIGDUMP skips printing the signature and outer signature -// algorithm. -#define X509_FLAG_NO_SIGDUMP (1L << 9) +// X509_ATTRIBUTE_create_by_txt behaves like |X509_ATTRIBUTE_create_by_NID| +// except the attribute's type is determined by calling |OBJ_txt2obj| with +// |attrname|. +OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt( + X509_ATTRIBUTE **attr, const char *attrname, int type, + const unsigned char *bytes, int len); -// X509_FLAG_NO_AUX skips printing auxiliary properties. (See |d2i_X509_AUX| and -// related functions.) -#define X509_FLAG_NO_AUX (1L << 10) +// X509_ATTRIBUTE_set1_object sets |attr|'s type to |obj|. It returns one on +// success and zero on error. +OPENSSL_EXPORT int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, + const ASN1_OBJECT *obj); -// X509_FLAG_NO_ATTRIBUTES skips printing CSR attributes. It does nothing for -// certificates and CRLs. -#define X509_FLAG_NO_ATTRIBUTES (1L << 11) +// X509_ATTRIBUTE_set1_data appends a value to |attr|'s value set and returns +// one on success or zero on error. The value is determined as follows: +// +// If |attrtype| is a |MBSTRING_*| constant, the value is an ASN.1 string. The +// string is determined by decoding |len| bytes from |data| in the encoding +// specified by |attrtype|, and then re-encoding it in a form appropriate for +// |attr|'s type. If |len| is -1, |strlen(data)| is used instead. See +// |ASN1_STRING_set_by_NID| for details. +// +// Otherwise, if |len| is not -1, the value is an ASN.1 string. |attrtype| is an +// |ASN1_STRING| type value and the |len| bytes from |data| are copied as the +// type-specific representation of |ASN1_STRING|. See |ASN1_STRING| for details. +// +// WARNING: If this form is used to construct a negative INTEGER or ENUMERATED, +// |attrtype| includes the |V_ASN1_NEG| flag for |ASN1_STRING|, but the function +// forgets to clear the flag for |ASN1_TYPE|. This matches OpenSSL but is +// probably a bug. For now, do not use this form with negative values. +// +// Otherwise, if |len| is -1, the value is constructed by passing |attrtype| and +// |data| to |ASN1_TYPE_set1|. That is, |attrtype| is an |ASN1_TYPE| type value, +// and |data| is cast to the corresponding pointer type. +// +// WARNING: Despite the name, this function appends to |attr|'s value set, +// rather than overwriting it. To overwrite the value set, create a new +// |X509_ATTRIBUTE| with |X509_ATTRIBUTE_new|. +// +// WARNING: If using the |MBSTRING_*| form, pass a length rather than relying on +// |strlen|. In particular, |strlen| will not behave correctly if the input is +// |MBSTRING_BMP| or |MBSTRING_UNIV|. +// +// WARNING: This function currently misinterprets |V_ASN1_OTHER| as an +// |MBSTRING_*| constant. This matches OpenSSL but means it is impossible to +// construct a value with a non-universal tag. +OPENSSL_EXPORT int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, + const void *data, int len); -// X509_FLAG_NO_IDS skips printing the issuerUniqueID and subjectUniqueID in a -// certificate. It is ignored in |X509_REQ_print_fp|. -#define X509_FLAG_NO_IDS (1L << 12) +// X509_ATTRIBUTE_get0_data returns the |idx|th value of |attr| in a +// type-specific representation to |attrtype|, or NULL if out of bounds or the +// type does not match. |attrtype| is one of the type values in |ASN1_TYPE|. On +// match, the return value uses the same representation as |ASN1_TYPE_set0|. See +// |ASN1_TYPE| for details. +OPENSSL_EXPORT void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, + int attrtype, void *unused); -// X509_print_ex writes a human-readable representation of |x| to |bp|. It -// returns one on success and zero on error. |nmflags| is the flags parameter -// for |X509_NAME_print_ex| when printing the subject and issuer. |cflag| should -// be some combination of the |X509_FLAG_*| constants. -OPENSSL_EXPORT int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag, - unsigned long cflag); +// X509_ATTRIBUTE_count returns the number of values in |attr|. +OPENSSL_EXPORT int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr); -// X509_print_ex_fp behaves like |X509_print_ex| but writes to |fp|. -OPENSSL_EXPORT int X509_print_ex_fp(FILE *fp, X509 *x, unsigned long nmflag, - unsigned long cflag); +// X509_ATTRIBUTE_get0_object returns the type of |attr|. +OPENSSL_EXPORT ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr); -// X509_print calls |X509_print_ex| with |XN_FLAG_COMPAT| and |X509_FLAG_COMPAT| -// flags. -OPENSSL_EXPORT int X509_print(BIO *bp, X509 *x); +// X509_ATTRIBUTE_get0_type returns the |idx|th value in |attr|, or NULL if out +// of bounds. Note this function returns one of |attr|'s values, not the type. +OPENSSL_EXPORT ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, + int idx); -// X509_print_fp behaves like |X509_print| but writes to |fp|. -OPENSSL_EXPORT int X509_print_fp(FILE *fp, X509 *x); +// X509at_get_attr_count returns the number of attributes in |x|. +OPENSSL_EXPORT int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x); -// X509_CRL_print writes a human-readable representation of |x| to |bp|. It -// returns one on success and zero on error. -OPENSSL_EXPORT int X509_CRL_print(BIO *bp, X509_CRL *x); +// X509at_get_attr_by_NID returns the index of the attribute in |x| of type +// |nid|, or a negative number if not found. If found, callers can use +// |X509at_get_attr| to look up the attribute by index. +// +// If |lastpos| is non-negative, it begins searching at |lastpos| + 1. Callers +// can thus loop over all matching attributes by first passing -1 and then +// passing the previously-returned value until no match is returned. +OPENSSL_EXPORT int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, + int nid, int lastpos); + +// X509at_get_attr_by_OBJ behaves like |X509at_get_attr_by_NID| but looks for +// attributes of type |obj|. +OPENSSL_EXPORT int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, + const ASN1_OBJECT *obj, int lastpos); + +// X509at_get_attr returns the attribute at index |loc| in |x|, or NULL if +// out of bounds. +OPENSSL_EXPORT X509_ATTRIBUTE *X509at_get_attr( + const STACK_OF(X509_ATTRIBUTE) *x, int loc); + +// X509at_delete_attr removes the attribute at index |loc| in |x|. It returns +// the removed attribute to the caller, or NULL if |loc| was out of bounds. If +// non-NULL, the caller must release the result with |X509_ATTRIBUTE_free| when +// done. +OPENSSL_EXPORT X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, + int loc); + +// X509at_add1_attr appends a copy of |attr| to the attribute list in |*x|. If +// |*x| is NULL, it allocates a new |STACK_OF(X509_ATTRIBUTE)| to hold the copy +// and sets |*x| to the new list. It returns |*x| on success and NULL on error. +// The caller retains ownership of |attr| and can release it independently of +// |*x|. +OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr( + STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr); + +// X509at_add1_attr_by_OBJ behaves like |X509at_add1_attr|, but adds an +// attribute created by |X509_ATTRIBUTE_create_by_OBJ|. +OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ( + STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj, int type, + const unsigned char *bytes, int len); + +// X509at_add1_attr_by_NID behaves like |X509at_add1_attr|, but adds an +// attribute created by |X509_ATTRIBUTE_create_by_NID|. +OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID( + STACK_OF(X509_ATTRIBUTE) **x, int nid, int type, const unsigned char *bytes, + int len); + +// X509at_add1_attr_by_txt behaves like |X509at_add1_attr|, but adds an +// attribute created by |X509_ATTRIBUTE_create_by_txt|. +OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt( + STACK_OF(X509_ATTRIBUTE) **x, const char *attrname, int type, + const unsigned char *bytes, int len); + + +// Printing functions. +// +// The following functions output human-readable representations of +// X.509-related structures. They should only be used for debugging or logging +// and not parsed programmatically. In many cases, the outputs are ambiguous, so +// attempting to parse them can lead to string injection vulnerabilities. + +// The following flags control |X509_print_ex| and |X509_REQ_print_ex|. + +// X509_FLAG_COMPAT disables all flags. It additionally causes names to be +// printed with a 16-byte indent. +#define X509_FLAG_COMPAT 0 + +// X509_FLAG_NO_HEADER skips a header identifying the type of object printed. +#define X509_FLAG_NO_HEADER 1L + +// X509_FLAG_NO_VERSION skips printing the X.509 version number. +#define X509_FLAG_NO_VERSION (1L << 1) + +// X509_FLAG_NO_SERIAL skips printing the serial number. It is ignored in +// |X509_REQ_print_fp|. +#define X509_FLAG_NO_SERIAL (1L << 2) + +// X509_FLAG_NO_SIGNAME skips printing the signature algorithm in the +// TBSCertificate. It is ignored in |X509_REQ_print_fp|. +#define X509_FLAG_NO_SIGNAME (1L << 3) + +// X509_FLAG_NO_ISSUER skips printing the issuer. +#define X509_FLAG_NO_ISSUER (1L << 4) + +// X509_FLAG_NO_ISSUER skips printing the notBefore and notAfter times. It is +// ignored in |X509_REQ_print_fp|. +#define X509_FLAG_NO_VALIDITY (1L << 5) + +// X509_FLAG_NO_ISSUER skips printing the subject. +#define X509_FLAG_NO_SUBJECT (1L << 6) + +// X509_FLAG_NO_PUBKEY skips printing the public key. +#define X509_FLAG_NO_PUBKEY (1L << 7) + +// X509_FLAG_NO_EXTENSIONS skips printing the extension list. It is ignored in +// |X509_REQ_print_fp|. CSRs instead have attributes, which is controlled by +// |X509_FLAG_NO_ATTRIBUTES|. +#define X509_FLAG_NO_EXTENSIONS (1L << 8) + +// X509_FLAG_NO_SIGDUMP skips printing the signature and outer signature +// algorithm. +#define X509_FLAG_NO_SIGDUMP (1L << 9) + +// X509_FLAG_NO_AUX skips printing auxiliary properties. (See |d2i_X509_AUX| and +// related functions.) +#define X509_FLAG_NO_AUX (1L << 10) + +// X509_FLAG_NO_ATTRIBUTES skips printing CSR attributes. It does nothing for +// certificates and CRLs. +#define X509_FLAG_NO_ATTRIBUTES (1L << 11) + +// X509_FLAG_NO_IDS skips printing the issuerUniqueID and subjectUniqueID in a +// certificate. It is ignored in |X509_REQ_print_fp|. +#define X509_FLAG_NO_IDS (1L << 12) + +// X509_print_ex writes a human-readable representation of |x| to |bp|. It +// returns one on success and zero on error. |nmflags| is the flags parameter +// for |X509_NAME_print_ex| when printing the subject and issuer. |cflag| should +// be some combination of the |X509_FLAG_*| constants. +OPENSSL_EXPORT int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag, + unsigned long cflag); + +// X509_print_ex_fp behaves like |X509_print_ex| but writes to |fp|. +OPENSSL_EXPORT int X509_print_ex_fp(FILE *fp, X509 *x, unsigned long nmflag, + unsigned long cflag); + +// X509_print calls |X509_print_ex| with |XN_FLAG_COMPAT| and |X509_FLAG_COMPAT| +// flags. +OPENSSL_EXPORT int X509_print(BIO *bp, X509 *x); + +// X509_print_fp behaves like |X509_print| but writes to |fp|. +OPENSSL_EXPORT int X509_print_fp(FILE *fp, X509 *x); + +// X509_CRL_print writes a human-readable representation of |x| to |bp|. It +// returns one on success and zero on error. +OPENSSL_EXPORT int X509_CRL_print(BIO *bp, X509_CRL *x); // X509_CRL_print_fp behaves like |X509_CRL_print| but writes to |fp|. OPENSSL_EXPORT int X509_CRL_print_fp(FILE *fp, X509_CRL *x); @@ -1789,8 +2082,6 @@ struct X509_algor_st { #define X509v3_KU_DECIPHER_ONLY 0x8000 #define X509v3_KU_UNDEF 0xffff -DEFINE_STACK_OF(X509_ATTRIBUTE) - // This stuff is certificate "auxiliary info" // it contains details which are useful in certificate // stores and databases. When used this is tagged onto @@ -1914,20 +2205,6 @@ OPENSSL_EXPORT void X509_SIG_getm(X509_SIG *sig, X509_ALGOR **out_alg, // a default description. OPENSSL_EXPORT const char *X509_verify_cert_error_string(long err); -// X509_verify checks that |x509| has a valid signature by |pkey|. It returns -// one if the signature is valid and zero otherwise. Note this function only -// checks the signature itself and does not perform a full certificate -// validation. -OPENSSL_EXPORT int X509_verify(X509 *x509, EVP_PKEY *pkey); - -// X509_REQ_verify checks that |req| has a valid signature by |pkey|. It returns -// one if the signature is valid and zero otherwise. -OPENSSL_EXPORT int X509_REQ_verify(X509_REQ *req, EVP_PKEY *pkey); - -// X509_CRL_verify checks that |crl| has a valid signature by |pkey|. It returns -// one if the signature is valid and zero otherwise. -OPENSSL_EXPORT int X509_CRL_verify(X509_CRL *crl, EVP_PKEY *pkey); - // NETSCAPE_SPKI_verify checks that |spki| has a valid signature by |pkey|. It // returns one if the signature is valid and zero otherwise. OPENSSL_EXPORT int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *spki, EVP_PKEY *pkey); @@ -1964,11 +2241,6 @@ OPENSSL_EXPORT int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *spki, OPENSSL_EXPORT int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *spki, EVP_PKEY *pkey, const EVP_MD *md); -// X509_ATTRIBUTE_dup returns a newly-allocated copy of |xa|, or NULL on error. -// This function works by serializing the structure, so if |xa| is incomplete, -// it may fail. -OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_dup(const X509_ATTRIBUTE *xa); - // X509_REVOKED_dup returns a newly-allocated copy of |rev|, or NULL on error. // This function works by serializing the structure, so if |rev| is incomplete, // it may fail. @@ -2029,15 +2301,6 @@ OPENSSL_EXPORT EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key); DECLARE_ASN1_FUNCTIONS_const(X509_SIG) -DECLARE_ASN1_FUNCTIONS_const(X509_ATTRIBUTE) - -// X509_ATTRIBUTE_create returns a newly-allocated |X509_ATTRIBUTE|, or NULL on -// error. The attribute has type |nid| and contains a single value determined by -// |attrtype| and |value|, which are interpreted as in |ASN1_TYPE_set|. Note -// this function takes ownership of |value|. -OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int attrtype, - void *value); - OPENSSL_EXPORT int X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj); OPENSSL_EXPORT int X509_add1_reject_object(X509 *x, ASN1_OBJECT *obj); OPENSSL_EXPORT void X509_trust_clear(X509 *x); @@ -2084,93 +2347,6 @@ OPENSSL_EXPORT int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, ASN1_BIT_STRING *signature, void *asn, EVP_MD_CTX *ctx); -// X509_REQ_extension_nid returns one if |nid| is a supported CSR attribute type -// for carrying extensions and zero otherwise. The supported types are -// |NID_ext_req| (pkcs-9-at-extensionRequest from RFC 2985) and |NID_ms_ext_req| -// (a Microsoft szOID_CERT_EXTENSIONS variant). -OPENSSL_EXPORT int X509_REQ_extension_nid(int nid); - -// X509_REQ_get_extensions decodes the list of requested extensions in |req| and -// returns a newly-allocated |STACK_OF(X509_EXTENSION)| containing the result. -// It returns NULL on error, or if |req| did not request extensions. -// -// This function supports both pkcs-9-at-extensionRequest from RFC 2985 and the -// Microsoft szOID_CERT_EXTENSIONS variant. -OPENSSL_EXPORT STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req); - -// X509_REQ_add_extensions_nid adds an attribute to |req| of type |nid|, to -// request the certificate extensions in |exts|. It returns one on success and -// zero on error. |nid| should be |NID_ext_req| or |NID_ms_ext_req|. -OPENSSL_EXPORT int X509_REQ_add_extensions_nid( - X509_REQ *req, const STACK_OF(X509_EXTENSION) *exts, int nid); - -// X509_REQ_add_extensions behaves like |X509_REQ_add_extensions_nid|, using the -// standard |NID_ext_req| for the attribute type. -OPENSSL_EXPORT int X509_REQ_add_extensions( - X509_REQ *req, const STACK_OF(X509_EXTENSION) *exts); - -// X509_REQ_get_attr_count returns the number of attributes in |req|. -OPENSSL_EXPORT int X509_REQ_get_attr_count(const X509_REQ *req); - -// X509_REQ_get_attr_by_NID returns the index of the attribute in |req| of type -// |nid|, or a negative number if not found. If found, callers can use -// |X509_REQ_get_attr| to look up the attribute by index. -// -// If |lastpos| is non-negative, it begins searching at |lastpos| + 1. Callers -// can thus loop over all matching attributes by first passing -1 and then -// passing the previously-returned value until no match is returned. -OPENSSL_EXPORT int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, - int lastpos); - -// X509_REQ_get_attr_by_OBJ behaves like |X509_REQ_get_attr_by_NID| but looks -// for attributes of type |obj|. -OPENSSL_EXPORT int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, - const ASN1_OBJECT *obj, - int lastpos); - -// X509_REQ_get_attr returns the attribute at index |loc| in |req|, or NULL if -// out of bounds. -OPENSSL_EXPORT X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc); - -// X509_REQ_delete_attr removes the attribute at index |loc| in |req|. It -// returns the removed attribute to the caller, or NULL if |loc| was out of -// bounds. If non-NULL, the caller must release the result with -// |X509_ATTRIBUTE_free| when done. It is also safe, but not necessary, to call -// |X509_ATTRIBUTE_free| if the result is NULL. -OPENSSL_EXPORT X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc); - -// X509_REQ_add1_attr appends a copy of |attr| to |req|'s list of attributes. It -// returns one on success and zero on error. -// -// TODO(https://crbug.com/boringssl/407): |attr| should be const. -OPENSSL_EXPORT int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr); - -// X509_REQ_add1_attr_by_OBJ appends a new attribute to |req| with type |obj|. -// It returns one on success and zero on error. The value is determined by -// |X509_ATTRIBUTE_set1_data|. -// -// WARNING: The interpretation of |attrtype|, |data|, and |len| is complex and -// error-prone. See |X509_ATTRIBUTE_set1_data| for details. -OPENSSL_EXPORT int X509_REQ_add1_attr_by_OBJ(X509_REQ *req, - const ASN1_OBJECT *obj, - int attrtype, - const unsigned char *data, - int len); - -// X509_REQ_add1_attr_by_NID behaves like |X509_REQ_add1_attr_by_OBJ| except the -// attribute type is determined by |nid|. -OPENSSL_EXPORT int X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, - int attrtype, - const unsigned char *data, - int len); - -// X509_REQ_add1_attr_by_txt behaves like |X509_REQ_add1_attr_by_OBJ| except the -// attribute type is determined by calling |OBJ_txt2obj| with |attrname|. -OPENSSL_EXPORT int X509_REQ_add1_attr_by_txt(X509_REQ *req, - const char *attrname, int attrtype, - const unsigned char *data, - int len); - OPENSSL_EXPORT int X509_CRL_sort(X509_CRL *crl); // X509_REVOKED_get0_serialNumber returns the serial number of the certificate @@ -2317,153 +2493,6 @@ OPENSSL_EXPORT int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit, unsigned long flags); -// X509at_get_attr_count returns the number of attributes in |x|. -OPENSSL_EXPORT int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x); - -// X509at_get_attr_by_NID returns the index of the attribute in |x| of type -// |nid|, or a negative number if not found. If found, callers can use -// |X509at_get_attr| to look up the attribute by index. -// -// If |lastpos| is non-negative, it begins searching at |lastpos| + 1. Callers -// can thus loop over all matching attributes by first passing -1 and then -// passing the previously-returned value until no match is returned. -OPENSSL_EXPORT int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, - int nid, int lastpos); - -// X509at_get_attr_by_OBJ behaves like |X509at_get_attr_by_NID| but looks for -// attributes of type |obj|. -OPENSSL_EXPORT int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, - const ASN1_OBJECT *obj, int lastpos); - -// X509at_get_attr returns the attribute at index |loc| in |x|, or NULL if -// out of bounds. -OPENSSL_EXPORT X509_ATTRIBUTE *X509at_get_attr( - const STACK_OF(X509_ATTRIBUTE) *x, int loc); - -// X509at_delete_attr removes the attribute at index |loc| in |x|. It returns -// the removed attribute to the caller, or NULL if |loc| was out of bounds. If -// non-NULL, the caller must release the result with |X509_ATTRIBUTE_free| when -// done. It is also safe, but not necessary, to call |X509_ATTRIBUTE_free| if -// the result is NULL. -OPENSSL_EXPORT X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, - int loc); - -// X509at_add1_attr appends a copy of |attr| to the attribute list in |*x|. If -// |*x| is NULL, it allocates a new |STACK_OF(X509_ATTRIBUTE)| to hold the copy -// and sets |*x| to the new list. It returns |*x| on success and NULL on error. -// The caller retains ownership of |attr| and can release it independently of -// |*x|. -OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr( - STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr); - -// X509at_add1_attr_by_OBJ behaves like |X509at_add1_attr|, but adds an -// attribute created by |X509_ATTRIBUTE_create_by_OBJ|. -OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ( - STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj, int type, - const unsigned char *bytes, int len); - -// X509at_add1_attr_by_NID behaves like |X509at_add1_attr|, but adds an -// attribute created by |X509_ATTRIBUTE_create_by_NID|. -OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID( - STACK_OF(X509_ATTRIBUTE) **x, int nid, int type, const unsigned char *bytes, - int len); - -// X509at_add1_attr_by_txt behaves like |X509at_add1_attr|, but adds an -// attribute created by |X509_ATTRIBUTE_create_by_txt|. -OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt( - STACK_OF(X509_ATTRIBUTE) **x, const char *attrname, int type, - const unsigned char *bytes, int len); - -// X509_ATTRIBUTE_create_by_NID returns a newly-allocated |X509_ATTRIBUTE| of -// type |nid|, or NULL on error. The value is determined as in -// |X509_ATTRIBUTE_set1_data|. -// -// If |attr| is non-NULL, the resulting |X509_ATTRIBUTE| is also written to -// |*attr|. If |*attr| was non-NULL when the function was called, |*attr| is -// reused instead of creating a new object. -// -// WARNING: The interpretation of |attrtype|, |data|, and |len| is complex and -// error-prone. See |X509_ATTRIBUTE_set1_data| for details. -// -// WARNING: The object reuse form is deprecated and may be removed in the -// future. It also currently incorrectly appends to the reused object's value -// set rather than overwriting it. -OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID( - X509_ATTRIBUTE **attr, int nid, int attrtype, const void *data, int len); - -// X509_ATTRIBUTE_create_by_OBJ behaves like |X509_ATTRIBUTE_create_by_NID| -// except the attribute's type is determined by |obj|. -OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ( - X509_ATTRIBUTE **attr, const ASN1_OBJECT *obj, int attrtype, - const void *data, int len); - -// X509_ATTRIBUTE_create_by_txt behaves like |X509_ATTRIBUTE_create_by_NID| -// except the attribute's type is determined by calling |OBJ_txt2obj| with -// |attrname|. -OPENSSL_EXPORT X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt( - X509_ATTRIBUTE **attr, const char *attrname, int type, - const unsigned char *bytes, int len); - -// X509_ATTRIBUTE_set1_object sets |attr|'s type to |obj|. It returns one on -// success and zero on error. -OPENSSL_EXPORT int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, - const ASN1_OBJECT *obj); - -// X509_ATTRIBUTE_set1_data appends a value to |attr|'s value set and returns -// one on success or zero on error. The value is determined as follows: -// -// If |attrtype| is a |MBSTRING_*| constant, the value is an ASN.1 string. The -// string is determined by decoding |len| bytes from |data| in the encoding -// specified by |attrtype|, and then re-encoding it in a form appropriate for -// |attr|'s type. If |len| is -1, |strlen(data)| is used instead. See -// |ASN1_STRING_set_by_NID| for details. -// -// Otherwise, if |len| is not -1, the value is an ASN.1 string. |attrtype| is an -// |ASN1_STRING| type value and the |len| bytes from |data| are copied as the -// type-specific representation of |ASN1_STRING|. See |ASN1_STRING| for details. -// -// WARNING: If this form is used to construct a negative INTEGER or ENUMERATED, -// |attrtype| includes the |V_ASN1_NEG| flag for |ASN1_STRING|, but the function -// forgets to clear the flag for |ASN1_TYPE|. This matches OpenSSL but is -// probably a bug. For now, do not use this form with negative values. -// -// Otherwise, if |len| is -1, the value is constructed by passing |attrtype| and -// |data| to |ASN1_TYPE_set1|. That is, |attrtype| is an |ASN1_TYPE| type value, -// and |data| is cast to the corresponding pointer type. -// -// WARNING: Despite the name, this function appends to |attr|'s value set, -// rather than overwriting it. To overwrite the value set, create a new -// |X509_ATTRIBUTE| with |X509_ATTRIBUTE_new|. -// -// WARNING: If using the |MBSTRING_*| form, pass a length rather than relying on -// |strlen|. In particular, |strlen| will not behave correctly if the input is -// |MBSTRING_BMP| or |MBSTRING_UNIV|. -// -// WARNING: This function currently misinterprets |V_ASN1_OTHER| as an -// |MBSTRING_*| constant. This matches OpenSSL but means it is impossible to -// construct a value with a non-universal tag. -OPENSSL_EXPORT int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, - const void *data, int len); - -// X509_ATTRIBUTE_get0_data returns the |idx|th value of |attr| in a -// type-specific representation to |attrtype|, or NULL if out of bounds or the -// type does not match. |attrtype| is one of the type values in |ASN1_TYPE|. On -// match, the return value uses the same representation as |ASN1_TYPE_set0|. See -// |ASN1_TYPE| for details. -OPENSSL_EXPORT void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, - int attrtype, void *unused); - -// X509_ATTRIBUTE_count returns the number of values in |attr|. -OPENSSL_EXPORT int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr); - -// X509_ATTRIBUTE_get0_object returns the type of |attr|. -OPENSSL_EXPORT ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr); - -// X509_ATTRIBUTE_get0_type returns the |idx|th value in |attr|, or NULL if out -// of bounds. Note this function returns one of |attr|'s values, not the type. -OPENSSL_EXPORT ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, - int idx); - OPENSSL_EXPORT int X509_verify_cert(X509_STORE_CTX *ctx); // PKCS#8 utilities From 437ef4d7f1399ad92ff55be7b418579c511065aa Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 10:41:02 -0400 Subject: [PATCH 23/56] Remove the X509at_* functions They're not used anywhere, as X509_REQ doesn't expose the underlying STACK_OF(X509_ATTRIBUTE) anyway. They're also very thin wrappers over the stack functions, so just delete them and inline them into X509_REQ functions. While I'm here, I've tidied up the add1_attr_by_* functions to reduce an unnecessary copy. Change-Id: Iec002c83ab7ad7267314e98866d680d12a82e971 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58927 Reviewed-by: Bob Beck Commit-Queue: David Benjamin --- crypto/x509/x509_att.c | 140 ----------------------------------------- crypto/x509/x509_req.c | 95 +++++++++++++++++++++------- include/openssl/x509.h | 61 +----------------- 3 files changed, 74 insertions(+), 222 deletions(-) diff --git a/crypto/x509/x509_att.c b/crypto/x509/x509_att.c index 0dda757f55..23e92f294b 100644 --- a/crypto/x509/x509_att.c +++ b/crypto/x509/x509_att.c @@ -56,153 +56,13 @@ #include #include -#include #include -#include #include #include "../asn1/internal.h" #include "internal.h" -int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x) { - return sk_X509_ATTRIBUTE_num(x); -} - -int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, - int lastpos) { - const ASN1_OBJECT *obj = OBJ_nid2obj(nid); - if (obj == NULL) { - return -1; - } - return X509at_get_attr_by_OBJ(x, obj, lastpos); -} - -int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, - const ASN1_OBJECT *obj, int lastpos) { - int n; - X509_ATTRIBUTE *ex; - - if (sk == NULL) { - return -1; - } - lastpos++; - if (lastpos < 0) { - lastpos = 0; - } - n = sk_X509_ATTRIBUTE_num(sk); - for (; lastpos < n; lastpos++) { - ex = sk_X509_ATTRIBUTE_value(sk, lastpos); - if (OBJ_cmp(ex->object, obj) == 0) { - return lastpos; - } - } - return -1; -} - -X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc) { - if (x == NULL || loc < 0 || sk_X509_ATTRIBUTE_num(x) <= (size_t)loc) { - return NULL; - } else { - return sk_X509_ATTRIBUTE_value(x, loc); - } -} - -X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc) { - X509_ATTRIBUTE *ret; - - if (x == NULL || loc < 0 || sk_X509_ATTRIBUTE_num(x) <= (size_t)loc) { - return NULL; - } - ret = sk_X509_ATTRIBUTE_delete(x, loc); - return ret; -} - -STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, - X509_ATTRIBUTE *attr) { - X509_ATTRIBUTE *new_attr = NULL; - STACK_OF(X509_ATTRIBUTE) *sk = NULL; - - if (x == NULL) { - OPENSSL_PUT_ERROR(X509, ERR_R_PASSED_NULL_PARAMETER); - goto err; - } - - if (*x == NULL) { - if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL) { - goto err; - } - } else { - sk = *x; - } - - if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL) { - goto err; - } - if (!sk_X509_ATTRIBUTE_push(sk, new_attr)) { - goto err; - } - if (*x == NULL) { - *x = sk; - } - return sk; -err: - if (new_attr != NULL) { - X509_ATTRIBUTE_free(new_attr); - } - if (sk != NULL) { - sk_X509_ATTRIBUTE_free(sk); - } - return NULL; -} - -STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, - const ASN1_OBJECT *obj, - int type, - const unsigned char *bytes, - int len) { - X509_ATTRIBUTE *attr; - STACK_OF(X509_ATTRIBUTE) *ret; - attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len); - if (!attr) { - return 0; - } - ret = X509at_add1_attr(x, attr); - X509_ATTRIBUTE_free(attr); - return ret; -} - -STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, - int nid, int type, - const unsigned char *bytes, - int len) { - X509_ATTRIBUTE *attr; - STACK_OF(X509_ATTRIBUTE) *ret; - attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len); - if (!attr) { - return 0; - } - ret = X509at_add1_attr(x, attr); - X509_ATTRIBUTE_free(attr); - return ret; -} - -STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, - const char *attrname, - int type, - const unsigned char *bytes, - int len) { - X509_ATTRIBUTE *attr; - STACK_OF(X509_ATTRIBUTE) *ret; - attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len); - if (!attr) { - return 0; - } - ret = X509at_add1_attr(x, attr); - X509_ATTRIBUTE_free(attr); - return ret; -} - X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int attrtype, const void *data, int len) { diff --git a/crypto/x509/x509_req.c b/crypto/x509/x509_req.c index 8734897fe7..69eb63c271 100644 --- a/crypto/x509/x509_req.c +++ b/crypto/x509/x509_req.c @@ -160,62 +160,111 @@ int X509_REQ_add_extensions(X509_REQ *req, return X509_REQ_add_extensions_nid(req, exts, NID_ext_req); } -// Request attribute functions - int X509_REQ_get_attr_count(const X509_REQ *req) { - return X509at_get_attr_count(req->req_info->attributes); + return sk_X509_ATTRIBUTE_num(req->req_info->attributes); } int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos) { - return X509at_get_attr_by_NID(req->req_info->attributes, nid, lastpos); + const ASN1_OBJECT *obj = OBJ_nid2obj(nid); + if (obj == NULL) { + return -1; + } + return X509_REQ_get_attr_by_OBJ(req, obj, lastpos); } int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj, int lastpos) { - return X509at_get_attr_by_OBJ(req->req_info->attributes, obj, lastpos); + if (req->req_info->attributes == NULL) { + return -1; + } + lastpos++; + if (lastpos < 0) { + lastpos = 0; + } + int n = sk_X509_ATTRIBUTE_num(req->req_info->attributes); + for (; lastpos < n; lastpos++) { + const X509_ATTRIBUTE *attr = + sk_X509_ATTRIBUTE_value(req->req_info->attributes, lastpos); + if (OBJ_cmp(attr->object, obj) == 0) { + return lastpos; + } + } + return -1; } X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc) { - return X509at_get_attr(req->req_info->attributes, loc); + if (req->req_info->attributes == NULL || loc < 0 || + sk_X509_ATTRIBUTE_num(req->req_info->attributes) <= (size_t)loc) { + return NULL; + } + return sk_X509_ATTRIBUTE_value(req->req_info->attributes, loc); } X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc) { - return X509at_delete_attr(req->req_info->attributes, loc); + if (req->req_info->attributes == NULL || loc < 0 || + sk_X509_ATTRIBUTE_num(req->req_info->attributes) <= (size_t)loc) { + return NULL; + } + return sk_X509_ATTRIBUTE_delete(req->req_info->attributes, loc); } -int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr) { - if (X509at_add1_attr(&req->req_info->attributes, attr)) { - return 1; +static int X509_REQ_add0_attr(X509_REQ *req, X509_ATTRIBUTE *attr) { + if (req->req_info->attributes == NULL) { + req->req_info->attributes = sk_X509_ATTRIBUTE_new_null(); } - return 0; + if (req->req_info->attributes == NULL || + !sk_X509_ATTRIBUTE_push(req->req_info->attributes, attr)) { + return 0; + } + + return 1; +} + +int X509_REQ_add1_attr(X509_REQ *req, const X509_ATTRIBUTE *attr) { + X509_ATTRIBUTE *new_attr = X509_ATTRIBUTE_dup(attr); + if (new_attr == NULL || !X509_REQ_add0_attr(req, new_attr)) { + X509_ATTRIBUTE_free(new_attr); + return 0; + } + + return 1; } int X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int attrtype, const unsigned char *data, int len) { - if (X509at_add1_attr_by_OBJ(&req->req_info->attributes, obj, attrtype, data, - len)) { - return 1; + X509_ATTRIBUTE *attr = + X509_ATTRIBUTE_create_by_OBJ(NULL, obj, attrtype, data, len); + if (attr == NULL || !X509_REQ_add0_attr(req, attr)) { + X509_ATTRIBUTE_free(attr); + return 0; } - return 0; + + return 1; } int X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int attrtype, const unsigned char *data, int len) { - if (X509at_add1_attr_by_NID(&req->req_info->attributes, nid, attrtype, data, - len)) { - return 1; + X509_ATTRIBUTE *attr = + X509_ATTRIBUTE_create_by_NID(NULL, nid, attrtype, data, len); + if (attr == NULL || !X509_REQ_add0_attr(req, attr)) { + X509_ATTRIBUTE_free(attr); + return 0; } - return 0; + + return 1; } int X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int attrtype, const unsigned char *data, int len) { - if (X509at_add1_attr_by_txt(&req->req_info->attributes, attrname, attrtype, - data, len)) { - return 1; + X509_ATTRIBUTE *attr = + X509_ATTRIBUTE_create_by_txt(NULL, attrname, attrtype, data, len); + if (attr == NULL || !X509_REQ_add0_attr(req, attr)) { + X509_ATTRIBUTE_free(attr); + return 0; } - return 0; + + return 1; } void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig, diff --git a/include/openssl/x509.h b/include/openssl/x509.h index a7e20b4f86..b3842ec001 100644 --- a/include/openssl/x509.h +++ b/include/openssl/x509.h @@ -832,9 +832,8 @@ OPENSSL_EXPORT X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc); // X509_REQ_add1_attr appends a copy of |attr| to |req|'s list of attributes. It // returns one on success and zero on error. -// -// TODO(https://crbug.com/boringssl/407): |attr| should be const. -OPENSSL_EXPORT int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr); +OPENSSL_EXPORT int X509_REQ_add1_attr(X509_REQ *req, + const X509_ATTRIBUTE *attr); // X509_REQ_add1_attr_by_OBJ appends a new attribute to |req| with type |obj|. // It returns one on success and zero on error. The value is determined by @@ -1532,62 +1531,6 @@ OPENSSL_EXPORT ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr); OPENSSL_EXPORT ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx); -// X509at_get_attr_count returns the number of attributes in |x|. -OPENSSL_EXPORT int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x); - -// X509at_get_attr_by_NID returns the index of the attribute in |x| of type -// |nid|, or a negative number if not found. If found, callers can use -// |X509at_get_attr| to look up the attribute by index. -// -// If |lastpos| is non-negative, it begins searching at |lastpos| + 1. Callers -// can thus loop over all matching attributes by first passing -1 and then -// passing the previously-returned value until no match is returned. -OPENSSL_EXPORT int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, - int nid, int lastpos); - -// X509at_get_attr_by_OBJ behaves like |X509at_get_attr_by_NID| but looks for -// attributes of type |obj|. -OPENSSL_EXPORT int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, - const ASN1_OBJECT *obj, int lastpos); - -// X509at_get_attr returns the attribute at index |loc| in |x|, or NULL if -// out of bounds. -OPENSSL_EXPORT X509_ATTRIBUTE *X509at_get_attr( - const STACK_OF(X509_ATTRIBUTE) *x, int loc); - -// X509at_delete_attr removes the attribute at index |loc| in |x|. It returns -// the removed attribute to the caller, or NULL if |loc| was out of bounds. If -// non-NULL, the caller must release the result with |X509_ATTRIBUTE_free| when -// done. -OPENSSL_EXPORT X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, - int loc); - -// X509at_add1_attr appends a copy of |attr| to the attribute list in |*x|. If -// |*x| is NULL, it allocates a new |STACK_OF(X509_ATTRIBUTE)| to hold the copy -// and sets |*x| to the new list. It returns |*x| on success and NULL on error. -// The caller retains ownership of |attr| and can release it independently of -// |*x|. -OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr( - STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr); - -// X509at_add1_attr_by_OBJ behaves like |X509at_add1_attr|, but adds an -// attribute created by |X509_ATTRIBUTE_create_by_OBJ|. -OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ( - STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj, int type, - const unsigned char *bytes, int len); - -// X509at_add1_attr_by_NID behaves like |X509at_add1_attr|, but adds an -// attribute created by |X509_ATTRIBUTE_create_by_NID|. -OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID( - STACK_OF(X509_ATTRIBUTE) **x, int nid, int type, const unsigned char *bytes, - int len); - -// X509at_add1_attr_by_txt behaves like |X509at_add1_attr|, but adds an -// attribute created by |X509_ATTRIBUTE_create_by_txt|. -OPENSSL_EXPORT STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt( - STACK_OF(X509_ATTRIBUTE) **x, const char *attrname, int type, - const unsigned char *bytes, int len); - // Printing functions. // From 58a4094ab832530972d72bed2d27df09d45abbce Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 10:43:55 -0400 Subject: [PATCH 24/56] Move the X509 time functions under "Convenience functions" These probably don't need their own section. They're just thin wrappers over other ASN1_TIME functions. Bug: 426 Change-Id: I8672feb0ca7ba1cf69b56d02d2559de5b80a3ee7 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58928 Reviewed-by: Bob Beck Commit-Queue: David Benjamin --- include/openssl/x509.h | 66 +++++++++++++++++++++--------------------- 1 file changed, 33 insertions(+), 33 deletions(-) diff --git a/include/openssl/x509.h b/include/openssl/x509.h index b3842ec001..8271b4a82b 100644 --- a/include/openssl/x509.h +++ b/include/openssl/x509.h @@ -1904,6 +1904,39 @@ OPENSSL_EXPORT X509 *X509_find_by_issuer_and_serial(const STACK_OF(X509) *sk, OPENSSL_EXPORT X509 *X509_find_by_subject(const STACK_OF(X509) *sk, X509_NAME *name); +// X509_cmp_time compares |s| against |*t|. On success, it returns a negative +// number if |s| <= |*t| and a positive number if |s| > |*t|. On error, it +// returns zero. If |t| is NULL, it uses the current time instead of |*t|. +// +// WARNING: Unlike most comparison functions, this function returns zero on +// error, not equality. +OPENSSL_EXPORT int X509_cmp_time(const ASN1_TIME *s, time_t *t); + +// X509_cmp_time_posix compares |s| against |t|. On success, it returns a +// negative number if |s| <= |t| and a positive number if |s| > |t|. On error, +// it returns zero. +// +// WARNING: Unlike most comparison functions, this function returns zero on +// error, not equality. +OPENSSL_EXPORT int X509_cmp_time_posix(const ASN1_TIME *s, int64_t t); + +// X509_cmp_current_time behaves like |X509_cmp_time| but compares |s| against +// the current time. +OPENSSL_EXPORT int X509_cmp_current_time(const ASN1_TIME *s); + +// X509_time_adj calls |X509_time_adj_ex| with |offset_day| equal to zero. +OPENSSL_EXPORT ASN1_TIME *X509_time_adj(ASN1_TIME *s, long offset_sec, + time_t *t); + +// X509_time_adj_ex behaves like |ASN1_TIME_adj|, but adds an offset to |*t|. If +// |t| is NULL, it uses the current time instead of |*t|. +OPENSSL_EXPORT ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s, int offset_day, + long offset_sec, time_t *t); + +// X509_gmtime_adj behaves like |X509_time_adj_ex| but adds |offset_sec| to the +// current time. +OPENSSL_EXPORT ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long offset_sec); + // ex_data functions. // @@ -2189,39 +2222,6 @@ OPENSSL_EXPORT int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *spki, EVP_PKEY *pkey, // it may fail. OPENSSL_EXPORT X509_REVOKED *X509_REVOKED_dup(const X509_REVOKED *rev); -// X509_cmp_time compares |s| against |*t|. On success, it returns a negative -// number if |s| <= |*t| and a positive number if |s| > |*t|. On error, it -// returns zero. If |t| is NULL, it uses the current time instead of |*t|. -// -// WARNING: Unlike most comparison functions, this function returns zero on -// error, not equality. -OPENSSL_EXPORT int X509_cmp_time(const ASN1_TIME *s, time_t *t); - -// X509_cmp_time_posix compares |s| against |t|. On success, it returns a -// negative number if |s| <= |t| and a positive number if |s| > |t|. On error, -// it returns zero. -// -// WARNING: Unlike most comparison functions, this function returns zero on -// error, not equality. -OPENSSL_EXPORT int X509_cmp_time_posix(const ASN1_TIME *s, int64_t t); - -// X509_cmp_current_time behaves like |X509_cmp_time| but compares |s| against -// the current time. -OPENSSL_EXPORT int X509_cmp_current_time(const ASN1_TIME *s); - -// X509_time_adj calls |X509_time_adj_ex| with |offset_day| equal to zero. -OPENSSL_EXPORT ASN1_TIME *X509_time_adj(ASN1_TIME *s, long offset_sec, - time_t *t); - -// X509_time_adj_ex behaves like |ASN1_TIME_adj|, but adds an offset to |*t|. If -// |t| is NULL, it uses the current time instead of |*t|. -OPENSSL_EXPORT ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s, int offset_day, - long offset_sec, time_t *t); - -// X509_gmtime_adj behaves like |X509_time_adj_ex| but adds |offset_sec| to the -// current time. -OPENSSL_EXPORT ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long offset_sec); - OPENSSL_EXPORT const char *X509_get_default_cert_area(void); OPENSSL_EXPORT const char *X509_get_default_cert_dir(void); OPENSSL_EXPORT const char *X509_get_default_cert_file(void); From 3e91d372c04663da488964e1dd9d6e838bfb14e7 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 11:43:27 -0400 Subject: [PATCH 25/56] Clarify in ssl.h documentation not to use the verify callback Change-Id: I54195f3fabbed788d3cf299d478d5151acfe2a4f Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58929 Commit-Queue: David Benjamin Reviewed-by: Bob Beck --- include/openssl/ssl.h | 36 +++++++++++++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-) diff --git a/include/openssl/ssl.h b/include/openssl/ssl.h index da78d1a5ae..0a1493db3a 100644 --- a/include/openssl/ssl.h +++ b/include/openssl/ssl.h @@ -2410,21 +2410,51 @@ OPENSSL_EXPORT int SSL_set1_groups_list(SSL *ssl, const char *groups); // SSL_CTX_set_verify configures certificate verification behavior. |mode| is // one of the |SSL_VERIFY_*| values defined above. |callback|, if not NULL, is -// used to customize certificate verification. See the behavior of -// |X509_STORE_CTX_set_verify_cb|. +// used to customize certificate verification, but is deprecated. See +// |X509_STORE_CTX_set_verify_cb| for details. // // The callback may use |SSL_get_ex_data_X509_STORE_CTX_idx| with // |X509_STORE_CTX_get_ex_data| to look up the |SSL| from |store_ctx|. +// +// WARNING: |callback| should be NULL. This callback does not replace the +// default certificate verification process and is, instead, called multiple +// times in the course of that process. It is very difficult to implement this +// callback safely, without inadvertently relying on implementation details or +// making incorrect assumptions about when the callback is called. +// +// Instead, use |SSL_CTX_set_custom_verify| or +// |SSL_CTX_set_cert_verify_callback| to customize certificate verification. +// Those callbacks can inspect the peer-sent chain, call |X509_verify_cert| and +// inspect the result, or perform other operations more straightforwardly. +// +// TODO(crbug.com/boringssl/426): We cite |X509_STORE_CTX_set_verify_cb| but +// haven't documented it yet. Later that will have a more detailed warning about +// why one should not use this callback. OPENSSL_EXPORT void SSL_CTX_set_verify( SSL_CTX *ctx, int mode, int (*callback)(int ok, X509_STORE_CTX *store_ctx)); // SSL_set_verify configures certificate verification behavior. |mode| is one of // the |SSL_VERIFY_*| values defined above. |callback|, if not NULL, is used to -// customize certificate verification. See the behavior of +// customize certificate verification, but is deprecated. See the behavior of // |X509_STORE_CTX_set_verify_cb|. // // The callback may use |SSL_get_ex_data_X509_STORE_CTX_idx| with // |X509_STORE_CTX_get_ex_data| to look up the |SSL| from |store_ctx|. +// +// WARNING: |callback| should be NULL. This callback does not replace the +// default certificate verification process and is, instead, called multiple +// times in the course of that process. It is very difficult to implement this +// callback safely, without inadvertently relying on implementation details or +// making incorrect assumptions about when the callback is called. +// +// Instead, use |SSL_set_custom_verify| or |SSL_CTX_set_cert_verify_callback| to +// customize certificate verification. Those callbacks can inspect the peer-sent +// chain, call |X509_verify_cert| and inspect the result, or perform other +// operations more straightforwardly. +// +// TODO(crbug.com/boringssl/426): We cite |X509_STORE_CTX_set_verify_cb| but +// haven't documented it yet. Later that will have a more detailed warning about +// why one should not use this callback. OPENSSL_EXPORT void SSL_set_verify(SSL *ssl, int mode, int (*callback)(int ok, X509_STORE_CTX *store_ctx)); From e2d14016687d99803987fa24e23e2a4ee1b03f33 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 15:29:11 -0400 Subject: [PATCH 26/56] Remove --size_t-is-usize from bindgen call This has been on by default since https://github.com/rust-lang/rust-bindgen/commit/cc78b6fdb6e829e5fb8fa1639f2182cb49333569, and now removed from recent bindgen altogether. Change-Id: Iea4c2a7480fe8b138c375686ca6b36e6d68257b3 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58965 Reviewed-by: Nabil Wadih Reviewed-by: Bob Beck Auto-Submit: David Benjamin Commit-Queue: Bob Beck --- rust/bssl-sys/CMakeLists.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/rust/bssl-sys/CMakeLists.txt b/rust/bssl-sys/CMakeLists.txt index 05f03f45c6..4cf85074b2 100644 --- a/rust/bssl-sys/CMakeLists.txt +++ b/rust/bssl-sys/CMakeLists.txt @@ -10,7 +10,6 @@ set(COMMAND ${BINDGEN_EXECUTABLE} "wrapper.h" --no-derive-default --enable-function-attribute-detection --use-core - --size_t-is-usize --default-macro-constant-type="signed" --rustified-enum="point_conversion_form_t" --allowlist-file=".*/include/openssl/.*\\.h" @@ -35,4 +34,4 @@ if(NOT BUILD_SHARED_LIBS) configure_file("build.rs" "build.rs" COPYONLY) endif() -configure_file("Cargo.toml" "Cargo.toml" COPYONLY) \ No newline at end of file +configure_file("Cargo.toml" "Cargo.toml" COPYONLY) From 26ead95e4667a3c49a04150d5ebae84050e8a5d3 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 12:45:08 -0400 Subject: [PATCH 27/56] Trim some unused XN_FLAG_* values These appear to be unused. Some ones of note: - XN_FLAG_FN_ALIGN breaks with multi-attribute RDNs anyway - XN_FLAG_FN_NONE is completely pointless Update-Note: Some seemingly unused XN_FLAG_* values were removed. If some project fails to build, we can put them back but one shouldn't be using this function in the first place. Change-Id: I4d8472e1e31aeec623b4d4e2aea48da7b1ef6798 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58930 Reviewed-by: Bob Beck Commit-Queue: David Benjamin --- crypto/x509/name_print.c | 56 +++++++++++------------------------ crypto/x509/x509_test.cc | 63 +++++++++++++++------------------------- include/openssl/x509.h | 18 ------------ 3 files changed, 41 insertions(+), 96 deletions(-) diff --git a/crypto/x509/name_print.c b/crypto/x509/name_print.c index 29207ccb69..5dc34dae54 100644 --- a/crypto/x509/name_print.c +++ b/crypto/x509/name_print.c @@ -56,6 +56,7 @@ #include +#include #include #include @@ -84,8 +85,7 @@ static int do_indent(BIO *out, int indent) { static int do_name_ex(BIO *out, const X509_NAME *n, int indent, unsigned long flags) { - int i, prev = -1, orflags, cnt; - int fn_opt, fn_nid; + int prev = -1, orflags; char objtmp[80]; const char *objbuf; int outlen, len; @@ -142,10 +142,8 @@ static int do_name_ex(BIO *out, const X509_NAME *n, int indent, sep_eq_len = 1; } - fn_opt = flags & XN_FLAG_FN_MASK; - - cnt = X509_NAME_entry_count(n); - for (i = 0; i < cnt; i++) { + int cnt = X509_NAME_entry_count(n); + for (int i = 0; i < cnt; i++) { const X509_NAME_ENTRY *ent; if (flags & XN_FLAG_DN_REV) { ent = X509_NAME_get_entry(n, cnt - i - 1); @@ -172,40 +170,20 @@ static int do_name_ex(BIO *out, const X509_NAME *n, int indent, prev = X509_NAME_ENTRY_set(ent); const ASN1_OBJECT *fn = X509_NAME_ENTRY_get_object(ent); const ASN1_STRING *val = X509_NAME_ENTRY_get_data(ent); - fn_nid = OBJ_obj2nid(fn); - if (fn_opt != XN_FLAG_FN_NONE) { - int objlen, fld_len; - if ((fn_opt == XN_FLAG_FN_OID) || (fn_nid == NID_undef)) { - OBJ_obj2txt(objtmp, sizeof objtmp, fn, 1); - fld_len = 0; // XXX: what should this be? - objbuf = objtmp; - } else { - if (fn_opt == XN_FLAG_FN_SN) { - fld_len = FN_WIDTH_SN; - objbuf = OBJ_nid2sn(fn_nid); - } else if (fn_opt == XN_FLAG_FN_LN) { - fld_len = FN_WIDTH_LN; - objbuf = OBJ_nid2ln(fn_nid); - } else { - fld_len = 0; // XXX: what should this be? - objbuf = ""; - } - } - objlen = strlen(objbuf); - if (!maybe_write(out, objbuf, objlen)) { - return -1; - } - if ((objlen < fld_len) && (flags & XN_FLAG_FN_ALIGN)) { - if (!do_indent(out, fld_len - objlen)) { - return -1; - } - outlen += fld_len - objlen; - } - if (!maybe_write(out, sep_eq, sep_eq_len)) { - return -1; - } - outlen += objlen + sep_eq_len; + assert((flags & XN_FLAG_FN_MASK) == XN_FLAG_FN_SN); + int fn_nid = OBJ_obj2nid(fn); + if (fn_nid == NID_undef) { + OBJ_obj2txt(objtmp, sizeof(objtmp), fn, 1); + objbuf = objtmp; + } else { + objbuf = OBJ_nid2sn(fn_nid); + } + int objlen = strlen(objbuf); + if (!maybe_write(out, objbuf, objlen) || + !maybe_write(out, sep_eq, sep_eq_len)) { + return -1; } + outlen += objlen + sep_eq_len; // If the field name is unknown then fix up the DER dump flag. We // might want to limit this further so it will DER dump on anything // other than a few 'standard' fields. diff --git a/crypto/x509/x509_test.cc b/crypto/x509/x509_test.cc index 530c24d5cc..9e369bd58d 100644 --- a/crypto/x509/x509_test.cc +++ b/crypto/x509/x509_test.cc @@ -4702,50 +4702,35 @@ TEST(X509Test, NamePrint) { "CN = \"Common " "Name/CN=A/CN=B,CN=A,CN=B+CN=A+CN=B;CN=A;CN=B\\0ACN=A\\0A\", " "CN = \" spaces \""}, - // |XN_FLAG_MULTILINE| is an OpenSSL-specific multi-line format that tries - // to vertically align the equal sizes. The vertical alignment doesn't - // quite handle multi-valued RDNs right and uses a non-RFC-2253 escaping. + // Callers can also customize the output, with both |XN_FLAG_*| and + // |ASN1_STRFLGS_*|. |XN_FLAG_SEP_SPLUS_SPC| uses semicolon separators. {/*indent=*/0, - /*flags=*/XN_FLAG_MULTILINE, - "countryName = US\n" - "stateOrProvinceName = Some State + " - "stateOrProvinceName = Some Other State \\U2603 + " - "stateOrProvinceName = Another State \\U2603 + " - "1.2.840.113554.4.1.72585.2 = \\U2603\n" - "1.2.840.113554.4.1.72585.3 = 0\\06\\02\\01\\01\\02\\01\\02\n" - "organizationName = Org Name\n" - "commonName = Common " - "Name/CN=A/CN=B,CN=A,CN=B+CN=A+CN=B;CN=A;CN=B\\0ACN=A\\0A\n" - "commonName = spaces "}, - // The multiline format indents every line. - {/*indent=*/2, - /*flags=*/XN_FLAG_MULTILINE, - " countryName = US\n" - " stateOrProvinceName = Some State + " - "stateOrProvinceName = Some Other State \\U2603 + " - "stateOrProvinceName = Another State \\U2603 + " - "1.2.840.113554.4.1.72585.2 = \\U2603\n" - " 1.2.840.113554.4.1.72585.3 = 0\\06\\02\\01\\01\\02\\01\\02\n" - " organizationName = Org Name\n" - " commonName = Common " - "Name/CN=A/CN=B,CN=A,CN=B+CN=A+CN=B;CN=A;CN=B\\0ACN=A\\0A\n" - " commonName = spaces "}, - // Callers can also customize the output, wuith both |XN_FLAG_*| and - // |ASN1_STRFLGS_*|. |XN_FLAG_SEP_SPLUS_SPC| uses semicolon separators and - // |XN_FLAG_FN_OID| forces OIDs. - {/*indent=*/0, - /*flags=*/XN_FLAG_SEP_SPLUS_SPC | XN_FLAG_FN_OID | ASN1_STRFLGS_RFC2253 | + /*flags=*/XN_FLAG_SEP_SPLUS_SPC | ASN1_STRFLGS_RFC2253 | ASN1_STRFLGS_ESC_QUOTE, - "2.5.4.6=US; " - "2.5.4.8=Some State + " - "2.5.4.8=Some Other State \\E2\\98\\83 + " - "2.5.4.8=Another State \\E2\\98\\83 + " + "C=US; " + "ST=Some State + " + "ST=Some Other State \\E2\\98\\83 + " + "ST=Another State \\E2\\98\\83 + " "1.2.840.113554.4.1.72585.2=\\E2\\98\\83; " "1.2.840.113554.4.1.72585.3=#3006020101020102; " - "2.5.4.10=Org Name; " - "2.5.4.3=\"Common " + "O=Org Name; " + "CN=\"Common " "Name/CN=A/CN=B,CN=A,CN=B+CN=A+CN=B;CN=A;CN=B\\0ACN=A\\0A\"; " - "2.5.4.3=\" spaces \""}, + "CN=\" spaces \""}, + // Node uses these parameters. + {/*indent=*/0, + /*flags=*/ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_CTRL | + ASN1_STRFLGS_UTF8_CONVERT | XN_FLAG_SEP_MULTILINE | XN_FLAG_FN_SN, + "C=US\n" + "ST=Some State + " + "ST=Some Other State \xE2\x98\x83 + " + "ST=Another State \xE2\x98\x83 + " + "1.2.840.113554.4.1.72585.2=\xE2\x98\x83\n" + "1.2.840.113554.4.1.72585.3=0\\06\\02\\01\\01\\02\\01\\02\n" + "O=Org Name\n" + "CN=Common " + "Name/CN=A/CN=B\\,CN=A\\,CN=B\\+CN=A\\+CN=B\\;CN=A\\;CN=B\\0ACN=A\\0A\n" + "CN=\\ spaces\\ "}, // |XN_FLAG_COMPAT| matches |X509_NAME_print|, rather than // |X509_NAME_print_ex|. // diff --git a/include/openssl/x509.h b/include/openssl/x509.h index 8271b4a82b..2954488df9 100644 --- a/include/openssl/x509.h +++ b/include/openssl/x509.h @@ -1670,15 +1670,6 @@ OPENSSL_EXPORT int X509_REQ_print_fp(FILE *fp, X509_REQ *req); // XN_FLAG_FN_SN uses the attribute type's short name, when available. #define XN_FLAG_FN_SN 0 -// XN_FLAG_FN_LN uses the attribute type's long name, when available. -#define XN_FLAG_FN_LN (1 << 21) - -// XN_FLAG_FN_OID always prints attribute types as OIDs. -#define XN_FLAG_FN_OID (2 << 21) - -// XN_FLAG_FN_NONE skips printing field names. -#define XN_FLAG_FN_NONE (3 << 21) - // XN_FLAG_SPC_EQ wraps the "=" operator with spaces when printing attributes. #define XN_FLAG_SPC_EQ (1 << 23) @@ -1686,10 +1677,6 @@ OPENSSL_EXPORT int X509_REQ_print_fp(FILE *fp, X509_REQ *req); // hex, as in RFC 2253. #define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24) -// XN_FLAG_FN_ALIGN aligns attribute names to 10 characters if using short -// names, and 25 characters if using long names. -#define XN_FLAG_FN_ALIGN (1 << 25) - // XN_FLAG_RFC2253 prints like RFC 2253. #define XN_FLAG_RFC2253 \ (ASN1_STRFLGS_RFC2253 | XN_FLAG_SEP_COMMA_PLUS | XN_FLAG_DN_REV | \ @@ -1700,11 +1687,6 @@ OPENSSL_EXPORT int X509_REQ_print_fp(FILE *fp, X509_REQ *req); (ASN1_STRFLGS_RFC2253 | ASN1_STRFLGS_ESC_QUOTE | XN_FLAG_SEP_CPLUS_SPC | \ XN_FLAG_SPC_EQ | XN_FLAG_FN_SN) -// XN_FLAG_MULTILINE prints a multi-line representation of the name. -#define XN_FLAG_MULTILINE \ - (ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | XN_FLAG_SEP_MULTILINE | \ - XN_FLAG_SPC_EQ | XN_FLAG_FN_LN | XN_FLAG_FN_ALIGN) - // X509_NAME_print_ex writes a human-readable representation of |nm| to |out|. // Each line of output is indented by |indent| spaces. It returns the number of // bytes written on success, and -1 on error. If |out| is NULL, it returns the From 1a5570b8e8e4b57bc7f0f1fdff93b28c6475c364 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 15:38:47 -0400 Subject: [PATCH 28/56] Update docs to recommend a much more convenient CMake invocation Newer CMakes support a -B parameter, which saves some fuss. Change-Id: Ifdbbb50b3720cdc42af098eb32941283692e9d99 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58966 Commit-Queue: David Benjamin Reviewed-by: Bob Beck Reviewed-by: Nabil Wadih --- BUILDING.md | 23 +++++++++-------------- FUZZING.md | 6 ++---- rust/bssl-crypto/Cargo.toml | 4 ++-- rust/bssl-crypto/README.md | 4 ++-- rust/bssl-sys/build.rs | 2 +- 5 files changed, 16 insertions(+), 23 deletions(-) diff --git a/BUILDING.md b/BUILDING.md index bedba3c3cb..4dcd0f48f5 100644 --- a/BUILDING.md +++ b/BUILDING.md @@ -48,17 +48,13 @@ most recent stable version of each tool. Using Ninja (note the 'N' is capitalized in the cmake invocation): - mkdir build - cd build - cmake -GNinja .. - ninja + cmake -GNinja -B build + ninja -C build Using Make (does not work on Windows): - mkdir build - cd build - cmake .. - make + cmake -B build + make -C build You usually don't need to run `cmake` again after changing `CMakeLists.txt` files because the build scripts will detect changes to them and rebuild @@ -69,10 +65,9 @@ debugging—optimisation isn't enabled. Pass `-DCMAKE_BUILD_TYPE=Release` to `cmake` to configure a release build. If you want to cross-compile then there is an example toolchain file for 32-bit -Intel in `util/`. Wipe out the build directory, recreate it and run `cmake` like -this: +Intel in `util/`. Wipe out the build directory, run `cmake` like this: - cmake -DCMAKE_TOOLCHAIN_FILE=../util/32-bit-toolchain.cmake -GNinja .. + cmake -B build -DCMAKE_TOOLCHAIN_FILE=../util/32-bit-toolchain.cmake -GNinja If you want to build as a shared library, pass `-DBUILD_SHARED_LIBS=1`. On Windows, where functions need to be tagged with `dllimport` when coming from a @@ -93,12 +88,12 @@ versions of the NDK include a CMake toolchain file which works with CMake 3.6.0 or later. This has been tested with version r16b of the NDK. Unpack the Android NDK somewhere and export `ANDROID_NDK` to point to the -directory. Then make a build directory as above and run CMake like this: +directory. Then run CMake like this: cmake -DANDROID_ABI=armeabi-v7a \ -DANDROID_PLATFORM=android-19 \ -DCMAKE_TOOLCHAIN_FILE=${ANDROID_NDK}/build/cmake/android.toolchain.cmake \ - -GNinja .. + -GNinja -B build Once you've run that, Ninja should produce Android-compatible binaries. You can replace `armeabi-v7a` in the above with `arm64-v8a` and use API level 21 or @@ -140,7 +135,7 @@ In order to build with prefixed symbols, the `BORINGSSL_PREFIX` CMake variable should specify the prefix to add to all symbols, and the `BORINGSSL_PREFIX_SYMBOLS` CMake variable should specify the path to a file which contains a list of symbols which should be prefixed (one per line; -comments are supported with `#`). In other words, `cmake .. +comments are supported with `#`). In other words, `cmake -B build -DBORINGSSL_PREFIX=MY_CUSTOM_PREFIX -DBORINGSSL_PREFIX_SYMBOLS=/path/to/symbols.txt` will configure the build to add the prefix `MY_CUSTOM_PREFIX` to all of the symbols listed in diff --git a/FUZZING.md b/FUZZING.md index 5653acc1f3..89cf5e9302 100644 --- a/FUZZING.md +++ b/FUZZING.md @@ -7,10 +7,8 @@ We use Clang's [libFuzzer](http://llvm.org/docs/LibFuzzer.html) for fuzz testing In order to build the fuzz tests you will need at least Clang 6.0. Pass `-DFUZZ=1` on the CMake command line to enable building BoringSSL with coverage and AddressSanitizer, and to build the fuzz test binaries. You'll probably need to set the `CC` and `CXX` environment variables too, like this: ``` -mkdir build -cd build -CC=clang CXX=clang++ cmake -GNinja -DFUZZ=1 .. -ninja +CC=clang CXX=clang++ cmake -GNinja -DFUZZ=1 -B build +ninja -C build ``` diff --git a/rust/bssl-crypto/Cargo.toml b/rust/bssl-crypto/Cargo.toml index 57a64401e8..7822767a09 100644 --- a/rust/bssl-crypto/Cargo.toml +++ b/rust/bssl-crypto/Cargo.toml @@ -7,5 +7,5 @@ license = "MIT" [dependencies] # the crate will need to be generated at this path by running this command at root -# `mkdir build && cd build && cmake -G Ninja .. -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja` -bssl-sys = {path = "../../build/rust/bssl-sys"} \ No newline at end of file +# `cmake -G Ninja -B build -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja -C build` +bssl-sys = {path = "../../build/rust/bssl-sys"} diff --git a/rust/bssl-crypto/README.md b/rust/bssl-crypto/README.md index 9e10fad873..0d52053ae4 100644 --- a/rust/bssl-crypto/README.md +++ b/rust/bssl-crypto/README.md @@ -5,10 +5,10 @@ rust bindings to boringssl which wrap bssl-sys, a low level autogenerated bindin Before using this crate, first generate the bssl-sys bindings by running this command from the root of the repo: ``` -mkdir build && cd build && cmake -G Ninja .. -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja +cmake -G Ninja -B build -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja -C build ``` Then to run all tests: ``` cd rust/bssl-crypto && cargo clippy && cargo deny check && cargo test -``` \ No newline at end of file +``` diff --git a/rust/bssl-sys/build.rs b/rust/bssl-sys/build.rs index c2b7358ad7..e5407025a8 100644 --- a/rust/bssl-sys/build.rs +++ b/rust/bssl-sys/build.rs @@ -30,7 +30,7 @@ fn main() { .unwrap(); println!("cargo:rustc-env=BINDGEN_RS_FILE={}", bindgen_file); - // building bssl-sys with: `mkdir build && cd build && cmake -G Ninja .. -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja` + // building bssl-sys with: `cmake -G Ninja -B build -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja -C build` // outputs this crate to /build/rust/bssl-sys/ so need to go up 3 levels to the root of the repo let repo_root = crate_path.parent().unwrap().parent().unwrap(); From a38d6008055bbaf897c8f84006cfa8e45ea9cc80 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 15:48:39 -0400 Subject: [PATCH 29/56] Fix allowlist regex in bindgen invocation The allowlist is just a regex, which means bindgen leaves it to the user to resolve Windows vs POSIX filepath differences. We need to support both / and \. It's unclear why only some headers are broken, but it's probably something to do with whether the header is included directly or indirectly. Unfortunately, in doing so, we run into a mess of escaping issues, so the regex is more permissing than ideal. Bug: 595 Change-Id: I8b785aeaaeff162d9eb2aced89928f9602445903 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58967 Auto-Submit: David Benjamin Reviewed-by: Bob Beck Commit-Queue: Bob Beck --- rust/bssl-sys/CMakeLists.txt | 28 +++++++++++++++++++++++----- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/rust/bssl-sys/CMakeLists.txt b/rust/bssl-sys/CMakeLists.txt index 4cf85074b2..c11510bc84 100644 --- a/rust/bssl-sys/CMakeLists.txt +++ b/rust/bssl-sys/CMakeLists.txt @@ -5,15 +5,33 @@ target_link_libraries(rust_wrapper crypto) # Generate architecture-specific wrappers. set(WRAPPER_TARGET ${CMAKE_BINARY_DIR}/rust/bssl-sys/src/wrapper_${RUST_BINDINGS}.rs) -set(COMMAND ${BINDGEN_EXECUTABLE} "wrapper.h" +set(COMMAND ${BINDGEN_EXECUTABLE} wrapper.h -o ${WRAPPER_TARGET} --no-derive-default --enable-function-attribute-detection --use-core - --default-macro-constant-type="signed" - --rustified-enum="point_conversion_form_t" - --allowlist-file=".*/include/openssl/.*\\.h" - --allowlist-file=".*/rust_wrapper\\.h" + --default-macro-constant-type=signed + --rustified-enum=point_conversion_form_t + # These regexes need to accept both / and \ to handle Windows file + # path differences, due a bindgen issue. See + # https://crbug.com/boringssl/595. Ideally, we would write [/\\], + # but there are many layers of escaping here. First, CMake + # interprets backslashes. Then CMake generates a Ninja or Make file. + # That, in turn, launches passes inputs to the shell on POSIX, and + # does something else on Windows. + # + # It is unlikely that every layer here has sufficiently well-defined + # escaping and correctly handled the next layer's escaping. On top + # of that, we'd likely need to detect Windows vs POSIX hosts and + # change the input. Instead, just use [[:punct:]] which is more + # permissive than necessary, but we only need to exclude unwanted + # libc heaaders. + # + # If bindgen ever supports some file-based config (see + # https://github.com/rust-lang/rust-bindgen/issues/2508), we can + # switch to that. + --allowlist-file=".*[[:punct:]]include[[:punct:]]openssl[[:punct:]].*\\.h" + --allowlist-file=".*[[:punct:]]rust_wrapper\\.h" -- # these are LLVM arg passthroughs -I../../include # https://doc.rust-lang.org/nightly/rustc/platform-support.html From bcecc7d834fc44ad257b2f23f88e1cf597ab2736 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Tue, 18 Apr 2023 14:13:13 -0400 Subject: [PATCH 30/56] Replace sort.Sort with sort.Slice Change-Id: I6e0361a42b9612ba4294cc8806203ea445bc9257 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58945 Reviewed-by: Bob Beck Auto-Submit: David Benjamin Commit-Queue: Bob Beck --- crypto/err/err_data_generate.go | 17 +---------------- crypto/obj/objects.go | 15 +-------------- util/make_errors.go | 19 ++----------------- 3 files changed, 4 insertions(+), 47 deletions(-) diff --git a/crypto/err/err_data_generate.go b/crypto/err/err_data_generate.go index 332b4e15ae..aab6ee649a 100644 --- a/crypto/err/err_data_generate.go +++ b/crypto/err/err_data_generate.go @@ -115,23 +115,8 @@ func (st *stringList) Add(key uint32, value string) error { return nil } -// keySlice is a type that implements sorting of entries values. -type keySlice []uint32 - -func (ks keySlice) Len() int { - return len(ks) -} - -func (ks keySlice) Less(i, j int) bool { - return (ks[i] >> 15) < (ks[j] >> 15) -} - -func (ks keySlice) Swap(i, j int) { - ks[i], ks[j] = ks[j], ks[i] -} - func (st *stringList) buildList() []uint32 { - sort.Sort(keySlice(st.entries)) + sort.Slice(st.entries, func(i, j int) bool { return (st.entries[i] >> 15) < (st.entries[j] >> 15) }) return st.entries } diff --git a/crypto/obj/objects.go b/crypto/obj/objects.go index 1b9ded347b..3715fcf934 100644 --- a/crypto/obj/objects.go +++ b/crypto/obj/objects.go @@ -520,21 +520,8 @@ extern "C" { return os.WriteFile(path, []byte(formatted), 0666) } -// TODO(davidben): Replace this with sort.Slice once Go 1.8 is sufficiently -// common. -type nidSorter struct { - nids []int - objs *objects - cmp func(a, b object) bool -} - -func (a nidSorter) obj(i int) object { return a.objs.byNID[a.nids[i]] } -func (a nidSorter) Len() int { return len(a.nids) } -func (a nidSorter) Swap(i, j int) { a.nids[i], a.nids[j] = a.nids[j], a.nids[i] } -func (a nidSorter) Less(i, j int) bool { return a.cmp(a.obj(i), a.obj(j)) } - func sortNIDs(nids []int, objs *objects, cmp func(a, b object) bool) { - sort.Sort(&nidSorter{nids, objs, cmp}) + sort.Slice(nids, func(i, j int) bool { return cmp(objs.byNID[nids[i]], objs.byNID[nids[j]]) }) } func writeData(path string, objs *objects) error { diff --git a/util/make_errors.go b/util/make_errors.go index 4e2718b8d9..5d1d3210ef 100644 --- a/util/make_errors.go +++ b/util/make_errors.go @@ -188,28 +188,13 @@ type assignment struct { value int } -type assignmentsSlice []assignment - -func (a assignmentsSlice) Len() int { - return len(a) -} - -func (a assignmentsSlice) Less(i, j int) bool { - return a[i].value < a[j].value -} - -func (a assignmentsSlice) Swap(i, j int) { - a[i], a[j] = a[j], a[i] -} - func outputAssignments(w io.Writer, assignments map[string]int) { - var sorted assignmentsSlice - + sorted := make([]assignment, 0, len(assignments)) for key, value := range assignments { sorted = append(sorted, assignment{key, value}) } - sort.Sort(sorted) + sort.Slice(sorted, func(i, j int) bool { return sorted[i].value < sorted[j].value }) for _, assignment := range sorted { fmt.Fprintf(w, "#define %s %d\n", assignment.key, assignment.value) From d5ac273d61061cf0cfece2dad64bc260f2eed0df Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Thu, 20 Apr 2023 18:15:20 -0400 Subject: [PATCH 31/56] Spell includes in wrapper.h like the rest of the project We already require that #include work. May as well be consistent in wrapper.h, so it's less path-sensitive. Change-Id: Idd12e1c56a6e5d11623b4da82e405a5e976601b0 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59045 Reviewed-by: Bob Beck Commit-Queue: David Benjamin --- rust/bssl-sys/wrapper.h | 154 ++++++++++++++++++++-------------------- 1 file changed, 77 insertions(+), 77 deletions(-) diff --git a/rust/bssl-sys/wrapper.h b/rust/bssl-sys/wrapper.h index 101b455d94..bd74049556 100644 --- a/rust/bssl-sys/wrapper.h +++ b/rust/bssl-sys/wrapper.h @@ -1,79 +1,79 @@ -#include "../../include/openssl/aes.h" -#include "../../include/openssl/asn1.h" -#include "../../include/openssl/asn1_mac.h" -#include "../../include/openssl/asn1t.h" -#include "../../include/openssl/base.h" -#include "../../include/openssl/base64.h" -#include "../../include/openssl/bio.h" -#include "../../include/openssl/blake2.h" -#include "../../include/openssl/blowfish.h" -#include "../../include/openssl/bn.h" -#include "../../include/openssl/buf.h" -#include "../../include/openssl/buffer.h" -#include "../../include/openssl/bytestring.h" -#include "../../include/openssl/cast.h" -#include "../../include/openssl/chacha.h" -#include "../../include/openssl/cipher.h" -#include "../../include/openssl/cmac.h" -#include "../../include/openssl/conf.h" -#include "../../include/openssl/cpu.h" -#include "../../include/openssl/crypto.h" -#include "../../include/openssl/ctrdrbg.h" -#include "../../include/openssl/curve25519.h" -#include "../../include/openssl/des.h" -#include "../../include/openssl/dh.h" -#include "../../include/openssl/digest.h" -#include "../../include/openssl/dsa.h" -#include "../../include/openssl/dtls1.h" -#include "../../include/openssl/e_os2.h" -#include "../../include/openssl/ec.h" -#include "../../include/openssl/ec_key.h" -#include "../../include/openssl/ecdh.h" -#include "../../include/openssl/ecdsa.h" -#include "../../include/openssl/engine.h" -#include "../../include/openssl/err.h" -#include "../../include/openssl/evp.h" -#include "../../include/openssl/evp_errors.h" -#include "../../include/openssl/ex_data.h" -#include "../../include/openssl/hkdf.h" -#include "../../include/openssl/hmac.h" -#include "../../include/openssl/hpke.h" -#include "../../include/openssl/hrss.h" -#include "../../include/openssl/is_boringssl.h" -#include "../../include/openssl/kdf.h" -#include "../../include/openssl/lhash.h" -#include "../../include/openssl/md4.h" -#include "../../include/openssl/md5.h" -#include "../../include/openssl/mem.h" -#include "../../include/openssl/obj.h" -#include "../../include/openssl/obj_mac.h" -#include "../../include/openssl/objects.h" -#include "../../include/openssl/opensslconf.h" -#include "../../include/openssl/opensslv.h" -#include "../../include/openssl/ossl_typ.h" -#include "../../include/openssl/pem.h" -#include "../../include/openssl/pkcs12.h" -#include "../../include/openssl/pkcs7.h" -#include "../../include/openssl/pkcs8.h" -#include "../../include/openssl/poly1305.h" -#include "../../include/openssl/pool.h" -#include "../../include/openssl/rand.h" -#include "../../include/openssl/rc4.h" -#include "../../include/openssl/ripemd.h" -#include "../../include/openssl/rsa.h" -#include "../../include/openssl/safestack.h" -#include "../../include/openssl/sha.h" -#include "../../include/openssl/siphash.h" -#include "../../include/openssl/span.h" -#include "../../include/openssl/srtp.h" -#include "../../include/openssl/ssl.h" -#include "../../include/openssl/ssl3.h" -#include "../../include/openssl/stack.h" -#include "../../include/openssl/thread.h" -#include "../../include/openssl/tls1.h" -#include "../../include/openssl/trust_token.h" -#include "../../include/openssl/x509.h" -#include "../../include/openssl/x509_vfy.h" -#include "../../include/openssl/x509v3.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "rust_wrapper.h" From ac6d55859a61f1316010890eee451f6b0930301d Mon Sep 17 00:00:00 2001 From: Bob Beck Date: Tue, 28 Mar 2023 14:23:03 -0600 Subject: [PATCH 32/56] Add mechanism for deprecated declarations. This allows us to mark functions as deprecated declarations with OPENSSL_DEPRECATED. We also add an OPENSSL_BEGIN_ALLOW_DEPRECATED and an OPENSSL_END_ALLOW_DEPRECATED for testing use to test deprecated functions. The purpose of this is to allow us to mark things people should not be using as deprecated, and force some inconvenience on the user of such things to notice them (as opposed to a only a warning to not use it that they may not see or read without something tripping them up.) The intent is to still allow use, with some effort, before removing the function, or moving it to libdecrepit. We initially mark X509V3_EXT_add and X509V3_EXT_add_alias as deprecated. Update-Note: We are starting to mark some functions in boringssl as deprecated declarations which will cause the compiler to emit warnings if they are used. The intention is both to prevent accidental use in new code, and to to call attention to call sites in existing code so that the documentation for the deprecated function can be revisted and appropriate action taken. Bug: 584 Change-Id: Ia9ff386f0d22588e8a5999eda1a48b8c28dca2de Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58405 Reviewed-by: Adam Langley Commit-Queue: Bob Beck --- crypto/crypto_test.cc | 9 +++++++++ crypto/x509v3/v3_lib.c | 2 ++ include/openssl/base.h | 27 +++++++++++++++++++++++++++ include/openssl/x509v3.h | 5 +++-- 4 files changed, 41 insertions(+), 2 deletions(-) diff --git a/crypto/crypto_test.cc b/crypto/crypto_test.cc index caccba53a0..4543d5c106 100644 --- a/crypto/crypto_test.cc +++ b/crypto/crypto_test.cc @@ -158,3 +158,12 @@ TEST(Crypto, OnDemandIntegrityTest) { BORINGSSL_integrity_test(); } #endif + +OPENSSL_DEPRECATED static void DeprecatedFunction() {} + +OPENSSL_BEGIN_ALLOW_DEPRECATED +TEST(CryptoTest, DeprecatedFunction) { + // This is deprecated, but should not trigger any warnings. + DeprecatedFunction(); +} +OPENSSL_END_ALLOW_DEPRECATED diff --git a/crypto/x509v3/v3_lib.c b/crypto/x509v3/v3_lib.c index 52528eac01..61cbeea28e 100644 --- a/crypto/x509v3/v3_lib.c +++ b/crypto/x509v3/v3_lib.c @@ -141,6 +141,7 @@ int X509V3_EXT_free(int nid, void *ext_data) { } int X509V3_EXT_add_alias(int nid_to, int nid_from) { +OPENSSL_BEGIN_ALLOW_DEPRECATED const X509V3_EXT_METHOD *ext; X509V3_EXT_METHOD *tmpext; @@ -159,6 +160,7 @@ int X509V3_EXT_add_alias(int nid_to, int nid_from) { return 0; } return 1; +OPENSSL_END_ALLOW_DEPRECATED } // Legacy function: we don't need to add standard extensions any more because diff --git a/include/openssl/base.h b/include/openssl/base.h index fb1815f802..80d18a78d8 100644 --- a/include/openssl/base.h +++ b/include/openssl/base.h @@ -221,6 +221,33 @@ extern "C" { #endif // defined(BORINGSSL_SHARED_LIBRARY) +#if defined(_MSC_VER) + +// OPENSSL_DEPRECATED is used to mark a function as deprecated. Use +// of any functions so marked in caller code will produce a warning. +// OPENSSL_BEGIN_ALLOW_DEPRECATED and OPENSSL_END_ALLOW_DEPRECATED +// can be used to suppress the warning in regions of caller code. +#define OPENSSL_DEPRECATED __declspec(deprecated) +#define OPENSSL_BEGIN_ALLOW_DEPRECATED \ + __pragma(warning(push)) __pragma(warning(disable : 4996)) +#define OPENSSL_END_ALLOW_DEPRECATED __pragma(warning(pop)) + +#elif defined(__GNUC__) || defined(__clang__) + +#define OPENSSL_DEPRECATED __attribute__((__deprecated__)) +#define OPENSSL_BEGIN_ALLOW_DEPRECATED \ + _Pragma("GCC diagnostic push") \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#define OPENSSL_END_ALLOW_DEPRECATED _Pragma("GCC diagnostic pop") + +#else + +#define OPENSSL_DEPRECATED +#define OPENSSL_BEGIN_ALLOW_DEPRECATED +#define OPENSSL_END_ALLOW_DEPRECATED + +#endif + #if defined(__GNUC__) || defined(__clang__) // MinGW has two different printf implementations. Ensure the format macro diff --git a/include/openssl/x509v3.h b/include/openssl/x509v3.h index ee90f584fb..d9c862da83 100644 --- a/include/openssl/x509v3.h +++ b/include/openssl/x509v3.h @@ -688,14 +688,15 @@ OPENSSL_EXPORT char *i2s_ASN1_ENUMERATED(const X509V3_EXT_METHOD *meth, // callers should simply handle the custom extension with the byte-based // |X509_EXTENSION| APIs directly. Registering |ext| with the library has little // practical value. -OPENSSL_EXPORT int X509V3_EXT_add(X509V3_EXT_METHOD *ext); +OPENSSL_EXPORT OPENSSL_DEPRECATED int X509V3_EXT_add(X509V3_EXT_METHOD *ext); // X509V3_EXT_add_alias registers a custom extension with NID |nid_to|. The // corresponding ASN.1 type is copied from |nid_from|. It returns one on success // and zero on error. // // WARNING: Do not use this function. See |X509V3_EXT_add|. -OPENSSL_EXPORT int X509V3_EXT_add_alias(int nid_to, int nid_from); +OPENSSL_EXPORT OPENSSL_DEPRECATED int X509V3_EXT_add_alias(int nid_to, + int nid_from); OPENSSL_EXPORT const X509V3_EXT_METHOD *X509V3_EXT_get( const X509_EXTENSION *ext); From b0b1f9dfc583c96d5f91b7f8cdb7efabcf22793b Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 19 Apr 2023 17:18:27 -0400 Subject: [PATCH 33/56] Only rerun bindgen when its dependencies change This took a bit of wrangling to get the depfiles working, but I eventually figured it out. ninja -d explain is very useful. Fixed: 597 Change-Id: I909a4c9418e9dc954e3d328da8f3a825e62544e4 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59005 Reviewed-by: Bob Beck Auto-Submit: David Benjamin Commit-Queue: Bob Beck --- CMakeLists.txt | 1 + cmake/go.cmake | 5 +-- cmake/paths.cmake | 11 +++++ rust/bssl-sys/CMakeLists.txt | 83 +++++++++++++++++++----------------- 4 files changed, 56 insertions(+), 44 deletions(-) create mode 100644 cmake/paths.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index a1fb153943..aac5f0d13f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,6 +17,7 @@ endif() include(sources.cmake) include(cmake/go.cmake) +include(cmake/paths.cmake) include(cmake/perlasm.cmake) enable_language(C) diff --git a/cmake/go.cmake b/cmake/go.cmake index 61a01f519d..966ad32ddb 100644 --- a/cmake/go.cmake +++ b/cmake/go.cmake @@ -34,10 +34,7 @@ function(go_executable dest package) else() # Ninja expects the target in the depfile to match the output. This is a # relative path from the build directory. - string(LENGTH "${CMAKE_BINARY_DIR}" root_dir_length) - math(EXPR root_dir_length "${root_dir_length} + 1") - string(SUBSTRING "${CMAKE_CURRENT_BINARY_DIR}" ${root_dir_length} -1 target) - set(target "${target}/${dest}") + binary_dir_relative_path(${dest} target) set(depfile "${CMAKE_CURRENT_BINARY_DIR}/${dest}.d") add_custom_command(OUTPUT ${dest} diff --git a/cmake/paths.cmake b/cmake/paths.cmake new file mode 100644 index 0000000000..43ebc40628 --- /dev/null +++ b/cmake/paths.cmake @@ -0,0 +1,11 @@ +# binary_dir_relative_path sets outvar to +# ${CMAKE_CURRENT_BINARY_DIR}/${cur_bin_dir_relative}, but expressed relative to +# ${CMAKE_BINARY_DIR}. +# +# TODO(davidben): When we require CMake 3.20 or later, this can be replaced with +# the built-in cmake_path(RELATIVE_PATH) function. +function(binary_dir_relative_path cur_bin_dir_relative outvar) + string(LENGTH "${CMAKE_BINARY_DIR}/" root_dir_length) + string(SUBSTRING "${CMAKE_CURRENT_BINARY_DIR}/${cur_bin_dir_relative}" ${root_dir_length} -1 result) + set(${outvar} ${result} PARENT_SCOPE) +endfunction() diff --git a/rust/bssl-sys/CMakeLists.txt b/rust/bssl-sys/CMakeLists.txt index c11510bc84..5e5f4469d2 100644 --- a/rust/bssl-sys/CMakeLists.txt +++ b/rust/bssl-sys/CMakeLists.txt @@ -2,48 +2,51 @@ add_library(rust_wrapper STATIC rust_wrapper.c) target_link_libraries(rust_wrapper crypto) +# Generate architecture-specific wrappers. bindgen must be called from +# ${CMAKE_BINARY_DIR}, with the output path as a relative path. bindgen writes +# the depfile using the same syntax as the command-line argument, and ninja +# requires a path relative to the top-level build directory. +set(wrapper src/wrapper_${RUST_BINDINGS}.rs) +binary_dir_relative_path(${wrapper} wrapper_relative) +binary_dir_relative_path(${wrapper}.d depfile_relative) -# Generate architecture-specific wrappers. -set(WRAPPER_TARGET ${CMAKE_BINARY_DIR}/rust/bssl-sys/src/wrapper_${RUST_BINDINGS}.rs) -set(COMMAND ${BINDGEN_EXECUTABLE} wrapper.h - -o ${WRAPPER_TARGET} - --no-derive-default - --enable-function-attribute-detection - --use-core - --default-macro-constant-type=signed - --rustified-enum=point_conversion_form_t - # These regexes need to accept both / and \ to handle Windows file - # path differences, due a bindgen issue. See - # https://crbug.com/boringssl/595. Ideally, we would write [/\\], - # but there are many layers of escaping here. First, CMake - # interprets backslashes. Then CMake generates a Ninja or Make file. - # That, in turn, launches passes inputs to the shell on POSIX, and - # does something else on Windows. - # - # It is unlikely that every layer here has sufficiently well-defined - # escaping and correctly handled the next layer's escaping. On top - # of that, we'd likely need to detect Windows vs POSIX hosts and - # change the input. Instead, just use [[:punct:]] which is more - # permissive than necessary, but we only need to exclude unwanted - # libc heaaders. - # - # If bindgen ever supports some file-based config (see - # https://github.com/rust-lang/rust-bindgen/issues/2508), we can - # switch to that. - --allowlist-file=".*[[:punct:]]include[[:punct:]]openssl[[:punct:]].*\\.h" - --allowlist-file=".*[[:punct:]]rust_wrapper\\.h" - -- # these are LLVM arg passthroughs - -I../../include - # https://doc.rust-lang.org/nightly/rustc/platform-support.html - --target=${RUST_BINDINGS}) - -add_custom_target( - bindgen_rust_${RUST_BINDINGS} - ALL - ${COMMAND} - BYPRODUCTS ${WRAPPER_TARGET} - WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} +add_custom_command( + OUTPUT ${wrapper} + COMMAND ${BINDGEN_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/wrapper.h + -o ${wrapper_relative} + --depfile=${depfile_relative} + --no-derive-default + --enable-function-attribute-detection + --use-core + --default-macro-constant-type=signed + --rustified-enum=point_conversion_form_t + # These regexes need to accept both / and \ to handle Windows file + # path differences, due a bindgen issue. See + # https://crbug.com/boringssl/595. Ideally, we would write [/\\], but + # there are many layers of escaping here. First, CMake interprets + # backslashes. Then CMake generates a Ninja or Make file. That, in + # turn, uses the shell on POSIX, and does something else on Windows. + # + # It is unlikely that every layer here has sufficiently well-defined + # escaping and correctly handled the next layer's escaping. On top of + # that, we'd likely need to detect Windows vs POSIX hosts and change + # the input. Instead, just use [[:punct:]] which is more permissive + # than necessary, but we only need to exclude unwanted libc headers. + # + # If bindgen ever supports some file-based config (see + # https://github.com/rust-lang/rust-bindgen/issues/2508), we can + # switch to that. + --allowlist-file=".*[[:punct:]]include[[:punct:]]openssl[[:punct:]].*\\.h" + --allowlist-file=".*[[:punct:]]rust_wrapper\\.h" + -- # these are LLVM arg passthroughs + -I${PROJECT_SOURCE_DIR}/include + # https://doc.rust-lang.org/nightly/rustc/platform-support.html + --target=${RUST_BINDINGS} + DEPENDS wrapper.h + DEPFILE ${CMAKE_CURRENT_BINARY_DIR}/${wrapper}.d + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) +add_custom_target(bssl_sys ALL DEPENDS ${wrapper}) # move files into build directory configure_file("src/lib.rs" "src/lib.rs") From de2d610a341f5a4b8c222425890537cb84c91400 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Fri, 21 Apr 2023 17:32:21 -0400 Subject: [PATCH 34/56] Remove TLS_RSA_WITH_NULL_SHA Per b/31553927, the last use of this is long gone. This cipher has been deprecated since it was (re)-added in 2015, so it's long past time to remove it. Update-Note: TLS_RSA_WITH_NULL_SHA is no longer available. Nothing should be enabling it anymore. Callers using SSL_CTX_set_strict_cipher_list instead of SSL_CTX_set_cipher_list will notice if they're affected very quickly, because the functino will fail if this cipher is referenced. As a deprecated cipher suite, this cipher was already unavailable unless explicitly named, so if your configuration doesn't say "TLS_RSA_WITH_NULL_SHA" or "NULL-SHA", you were not using this cipher. Bug: b:31553927 Change-Id: Id560bb4f9b156be3650d63f4ecf7783fad5ae209 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59145 Commit-Queue: David Benjamin Reviewed-by: Bob Beck Commit-Queue: Bob Beck Auto-Submit: David Benjamin --- crypto/cipher_extra/e_tls.c | 26 ------------------------ include/openssl/aead.h | 2 -- include/openssl/ssl.h | 3 --- ssl/internal.h | 3 +-- ssl/ssl_cipher.cc | 34 +++----------------------------- ssl/test/fuzzer.h | 2 +- ssl/test/runner/cipher_suites.go | 6 ------ ssl/test/runner/runner.go | 5 ----- 8 files changed, 5 insertions(+), 76 deletions(-) diff --git a/crypto/cipher_extra/e_tls.c b/crypto/cipher_extra/e_tls.c index cfaf95dc70..00b482432c 100644 --- a/crypto/cipher_extra/e_tls.c +++ b/crypto/cipher_extra/e_tls.c @@ -442,13 +442,6 @@ static int aead_tls_get_iv(const EVP_AEAD_CTX *ctx, const uint8_t **out_iv, return 1; } -static int aead_null_sha1_tls_init(EVP_AEAD_CTX *ctx, const uint8_t *key, - size_t key_len, size_t tag_len, - enum evp_aead_direction_t dir) { - return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_enc_null(), - EVP_sha1(), 1 /* implicit iv */); -} - static const EVP_AEAD aead_aes_128_cbc_sha1_tls = { SHA_DIGEST_LENGTH + 16, // key len (SHA1 + AES128) 16, // nonce len (IV) @@ -551,23 +544,6 @@ static const EVP_AEAD aead_des_ede3_cbc_sha1_tls_implicit_iv = { aead_tls_tag_len, }; -static const EVP_AEAD aead_null_sha1_tls = { - SHA_DIGEST_LENGTH, // key len - 0, // nonce len - SHA_DIGEST_LENGTH, // overhead (SHA1) - SHA_DIGEST_LENGTH, // max tag length - 0, // seal_scatter_supports_extra_in - - NULL, // init - aead_null_sha1_tls_init, - aead_tls_cleanup, - aead_tls_open, - aead_tls_seal_scatter, - NULL, // open_gather - NULL, // get_iv - aead_tls_tag_len, -}; - const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls(void) { return &aead_aes_128_cbc_sha1_tls; } @@ -591,5 +567,3 @@ const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls(void) { const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls_implicit_iv(void) { return &aead_des_ede3_cbc_sha1_tls_implicit_iv; } - -const EVP_AEAD *EVP_aead_null_sha1_tls(void) { return &aead_null_sha1_tls; } diff --git a/include/openssl/aead.h b/include/openssl/aead.h index 131cfecd2a..26338800a3 100644 --- a/include/openssl/aead.h +++ b/include/openssl/aead.h @@ -408,8 +408,6 @@ OPENSSL_EXPORT const EVP_AEAD *EVP_aead_aes_256_cbc_sha1_tls_implicit_iv(void); OPENSSL_EXPORT const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls(void); OPENSSL_EXPORT const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls_implicit_iv(void); -OPENSSL_EXPORT const EVP_AEAD *EVP_aead_null_sha1_tls(void); - // EVP_aead_aes_128_gcm_tls12 is AES-128 in Galois Counter Mode using the TLS // 1.2 nonce construction. OPENSSL_EXPORT const EVP_AEAD *EVP_aead_aes_128_gcm_tls12(void); diff --git a/include/openssl/ssl.h b/include/openssl/ssl.h index 0a1493db3a..fdea6ae492 100644 --- a/include/openssl/ssl.h +++ b/include/openssl/ssl.h @@ -1449,9 +1449,6 @@ OPENSSL_EXPORT int SSL_CIPHER_get_bits(const SSL_CIPHER *cipher, // // |SHA1|, and its alias |SHA|, match legacy cipher suites using HMAC-SHA1. // -// Although implemented, authentication-only ciphers match no rules and must be -// explicitly selected by name. -// // Deprecated cipher rules: // // |kEDH|, |EDH|, |kEECDH|, and |EECDH| are legacy aliases for |kDHE|, |DHE|, diff --git a/ssl/internal.h b/ssl/internal.h index 15ad6c2172..e12b12f695 100644 --- a/ssl/internal.h +++ b/ssl/internal.h @@ -547,8 +547,7 @@ BSSL_NAMESPACE_BEGIN #define SSL_AES256 0x00000004u #define SSL_AES128GCM 0x00000008u #define SSL_AES256GCM 0x00000010u -#define SSL_eNULL 0x00000020u -#define SSL_CHACHA20POLY1305 0x00000040u +#define SSL_CHACHA20POLY1305 0x00000020u #define SSL_AES (SSL_AES128 | SSL_AES256 | SSL_AES128GCM | SSL_AES256GCM) diff --git a/ssl/ssl_cipher.cc b/ssl/ssl_cipher.cc index 73564b390e..383329403d 100644 --- a/ssl/ssl_cipher.cc +++ b/ssl/ssl_cipher.cc @@ -157,17 +157,6 @@ BSSL_NAMESPACE_BEGIN static constexpr SSL_CIPHER kCiphers[] = { // The RSA ciphers - // Cipher 02 - { - SSL3_TXT_RSA_NULL_SHA, - "TLS_RSA_WITH_NULL_SHA", - SSL3_CK_RSA_NULL_SHA, - SSL_kRSA, - SSL_aRSA, - SSL_eNULL, - SSL_SHA1, - SSL_HANDSHAKE_MAC_DEFAULT, - }, // Cipher 0A { @@ -498,7 +487,6 @@ typedef struct cipher_alias_st { } CIPHER_ALIAS; static const CIPHER_ALIAS kCipherAliases[] = { - // "ALL" doesn't include eNULL. It must be explicitly enabled. {"ALL", ~0u, ~0u, ~0u, ~0u, 0}, // The "COMPLEMENTOFDEFAULT" rule is omitted. It matches nothing. @@ -599,9 +587,7 @@ bool ssl_cipher_get_evp_aead(const EVP_AEAD **out_aead, *out_fixed_iv_len = EVP_AEAD_nonce_length(*out_aead); } } else if (cipher->algorithm_mac == SSL_SHA1) { - if (cipher->algorithm_enc == SSL_eNULL) { - *out_aead = EVP_aead_null_sha1_tls(); - } else if (cipher->algorithm_enc == SSL_3DES) { + if (cipher->algorithm_enc == SSL_3DES) { if (version == TLS1_VERSION) { *out_aead = EVP_aead_des_ede3_cbc_sha1_tls_implicit_iv(); *out_fixed_iv_len = 8; @@ -866,9 +852,7 @@ static void ssl_cipher_apply_rule( !(alg_auth & cp->algorithm_auth) || !(alg_enc & cp->algorithm_enc) || !(alg_mac & cp->algorithm_mac) || - (min_version != 0 && SSL_CIPHER_get_min_version(cp) != min_version) || - // The NULL cipher must be selected explicitly. - cp->algorithm_enc == SSL_eNULL) { + (min_version != 0 && SSL_CIPHER_get_min_version(cp) != min_version)) { continue; } } @@ -1383,8 +1367,6 @@ int SSL_CIPHER_is_aead(const SSL_CIPHER *cipher) { int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *cipher) { switch (cipher->algorithm_enc) { - case SSL_eNULL: - return NID_undef; case SSL_3DES: return NID_des_ede3_cbc; case SSL_AES128: @@ -1457,8 +1439,7 @@ int SSL_CIPHER_get_prf_nid(const SSL_CIPHER *cipher) { } int SSL_CIPHER_is_block_cipher(const SSL_CIPHER *cipher) { - return (cipher->algorithm_enc & SSL_eNULL) == 0 && - cipher->algorithm_mac != SSL_AEAD; + return cipher->algorithm_mac != SSL_AEAD; } uint16_t SSL_CIPHER_get_min_version(const SSL_CIPHER *cipher) { @@ -1557,11 +1538,6 @@ int SSL_CIPHER_get_bits(const SSL_CIPHER *cipher, int *out_alg_bits) { strength_bits = 112; break; - case SSL_eNULL: - alg_bits = 0; - strength_bits = 0; - break; - default: assert(0); alg_bits = 0; @@ -1652,10 +1628,6 @@ const char *SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, enc = "ChaCha20-Poly1305"; break; - case SSL_eNULL: - enc="None"; - break; - default: enc = "unknown"; break; diff --git a/ssl/test/fuzzer.h b/ssl/test/fuzzer.h index 8f73fc01a1..e18a820532 100644 --- a/ssl/test/fuzzer.h +++ b/ssl/test/fuzzer.h @@ -414,7 +414,7 @@ class TLSFuzzer { SSL_CTX_enable_ocsp_stapling(ctx_.get()); // Enable versions and ciphers that are off by default. - if (!SSL_CTX_set_strict_cipher_list(ctx_.get(), "ALL:NULL-SHA")) { + if (!SSL_CTX_set_strict_cipher_list(ctx_.get(), "ALL")) { return false; } diff --git a/ssl/test/runner/cipher_suites.go b/ssl/test/runner/cipher_suites.go index 5db57498be..b86f515f54 100644 --- a/ssl/test/runner/cipher_suites.go +++ b/ssl/test/runner/cipher_suites.go @@ -127,11 +127,6 @@ var cipherSuites = []*cipherSuite{ {TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA, 32, 20, ivLenAES, ecdhePSKKA, suiteECDHE | suitePSK, cipherAES, macSHA1, nil}, {TLS_PSK_WITH_AES_128_CBC_SHA, 16, 20, ivLenAES, pskKA, suitePSK, cipherAES, macSHA1, nil}, {TLS_PSK_WITH_AES_256_CBC_SHA, 32, 20, ivLenAES, pskKA, suitePSK, cipherAES, macSHA1, nil}, - {TLS_RSA_WITH_NULL_SHA, 0, 20, noIV, rsaKA, 0, cipherNull, macSHA1, nil}, -} - -func noIV(vers uint16) int { - return 0 } func ivLenChaCha20Poly1305(vers uint16) int { @@ -364,7 +359,6 @@ func cipherSuiteFromID(id uint16) *cipherSuite { // A list of the possible cipher suite ids. Taken from // http://www.iana.org/assignments/tls-parameters/tls-parameters.xml const ( - TLS_RSA_WITH_NULL_SHA uint16 = 0x0002 TLS_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x000a TLS_RSA_WITH_AES_128_CBC_SHA uint16 = 0x002f TLS_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0035 diff --git a/ssl/test/runner/runner.go b/ssl/test/runner/runner.go index dde60dfdf1..745ba7d606 100644 --- a/ssl/test/runner/runner.go +++ b/ssl/test/runner/runner.go @@ -1850,7 +1850,6 @@ var testCipherSuites = []testCipherSuite{ {"CHACHA20_POLY1305_SHA256", TLS_CHACHA20_POLY1305_SHA256}, {"AES_128_GCM_SHA256", TLS_AES_128_GCM_SHA256}, {"AES_256_GCM_SHA384", TLS_AES_256_GCM_SHA384}, - {"RSA_WITH_NULL_SHA", TLS_RSA_WITH_NULL_SHA}, } func hasComponent(suiteName, component string) bool { @@ -3673,10 +3672,6 @@ func addTestForCipherSuite(suite testCipherSuite, ver tlsVersion, protocol proto "-psk", psk, "-psk-identity", pskIdentity) } - if hasComponent(suite.name, "NULL") { - // NULL ciphers must be explicitly enabled. - flags = append(flags, "-cipher", "DEFAULT:NULL-SHA") - } var shouldFail bool if isTLS12Only(suite.name) && ver.version < VersionTLS12 { From edf7662c8207b116f45e3b31f13c326916b93d34 Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Tue, 25 Apr 2023 09:21:10 -0700 Subject: [PATCH 35/56] Allow passing extra flags to BoGo shim Add a new flag, -shim-extra-flags, which allows specifying additional flags to pass to the shim binary on all invocations. These flags will be passed as the first flags to the shim in order to take advantage of some slightly confusing Go flag semantics. Change-Id: I382f47bfe2662903b43135fcb249b46646fc9e7b Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59245 Commit-Queue: David Benjamin Reviewed-by: David Benjamin --- ssl/test/runner/runner.go | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/ssl/test/runner/runner.go b/ssl/test/runner/runner.go index 745ba7d606..1da1e2a4f1 100644 --- a/ssl/test/runner/runner.go +++ b/ssl/test/runner/runner.go @@ -65,6 +65,7 @@ var ( allowHintMismatch = flag.String("allow-hint-mismatch", "", "Semicolon-separated patterns of tests where hints may mismatch") numWorkersFlag = flag.Int("num-workers", runtime.NumCPU(), "The number of workers to run in parallel.") shimPath = flag.String("shim-path", "../../../build/ssl/test/bssl_shim", "The location of the shim binary.") + shimExtraFlags = flag.String("shim-extra-flags", "", "Semicolon-separated extra flags to pass to the shim binary on each invocation.") handshakerPath = flag.String("handshaker-path", "../../../build/ssl/test/handshaker", "The location of the handshaker binary.") resourceDir = flag.String("resource-dir", ".", "The directory in which to find certificate and key files.") fuzzer = flag.Bool("fuzzer", false, "If true, tests against a BoringSSL built in fuzzer mode.") @@ -1433,6 +1434,9 @@ func runTest(statusChan chan statusMsg, test *testCase, shimPath string, mallocN }() var flags []string + if len(*shimExtraFlags) > 0 { + flags = strings.Split(*shimExtraFlags, ";") + } if test.testType == serverTest { flags = append(flags, "-server") @@ -1877,7 +1881,12 @@ func bigFromHex(hex string) *big.Int { func convertToSplitHandshakeTests(tests []testCase) (splitHandshakeTests []testCase, err error) { var stdout bytes.Buffer - shim := exec.Command(*shimPath, "-is-handshaker-supported") + var flags []string + if len(*shimExtraFlags) > 0 { + flags = strings.Split(*shimExtraFlags, ";") + } + flags = append(flags, "-is-handshaker-supported") + shim := exec.Command(*shimPath, flags...) shim.Stdout = &stdout if err := shim.Run(); err != nil { return nil, err From 5748eb8a3314281151af1edc63ba58bfd7097d7d Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Mon, 24 Apr 2023 16:09:23 -0400 Subject: [PATCH 36/56] Move convert_wycheproof into its own package This can still be run like go run ../../util/convert_wycheproof. This is part of an attempt to reland 54b04fdc21d540a6e24f9ddb7ddc3e583518e24f, which ran into an issue with internal tooling that could not handle standalone Go files. Since the only such target we actually needed to run in that repository is convert_wycheproof, just promote it into its own package. Then we can stop trying to import util. Change-Id: I6237777dad09e5c81ad961816ce14a287ab2d46a Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59185 Reviewed-by: Adam Langley Commit-Queue: Adam Langley Auto-Submit: David Benjamin --- util/{ => convert_wycheproof}/convert_wycheproof.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) rename util/{ => convert_wycheproof}/convert_wycheproof.go (98%) diff --git a/util/convert_wycheproof.go b/util/convert_wycheproof/convert_wycheproof.go similarity index 98% rename from util/convert_wycheproof.go rename to util/convert_wycheproof/convert_wycheproof.go index a7dfc81805..076f8e480d 100644 --- a/util/convert_wycheproof.go +++ b/util/convert_wycheproof/convert_wycheproof.go @@ -12,8 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -// convert_wycheproof.go converts Wycheproof test vectors into a format more -// easily consumed by BoringSSL. +// convert_wycheproof converts Wycheproof test vectors into a format more easily +// consumed by BoringSSL. package main import ( From ece1f86968f576ec6876fc398fd191256ce31039 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Mon, 24 Apr 2023 16:14:08 -0400 Subject: [PATCH 37/56] Re-add go:build ignore lines This reverts commit bab2f96e2637acb107fe9b099c58befbca918748. This clears the sea of red in my editor. Change-Id: I600ef6c36556fb526da729f0f0d8bc69db5c5a08 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59186 Reviewed-by: Adam Langley Commit-Queue: David Benjamin --- crypto/err/err_data_generate.go | 2 ++ crypto/fipsmodule/bn/bn_test_to_fuzzer.go | 2 ++ crypto/fipsmodule/bn/check_bn_tests.go | 2 ++ crypto/fipsmodule/ec/make_ec_scalar_base_mult_tests.go | 2 ++ crypto/fipsmodule/ec/make_p256-nistz-tests.go | 2 ++ crypto/fipsmodule/ec/make_tables.go | 2 ++ crypto/obj/objects.go | 2 ++ crypto/x509/test/make_basic_constraints.go | 2 ++ crypto/x509/test/make_invalid_extensions.go | 2 ++ crypto/x509/test/make_many_constraints.go | 2 ++ crypto/x509/test/make_policy_certs.go | 2 ++ util/all_tests.go | 2 ++ util/check_filenames.go | 2 ++ util/check_imported_libraries.go | 2 ++ util/check_stack.go | 2 ++ util/compare_benchmarks.go | 2 ++ util/convert_comments.go | 2 ++ util/convert_wycheproof/convert_wycheproof.go | 2 ++ util/diff_asm.go | 2 ++ util/doc.go | 2 ++ util/embed_test_data.go | 2 ++ util/fetch_ech_config_list.go | 2 ++ util/fipstools/acvp/acvptool/test/check_expected.go | 2 ++ util/fipstools/acvp/acvptool/test/trim_vectors.go | 2 ++ util/fipstools/break-hash.go | 2 ++ util/fipstools/break-kat.go | 2 ++ util/godeps.go | 2 ++ util/make_errors.go | 2 ++ util/make_prefix_headers.go | 2 ++ util/read_symbols.go | 2 ++ util/run_android_tests.go | 2 ++ 31 files changed, 62 insertions(+) diff --git a/crypto/err/err_data_generate.go b/crypto/err/err_data_generate.go index aab6ee649a..d4a7c28a8f 100644 --- a/crypto/err/err_data_generate.go +++ b/crypto/err/err_data_generate.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/crypto/fipsmodule/bn/bn_test_to_fuzzer.go b/crypto/fipsmodule/bn/bn_test_to_fuzzer.go index 1e48df350d..2915db5f9d 100644 --- a/crypto/fipsmodule/bn/bn_test_to_fuzzer.go +++ b/crypto/fipsmodule/bn/bn_test_to_fuzzer.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/crypto/fipsmodule/bn/check_bn_tests.go b/crypto/fipsmodule/bn/check_bn_tests.go index dd1def80d7..032b9e328d 100644 --- a/crypto/fipsmodule/bn/check_bn_tests.go +++ b/crypto/fipsmodule/bn/check_bn_tests.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/crypto/fipsmodule/ec/make_ec_scalar_base_mult_tests.go b/crypto/fipsmodule/ec/make_ec_scalar_base_mult_tests.go index 169d226ad1..1d3896aa98 100644 --- a/crypto/fipsmodule/ec/make_ec_scalar_base_mult_tests.go +++ b/crypto/fipsmodule/ec/make_ec_scalar_base_mult_tests.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/crypto/fipsmodule/ec/make_p256-nistz-tests.go b/crypto/fipsmodule/ec/make_p256-nistz-tests.go index 04a1a1c874..e10990b30e 100644 --- a/crypto/fipsmodule/ec/make_p256-nistz-tests.go +++ b/crypto/fipsmodule/ec/make_p256-nistz-tests.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/crypto/fipsmodule/ec/make_tables.go b/crypto/fipsmodule/ec/make_tables.go index b60712b009..120c40bd5a 100644 --- a/crypto/fipsmodule/ec/make_tables.go +++ b/crypto/fipsmodule/ec/make_tables.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/crypto/obj/objects.go b/crypto/obj/objects.go index 3715fcf934..077a6e12f6 100644 --- a/crypto/obj/objects.go +++ b/crypto/obj/objects.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/crypto/x509/test/make_basic_constraints.go b/crypto/x509/test/make_basic_constraints.go index 67f4b913d3..ea502b4c8d 100644 --- a/crypto/x509/test/make_basic_constraints.go +++ b/crypto/x509/test/make_basic_constraints.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // make_basic_constraints.go generates self-signed certificates with the basic // constraints extension. package main diff --git a/crypto/x509/test/make_invalid_extensions.go b/crypto/x509/test/make_invalid_extensions.go index 884d933555..8287bf8d31 100644 --- a/crypto/x509/test/make_invalid_extensions.go +++ b/crypto/x509/test/make_invalid_extensions.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // make_invalid_extensions.go generates a number of certificate chains with // invalid extension encodings. package main diff --git a/crypto/x509/test/make_many_constraints.go b/crypto/x509/test/make_many_constraints.go index 07f2edc760..24a5c40717 100644 --- a/crypto/x509/test/make_many_constraints.go +++ b/crypto/x509/test/make_many_constraints.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // make_many_constraints.go generates test certificates many_constraints.pem, // many_names*.pem, and some_names*.pem for x509_test.cc package main diff --git a/crypto/x509/test/make_policy_certs.go b/crypto/x509/test/make_policy_certs.go index b1c5a60efe..739d8ced39 100644 --- a/crypto/x509/test/make_policy_certs.go +++ b/crypto/x509/test/make_policy_certs.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // make_policy_certs.go generates certificates for testing policy handling. package main diff --git a/util/all_tests.go b/util/all_tests.go index 8d81463e04..c0dceba55e 100644 --- a/util/all_tests.go +++ b/util/all_tests.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/util/check_filenames.go b/util/check_filenames.go index 886c3f6091..384c19f510 100644 --- a/util/check_filenames.go +++ b/util/check_filenames.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // check_filenames.go checks that filenames are unique. Some of our consumers do // not support multiple files with the same name in the same build target, even // if they are in different directories. diff --git a/util/check_imported_libraries.go b/util/check_imported_libraries.go index 187e51441f..f3803f1c1d 100644 --- a/util/check_imported_libraries.go +++ b/util/check_imported_libraries.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // check_imported_libraries.go checks that each of its arguments only imports // allowed libraries. This is used to avoid accidental dependencies on // libstdc++.so. diff --git a/util/check_stack.go b/util/check_stack.go index b718ea4aca..ad763e6529 100644 --- a/util/check_stack.go +++ b/util/check_stack.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // check_stack.go checks that each of its arguments has a non-executable stack. // See https://www.airs.com/blog/archives/518 for details. package main diff --git a/util/compare_benchmarks.go b/util/compare_benchmarks.go index d631f832b1..05e1b5db0d 100644 --- a/util/compare_benchmarks.go +++ b/util/compare_benchmarks.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // compare_benchmarks takes the JSON-formatted output of bssl speed and // compares it against a baseline output. package main diff --git a/util/convert_comments.go b/util/convert_comments.go index 917f29c861..df9e3d3ae3 100644 --- a/util/convert_comments.go +++ b/util/convert_comments.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/util/convert_wycheproof/convert_wycheproof.go b/util/convert_wycheproof/convert_wycheproof.go index 076f8e480d..88a908d85d 100644 --- a/util/convert_wycheproof/convert_wycheproof.go +++ b/util/convert_wycheproof/convert_wycheproof.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // convert_wycheproof converts Wycheproof test vectors into a format more easily // consumed by BoringSSL. package main diff --git a/util/diff_asm.go b/util/diff_asm.go index 27c0aa20af..5ac1c04bbd 100644 --- a/util/diff_asm.go +++ b/util/diff_asm.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/util/doc.go b/util/doc.go index e7f1b5911f..4fb73ca0dc 100644 --- a/util/doc.go +++ b/util/doc.go @@ -1,3 +1,5 @@ +//go:build ignore + // doc generates HTML files from the comments in header files. // // doc expects to be given the path to a JSON file via the --config option. diff --git a/util/embed_test_data.go b/util/embed_test_data.go index 0a0d1e3f1b..ae7135fae4 100644 --- a/util/embed_test_data.go +++ b/util/embed_test_data.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // embed_test_data generates a C++ source file which exports a function, // GetTestData, which looks up the specified data files. package main diff --git a/util/fetch_ech_config_list.go b/util/fetch_ech_config_list.go index 8f09e66b1f..732d0d3b8a 100644 --- a/util/fetch_ech_config_list.go +++ b/util/fetch_ech_config_list.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/util/fipstools/acvp/acvptool/test/check_expected.go b/util/fipstools/acvp/acvptool/test/check_expected.go index c5dc0f670f..d02f272983 100644 --- a/util/fipstools/acvp/acvptool/test/check_expected.go +++ b/util/fipstools/acvp/acvptool/test/check_expected.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/util/fipstools/acvp/acvptool/test/trim_vectors.go b/util/fipstools/acvp/acvptool/test/trim_vectors.go index 53e970e028..703f75fd20 100644 --- a/util/fipstools/acvp/acvptool/test/trim_vectors.go +++ b/util/fipstools/acvp/acvptool/test/trim_vectors.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // trimvectors takes an ACVP vector set file and discards all but a single test // from each test group. This hope is that this achieves good coverage without // having to check in megabytes worth of JSON files. diff --git a/util/fipstools/break-hash.go b/util/fipstools/break-hash.go index e37da75253..a4ab8083df 100644 --- a/util/fipstools/break-hash.go +++ b/util/fipstools/break-hash.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // break-hash parses an ELF binary containing the FIPS module and corrupts the // first byte of the module. This should cause the integrity check to fail. package main diff --git a/util/fipstools/break-kat.go b/util/fipstools/break-kat.go index c412d0e28f..e4d323abcb 100644 --- a/util/fipstools/break-kat.go +++ b/util/fipstools/break-kat.go @@ -1,3 +1,5 @@ +//go:build + // break-kat corrupts a known-answer-test input in a binary and writes the // corrupted binary to stdout. This is used to demonstrate that the KATs in the // binary notice the error. diff --git a/util/godeps.go b/util/godeps.go index 960faa46be..56be55944f 100644 --- a/util/godeps.go +++ b/util/godeps.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // godeps prints out dependencies of a package in either CMake or Make depfile // format, for incremental rebuilds. // diff --git a/util/make_errors.go b/util/make_errors.go index 5d1d3210ef..874a001b29 100644 --- a/util/make_errors.go +++ b/util/make_errors.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( diff --git a/util/make_prefix_headers.go b/util/make_prefix_headers.go index b39e4ec7c6..8787654b5c 100644 --- a/util/make_prefix_headers.go +++ b/util/make_prefix_headers.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // This program takes a file containing newline-separated symbols, and generates // boringssl_prefix_symbols.h, boringssl_prefix_symbols_asm.h, and // boringssl_prefix_symbols_nasm.inc. These header files can be used to build diff --git a/util/read_symbols.go b/util/read_symbols.go index b407ecb10c..ab2184c0cc 100644 --- a/util/read_symbols.go +++ b/util/read_symbols.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + // read_symbols scans one or more .a files and, for each object contained in // the .a files, reads the list of symbols in that object file. package main diff --git a/util/run_android_tests.go b/util/run_android_tests.go index 67a13e7e41..ce878195fc 100644 --- a/util/run_android_tests.go +++ b/util/run_android_tests.go @@ -12,6 +12,8 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +//go:build ignore + package main import ( From 4b6d950d8921d6dd5365de0797fcc97302b9561b Mon Sep 17 00:00:00 2001 From: Steven Valdez Date: Tue, 18 Apr 2023 12:03:42 -0400 Subject: [PATCH 38/56] Align TRUST_TOKEN_pst_v1_voprf with draft-21 of VOPRF This aligns the DLEQ proof portion of TRUST_TOKEN_pst_v1_voprf with draft-irtf-cfrg-voprf-21. The blind and finalize operations still differ. Additionally, as VOPRF doesn't include batched issuance, the issuance process around the DLEQ proof is adapted from draft-robert-privacypass-batched-tokens-01. Bug: chromium:1414562 Change-Id: If1c6de0f92089a826968a57279ae598ccf89ca3e Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58906 Commit-Queue: Steven Valdez Reviewed-by: David Benjamin --- crypto/fipsmodule/ec/internal.h | 10 +- crypto/trust_token/internal.h | 4 + crypto/trust_token/trust_token_test.cc | 289 +++++++++++++++ crypto/trust_token/voprf.c | 472 ++++++++++++++++++++++++- 4 files changed, 753 insertions(+), 22 deletions(-) diff --git a/crypto/fipsmodule/ec/internal.h b/crypto/fipsmodule/ec/internal.h index 846431fd8f..3b6fa4a4b0 100644 --- a/crypto/fipsmodule/ec/internal.h +++ b/crypto/fipsmodule/ec/internal.h @@ -91,6 +91,8 @@ extern "C" { // be the largest fields anyone plausibly uses. #define EC_MAX_BYTES 66 #define EC_MAX_WORDS ((EC_MAX_BYTES + BN_BYTES - 1) / BN_BYTES) +#define EC_MAX_COMPRESSED (EC_MAX_BYTES + 1) +#define EC_MAX_UNCOMPRESSED (2 * EC_MAX_BYTES + 1) static_assert(EC_MAX_WORDS <= BN_SMALL_MAX_WORDS, "bn_*_small functions not usable"); @@ -119,8 +121,8 @@ OPENSSL_EXPORT void ec_scalar_to_bytes(const EC_GROUP *group, uint8_t *out, // ec_scalar_from_bytes deserializes |in| and stores the resulting scalar over // group |group| to |out|. It returns one on success and zero if |in| is // invalid. -int ec_scalar_from_bytes(const EC_GROUP *group, EC_SCALAR *out, - const uint8_t *in, size_t len); +OPENSSL_EXPORT int ec_scalar_from_bytes(const EC_GROUP *group, EC_SCALAR *out, + const uint8_t *in, size_t len); // ec_scalar_reduce sets |out| to |words|, reduced modulo the group order. // |words| must be less than order^2. |num| must be at most twice the width of @@ -279,8 +281,8 @@ void ec_affine_to_jacobian(const EC_GROUP *group, EC_RAW_POINT *out, // // If only extracting the x-coordinate, use |ec_get_x_coordinate_*| which is // slightly faster. -int ec_jacobian_to_affine(const EC_GROUP *group, EC_AFFINE *out, - const EC_RAW_POINT *p); +OPENSSL_EXPORT int ec_jacobian_to_affine(const EC_GROUP *group, EC_AFFINE *out, + const EC_RAW_POINT *p); // ec_jacobian_to_affine_batch converts |num| points in |in| from Jacobian // coordinates to affine coordinates and writes the results to |out|. It returns diff --git a/crypto/trust_token/internal.h b/crypto/trust_token/internal.h index e940565f22..8fc5d6eae3 100644 --- a/crypto/trust_token/internal.h +++ b/crypto/trust_token/internal.h @@ -239,6 +239,10 @@ STACK_OF(TRUST_TOKEN_PRETOKEN) *voprf_pst1_blind(CBB *cbb, size_t count, int voprf_pst1_sign(const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, size_t num_requested, size_t num_to_issue, uint8_t private_metadata); +OPENSSL_EXPORT int voprf_pst1_sign_with_proof_scalar_for_testing( + const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, size_t num_requested, + size_t num_to_issue, uint8_t private_metadata, + const uint8_t *proof_scalar_buf, size_t proof_scalar_len); STACK_OF(TRUST_TOKEN) *voprf_pst1_unblind( const TRUST_TOKEN_CLIENT_KEY *key, const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count, diff --git a/crypto/trust_token/trust_token_test.cc b/crypto/trust_token/trust_token_test.cc index 376eacfe34..df679b6166 100644 --- a/crypto/trust_token/trust_token_test.cc +++ b/crypto/trust_token/trust_token_test.cc @@ -314,6 +314,295 @@ TEST(TrustTokenTest, HPST1) { EXPECT_EQ(Bytes(h), Bytes(expected_bytes, expected_len)); } +static int ec_point_uncompressed_from_compressed( + const EC_GROUP *group, uint8_t out[EC_MAX_UNCOMPRESSED], size_t *out_len, + const uint8_t *in, size_t len) { + bssl::UniquePtr point(EC_POINT_new(group)); + if (!point || + !EC_POINT_oct2point(group, point.get(), in, len, nullptr)) { + return 0; + } + + *out_len = + EC_POINT_point2oct(group, point.get(), POINT_CONVERSION_UNCOMPRESSED, out, + EC_MAX_UNCOMPRESSED, nullptr); + return 1; +} + +static bool setup_voprf_test_key(const EC_GROUP *group, + TRUST_TOKEN_ISSUER_KEY *out) { + static const uint8_t kPrivateKey[] = { + 0x05, 0x16, 0x46, 0xb9, 0xe6, 0xe7, 0xa7, 0x1a, 0xe2, 0x7c, 0x1e, 0x1d, + 0x0b, 0x87, 0xb4, 0x38, 0x1d, 0xb6, 0xd3, 0x59, 0x5e, 0xee, 0xb1, 0xad, + 0xb4, 0x15, 0x79, 0xad, 0xbf, 0x99, 0x2f, 0x42, 0x78, 0xf9, 0x01, 0x6e, + 0xaf, 0xc9, 0x44, 0xed, 0xaa, 0x2b, 0x43, 0x18, 0x35, 0x81, 0x77, 0x9d + }; + + static const uint8_t kPublicKey[] = { + 0x03, 0x1d, 0x68, 0x96, 0x86, 0xc6, 0x11, 0x99, 0x1b, 0x55, + 0xf1, 0xa1, 0xd8, 0xf4, 0x30, 0x5c, 0xcd, 0x6c, 0xb7, 0x19, + 0x44, 0x6f, 0x66, 0x0a, 0x30, 0xdb, 0x61, 0xb7, 0xaa, 0x87, + 0xb4, 0x6a, 0xcf, 0x59, 0xb7, 0xc0, 0xd4, 0xa9, 0x07, 0x7b, + 0x3d, 0xa2, 0x1c, 0x25, 0xdd, 0x48, 0x22, 0x29, 0xa0 + }; + + if (!ec_scalar_from_bytes(group, &out->xs, kPrivateKey, + sizeof(kPrivateKey))) { + return false; + } + + bssl::UniquePtr pub(EC_POINT_new(group)); + return pub && + EC_POINT_oct2point(group, pub.get(), kPublicKey, sizeof(kPublicKey), + nullptr) && + ec_jacobian_to_affine(group, &out->pubs, &pub->raw); +} + +TEST(TrustTokenTest, PSTV1VOPRFTestVector1) { + const EC_GROUP *group = EC_GROUP_new_by_curve_name(NID_secp384r1); + TRUST_TOKEN_ISSUER_KEY key; + ASSERT_TRUE(setup_voprf_test_key(group, &key)); + + static const uint8_t kBlindedElement[] = { + 0x02, 0xd3, 0x38, 0xc0, 0x5c, 0xbe, 0xcb, 0x82, 0xde, 0x13, + 0xd6, 0x70, 0x0f, 0x09, 0xcb, 0x61, 0x19, 0x05, 0x43, 0xa7, + 0xb7, 0xe2, 0xc6, 0xcd, 0x4f, 0xca, 0x56, 0x88, 0x7e, 0x56, + 0x4e, 0xa8, 0x26, 0x53, 0xb2, 0x7f, 0xda, 0xd3, 0x83, 0x99, + 0x5e, 0xa6, 0xd0, 0x2c, 0xf2, 0x6d, 0x0e, 0x24, 0xd9 + }; + + static const uint8_t kEvaluatedElement[] = { + 0x02, 0xa7, 0xbb, 0xa5, 0x89, 0xb3, 0xe8, 0x67, 0x2a, 0xa1, + 0x9e, 0x8f, 0xd2, 0x58, 0xde, 0x2e, 0x6a, 0xae, 0x20, 0x10, + 0x1c, 0x8d, 0x76, 0x12, 0x46, 0xde, 0x97, 0xa6, 0xb5, 0xee, + 0x9c, 0xf1, 0x05, 0xfe, 0xbc, 0xe4, 0x32, 0x7a, 0x32, 0x62, + 0x55, 0xa3, 0xc6, 0x04, 0xf6, 0x3f, 0x60, 0x0e, 0xf6 + }; + + static const uint8_t kProof[] = { + 0xbf, 0xc6, 0xcf, 0x38, 0x59, 0x12, 0x7f, 0x5f, 0xe2, 0x55, 0x48, 0x85, + 0x98, 0x56, 0xd6, 0xb7, 0xfa, 0x1c, 0x74, 0x59, 0xf0, 0xba, 0x57, 0x12, + 0xa8, 0x06, 0xfc, 0x09, 0x1a, 0x30, 0x00, 0xc4, 0x2d, 0x8b, 0xa3, 0x4f, + 0xf4, 0x5f, 0x32, 0xa5, 0x2e, 0x40, 0x53, 0x3e, 0xfd, 0x2a, 0x03, 0xbc, + 0x87, 0xf3, 0xbf, 0x4f, 0x9f, 0x58, 0x02, 0x82, 0x97, 0xcc, 0xb9, 0xcc, + 0xb1, 0x8a, 0xe7, 0x18, 0x2b, 0xcd, 0x1e, 0xf2, 0x39, 0xdf, 0x77, 0xe3, + 0xbe, 0x65, 0xef, 0x14, 0x7f, 0x3a, 0xcf, 0x8b, 0xc9, 0xcb, 0xfc, 0x55, + 0x24, 0xb7, 0x02, 0x26, 0x34, 0x14, 0xf0, 0x43, 0xe3, 0xb7, 0xca, 0x2e + }; + + static const uint8_t kProofScalar[] = { + 0x80, 0x3d, 0x95, 0x5f, 0x0e, 0x07, 0x3a, 0x04, 0xaa, 0x5d, 0x92, 0xb3, + 0xfb, 0x73, 0x9f, 0x56, 0xf9, 0xdb, 0x00, 0x12, 0x66, 0x67, 0x7f, 0x62, + 0xc0, 0x95, 0x02, 0x1d, 0xb0, 0x18, 0xcd, 0x8c, 0xbb, 0x55, 0x94, 0x1d, + 0x40, 0x73, 0x69, 0x8c, 0xe4, 0x5c, 0x40, 0x5d, 0x13, 0x48, 0xb7, 0xb1 + }; + + uint8_t blinded_buf[EC_MAX_UNCOMPRESSED]; + size_t blinded_len; + ASSERT_TRUE(ec_point_uncompressed_from_compressed( + group, blinded_buf, &blinded_len, kBlindedElement, + sizeof(kBlindedElement))); + + CBS sign_input; + CBS_init(&sign_input, blinded_buf, blinded_len); + bssl::ScopedCBB response; + ASSERT_TRUE(CBB_init(response.get(), 0)); + ASSERT_TRUE(voprf_pst1_sign_with_proof_scalar_for_testing( + &key, response.get(), &sign_input, /*num_requested=*/1, + /*num_to_issue=*/1, + /*private_metadata=*/0, kProofScalar, sizeof(kProofScalar))); + + uint8_t evaluated_buf[EC_MAX_UNCOMPRESSED]; + size_t evaluated_len; + ASSERT_TRUE(ec_point_uncompressed_from_compressed( + group, evaluated_buf, &evaluated_len, kEvaluatedElement, + sizeof(kEvaluatedElement))); + + bssl::ScopedCBB expected_response; + ASSERT_TRUE(CBB_init(expected_response.get(), 0)); + ASSERT_TRUE( + CBB_add_bytes(expected_response.get(), evaluated_buf, evaluated_len)); + ASSERT_TRUE(CBB_add_u16(expected_response.get(), sizeof(kProof))); + ASSERT_TRUE(CBB_add_bytes(expected_response.get(), kProof, sizeof(kProof))); + ASSERT_TRUE(CBB_flush(expected_response.get())); + + ASSERT_EQ(Bytes(CBB_data(expected_response.get()), + CBB_len(expected_response.get())), + Bytes(CBB_data(response.get()), CBB_len(response.get()))); +} + +TEST(TrustTokenTest, PSTV1VOPRFTestVector2) { + const EC_GROUP *group = EC_GROUP_new_by_curve_name(NID_secp384r1); + TRUST_TOKEN_ISSUER_KEY key; + ASSERT_TRUE(setup_voprf_test_key(group, &key)); + + static const uint8_t kBlindedElement[] = { + 0x02, 0xf2, 0x74, 0x69, 0xe0, 0x59, 0x88, 0x6f, 0x22, 0x1b, + 0xe5, 0xf2, 0xcc, 0xa0, 0x3d, 0x2b, 0xdc, 0x61, 0xe5, 0x52, + 0x21, 0x72, 0x1c, 0x3b, 0x3e, 0x56, 0xfc, 0x01, 0x2e, 0x36, + 0xd3, 0x1a, 0xe5, 0xf8, 0xdc, 0x05, 0x81, 0x09, 0x59, 0x15, + 0x56, 0xa6, 0xdb, 0xd3, 0xa8, 0xc6, 0x9c, 0x43, 0x3b + }; + + static const uint8_t kEvaluatedElement[] = { + 0x03, 0xf1, 0x6f, 0x90, 0x39, 0x47, 0x03, 0x54, 0x00, 0xe9, + 0x6b, 0x7f, 0x53, 0x1a, 0x38, 0xd4, 0xa0, 0x7a, 0xc8, 0x9a, + 0x80, 0xf8, 0x9d, 0x86, 0xa1, 0xbf, 0x08, 0x9c, 0x52, 0x5a, + 0x92, 0xc7, 0xf4, 0x73, 0x37, 0x29, 0xca, 0x30, 0xc5, 0x6c, + 0xe7, 0x8b, 0x1a, 0xb4, 0xf7, 0xd9, 0x2d, 0xb8, 0xb4 + }; + + static const uint8_t kProof[] = { + 0xd0, 0x05, 0xd6, 0xda, 0xaa, 0xd7, 0x57, 0x14, 0x14, 0xc1, 0xe0, + 0xc7, 0x5f, 0x7e, 0x57, 0xf2, 0x11, 0x3c, 0xa9, 0xf4, 0x60, 0x4e, + 0x84, 0xbc, 0x90, 0xf9, 0xbe, 0x52, 0xda, 0x89, 0x6f, 0xff, 0x3b, + 0xee, 0x49, 0x6d, 0xcd, 0xe2, 0xa5, 0x78, 0xae, 0x9d, 0xf3, 0x15, + 0x03, 0x25, 0x85, 0xf8, 0x01, 0xfb, 0x21, 0xc6, 0x08, 0x0a, 0xc0, + 0x56, 0x72, 0xb2, 0x91, 0xe5, 0x75, 0xa4, 0x02, 0x95, 0xb3, 0x06, + 0xd9, 0x67, 0x71, 0x7b, 0x28, 0xe0, 0x8f, 0xcc, 0x8a, 0xd1, 0xca, + 0xb4, 0x78, 0x45, 0xd1, 0x6a, 0xf7, 0x3b, 0x3e, 0x64, 0x3d, 0xdc, + 0xc1, 0x91, 0x20, 0x8e, 0x71, 0xc6, 0x46, 0x30 + }; + + static const uint8_t kProofScalar[] = { + 0x80, 0x3d, 0x95, 0x5f, 0x0e, 0x07, 0x3a, 0x04, 0xaa, 0x5d, 0x92, 0xb3, + 0xfb, 0x73, 0x9f, 0x56, 0xf9, 0xdb, 0x00, 0x12, 0x66, 0x67, 0x7f, 0x62, + 0xc0, 0x95, 0x02, 0x1d, 0xb0, 0x18, 0xcd, 0x8c, 0xbb, 0x55, 0x94, 0x1d, + 0x40, 0x73, 0x69, 0x8c, 0xe4, 0x5c, 0x40, 0x5d, 0x13, 0x48, 0xb7, 0xb1 + }; + + uint8_t blinded_buf[EC_MAX_UNCOMPRESSED]; + size_t blinded_len; + ASSERT_TRUE(ec_point_uncompressed_from_compressed( + group, blinded_buf, &blinded_len, kBlindedElement, + sizeof(kBlindedElement))); + + CBS sign_input; + CBS_init(&sign_input, blinded_buf, blinded_len); + bssl::ScopedCBB response; + ASSERT_TRUE(CBB_init(response.get(), 0)); + ASSERT_TRUE(voprf_pst1_sign_with_proof_scalar_for_testing( + &key, response.get(), &sign_input, /*num_requested=*/1, + /*num_to_issue=*/1, + /*private_metadata=*/0, kProofScalar, sizeof(kProofScalar))); + + uint8_t evaluated_buf[EC_MAX_UNCOMPRESSED]; + size_t evaluated_len; + ASSERT_TRUE(ec_point_uncompressed_from_compressed( + group, evaluated_buf, &evaluated_len, kEvaluatedElement, + sizeof(kEvaluatedElement))); + + bssl::ScopedCBB expected_response; + ASSERT_TRUE(CBB_init(expected_response.get(), 0)); + ASSERT_TRUE( + CBB_add_bytes(expected_response.get(), evaluated_buf, evaluated_len)); + ASSERT_TRUE(CBB_add_u16(expected_response.get(), sizeof(kProof))); + ASSERT_TRUE(CBB_add_bytes(expected_response.get(), kProof, sizeof(kProof))); + ASSERT_TRUE(CBB_flush(expected_response.get())); + + ASSERT_EQ(Bytes(CBB_data(expected_response.get()), + CBB_len(expected_response.get())), + Bytes(CBB_data(response.get()), CBB_len(response.get()))); +} + +TEST(TrustTokenTest, PSTV1VOPRFTestVector3) { + const EC_GROUP *group = EC_GROUP_new_by_curve_name(NID_secp384r1); + TRUST_TOKEN_ISSUER_KEY key; + ASSERT_TRUE(setup_voprf_test_key(group, &key)); + + static const uint8_t kBlindedElement1[] = { + 0x02, 0xd3, 0x38, 0xc0, 0x5c, 0xbe, 0xcb, 0x82, 0xde, 0x13, + 0xd6, 0x70, 0x0f, 0x09, 0xcb, 0x61, 0x19, 0x05, 0x43, 0xa7, + 0xb7, 0xe2, 0xc6, 0xcd, 0x4f, 0xca, 0x56, 0x88, 0x7e, 0x56, + 0x4e, 0xa8, 0x26, 0x53, 0xb2, 0x7f, 0xda, 0xd3, 0x83, 0x99, + 0x5e, 0xa6, 0xd0, 0x2c, 0xf2, 0x6d, 0x0e, 0x24, 0xd9 + }; + static const uint8_t kBlindedElement2[] = { + 0x02, 0xfa, 0x02, 0x47, 0x0d, 0x7f, 0x15, 0x10, 0x18, 0xb4, + 0x1e, 0x82, 0x22, 0x3c, 0x32, 0xfa, 0xd8, 0x24, 0xde, 0x6a, + 0xd4, 0xb5, 0xce, 0x9f, 0x8e, 0x9f, 0x98, 0x08, 0x3c, 0x9a, + 0x72, 0x6d, 0xe9, 0xa1, 0xfc, 0x39, 0xd7, 0xa0, 0xcb, 0x6f, + 0x4f, 0x18, 0x8d, 0xd9, 0xce, 0xa0, 0x14, 0x74, 0xcd + }; + + static const uint8_t kEvaluatedElement1[] = { + 0x02, 0xa7, 0xbb, 0xa5, 0x89, 0xb3, 0xe8, 0x67, 0x2a, 0xa1, + 0x9e, 0x8f, 0xd2, 0x58, 0xde, 0x2e, 0x6a, 0xae, 0x20, 0x10, + 0x1c, 0x8d, 0x76, 0x12, 0x46, 0xde, 0x97, 0xa6, 0xb5, 0xee, + 0x9c, 0xf1, 0x05, 0xfe, 0xbc, 0xe4, 0x32, 0x7a, 0x32, 0x62, + 0x55, 0xa3, 0xc6, 0x04, 0xf6, 0x3f, 0x60, 0x0e, 0xf6 + }; + + static const uint8_t kEvaluatedElement2[] = { + 0x02, 0x8e, 0x9e, 0x11, 0x56, 0x25, 0xff, 0x4c, 0x2f, 0x07, + 0xbf, 0x87, 0xce, 0x3f, 0xd7, 0x3f, 0xc7, 0x79, 0x94, 0xa7, + 0xa0, 0xc1, 0xdf, 0x03, 0xd2, 0xa6, 0x30, 0xa3, 0xd8, 0x45, + 0x93, 0x0e, 0x2e, 0x63, 0xa1, 0x65, 0xb1, 0x14, 0xd9, 0x8f, + 0xe3, 0x4e, 0x61, 0xb6, 0x8d, 0x23, 0xc0, 0xb5, 0x0a + }; + + static const uint8_t kProof[] = { + 0x6d, 0x8d, 0xcb, 0xd2, 0xfc, 0x95, 0x55, 0x0a, 0x02, 0x21, 0x1f, + 0xb7, 0x8a, 0xfd, 0x01, 0x39, 0x33, 0xf3, 0x07, 0xd2, 0x1e, 0x7d, + 0x85, 0x5b, 0x0b, 0x1e, 0xd0, 0xaf, 0x78, 0x07, 0x6d, 0x81, 0x37, + 0xad, 0x8b, 0x0a, 0x1b, 0xfa, 0x05, 0x67, 0x6d, 0x32, 0x52, 0x49, + 0xc1, 0xdb, 0xb9, 0xa5, 0x2b, 0xd8, 0x1b, 0x1c, 0x2b, 0x7b, 0x0e, + 0xfc, 0x77, 0xcf, 0x7b, 0x27, 0x8e, 0x1c, 0x94, 0x7f, 0x62, 0x83, + 0xf1, 0xd4, 0xc5, 0x13, 0x05, 0x3f, 0xc0, 0xad, 0x19, 0xe0, 0x26, + 0xfb, 0x0c, 0x30, 0x65, 0x4b, 0x53, 0xd9, 0xce, 0xa4, 0xb8, 0x7b, + 0x03, 0x72, 0x71, 0xb5, 0xd2, 0xe2, 0xd0, 0xea + }; + + static const uint8_t kProofScalar[] = { + 0xa0, 0x97, 0xe7, 0x22, 0xed, 0x24, 0x27, 0xde, 0x86, 0x96, + 0x69, 0x10, 0xac, 0xba, 0x9f, 0x5c, 0x35, 0x0e, 0x80, 0x40, + 0xf8, 0x28, 0xbf, 0x6c, 0xec, 0xa2, 0x74, 0x05, 0x42, 0x0c, + 0xdf, 0x3d, 0x63, 0xcb, 0x3a, 0xef, 0x00, 0x5f, 0x40, 0xba, + 0x51, 0x94, 0x3c, 0x80, 0x26, 0x87, 0x79, 0x63 + }; + + uint8_t blinded_buf[2*EC_MAX_UNCOMPRESSED]; + size_t blinded_len; + ASSERT_TRUE(ec_point_uncompressed_from_compressed( + group, blinded_buf, &blinded_len, kBlindedElement1, + sizeof(kBlindedElement1))); + size_t offset = blinded_len; + ASSERT_TRUE(ec_point_uncompressed_from_compressed( + group, blinded_buf + offset, &blinded_len, kBlindedElement2, + sizeof(kBlindedElement2))); + + CBS sign_input; + CBS_init(&sign_input, blinded_buf, offset + blinded_len); + bssl::ScopedCBB response; + ASSERT_TRUE(CBB_init(response.get(), 0)); + ASSERT_TRUE(voprf_pst1_sign_with_proof_scalar_for_testing( + &key, response.get(), &sign_input, /*num_requested=*/2, + /*num_to_issue=*/2, + /*private_metadata=*/0, kProofScalar, sizeof(kProofScalar))); + + uint8_t evaluated_buf[2 * EC_MAX_UNCOMPRESSED]; + size_t evaluated_len; + ASSERT_TRUE(ec_point_uncompressed_from_compressed( + group, evaluated_buf, &evaluated_len, kEvaluatedElement1, + sizeof(kEvaluatedElement1))); + offset = evaluated_len; + ASSERT_TRUE(ec_point_uncompressed_from_compressed( + group, evaluated_buf + offset, &evaluated_len, kEvaluatedElement2, + sizeof(kEvaluatedElement2))); + + bssl::ScopedCBB expected_response; + ASSERT_TRUE(CBB_init(expected_response.get(), 0)); + ASSERT_TRUE(CBB_add_bytes(expected_response.get(), evaluated_buf, + offset + evaluated_len)); + ASSERT_TRUE(CBB_add_u16(expected_response.get(), sizeof(kProof))); + ASSERT_TRUE(CBB_add_bytes(expected_response.get(), kProof, sizeof(kProof))); + ASSERT_TRUE(CBB_flush(expected_response.get())); + + ASSERT_EQ(Bytes(CBB_data(expected_response.get()), + CBB_len(expected_response.get())), + Bytes(CBB_data(response.get()), CBB_len(response.get()))); +} + static std::vector AllMethods() { return { TRUST_TOKEN_experiment_v1(), diff --git a/crypto/trust_token/voprf.c b/crypto/trust_token/voprf.c index d414bfd52e..aa7df8ef78 100644 --- a/crypto/trust_token/voprf.c +++ b/crypto/trust_token/voprf.c @@ -63,18 +63,24 @@ static int voprf_init_method(VOPRF_METHOD *method, int curve_nid, static int cbb_add_point(CBB *out, const EC_GROUP *group, const EC_AFFINE *point) { - size_t len = ec_point_byte_len(group, POINT_CONVERSION_UNCOMPRESSED); - if (len == 0) { - return 0; - } - uint8_t *p; + size_t len = ec_point_byte_len(group, POINT_CONVERSION_UNCOMPRESSED); return CBB_add_space(out, &p, len) && ec_point_to_bytes(group, point, POINT_CONVERSION_UNCOMPRESSED, p, len) == len && CBB_flush(out); } +static int cbb_serialize_point(CBB *out, const EC_GROUP *group, + const EC_AFFINE *point) { + uint8_t *p; + size_t len = ec_point_byte_len(group, POINT_CONVERSION_COMPRESSED); + return CBB_add_u16(out, len) && CBB_add_space(out, &p, len) && + ec_point_to_bytes(group, point, POINT_CONVERSION_COMPRESSED, p, len) == + len && + CBB_flush(out); +} + static int cbs_get_point(CBS *cbs, const EC_GROUP *group, EC_AFFINE *out) { CBS child; size_t plen = 1 + 2 * BN_num_bytes(&group->field); @@ -299,6 +305,30 @@ static int hash_to_scalar_dleq(const VOPRF_METHOD *method, EC_SCALAR *out, return ok; } +static int hash_to_scalar_challenge(const VOPRF_METHOD *method, EC_SCALAR *out, + const EC_AFFINE *Bm, const EC_AFFINE *a0, + const EC_AFFINE *a1, const EC_AFFINE *a2, + const EC_AFFINE *a3) { + static const uint8_t kChallengeLabel[] = "Challenge"; + + CBB cbb; + uint8_t transcript[5 * EC_MAX_COMPRESSED + 2 + sizeof(kChallengeLabel) - 1]; + size_t len; + if (!CBB_init_fixed(&cbb, transcript, sizeof(transcript)) || + !cbb_serialize_point(&cbb, method->group, Bm) || + !cbb_serialize_point(&cbb, method->group, a0) || + !cbb_serialize_point(&cbb, method->group, a1) || + !cbb_serialize_point(&cbb, method->group, a2) || + !cbb_serialize_point(&cbb, method->group, a3) || + !CBB_add_bytes(&cbb, kChallengeLabel, sizeof(kChallengeLabel) - 1) || + !CBB_finish(&cbb, NULL, &len) || + !method->hash_to_scalar(method->group, out, transcript, len)) { + return 0; + } + + return 1; +} + static int hash_to_scalar_batch(const VOPRF_METHOD *method, EC_SCALAR *out, const CBB *points, size_t index) { static const uint8_t kDLEQBatchLabel[] = "DLEQ BATCH"; @@ -455,9 +485,9 @@ static int dleq_verify(const VOPRF_METHOD *method, CBS *cbs, return 1; } -static int voprf_sign(const VOPRF_METHOD *method, - const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, - size_t num_requested, size_t num_to_issue) { +static int voprf_sign_tt(const VOPRF_METHOD *method, + const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, + size_t num_requested, size_t num_to_issue) { const EC_GROUP *group = method->group; if (num_requested < num_to_issue) { OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_INTERNAL_ERROR); @@ -553,7 +583,7 @@ static int voprf_sign(const VOPRF_METHOD *method, return ret; } -static STACK_OF(TRUST_TOKEN) *voprf_unblind( +static STACK_OF(TRUST_TOKEN) *voprf_unblind_tt( const VOPRF_METHOD *method, const TRUST_TOKEN_CLIENT_KEY *key, const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count, uint32_t key_id) { @@ -673,6 +703,397 @@ static STACK_OF(TRUST_TOKEN) *voprf_unblind( return ret; } +static void sha384_update_u16(SHA512_CTX *ctx, uint16_t v) { + uint8_t buf[2] = {v >> 8, v & 0xff}; + SHA384_Update(ctx, buf, 2); +} + +static void sha384_update_point_with_length( + SHA512_CTX *ctx, const EC_GROUP *group, const EC_AFFINE *point) { + uint8_t buf[EC_MAX_COMPRESSED]; + size_t len = ec_point_to_bytes(group, point, POINT_CONVERSION_COMPRESSED, + buf, sizeof(buf)); + assert(len > 0); + sha384_update_u16(ctx, (uint16_t)len); + SHA384_Update(ctx, buf, len); +} + +static int compute_composite_seed(const VOPRF_METHOD *method, + uint8_t out[SHA384_DIGEST_LENGTH], + const EC_AFFINE *pub) { + const EC_GROUP *group = method->group; + static const uint8_t kSeedDST[] = "Seed-OPRFV1-\x01-P384-SHA384"; + + SHA512_CTX hash_ctx; + SHA384_Init(&hash_ctx); + sha384_update_point_with_length(&hash_ctx, group, pub); + sha384_update_u16(&hash_ctx, sizeof(kSeedDST) - 1); + SHA384_Update(&hash_ctx, kSeedDST, sizeof(kSeedDST) - 1); + SHA384_Final(out, &hash_ctx); + + return 1; +} + +static int compute_composite_element(const VOPRF_METHOD *method, + uint8_t seed[SHA384_DIGEST_LENGTH], + EC_SCALAR *di, size_t index, + const EC_AFFINE *C, const EC_AFFINE *D) { + static const uint8_t kCompositeLabel[] = "Composite"; + const EC_GROUP *group = method->group; + + if (index > UINT16_MAX) { + return 0; + } + + CBB cbb; + uint8_t transcript[2 + SHA384_DIGEST_LENGTH + 2 + 2 * EC_MAX_COMPRESSED + + sizeof(kCompositeLabel) - 1]; + size_t len; + if (!CBB_init_fixed(&cbb, transcript, sizeof(transcript)) || + !CBB_add_u16(&cbb, SHA384_DIGEST_LENGTH) || + !CBB_add_bytes(&cbb, seed, SHA384_DIGEST_LENGTH) || + !CBB_add_u16(&cbb, index) || + !cbb_serialize_point(&cbb, group, C) || + !cbb_serialize_point(&cbb, group, D) || + !CBB_add_bytes(&cbb, kCompositeLabel, + sizeof(kCompositeLabel) - 1) || + !CBB_finish(&cbb, NULL, &len) || + !method->hash_to_scalar(method->group, di, transcript, len)) { + return 0; + } + + return 1; +} + +static int generate_proof(const VOPRF_METHOD *method, CBB *cbb, + const TRUST_TOKEN_ISSUER_KEY *priv, + const EC_SCALAR *r, const EC_RAW_POINT *M, + const EC_RAW_POINT *Z) { + const EC_GROUP *group = method->group; + + enum { + idx_M, + idx_Z, + idx_t2, + idx_t3, + num_idx, + }; + EC_RAW_POINT jacobians[num_idx]; + + if (!ec_point_mul_scalar_base(group, &jacobians[idx_t2], r) || + !ec_point_mul_scalar(group, &jacobians[idx_t3], M, r)) { + return 0; + } + + + EC_AFFINE affines[num_idx]; + jacobians[idx_M] = *M; + jacobians[idx_Z] = *Z; + if (!ec_jacobian_to_affine_batch(group, affines, jacobians, num_idx)) { + return 0; + } + + EC_SCALAR c; + if (!hash_to_scalar_challenge(method, &c, &priv->pubs, &affines[idx_M], + &affines[idx_Z], &affines[idx_t2], + &affines[idx_t3])) { + return 0; + } + + EC_SCALAR c_mont; + ec_scalar_to_montgomery(group, &c_mont, &c); + + // s = r - c*xs + EC_SCALAR s; + ec_scalar_mul_montgomery(group, &s, &priv->xs, &c_mont); + ec_scalar_sub(group, &s, r, &s); + + // Store DLEQ proof in transcript. + if (!scalar_to_cbb(cbb, group, &c) || + !scalar_to_cbb(cbb, group, &s)) { + return 0; + } + + return 1; +} + +static int verify_proof(const VOPRF_METHOD *method, CBS *cbs, + const TRUST_TOKEN_CLIENT_KEY *pub, + const EC_RAW_POINT *M, const EC_RAW_POINT *Z) { + const EC_GROUP *group = method->group; + + enum { + idx_M, + idx_Z, + idx_t2, + idx_t3, + num_idx, + }; + EC_RAW_POINT jacobians[num_idx]; + + EC_SCALAR c, s; + if (!scalar_from_cbs(cbs, group, &c) || + !scalar_from_cbs(cbs, group, &s)) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE); + return 0; + } + + EC_RAW_POINT pubs; + ec_affine_to_jacobian(group, &pubs, &pub->pubs); + if (!ec_point_mul_scalar_public(group, &jacobians[idx_t2], &s, &pubs, + &c) || + !mul_public_2(group, &jacobians[idx_t3], M, &s, Z, &c)) { + return 0; + } + + EC_AFFINE affines[num_idx]; + jacobians[idx_M] = *M; + jacobians[idx_Z] = *Z; + if (!ec_jacobian_to_affine_batch(group, affines, jacobians, num_idx)) { + return 0; + } + + EC_SCALAR expected_c; + if (!hash_to_scalar_challenge(method, &expected_c, &pub->pubs, + &affines[idx_M], &affines[idx_Z], + &affines[idx_t2], &affines[idx_t3])) { + return 0; + } + + // c == expected_c + if (!ec_scalar_equal_vartime(group, &c, &expected_c)) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_INVALID_PROOF); + return 0; + } + + return 1; +} + +static int voprf_sign_impl(const VOPRF_METHOD *method, + const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, + CBS *cbs, size_t num_requested, size_t num_to_issue, + const EC_SCALAR *proof_scalar) { + const EC_GROUP *group = method->group; + if (num_requested < num_to_issue) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_INTERNAL_ERROR); + return 0; + } + + if (num_to_issue > ((size_t)-1) / sizeof(EC_RAW_POINT) || + num_to_issue > ((size_t)-1) / sizeof(EC_SCALAR)) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_OVERFLOW); + return 0; + } + + int ret = 0; + EC_RAW_POINT *BTs = OPENSSL_malloc(num_to_issue * sizeof(EC_RAW_POINT)); + EC_RAW_POINT *Zs = OPENSSL_malloc(num_to_issue * sizeof(EC_RAW_POINT)); + EC_SCALAR *dis = OPENSSL_malloc(num_to_issue * sizeof(EC_SCALAR)); + if (!BTs || !Zs || !dis) { + goto err; + } + + uint8_t seed[SHA384_DIGEST_LENGTH]; + if (!compute_composite_seed(method, seed, &key->pubs)) { + goto err; + } + + // This implements the BlindEvaluateBatch as defined in section 4 of + // draft-robert-privacypass-batched-tokens-01, based on the constructions + // in draft-irtf-cfrg-voprf-21. To optimize the computation of the proof, + // the computation of di is done during the token signing and passed into + // the proof generation. + for (size_t i = 0; i < num_to_issue; i++) { + EC_AFFINE BT_affine, Z_affine; + EC_RAW_POINT BT, Z; + if (!cbs_get_point(cbs, group, &BT_affine)) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE); + goto err; + } + ec_affine_to_jacobian(group, &BT, &BT_affine); + if (!ec_point_mul_scalar(group, &Z, &BT, &key->xs) || + !ec_jacobian_to_affine(group, &Z_affine, &Z) || + !cbb_add_point(cbb, group, &Z_affine)) { + goto err; + } + BTs[i] = BT; + Zs[i] = Z; + if (!compute_composite_element(method, seed, &dis[i], i, &BT_affine, + &Z_affine)) { + goto err; + } + + if (!CBB_flush(cbb)) { + goto err; + } + } + + EC_RAW_POINT M, Z; + if (!ec_point_mul_scalar_public_batch(group, &M, + /*g_scalar=*/NULL, BTs, dis, + num_to_issue) || + !ec_point_mul_scalar(group, &Z, &M, &key->xs)) { + goto err; + } + + CBB proof; + if (!CBB_add_u16_length_prefixed(cbb, &proof) || + !generate_proof(method, &proof, key, proof_scalar, &M, &Z) || + !CBB_flush(cbb)) { + goto err; + } + + // Skip over any unused requests. + size_t point_len = 1 + 2 * BN_num_bytes(&group->field); + if (!CBS_skip(cbs, point_len * (num_requested - num_to_issue))) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE); + goto err; + } + + ret = 1; + +err: + OPENSSL_free(BTs); + OPENSSL_free(Zs); + OPENSSL_free(dis); + return ret; +} + +static int voprf_sign(const VOPRF_METHOD *method, + const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, + size_t num_requested, size_t num_to_issue) { + EC_SCALAR proof_scalar; + if (!ec_random_nonzero_scalar(method->group, &proof_scalar, + kDefaultAdditionalData)) { + return 0; + } + + return voprf_sign_impl(method, key, cbb, cbs, num_requested, num_to_issue, + &proof_scalar); +} + +static int voprf_sign_with_proof_scalar_for_testing( + const VOPRF_METHOD *method, const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, + CBS *cbs, size_t num_requested, size_t num_to_issue, + const uint8_t *proof_scalar_buf, size_t proof_scalar_len) { + EC_SCALAR proof_scalar; + if (!ec_scalar_from_bytes(method->group, &proof_scalar, proof_scalar_buf, + proof_scalar_len)) { + return 0; + } + return voprf_sign_impl(method, key, cbb, cbs, num_requested, num_to_issue, + &proof_scalar); +} + +static STACK_OF(TRUST_TOKEN) *voprf_unblind( + const VOPRF_METHOD *method, const TRUST_TOKEN_CLIENT_KEY *key, + const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count, + uint32_t key_id) { + const EC_GROUP *group = method->group; + if (count > sk_TRUST_TOKEN_PRETOKEN_num(pretokens)) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE); + return NULL; + } + + if (count > ((size_t)-1) / sizeof(EC_RAW_POINT) || + count > ((size_t)-1) / sizeof(EC_SCALAR)) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, ERR_R_OVERFLOW); + return NULL; + } + + int ok = 0; + STACK_OF(TRUST_TOKEN) *ret = sk_TRUST_TOKEN_new_null(); + EC_RAW_POINT *BTs = OPENSSL_malloc(count * sizeof(EC_RAW_POINT)); + EC_RAW_POINT *Zs = OPENSSL_malloc(count * sizeof(EC_RAW_POINT)); + EC_SCALAR *dis = OPENSSL_malloc(count * sizeof(EC_SCALAR)); + if (ret == NULL || !BTs || !Zs || !dis) { + goto err; + } + + uint8_t seed[SHA384_DIGEST_LENGTH]; + if (!compute_composite_seed(method, seed, &key->pubs)) { + goto err; + } + + for (size_t i = 0; i < count; i++) { + const TRUST_TOKEN_PRETOKEN *pretoken = + sk_TRUST_TOKEN_PRETOKEN_value(pretokens, i); + + EC_AFFINE Z_affine; + if (!cbs_get_point(cbs, group, &Z_affine)) { + OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE); + goto err; + } + + ec_affine_to_jacobian(group, &BTs[i], &pretoken->Tp); + ec_affine_to_jacobian(group, &Zs[i], &Z_affine); + if (!compute_composite_element(method, seed, &dis[i], i, &pretoken->Tp, + &Z_affine)) { + goto err; + } + + // Unblind the token. + // pretoken->r is rinv. + EC_RAW_POINT N; + EC_AFFINE N_affine; + if (!ec_point_mul_scalar(group, &N, &Zs[i], &pretoken->r) || + !ec_jacobian_to_affine(group, &N_affine, &N)) { + goto err; + } + + // Serialize the token. Include |key_id| to avoid an extra copy in the layer + // above. + CBB token_cbb; + size_t point_len = 1 + 2 * BN_num_bytes(&group->field); + if (!CBB_init(&token_cbb, 4 + TRUST_TOKEN_NONCE_SIZE + (2 + point_len)) || + !CBB_add_u32(&token_cbb, key_id) || + !CBB_add_bytes(&token_cbb, pretoken->salt, TRUST_TOKEN_NONCE_SIZE) || + !cbb_add_point(&token_cbb, group, &N_affine) || + !CBB_flush(&token_cbb)) { + CBB_cleanup(&token_cbb); + goto err; + } + + TRUST_TOKEN *token = + TRUST_TOKEN_new(CBB_data(&token_cbb), CBB_len(&token_cbb)); + CBB_cleanup(&token_cbb); + if (token == NULL || + !sk_TRUST_TOKEN_push(ret, token)) { + TRUST_TOKEN_free(token); + goto err; + } + } + + EC_RAW_POINT M, Z; + if (!ec_point_mul_scalar_public_batch(group, &M, + /*g_scalar=*/NULL, BTs, dis, + count) || + !ec_point_mul_scalar_public_batch(group, &Z, + /*g_scalar=*/NULL, Zs, dis, + count)) { + goto err; + } + + CBS proof; + if (!CBS_get_u16_length_prefixed(cbs, &proof) || + !verify_proof(method, &proof, key, &M, &Z) || + CBS_len(&proof) != 0) { + goto err; + } + + ok = 1; + +err: + OPENSSL_free(BTs); + OPENSSL_free(Zs); + OPENSSL_free(dis); + if (!ok) { + sk_TRUST_TOKEN_pop_free(ret, TRUST_TOKEN_free); + ret = NULL; + } + return ret; +} + static int voprf_read(const VOPRF_METHOD *method, const TRUST_TOKEN_ISSUER_KEY *key, uint8_t out_nonce[TRUST_TOKEN_NONCE_SIZE], @@ -804,8 +1225,8 @@ int voprf_exp2_sign(const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, if (!voprf_exp2_init_method() || private_metadata != 0) { return 0; } - return voprf_sign(&voprf_exp2_method, key, cbb, cbs, num_requested, - num_to_issue); + return voprf_sign_tt(&voprf_exp2_method, key, cbb, cbs, num_requested, + num_to_issue); } STACK_OF(TRUST_TOKEN) *voprf_exp2_unblind( @@ -815,7 +1236,8 @@ STACK_OF(TRUST_TOKEN) *voprf_exp2_unblind( if (!voprf_exp2_init_method()) { return NULL; } - return voprf_unblind(&voprf_exp2_method, key, pretokens, cbs, count, key_id); + return voprf_unblind_tt(&voprf_exp2_method, key, pretokens, cbs, count, + key_id); } int voprf_exp2_read(const TRUST_TOKEN_ISSUER_KEY *key, @@ -834,16 +1256,17 @@ int voprf_exp2_read(const TRUST_TOKEN_ISSUER_KEY *key, static int voprf_pst1_hash_to_group(const EC_GROUP *group, EC_RAW_POINT *out, const uint8_t t[TRUST_TOKEN_NONCE_SIZE]) { - const uint8_t kHashTLabel[] = "TrustToken VOPRF PST V1 HashToGroup"; - return ec_hash_to_curve_p384_xmd_sha384_sswu( - group, out, kHashTLabel, sizeof(kHashTLabel), t, TRUST_TOKEN_NONCE_SIZE); + const uint8_t kHashTLabel[] = "HashToGroup-OPRFV1-\x01-P384-SHA384"; + return ec_hash_to_curve_p384_xmd_sha384_sswu(group, out, kHashTLabel, + sizeof(kHashTLabel) - 1, t, + TRUST_TOKEN_NONCE_SIZE); } static int voprf_pst1_hash_to_scalar(const EC_GROUP *group, EC_SCALAR *out, uint8_t *buf, size_t len) { - const uint8_t kHashCLabel[] = "TrustToken VOPRF PST V1 HashToScalar"; - return ec_hash_to_scalar_p384_xmd_sha384( - group, out, kHashCLabel, sizeof(kHashCLabel), buf, len); + const uint8_t kHashCLabel[] = "HashToScalar-OPRFV1-\x01-P384-SHA384"; + return ec_hash_to_scalar_p384_xmd_sha384(group, out, kHashCLabel, + sizeof(kHashCLabel) - 1, buf, len); } static int voprf_pst1_ok = 0; @@ -921,6 +1344,19 @@ int voprf_pst1_sign(const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, num_to_issue); } + +int voprf_pst1_sign_with_proof_scalar_for_testing( + const TRUST_TOKEN_ISSUER_KEY *key, CBB *cbb, CBS *cbs, size_t num_requested, + size_t num_to_issue, uint8_t private_metadata, + const uint8_t *proof_scalar_buf, size_t proof_scalar_len) { + if (!voprf_pst1_init_method() || private_metadata != 0) { + return 0; + } + return voprf_sign_with_proof_scalar_for_testing( + &voprf_pst1_method, key, cbb, cbs, num_requested, num_to_issue, + proof_scalar_buf, proof_scalar_len); +} + STACK_OF(TRUST_TOKEN) *voprf_pst1_unblind( const TRUST_TOKEN_CLIENT_KEY *key, const STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens, CBS *cbs, size_t count, From d5f3a9e82fc6735eff5733f51b892d776f4a84eb Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Tue, 25 Apr 2023 18:01:14 -0400 Subject: [PATCH 39/56] Squeeze a block at a time when computing the matrix in Kyber We were currently squeezing 3 bytes at a time. And because kyber.c and keccak.c are separate files, we've got an optimization barrier, at least in non-LTO builds, at a very inconvenient place. Instead, extract the full 168 bytes (SHAKE-128 rate) at a time. This is conveniently a multiple of three, so we don't need to worry about partial coefficients. We're still doing a copy due to the Keccak abstraction, but it should extend cleanly to either LTO or a different abstraction to read from the state directly. Even without that, it's a significant perf win. Benchmarks on an M1: Before: Did 87390 Kyber generate + decap operations in 4001590us (21838.8 ops/sec) Did 119000 Kyber parse + encap operations in 4009460us (29679.8 ops/sec) After: Did 96747 Kyber generate + decap operations in 4003687us (24164.5 ops/sec) [+10.6%] Did 152000 Kyber parse + encap operations in 4018360us (37826.4 ops/sec) [+27.4%] Change-Id: Iada393edf0c634b7410a34374fb90242a392a9d3 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59265 Commit-Queue: Adam Langley Reviewed-by: Adam Langley Auto-Submit: David Benjamin Commit-Queue: David Benjamin --- crypto/kyber/kyber.c | 27 +++++++++++++++++---------- 1 file changed, 17 insertions(+), 10 deletions(-) diff --git a/crypto/kyber/kyber.c b/crypto/kyber/kyber.c index f2ac30bd31..010d9d4c7a 100644 --- a/crypto/kyber/kyber.c +++ b/crypto/kyber/kyber.c @@ -283,16 +283,23 @@ static void scalar_inner_product(scalar *out, const vector *lhs, // operates on public inputs. static void scalar_from_keccak_vartime(scalar *out, struct BORINGSSL_keccak_st *keccak_ctx) { - uint8_t bytes[3]; - for (int i = 0; i < DEGREE;) { - BORINGSSL_keccak_squeeze(keccak_ctx, bytes, sizeof(bytes)); - uint16_t d1 = bytes[0] + 256 * (bytes[1] % 16); - uint16_t d2 = bytes[1] / 16 + 16 * bytes[2]; - if (d1 < kPrime) { - out->c[i++] = d1; - } - if (d2 < kPrime && i < DEGREE) { - out->c[i++] = d2; + assert(keccak_ctx->offset == 0); + assert(keccak_ctx->rate_bytes == 168); + static_assert(168 % 3 == 0, "block and coefficient boundaries do not align"); + + int done = 0; + while (done < DEGREE) { + uint8_t block[168]; + BORINGSSL_keccak_squeeze(keccak_ctx, block, sizeof(block)); + for (size_t i = 0; i < sizeof(block) && done < DEGREE; i += 3) { + uint16_t d1 = block[i] + 256 * (block[i + 1] % 16); + uint16_t d2 = block[i + 1] / 16 + 16 * block[i + 2]; + if (d1 < kPrime) { + out->c[done++] = d1; + } + if (d2 < kPrime && done < DEGREE) { + out->c[done++] = d2; + } } } } From d42c4e4fb125a3dbcc67c5b3f552b99b64751194 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Sat, 22 Apr 2023 16:12:38 -0400 Subject: [PATCH 40/56] Specify the TLS cipher order more straightforwardly We previously used the functions from the cipher language to define it, but it's more straightforward to just list them out. Change-Id: I1467d6db47a93c8443a0a448ef974c827b1b3233 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59146 Reviewed-by: Bob Beck Commit-Queue: David Benjamin --- ssl/ssl_cipher.cc | 188 ++++++++++++++++++++-------------------------- 1 file changed, 81 insertions(+), 107 deletions(-) diff --git a/ssl/ssl_cipher.cc b/ssl/ssl_cipher.cc index 383329403d..f6259b2410 100644 --- a/ssl/ssl_cipher.cc +++ b/ssl/ssl_cipher.cc @@ -455,6 +455,16 @@ Span AllCiphers() { return MakeConstSpan(kCiphers, OPENSSL_ARRAY_SIZE(kCiphers)); } +static constexpr size_t NumTLS13Ciphers() { + size_t num = 0; + for (const auto &cipher : kCiphers) { + if (cipher.algorithm_mkey == SSL_kGENERIC) { + num++; + } + } + return num; +} + #define CIPHER_ADD 1 #define CIPHER_KILL 2 #define CIPHER_DEL 3 @@ -689,54 +699,6 @@ static void ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr, *head = curr; } -static bool ssl_cipher_collect_ciphers(Array *out_co_list, - CIPHER_ORDER **out_head, - CIPHER_ORDER **out_tail) { - Array co_list; - if (!co_list.Init(OPENSSL_ARRAY_SIZE(kCiphers))) { - return false; - } - - size_t co_list_num = 0; - for (const SSL_CIPHER &cipher : kCiphers) { - // TLS 1.3 ciphers do not participate in this mechanism. - if (cipher.algorithm_mkey != SSL_kGENERIC) { - co_list[co_list_num].cipher = &cipher; - co_list[co_list_num].next = NULL; - co_list[co_list_num].prev = NULL; - co_list[co_list_num].active = false; - co_list[co_list_num].in_group = false; - co_list_num++; - } - } - - // Prepare linked list from list entries. - if (co_list_num > 0) { - co_list[0].prev = NULL; - - if (co_list_num > 1) { - co_list[0].next = &co_list[1]; - - for (size_t i = 1; i < co_list_num - 1; i++) { - co_list[i].prev = &co_list[i - 1]; - co_list[i].next = &co_list[i + 1]; - } - - co_list[co_list_num - 1].prev = &co_list[co_list_num - 2]; - } - - co_list[co_list_num - 1].next = NULL; - - *out_head = &co_list[0]; - *out_tail = &co_list[co_list_num - 1]; - } else { - *out_head = nullptr; - *out_tail = nullptr; - } - *out_co_list = std::move(co_list); - return true; -} - SSLCipherPreferenceList::~SSLCipherPreferenceList() { OPENSSL_free(in_group_flags); } @@ -1139,67 +1101,79 @@ bool ssl_create_cipher_list(UniquePtr *out_cipher_list, return false; } - // Now we have to collect the available ciphers from the compiled in ciphers. - // We cannot get more than the number compiled in, so it is used for - // allocation. - Array co_list; - CIPHER_ORDER *head = nullptr, *tail = nullptr; - if (!ssl_cipher_collect_ciphers(&co_list, &head, &tail)) { - return false; + // We prefer ECDHE ciphers over non-PFS ciphers. Then we prefer AEAD over + // non-AEAD. The constants are masked by 0xffff to remove the vestigial 0x03 + // byte from SSL 2.0. + static const uint16_t kAESCiphers[] = { + TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 & 0xffff, + TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256 & 0xffff, + TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 & 0xffff, + TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384 & 0xffff, + }; + static const uint16_t kChaChaCiphers[] = { + TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 & 0xffff, + TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 & 0xffff, + TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 & 0xffff, + }; + static const uint16_t kLegacyCiphers[] = { + TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA & 0xffff, + TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA & 0xffff, + TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA & 0xffff, + TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA & 0xffff, + TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA & 0xffff, + TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA & 0xffff, + TLS1_CK_RSA_WITH_AES_128_GCM_SHA256 & 0xffff, + TLS1_CK_RSA_WITH_AES_256_GCM_SHA384 & 0xffff, + TLS1_CK_RSA_WITH_AES_128_SHA & 0xffff, + TLS1_CK_PSK_WITH_AES_128_CBC_SHA & 0xffff, + TLS1_CK_RSA_WITH_AES_256_SHA & 0xffff, + TLS1_CK_PSK_WITH_AES_256_CBC_SHA & 0xffff, + SSL3_CK_RSA_DES_192_CBC3_SHA & 0xffff, + }; + + // Set up a linked list of ciphers. + CIPHER_ORDER co_list[OPENSSL_ARRAY_SIZE(kAESCiphers) + + OPENSSL_ARRAY_SIZE(kChaChaCiphers) + + OPENSSL_ARRAY_SIZE(kLegacyCiphers)]; + for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(co_list); i++) { + co_list[i].next = + i + 1 < OPENSSL_ARRAY_SIZE(co_list) ? &co_list[i + 1] : nullptr; + co_list[i].prev = i == 0 ? nullptr : &co_list[i - 1]; + co_list[i].active = false; + co_list[i].in_group = false; } - - // Now arrange all ciphers by preference: - // TODO(davidben): Compute this order once and copy it. - - // Everything else being equal, prefer ECDHE_ECDSA and ECDHE_RSA over other - // key exchange mechanisms - ssl_cipher_apply_rule(0, SSL_kECDHE, SSL_aECDSA, ~0u, ~0u, 0, CIPHER_ADD, -1, - false, &head, &tail); - ssl_cipher_apply_rule(0, SSL_kECDHE, ~0u, ~0u, ~0u, 0, CIPHER_ADD, -1, false, - &head, &tail); - ssl_cipher_apply_rule(0, ~0u, ~0u, ~0u, ~0u, 0, CIPHER_DEL, -1, false, &head, - &tail); - - // Order the bulk ciphers. First the preferred AEAD ciphers. We prefer - // CHACHA20 unless there is hardware support for fast and constant-time - // AES_GCM. Of the two CHACHA20 variants, the new one is preferred over the - // old one. + CIPHER_ORDER *head = &co_list[0]; + CIPHER_ORDER *tail = &co_list[OPENSSL_ARRAY_SIZE(co_list) - 1]; + + // Order AES ciphers vs ChaCha ciphers based on whether we have AES hardware. + // + // TODO(crbug.com/boringssl/29): We should also set up equipreference groups + // as a server. + size_t num = 0; if (has_aes_hw) { - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_AES128GCM, ~0u, 0, CIPHER_ADD, -1, - false, &head, &tail); - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_AES256GCM, ~0u, 0, CIPHER_ADD, -1, - false, &head, &tail); - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_CHACHA20POLY1305, ~0u, 0, CIPHER_ADD, - -1, false, &head, &tail); - } else { - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_CHACHA20POLY1305, ~0u, 0, CIPHER_ADD, - -1, false, &head, &tail); - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_AES128GCM, ~0u, 0, CIPHER_ADD, -1, - false, &head, &tail); - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_AES256GCM, ~0u, 0, CIPHER_ADD, -1, - false, &head, &tail); - } - - // Then the legacy non-AEAD ciphers: AES_128_CBC, AES_256_CBC, - // 3DES_EDE_CBC_SHA. - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_AES128, ~0u, 0, CIPHER_ADD, -1, false, - &head, &tail); - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_AES256, ~0u, 0, CIPHER_ADD, -1, false, - &head, &tail); - ssl_cipher_apply_rule(0, ~0u, ~0u, SSL_3DES, ~0u, 0, CIPHER_ADD, -1, false, - &head, &tail); - - // Temporarily enable everything else for sorting - ssl_cipher_apply_rule(0, ~0u, ~0u, ~0u, ~0u, 0, CIPHER_ADD, -1, false, &head, - &tail); - - // Move ciphers without forward secrecy to the end. - ssl_cipher_apply_rule(0, (SSL_kRSA | SSL_kPSK), ~0u, ~0u, ~0u, 0, CIPHER_ORD, - -1, false, &head, &tail); - - // Now disable everything (maintaining the ordering!) - ssl_cipher_apply_rule(0, ~0u, ~0u, ~0u, ~0u, 0, CIPHER_DEL, -1, false, &head, - &tail); + for (uint16_t id : kAESCiphers) { + co_list[num++].cipher = SSL_get_cipher_by_value(id); + assert(co_list[num - 1].cipher != nullptr); + } + } + for (uint16_t id : kChaChaCiphers) { + co_list[num++].cipher = SSL_get_cipher_by_value(id); + assert(co_list[num - 1].cipher != nullptr); + } + if (!has_aes_hw) { + for (uint16_t id : kAESCiphers) { + co_list[num++].cipher = SSL_get_cipher_by_value(id); + assert(co_list[num - 1].cipher != nullptr); + } + } + for (uint16_t id : kLegacyCiphers) { + co_list[num++].cipher = SSL_get_cipher_by_value(id); + assert(co_list[num - 1].cipher != nullptr); + } + assert(num == OPENSSL_ARRAY_SIZE(co_list)); + static_assert(OPENSSL_ARRAY_SIZE(co_list) + NumTLS13Ciphers() == + OPENSSL_ARRAY_SIZE(kCiphers), + "Not all ciphers are included in the cipher order"); // If the rule_string begins with DEFAULT, apply the default rule before // using the (possibly available) additional rules. From a0afd6ae2cbfcdfc56a355f4b53a6c2583414634 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Tue, 25 Apr 2023 21:36:35 -0400 Subject: [PATCH 41/56] Add some missing includes When building BCM sources individually, this gets missed. Change-Id: I58858da441daaeffc5e54b653f5436fe817c4178 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59306 Auto-Submit: David Benjamin Commit-Queue: Adam Langley Reviewed-by: Adam Langley --- crypto/fipsmodule/self_check/self_check.c | 1 + crypto/fipsmodule/tls/kdf.c | 1 + 2 files changed, 2 insertions(+) diff --git a/crypto/fipsmodule/self_check/self_check.c b/crypto/fipsmodule/self_check/self_check.c index 3b51e2fe22..525cd1692e 100644 --- a/crypto/fipsmodule/self_check/self_check.c +++ b/crypto/fipsmodule/self_check/self_check.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include #include diff --git a/crypto/fipsmodule/tls/kdf.c b/crypto/fipsmodule/tls/kdf.c index 9c6cfaf03c..c4f4976c7f 100644 --- a/crypto/fipsmodule/tls/kdf.c +++ b/crypto/fipsmodule/tls/kdf.c @@ -54,6 +54,7 @@ #include #include +#include #include #include From 0c7527bb3a34a95387856827702bbb46c408457d Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Tue, 25 Apr 2023 21:45:00 -0400 Subject: [PATCH 42/56] X509_sign, etc., should return the length of the signature on success Prior to https://boringssl-review.googlesource.com/c/boringssl/+/58548, ASN1_item_sign_ctx returned the length of the signature on success. It's unclear why anyone would ever want this, but some test was sensitive to it. (I think it was a typo.) Restore the old behavior. Change-Id: Ibf3e45331a339226744d51df703634d02b08a7c4 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59307 Reviewed-by: Bob Beck Auto-Submit: David Benjamin Commit-Queue: Bob Beck --- crypto/x509/a_sign.c | 2 +- crypto/x509/x509_test.cc | 7 +++++- include/openssl/x509.h | 53 ++++++++++++++++++++-------------------- 3 files changed, 34 insertions(+), 28 deletions(-) diff --git a/crypto/x509/a_sign.c b/crypto/x509/a_sign.c index 8ee4779883..7f80e5b020 100644 --- a/crypto/x509/a_sign.c +++ b/crypto/x509/a_sign.c @@ -126,7 +126,7 @@ int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, out = NULL; signature->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); signature->flags |= ASN1_STRING_FLAG_BITS_LEFT; - ret = 1; + ret = (int)out_len; err: EVP_MD_CTX_cleanup(ctx); diff --git a/crypto/x509/x509_test.cc b/crypto/x509/x509_test.cc index 9e369bd58d..404ce5ba14 100644 --- a/crypto/x509/x509_test.cc +++ b/crypto/x509/x509_test.cc @@ -2048,7 +2048,12 @@ TEST(X509Test, SignCertificate) { ASSERT_TRUE( X509_set1_signature_value(cert.get(), sig.data(), sig.size())); } else { - ASSERT_TRUE(X509_sign(cert.get(), pkey.get(), EVP_sha384())); + int ret = X509_sign(cert.get(), pkey.get(), EVP_sha384()); + ASSERT_GT(ret, 0); + // |X509_sign| returns the length of the signature on success. + const ASN1_BIT_STRING *sig; + X509_get0_signature(&sig, /*out_alg=*/nullptr, cert.get()); + EXPECT_EQ(ret, ASN1_STRING_length(sig)); } // Check the signature. diff --git a/include/openssl/x509.h b/include/openssl/x509.h index 2954488df9..776a8425fd 100644 --- a/include/openssl/x509.h +++ b/include/openssl/x509.h @@ -348,16 +348,17 @@ OPENSSL_EXPORT X509_EXTENSION *X509_delete_ext(X509 *x, int loc); OPENSSL_EXPORT int X509_add_ext(X509 *x, const X509_EXTENSION *ex, int loc); // X509_sign signs |x509| with |pkey| and replaces the signature algorithm and -// signature fields. It returns one on success and zero on error. This function -// uses digest algorithm |md|, or |pkey|'s default if NULL. Other signing -// parameters use |pkey|'s defaults. To customize them, use |X509_sign_ctx|. +// signature fields. It returns the length of the signature on success and zero +// on error. This function uses digest algorithm |md|, or |pkey|'s default if +// NULL. Other signing parameters use |pkey|'s defaults. To customize them, use +// |X509_sign_ctx|. OPENSSL_EXPORT int X509_sign(X509 *x509, EVP_PKEY *pkey, const EVP_MD *md); // X509_sign_ctx signs |x509| with |ctx| and replaces the signature algorithm -// and signature fields. It returns one on success and zero on error. The -// signature algorithm and parameters come from |ctx|, which must have been -// initialized with |EVP_DigestSignInit|. The caller should configure the -// corresponding |EVP_PKEY_CTX| before calling this function. +// and signature fields. It returns the length of the signature on success and +// zero on error. The signature algorithm and parameters come from |ctx|, which +// must have been initialized with |EVP_DigestSignInit|. The caller should +// configure the corresponding |EVP_PKEY_CTX| before calling this function. OPENSSL_EXPORT int X509_sign_ctx(X509 *x509, EVP_MD_CTX *ctx); // i2d_re_X509_tbs serializes the TBSCertificate portion of |x509|, as described @@ -634,18 +635,18 @@ OPENSSL_EXPORT int X509_CRL_add_ext(X509_CRL *x, const X509_EXTENSION *ex, int loc); // X509_CRL_sign signs |crl| with |pkey| and replaces the signature algorithm -// and signature fields. It returns one on success and zero on error. This -// function uses digest algorithm |md|, or |pkey|'s default if NULL. Other -// signing parameters use |pkey|'s defaults. To customize them, use -// |X509_CRL_sign_ctx|. +// and signature fields. It returns the length of the signature on success and +// zero on error. This function uses digest algorithm |md|, or |pkey|'s default +// if NULL. Other signing parameters use |pkey|'s defaults. To customize them, +// use |X509_CRL_sign_ctx|. OPENSSL_EXPORT int X509_CRL_sign(X509_CRL *crl, EVP_PKEY *pkey, const EVP_MD *md); // X509_CRL_sign_ctx signs |crl| with |ctx| and replaces the signature algorithm -// and signature fields. It returns one on success and zero on error. The -// signature algorithm and parameters come from |ctx|, which must have been -// initialized with |EVP_DigestSignInit|. The caller should configure the -// corresponding |EVP_PKEY_CTX| before calling this function. +// and signature fields. It returns the length of the signature on success and +// zero on error. The signature algorithm and parameters come from |ctx|, which +// must have been initialized with |EVP_DigestSignInit|. The caller should +// configure the corresponding |EVP_PKEY_CTX| before calling this function. OPENSSL_EXPORT int X509_CRL_sign_ctx(X509_CRL *crl, EVP_MD_CTX *ctx); // i2d_re_X509_CRL_tbs serializes the TBSCertList portion of |crl|, as described @@ -873,18 +874,18 @@ OPENSSL_EXPORT int X509_REQ_add_extensions( X509_REQ *req, const STACK_OF(X509_EXTENSION) *exts); // X509_REQ_sign signs |req| with |pkey| and replaces the signature algorithm -// and signature fields. It returns one on success and zero on error. This -// function uses digest algorithm |md|, or |pkey|'s default if NULL. Other -// signing parameters use |pkey|'s defaults. To customize them, use -// |X509_REQ_sign_ctx|. +// and signature fields. It returns the length of the signature on success and +// zero on error. This function uses digest algorithm |md|, or |pkey|'s default +// if NULL. Other signing parameters use |pkey|'s defaults. To customize them, +// use |X509_REQ_sign_ctx|. OPENSSL_EXPORT int X509_REQ_sign(X509_REQ *req, EVP_PKEY *pkey, const EVP_MD *md); // X509_REQ_sign_ctx signs |req| with |ctx| and replaces the signature algorithm -// and signature fields. It returns one on success and zero on error. The -// signature algorithm and parameters come from |ctx|, which must have been -// initialized with |EVP_DigestSignInit|. The caller should configure the -// corresponding |EVP_PKEY_CTX| before calling this function. +// and signature fields. It returns the length of the signature on success and +// zero on error. The signature algorithm and parameters come from |ctx|, which +// must have been initialized with |EVP_DigestSignInit|. The caller should +// configure the corresponding |EVP_PKEY_CTX| before calling this function. OPENSSL_EXPORT int X509_REQ_sign_ctx(X509_REQ *req, EVP_MD_CTX *ctx); // i2d_re_X509_REQ_tbs serializes the CertificationRequestInfo (see RFC 2986) @@ -2193,9 +2194,9 @@ OPENSSL_EXPORT int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *spki, EVP_PKEY *pkey); // NETSCAPE_SPKI_sign signs |spki| with |pkey| and replaces the signature -// algorithm and signature fields. It returns one on success and zero on error. -// This function uses digest algorithm |md|, or |pkey|'s default if NULL. Other -// signing parameters use |pkey|'s defaults. +// algorithm and signature fields. It returns the length of the signature on +// success and zero on error. This function uses digest algorithm |md|, or +// |pkey|'s default if NULL. Other signing parameters use |pkey|'s defaults. OPENSSL_EXPORT int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *spki, EVP_PKEY *pkey, const EVP_MD *md); From b352546be44551f5aabc428ac4d0cc161cd1b2ec Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Tue, 25 Apr 2023 21:35:16 -0400 Subject: [PATCH 43/56] Remove go:build ignore from convert_wycheproof The reason to make it a package was to avoid needing this, but I missed that git put it back. Change-Id: Idd6df275aa964083db525d4d5e300128b204d973 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59305 Commit-Queue: Bob Beck Reviewed-by: Bob Beck Auto-Submit: David Benjamin --- util/convert_wycheproof/convert_wycheproof.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/util/convert_wycheproof/convert_wycheproof.go b/util/convert_wycheproof/convert_wycheproof.go index 88a908d85d..076f8e480d 100644 --- a/util/convert_wycheproof/convert_wycheproof.go +++ b/util/convert_wycheproof/convert_wycheproof.go @@ -12,8 +12,6 @@ // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -//go:build ignore - // convert_wycheproof converts Wycheproof test vectors into a format more easily // consumed by BoringSSL. package main From 26669ff930a1898c77c3415e68acc97c1ef495f2 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Fri, 21 Apr 2023 15:12:24 -0400 Subject: [PATCH 44/56] Don't copy all of bssl-sys into the CMake build directory Instead, just have it look for the files it needs via a BORINGSSL_BUILD_DIR environment variable. This avoids hardcoding "../../build" anywhere that cannot be easily overriden by the user. Although this puts logic in a build.rs file, which is problematic for repositories with more coherent build stories like Android or Chromium, those are already driving the bindgen and link process themselves, without calling CMake. I.e. this file should already only be used for standalone development and testing and not directly impact them. (Though we'd like to keep it vaguely analogous to better predict without a change will impact downstream folks.) For now, I've kept bindgen generated from CMake, mostly in anticipation of using the inline functions feature. Building the synthesized C file from CMake seems less of a headache than Cargo. Additionally, calling bindgen from the command-line is closer to how those consumers will do it, so this forces us to stick to bindgen invocations that can be expressed via command-line arguments. (E.g. the mess that is regexes and escaping.) As part of this, I've removed the messy "find the first matching wrapper file" behavior in build.rs. Instead, it knows the expected TARGET and just finds the file with matching name. This means we'll be stricter about matching the two. (Otherwise there's no point in naming it by target name anyway.) Fixed: 598 Change-Id: I07fa74f7e5f5f008d6f0ceec648a2378df7d317a Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59105 Reviewed-by: Matthew Maurer Reviewed-by: Nabil Wadih Commit-Queue: David Benjamin Reviewed-by: Bob Beck --- rust/bssl-crypto/Cargo.toml | 4 +--- rust/bssl-crypto/README.md | 7 +------ rust/bssl-sys/CMakeLists.txt | 11 +--------- rust/bssl-sys/README.md | 7 +++---- rust/bssl-sys/build.rs | 39 ++++++++++++++++++++---------------- 5 files changed, 28 insertions(+), 40 deletions(-) diff --git a/rust/bssl-crypto/Cargo.toml b/rust/bssl-crypto/Cargo.toml index 7822767a09..c60e9ca28f 100644 --- a/rust/bssl-crypto/Cargo.toml +++ b/rust/bssl-crypto/Cargo.toml @@ -6,6 +6,4 @@ publish = false license = "MIT" [dependencies] -# the crate will need to be generated at this path by running this command at root -# `cmake -G Ninja -B build -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja -C build` -bssl-sys = {path = "../../build/rust/bssl-sys"} +bssl-sys = {path = "../bssl-sys"} diff --git a/rust/bssl-crypto/README.md b/rust/bssl-crypto/README.md index 0d52053ae4..dff669bcd8 100644 --- a/rust/bssl-crypto/README.md +++ b/rust/bssl-crypto/README.md @@ -1,12 +1,7 @@ bssl-crypto ============ -rust bindings to boringssl which wrap bssl-sys, a low level autogenerated binding - -Before using this crate, first generate the bssl-sys bindings by running this command from the root of the repo: -``` -cmake -G Ninja -B build -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja -C build -``` +Rust bindings to BoringSSL which wrap bssl-sys. Before using this crate, first [set up `bssl-sys`](../bssl-sys/README.md). Then to run all tests: ``` diff --git a/rust/bssl-sys/CMakeLists.txt b/rust/bssl-sys/CMakeLists.txt index 5e5f4469d2..d17a8f1033 100644 --- a/rust/bssl-sys/CMakeLists.txt +++ b/rust/bssl-sys/CMakeLists.txt @@ -6,7 +6,7 @@ target_link_libraries(rust_wrapper crypto) # ${CMAKE_BINARY_DIR}, with the output path as a relative path. bindgen writes # the depfile using the same syntax as the command-line argument, and ninja # requires a path relative to the top-level build directory. -set(wrapper src/wrapper_${RUST_BINDINGS}.rs) +set(wrapper wrapper_${RUST_BINDINGS}.rs) binary_dir_relative_path(${wrapper} wrapper_relative) binary_dir_relative_path(${wrapper}.d depfile_relative) @@ -47,12 +47,3 @@ add_custom_command( WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) add_custom_target(bssl_sys ALL DEPENDS ${wrapper}) - -# move files into build directory -configure_file("src/lib.rs" "src/lib.rs") - -if(NOT BUILD_SHARED_LIBS) - configure_file("build.rs" "build.rs" COPYONLY) -endif() - -configure_file("Cargo.toml" "Cargo.toml" COPYONLY) diff --git a/rust/bssl-sys/README.md b/rust/bssl-sys/README.md index fb5230a83a..e2efd6c447 100644 --- a/rust/bssl-sys/README.md +++ b/rust/bssl-sys/README.md @@ -4,10 +4,9 @@ bssl-sys A low-level binding crate for Rust that moves in lockstop with BoringSSL. BoringSSL explicitly does not have a stable ABI, `bssl-sys` is the solution for preventing subtle-memory corruption bugs due to version skew. ### How it works -`bssl-sys` uses `bindgen` as part of the cmake build process to generate Rust compatibility shims for the targeted platform. It is important to generate it for the correct platform because `bindgen` uses LLVM information for alignment which varies depending on architecture. These files are then packaged into a Rust crate. +`bssl-sys` uses `bindgen` as part of the cmake build process to generate Rust compatibility shims for the targeted platform. It is important to generate it for the correct platform because `bindgen` uses LLVM information for alignment which varies depending on architecture. ### To Use -Build `boringssl` with `-DRUST_BINDINGS=` and ensure that you have `bindgen` installed. - -The `rust-triple` option should be one of the supported targets at https://doc.rust-lang.org/nightly/rustc/platform-support.html. +Build `boringssl` with `-DRUST_BINDINGS=` and ensure that you have `bindgen` installed. The `rust-triple` option should match the [Rust target triple](https://doc.rust-lang.org/nightly/rustc/platform-support.html) when building `bssl-sys`. +From there, the `bssl-sys` crate can be built. By default, it looks for `bindgen` output and BoringSSL static libraries in the `build` directory. This can be reconfigured with `BORINGSSL_BUILD_DIR` environment variable. Note the environment variable is evaluated relative to `rust/bssl-sys/src`, so using an absolute path may be more convenient. diff --git a/rust/bssl-sys/build.rs b/rust/bssl-sys/build.rs index e5407025a8..2d7461ab99 100644 --- a/rust/bssl-sys/build.rs +++ b/rust/bssl-sys/build.rs @@ -15,38 +15,43 @@ use std::env; use std::path::Path; +use std::path::PathBuf; + +fn get_bssl_build_dir() -> PathBuf { + println!("cargo:rerun-if-env-changed=BORINGSSL_BUILD_DIR"); + if let Some(build_dir) = env::var_os("BORINGSSL_BUILD_DIR") { + return PathBuf::from(build_dir); + } + + let crate_dir = env::var_os("CARGO_MANIFEST_DIR").unwrap(); + return Path::new(&crate_dir).join("../../build"); +} fn main() { - let dir = env::var("CARGO_MANIFEST_DIR").unwrap(); - let crate_path = Path::new(&dir); + let bssl_build_dir = get_bssl_build_dir(); + let bssl_sys_build_dir = bssl_build_dir.join("rust/bssl-sys"); + let target = env::var("TARGET").unwrap(); // Find the bindgen generated target platform bindings file and set BINDGEN_RS_FILE - let bindgen_file = crate_path - .join("src") - .read_dir() - .unwrap() - .map(|file| file.unwrap().file_name().into_string().unwrap()) - .find(|file| file.starts_with("wrapper_")) - .unwrap(); - println!("cargo:rustc-env=BINDGEN_RS_FILE={}", bindgen_file); - - // building bssl-sys with: `cmake -G Ninja -B build -DRUST_BINDINGS="$(gcc -dumpmachine)" && ninja -C build` - // outputs this crate to /build/rust/bssl-sys/ so need to go up 3 levels to the root of the repo - let repo_root = crate_path.parent().unwrap().parent().unwrap(); + let bindgen_file = bssl_sys_build_dir.join(format!("wrapper_{}.rs", target)); + println!("cargo:rustc-env=BINDGEN_RS_FILE={}", bindgen_file.display()); // Statically link libraries. println!( "cargo:rustc-link-search=native={}", - repo_root.join("crypto").display() + bssl_build_dir.join("crypto").display() ); println!("cargo:rustc-link-lib=static=crypto"); println!( "cargo:rustc-link-search=native={}", - repo_root.join("ssl").display() + bssl_build_dir.join("ssl").display() ); println!("cargo:rustc-link-lib=static=ssl"); - println!("cargo:rustc-link-search=native={}", crate_path.display()); + println!( + "cargo:rustc-link-search=native={}", + bssl_sys_build_dir.display() + ); println!("cargo:rustc-link-lib=static=rust_wrapper"); } From 691e45a9718e5e326b9af9843ab240fae8a07481 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Fri, 21 Apr 2023 15:44:49 -0400 Subject: [PATCH 45/56] Remove unimplemented SSL BIO_ctrl values We have since added an implementation of a subset of the SSL BIO, but we don't implement all the features, notably some of the BIO_ctrl values. Remove them, so it doesn't look like they should work. Update-Note: I found no code using those symbols (that we build). If anything was, they most likely were broken. Now they'll fail to build and the brokenness will be more obvious. (If we find something needs it, we can always go back and implement them.) Fixed: 420 Change-Id: Iad03fa65f098023dca555a9b2ac0214ba4264546 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59125 Reviewed-by: Adam Langley Commit-Queue: Adam Langley Auto-Submit: David Benjamin --- include/openssl/bio.h | 4 ---- 1 file changed, 4 deletions(-) diff --git a/include/openssl/bio.h b/include/openssl/bio.h index abe7aec95a..707a4b1553 100644 --- a/include/openssl/bio.h +++ b/include/openssl/bio.h @@ -873,7 +873,6 @@ struct bio_st { #define BIO_C_GET_FILE_PTR 107 #define BIO_C_SET_FILENAME 108 #define BIO_C_SET_SSL 109 -#define BIO_C_GET_SSL 110 #define BIO_C_SET_MD 111 #define BIO_C_GET_MD 112 #define BIO_C_GET_CIPHER_STATUS 113 @@ -887,9 +886,6 @@ struct bio_st { #define BIO_C_GET_PROXY_PARAM 121 #define BIO_C_SET_BUFF_READ_DATA 122 // data to read first #define BIO_C_GET_ACCEPT 124 -#define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125 -#define BIO_C_GET_SSL_NUM_RENEGOTIATES 126 -#define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127 #define BIO_C_FILE_SEEK 128 #define BIO_C_GET_CIPHER_CTX 129 #define BIO_C_SET_BUF_MEM_EOF_RETURN 130 // return end of input value From d206f3db6ac2b74e8949ddd9947b94a5424d6a1d Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Thu, 20 Apr 2023 00:39:19 -0400 Subject: [PATCH 46/56] Move the old SPKAC types to their own section Also fixes some copy-paste errors in earlier docs. Bug: 426 Change-Id: I330445477b6feb50f65a868130387804114f23a8 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59205 Commit-Queue: David Benjamin Auto-Submit: David Benjamin Reviewed-by: Adam Langley --- include/openssl/x509.h | 163 +++++++++++++++++++++++++++-------------- 1 file changed, 108 insertions(+), 55 deletions(-) diff --git a/include/openssl/x509.h b/include/openssl/x509.h index 776a8425fd..8deb767ef1 100644 --- a/include/openssl/x509.h +++ b/include/openssl/x509.h @@ -1533,6 +1533,112 @@ OPENSSL_EXPORT ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx); +// SignedPublicKeyAndChallenge structures. +// +// The SignedPublicKeyAndChallenge (SPKAC) is a legacy structure to request +// certificates, primarily in the legacy HTML tag. An SPKAC structure +// is represented by a |NETSCAPE_SPKI| structure. +// +// The structure is described in +// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/keygen + +// A Netscape_spki_st, or |NETSCAPE_SPKI|, represents a +// SignedPublicKeyAndChallenge structure. Although this structure contains a +// |spkac| field of type |NETSCAPE_SPKAC|, these are misnamed. The SPKAC is the +// entire structure, not the signed portion. +struct Netscape_spki_st { + NETSCAPE_SPKAC *spkac; + X509_ALGOR *sig_algor; + ASN1_BIT_STRING *signature; +} /* NETSCAPE_SPKI */; + +// NETSCAPE_SPKI is an |ASN1_ITEM| whose ASN.1 type is +// SignedPublicKeyAndChallenge and C type is |NETSCAPE_SPKI*|. +DECLARE_ASN1_ITEM(NETSCAPE_SPKI) + +// NETSCAPE_SPKI_new returns a newly-allocated, empty |NETSCAPE_SPKI| object, or +// NULL on error. +OPENSSL_EXPORT NETSCAPE_SPKI *NETSCAPE_SPKI_new(void); + +// NETSCAPE_SPKI_free releases memory associated with |spki|. +OPENSSL_EXPORT void NETSCAPE_SPKI_free(NETSCAPE_SPKI *spki); + +// d2i_NETSCAPE_SPKI parses up to |len| bytes from |*inp| as a DER-encoded +// SignedPublicKeyAndChallenge structure, as described in |d2i_SAMPLE|. +OPENSSL_EXPORT NETSCAPE_SPKI *d2i_NETSCAPE_SPKI(NETSCAPE_SPKI **out, + const uint8_t **inp, long len); + +// i2d_NETSCAPE_SPKI marshals |spki| as a DER-encoded +// SignedPublicKeyAndChallenge structure, as described in |i2d_SAMPLE|. +OPENSSL_EXPORT int i2d_NETSCAPE_SPKI(const NETSCAPE_SPKI *spki, uint8_t **outp); + +// NETSCAPE_SPKI_verify checks that |spki| has a valid signature by |pkey|. It +// returns one if the signature is valid and zero otherwise. +OPENSSL_EXPORT int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *spki, EVP_PKEY *pkey); + +// NETSCAPE_SPKI_b64_decode decodes |len| bytes from |str| as a base64-encoded +// SignedPublicKeyAndChallenge structure. It returns a newly-allocated +// |NETSCAPE_SPKI| structure with the result, or NULL on error. If |len| is 0 or +// negative, the length is calculated with |strlen| and |str| must be a +// NUL-terminated C string. +OPENSSL_EXPORT NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, + ossl_ssize_t len); + +// NETSCAPE_SPKI_b64_encode encodes |spki| as a base64-encoded +// SignedPublicKeyAndChallenge structure. It returns a newly-allocated +// NUL-terminated C string with the result, or NULL on error. The caller must +// release the memory with |OPENSSL_free| when done. +OPENSSL_EXPORT char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *spki); + +// NETSCAPE_SPKI_get_pubkey decodes and returns the public key in |spki| as an +// |EVP_PKEY|, or NULL on error. The caller takes ownership of the resulting +// pointer and must call |EVP_PKEY_free| when done. +OPENSSL_EXPORT EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *spki); + +// NETSCAPE_SPKI_set_pubkey sets |spki|'s public key to |pkey|. It returns one +// on success or zero on error. This function does not take ownership of |pkey|, +// so the caller may continue to manage its lifetime independently of |spki|. +OPENSSL_EXPORT int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *spki, + EVP_PKEY *pkey); + +// NETSCAPE_SPKI_sign signs |spki| with |pkey| and replaces the signature +// algorithm and signature fields. It returns the length of the signature on +// success and zero on error. This function uses digest algorithm |md|, or +// |pkey|'s default if NULL. Other signing parameters use |pkey|'s defaults. +OPENSSL_EXPORT int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *spki, EVP_PKEY *pkey, + const EVP_MD *md); + +// A Netscape_spkac_st, or |NETSCAPE_SPKAC|, represents a PublicKeyAndChallenge +// structure. This type is misnamed. The full SPKAC includes the signature, +// which is represented with the |NETSCAPE_SPKI| type. +struct Netscape_spkac_st { + X509_PUBKEY *pubkey; + ASN1_IA5STRING *challenge; +} /* NETSCAPE_SPKAC */; + +// NETSCAPE_SPKAC is an |ASN1_ITEM| whose ASN.1 type is PublicKeyAndChallenge +// and C type is |NETSCAPE_SPKAC*|. +DECLARE_ASN1_ITEM(NETSCAPE_SPKAC) + +// NETSCAPE_SPKAC_new returns a newly-allocated, empty |NETSCAPE_SPKAC| object, +// or NULL on error. +OPENSSL_EXPORT NETSCAPE_SPKAC *NETSCAPE_SPKAC_new(void); + +// NETSCAPE_SPKAC_free releases memory associated with |spkac|. +OPENSSL_EXPORT void NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *spkac); + +// d2i_NETSCAPE_SPKAC parses up to |len| bytes from |*inp| as a DER-encoded +// PublicKeyAndChallenge structure, as described in |d2i_SAMPLE|. +OPENSSL_EXPORT NETSCAPE_SPKAC *d2i_NETSCAPE_SPKAC(NETSCAPE_SPKAC **out, + const uint8_t **inp, + long len); + +// i2d_NETSCAPE_SPKAC marshals |spkac| as a DER-encoded PublicKeyAndChallenge +// structure, as described in |i2d_SAMPLE|. +OPENSSL_EXPORT int i2d_NETSCAPE_SPKAC(const NETSCAPE_SPKAC *spkac, + uint8_t **outp); + + // Printing functions. // // The following functions output human-readable representations of @@ -1563,11 +1669,11 @@ OPENSSL_EXPORT ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, // X509_FLAG_NO_ISSUER skips printing the issuer. #define X509_FLAG_NO_ISSUER (1L << 4) -// X509_FLAG_NO_ISSUER skips printing the notBefore and notAfter times. It is +// X509_FLAG_NO_VALIDITY skips printing the notBefore and notAfter times. It is // ignored in |X509_REQ_print_fp|. #define X509_FLAG_NO_VALIDITY (1L << 5) -// X509_FLAG_NO_ISSUER skips printing the subject. +// X509_FLAG_NO_SUBJECT skips printing the subject. #define X509_FLAG_NO_SUBJECT (1L << 6) // X509_FLAG_NO_PUBKEY skips printing the public key. @@ -2125,20 +2231,6 @@ struct X509_info_st { DEFINE_STACK_OF(X509_INFO) -// The next 2 structures and their 8 routines were sent to me by -// Pat Richard and are used to manipulate -// Netscapes spki structures - useful if you are writing a CA web page -struct Netscape_spkac_st { - X509_PUBKEY *pubkey; - ASN1_IA5STRING *challenge; // challenge sent in atlas >= PR2 -} /* NETSCAPE_SPKAC */; - -struct Netscape_spki_st { - NETSCAPE_SPKAC *spkac; // signed public key and challenge - X509_ALGOR *sig_algor; - ASN1_BIT_STRING *signature; -} /* NETSCAPE_SPKI */; - // X509_get_pathlen returns path length constraint from the basic constraints // extension in |x509|. (See RFC 5280, section 4.2.1.9.) It returns -1 if the // constraint is not present, or if some extension in |x509| was invalid. @@ -2164,42 +2256,6 @@ OPENSSL_EXPORT void X509_SIG_getm(X509_SIG *sig, X509_ALGOR **out_alg, // a default description. OPENSSL_EXPORT const char *X509_verify_cert_error_string(long err); -// NETSCAPE_SPKI_verify checks that |spki| has a valid signature by |pkey|. It -// returns one if the signature is valid and zero otherwise. -OPENSSL_EXPORT int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *spki, EVP_PKEY *pkey); - -// NETSCAPE_SPKI_b64_decode decodes |len| bytes from |str| as a base64-encoded -// Netscape signed public key and challenge (SPKAC) structure. It returns a -// newly-allocated |NETSCAPE_SPKI| structure with the result, or NULL on error. -// If |len| is 0 or negative, the length is calculated with |strlen| and |str| -// must be a NUL-terminated C string. -OPENSSL_EXPORT NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, - ossl_ssize_t len); - -// NETSCAPE_SPKI_b64_encode encodes |spki| as a base64-encoded Netscape signed -// public key and challenge (SPKAC) structure. It returns a newly-allocated -// NUL-terminated C string with the result, or NULL on error. The caller must -// release the memory with |OPENSSL_free| when done. -OPENSSL_EXPORT char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *spki); - -// NETSCAPE_SPKI_get_pubkey decodes and returns the public key in |spki| as an -// |EVP_PKEY|, or NULL on error. The caller takes ownership of the resulting -// pointer and must call |EVP_PKEY_free| when done. -OPENSSL_EXPORT EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *spki); - -// NETSCAPE_SPKI_set_pubkey sets |spki|'s public key to |pkey|. It returns one -// on success or zero on error. This function does not take ownership of |pkey|, -// so the caller may continue to manage its lifetime independently of |spki|. -OPENSSL_EXPORT int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *spki, - EVP_PKEY *pkey); - -// NETSCAPE_SPKI_sign signs |spki| with |pkey| and replaces the signature -// algorithm and signature fields. It returns the length of the signature on -// success and zero on error. This function uses digest algorithm |md|, or -// |pkey|'s default if NULL. Other signing parameters use |pkey|'s defaults. -OPENSSL_EXPORT int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *spki, EVP_PKEY *pkey, - const EVP_MD *md); - // X509_REVOKED_dup returns a newly-allocated copy of |rev|, or NULL on error. // This function works by serializing the structure, so if |rev| is incomplete, // it may fail. @@ -2246,9 +2302,6 @@ OPENSSL_EXPORT int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, OPENSSL_EXPORT X509_PKEY *X509_PKEY_new(void); OPENSSL_EXPORT void X509_PKEY_free(X509_PKEY *a); -DECLARE_ASN1_FUNCTIONS_const(NETSCAPE_SPKI) -DECLARE_ASN1_FUNCTIONS_const(NETSCAPE_SPKAC) - OPENSSL_EXPORT X509_INFO *X509_INFO_new(void); OPENSSL_EXPORT void X509_INFO_free(X509_INFO *a); From a02b7435ca52b81c7cce656d577c8423b1cc4bb3 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 26 Apr 2023 15:55:32 -0400 Subject: [PATCH 47/56] runner: Remove an unnecessary use of AllCurves AllCurves interferes with cross-version handshake hint tests. If any curve is removed, the test breaks. This is a particular nuisance for signing tests, where we'd rather like to see cross-version hint compatibility. It's also a nuisance for writing test suppressions because the remove curve is not actually listed in the test name. The signing tests don't actually need to enable all curves. They just need to handle some TLS 1.2 ECDSA rules. Fix that by having the test know the expected curve and to configure it explicitly. Hopefully that'll reduce the exceptions needed in the future. Change-Id: I432e084c49a943afc92726ccf0b73658e7bd30b1 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59325 Reviewed-by: Adam Langley Commit-Queue: David Benjamin Auto-Submit: David Benjamin --- ssl/test/runner/runner.go | 51 ++++++++++++++++++++++++--------------- 1 file changed, 31 insertions(+), 20 deletions(-) diff --git a/ssl/test/runner/runner.go b/ssl/test/runner/runner.go index 1da1e2a4f1..fc8c6ff585 100644 --- a/ssl/test/runner/runner.go +++ b/ssl/test/runner/runner.go @@ -9724,26 +9724,29 @@ var testSignatureAlgorithms = []struct { name string id signatureAlgorithm cert testCert + // If non-zero, the curve that must be supported in TLS 1.2 for cert to be + // accepted. + curve CurveID }{ - {"RSA_PKCS1_SHA1", signatureRSAPKCS1WithSHA1, testCertRSA}, - {"RSA_PKCS1_SHA256", signatureRSAPKCS1WithSHA256, testCertRSA}, - {"RSA_PKCS1_SHA384", signatureRSAPKCS1WithSHA384, testCertRSA}, - {"RSA_PKCS1_SHA512", signatureRSAPKCS1WithSHA512, testCertRSA}, - {"ECDSA_SHA1", signatureECDSAWithSHA1, testCertECDSAP256}, + {"RSA_PKCS1_SHA1", signatureRSAPKCS1WithSHA1, testCertRSA, 0}, + {"RSA_PKCS1_SHA256", signatureRSAPKCS1WithSHA256, testCertRSA, 0}, + {"RSA_PKCS1_SHA384", signatureRSAPKCS1WithSHA384, testCertRSA, 0}, + {"RSA_PKCS1_SHA512", signatureRSAPKCS1WithSHA512, testCertRSA, 0}, + {"ECDSA_SHA1", signatureECDSAWithSHA1, testCertECDSAP256, CurveP256}, // The “P256” in the following line is not a mistake. In TLS 1.2 the // hash function doesn't have to match the curve and so the same // signature algorithm works with P-224. - {"ECDSA_P224_SHA256", signatureECDSAWithP256AndSHA256, testCertECDSAP224}, - {"ECDSA_P256_SHA256", signatureECDSAWithP256AndSHA256, testCertECDSAP256}, - {"ECDSA_P384_SHA384", signatureECDSAWithP384AndSHA384, testCertECDSAP384}, - {"ECDSA_P521_SHA512", signatureECDSAWithP521AndSHA512, testCertECDSAP521}, - {"RSA_PSS_SHA256", signatureRSAPSSWithSHA256, testCertRSA}, - {"RSA_PSS_SHA384", signatureRSAPSSWithSHA384, testCertRSA}, - {"RSA_PSS_SHA512", signatureRSAPSSWithSHA512, testCertRSA}, - {"Ed25519", signatureEd25519, testCertEd25519}, + {"ECDSA_P224_SHA256", signatureECDSAWithP256AndSHA256, testCertECDSAP224, CurveP224}, + {"ECDSA_P256_SHA256", signatureECDSAWithP256AndSHA256, testCertECDSAP256, CurveP256}, + {"ECDSA_P384_SHA384", signatureECDSAWithP384AndSHA384, testCertECDSAP384, CurveP384}, + {"ECDSA_P521_SHA512", signatureECDSAWithP521AndSHA512, testCertECDSAP521, CurveP521}, + {"RSA_PSS_SHA256", signatureRSAPSSWithSHA256, testCertRSA, 0}, + {"RSA_PSS_SHA384", signatureRSAPSSWithSHA384, testCertRSA, 0}, + {"RSA_PSS_SHA512", signatureRSAPSSWithSHA512, testCertRSA, 0}, + {"Ed25519", signatureEd25519, testCertEd25519, 0}, // Tests for key types prior to TLS 1.2. - {"RSA", 0, testCertRSA}, - {"ECDSA", 0, testCertECDSAP256}, + {"RSA", 0, testCertRSA, 0}, + {"ECDSA", 0, testCertECDSAP256, CurveP256}, } const fakeSigAlg1 signatureAlgorithm = 0x2a01 @@ -9795,6 +9798,14 @@ func addSignatureAlgorithmTests() { rejectByDefault = true } + var curveFlags []string + if alg.curve != 0 && ver.version <= VersionTLS12 { + // In TLS 1.2, the ECDH curve list also constrains ECDSA keys. Ensure the + // corresponding curve is enabled on the shim. Also include X25519 to + // ensure the shim and runner have something in common for ECDH. + curveFlags = flagInts("-curves", []int{int(CurveX25519), int(alg.curve)}) + } + var signError, signLocalError, verifyError, verifyLocalError, defaultError, defaultLocalError string if shouldFail { signError = ":NO_COMMON_SIGNATURE_ALGORITHMS:" @@ -9833,7 +9844,7 @@ func addSignatureAlgorithmTests() { "-cert-file", path.Join(*resourceDir, getShimCertificate(alg.cert)), "-key-file", path.Join(*resourceDir, getShimKey(alg.cert)), }, - flagInts("-curves", shimConfig.AllCurves)..., + curveFlags..., ), shouldFail: shouldFail, expectedError: signError, @@ -9857,7 +9868,7 @@ func addSignatureAlgorithmTests() { "-cert-file", path.Join(*resourceDir, getShimCertificate(alg.cert)), "-key-file", path.Join(*resourceDir, getShimKey(alg.cert)), }, - flagInts("-curves", shimConfig.AllCurves)..., + curveFlags..., ), expectations: connectionExpectations{ peerSignatureAlgorithm: alg.id, @@ -9898,7 +9909,7 @@ func addSignatureAlgorithmTests() { IgnorePeerSignatureAlgorithmPreferences: shouldFail, }, }, - flags: flagInts("-curves", shimConfig.AllCurves), + flags: curveFlags, // Resume the session to assert the peer signature // algorithm is reported on both handshakes. resumeSession: !shouldFail, @@ -9931,7 +9942,7 @@ func addSignatureAlgorithmTests() { }, flags: append( []string{"-expect-peer-signature-algorithm", strconv.Itoa(int(alg.id))}, - flagInts("-curves", shimConfig.AllCurves)..., + curveFlags..., ), // Resume the session to assert the peer signature // algorithm is reported on both handshakes. @@ -9955,7 +9966,7 @@ func addSignatureAlgorithmTests() { InvalidSignature: true, }, }, - flags: flagInts("-curves", shimConfig.AllCurves), + flags: curveFlags, shouldFail: true, expectedError: ":BAD_SIGNATURE:", } From 2f6409e888c293d59d23f7b3098070f1b52e7a0e Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Mon, 10 Apr 2023 21:09:11 +0000 Subject: [PATCH 48/56] Support WPA 3.1 "enterprise" mode. It's unwise for organisations to try and define TLS profiles. As in this case, they usually make security worse. However, since this is already established and supported by Android, this change raises it to the level of a supported policy. Change-Id: Ic66d5eaa33d884e57fc6d8eb922d86882b621e9e Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/58626 Reviewed-by: David Benjamin Commit-Queue: Adam Langley --- include/openssl/ssl.h | 26 ++++- ssl/handshake_client.cc | 36 +++--- ssl/internal.h | 26 ++--- ssl/s3_both.cc | 48 +++++--- ssl/ssl_lib.cc | 58 ++++++++- ssl/test/runner/common.go | 4 + ssl/test/runner/runner.go | 240 +++++++++++++++++++++++--------------- ssl/test/test_config.cc | 10 ++ ssl/test/test_config.h | 1 + ssl/tls13_client.cc | 2 +- ssl/tls13_server.cc | 2 +- 11 files changed, 308 insertions(+), 145 deletions(-) diff --git a/include/openssl/ssl.h b/include/openssl/ssl.h index fdea6ae492..5b5e3febd6 100644 --- a/include/openssl/ssl.h +++ b/include/openssl/ssl.h @@ -5187,6 +5187,10 @@ OPENSSL_EXPORT uint16_t SSL_CIPHER_get_value(const SSL_CIPHER *cipher); // parameters of a TLS connection. enum ssl_compliance_policy_t BORINGSSL_ENUM_INT { + // ssl_compliance_policy_none does nothing. However, since setting this + // doesn't undo other policies it's an error to try and set it. + ssl_compliance_policy_none, + // ssl_policy_fips_202205 configures a TLS connection to use: // * TLS 1.2 or 1.3 // * For TLS 1.2, only ECDHE_[RSA|ECDSA]_WITH_AES_*_GCM_SHA*. @@ -5201,12 +5205,32 @@ enum ssl_compliance_policy_t BORINGSSL_ENUM_INT { // Note: this setting aids with compliance with NIST requirements but does not // guarantee it. Careful reading of SP 800-52r2 is recommended. ssl_compliance_policy_fips_202205, + + // ssl_compliance_policy_wpa3_192_202304 configures a TLS connection to use: + // * TLS 1.2 or 1.3. + // * For TLS 1.2, only TLS_ECDHE_[ECDSA|RSA]_WITH_AES_256_GCM_SHA384. + // * For TLS 1.3, only AES-256-GCM. + // * P-384 for key agreement. + // * For handshake signatures, only ECDSA with P-384 and SHA-384, or RSA + // with SHA-384 or SHA-512. + // + // No limitations on the certificate chain nor leaf public key are imposed, + // other than by the supported signature algorithms. But WPA3's "192-bit" + // mode requires at least P-384 or 3072-bit along the chain. The caller must + // enforce this themselves on the verified chain using functions such as + // `X509_STORE_CTX_get0_chain`. + // + // Note that this setting is less secure than the default. The + // implementation risks of using a more obscure primitive like P-384 + // dominate other considerations. + ssl_compliance_policy_wpa3_192_202304, }; // SSL_CTX_set_compliance_policy configures various aspects of |ctx| based on // the given policy requirements. Subsequently calling other functions that // configure |ctx| may override |policy|, or may not. This should be the final -// configuration function called in order to have defined behaviour. +// configuration function called in order to have defined behaviour. It's a +// fatal error if |policy| is |ssl_compliance_policy_none|. OPENSSL_EXPORT int SSL_CTX_set_compliance_policy( SSL_CTX *ctx, enum ssl_compliance_policy_t policy); diff --git a/ssl/handshake_client.cc b/ssl/handshake_client.cc index 7fe2a2b567..971ebd0b1a 100644 --- a/ssl/handshake_client.cc +++ b/ssl/handshake_client.cc @@ -215,6 +215,14 @@ static void ssl_get_client_disabled(const SSL_HANDSHAKE *hs, } } +static bool ssl_add_tls13_cipher(CBB *cbb, uint16_t cipher_id, + ssl_compliance_policy_t policy) { + if (ssl_tls13_cipher_meets_policy(cipher_id, policy)) { + return CBB_add_u16(cbb, cipher_id); + } + return true; +} + static bool ssl_write_client_cipher_list(const SSL_HANDSHAKE *hs, CBB *out, ssl_client_hello_type_t type) { const SSL *const ssl = hs->ssl; @@ -235,26 +243,22 @@ static bool ssl_write_client_cipher_list(const SSL_HANDSHAKE *hs, CBB *out, // Add TLS 1.3 ciphers. Order ChaCha20-Poly1305 relative to AES-GCM based on // hardware support. if (hs->max_version >= TLS1_3_VERSION) { - const bool include_chacha20 = ssl_tls13_cipher_meets_policy( - TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff, - ssl->config->only_fips_cipher_suites_in_tls13); - const bool has_aes_hw = ssl->config->aes_hw_override ? ssl->config->aes_hw_override_value : EVP_has_aes_hardware(); - if (!has_aes_hw && // - include_chacha20 && // - !CBB_add_u16(&child, TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff)) { - return false; - } - if (!CBB_add_u16(&child, TLS1_3_CK_AES_128_GCM_SHA256 & 0xffff) || - !CBB_add_u16(&child, TLS1_3_CK_AES_256_GCM_SHA384 & 0xffff)) { - return false; - } - if (has_aes_hw && // - include_chacha20 && // - !CBB_add_u16(&child, TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff)) { + if ((!has_aes_hw && // + !ssl_add_tls13_cipher(&child, + TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff, + ssl->config->tls13_cipher_policy)) || + !ssl_add_tls13_cipher(&child, TLS1_3_CK_AES_128_GCM_SHA256 & 0xffff, + ssl->config->tls13_cipher_policy) || + !ssl_add_tls13_cipher(&child, TLS1_3_CK_AES_256_GCM_SHA384 & 0xffff, + ssl->config->tls13_cipher_policy) || + (has_aes_hw && // + !ssl_add_tls13_cipher(&child, + TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff, + ssl->config->tls13_cipher_policy))) { return false; } } diff --git a/ssl/internal.h b/ssl/internal.h index e12b12f695..01decb03b3 100644 --- a/ssl/internal.h +++ b/ssl/internal.h @@ -660,17 +660,17 @@ size_t ssl_cipher_get_record_split_len(const SSL_CIPHER *cipher); // ssl_choose_tls13_cipher returns an |SSL_CIPHER| corresponding with the best // available from |cipher_suites| compatible with |version|, |group_id|, and -// |only_fips|. It returns NULL if there isn't a compatible cipher. |has_aes_hw| +// |policy|. It returns NULL if there isn't a compatible cipher. |has_aes_hw| // indicates if the choice should be made as if support for AES in hardware // is available. const SSL_CIPHER *ssl_choose_tls13_cipher(CBS cipher_suites, bool has_aes_hw, uint16_t version, uint16_t group_id, - bool only_fips); + enum ssl_compliance_policy_t policy); // ssl_tls13_cipher_meets_policy returns true if |cipher_id| is acceptable given -// |only_fips|. (For now there's only a single policy and so the policy argument -// is just a bool.) -bool ssl_tls13_cipher_meets_policy(uint16_t cipher_id, bool only_fips); +// |policy|. +bool ssl_tls13_cipher_meets_policy(uint16_t cipher_id, + enum ssl_compliance_policy_t policy); // Transcript layer. @@ -3063,6 +3063,10 @@ struct SSL_CONFIG { // structure for the client to use when negotiating ECH. Array client_ech_config_list; + // tls13_cipher_policy limits the set of ciphers that can be selected when + // negotiating a TLS 1.3 connection. + enum ssl_compliance_policy_t tls13_cipher_policy = ssl_compliance_policy_none; + // verify_mode is a bitmask of |SSL_VERIFY_*| values. uint8_t verify_mode = SSL_VERIFY_NONE; @@ -3112,10 +3116,6 @@ struct SSL_CONFIG { // permute_extensions is whether to permute extensions when sending messages. bool permute_extensions : 1; - // only_fips_cipher_suites_in_tls13 constrains the selection of cipher suites - // in TLS 1.3 such that only FIPS approved ones will be selected. - bool only_fips_cipher_suites_in_tls13 : 1; - // aes_hw_override if set indicates we should override checking for aes // hardware support, and use the value in aes_hw_override_value instead. bool aes_hw_override : 1; @@ -3684,6 +3684,10 @@ struct ssl_ctx_st { int (*legacy_ocsp_callback)(SSL *ssl, void *arg) = nullptr; void *legacy_ocsp_callback_arg = nullptr; + // tls13_cipher_policy limits the set of ciphers that can be selected when + // negotiating a TLS 1.3 connection. + enum ssl_compliance_policy_t tls13_cipher_policy = ssl_compliance_policy_none; + // verify_sigalgs, if not empty, is the set of signature algorithms // accepted from the peer in decreasing order of preference. bssl::Array verify_sigalgs; @@ -3731,10 +3735,6 @@ struct ssl_ctx_st { // If enable_early_data is true, early data can be sent and accepted. bool enable_early_data : 1; - // only_fips_cipher_suites_in_tls13 constrains the selection of cipher suites - // in TLS 1.3 such that only FIPS approved ones will be selected. - bool only_fips_cipher_suites_in_tls13 : 1; - // aes_hw_override if set indicates we should override checking for AES // hardware support, and use the value in aes_hw_override_value instead. bool aes_hw_override : 1; diff --git a/ssl/s3_both.cc b/ssl/s3_both.cc index f8352f3d75..6d33c6d7d6 100644 --- a/ssl/s3_both.cc +++ b/ssl/s3_both.cc @@ -685,26 +685,44 @@ class CipherScorer { const bool aes_is_fine_; }; -bool ssl_tls13_cipher_meets_policy(uint16_t cipher_id, bool only_fips) { - if (!only_fips) { - return true; - } - - switch (cipher_id) { - case TLS1_3_CK_AES_128_GCM_SHA256 & 0xffff: - case TLS1_3_CK_AES_256_GCM_SHA384 & 0xffff: +bool ssl_tls13_cipher_meets_policy(uint16_t cipher_id, + enum ssl_compliance_policy_t policy) { + switch (policy) { + case ssl_compliance_policy_none: return true; - case TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff: - return false; - default: - assert(false); - return false; + + case ssl_compliance_policy_fips_202205: + switch (cipher_id) { + case TLS1_3_CK_AES_128_GCM_SHA256 & 0xffff: + case TLS1_3_CK_AES_256_GCM_SHA384 & 0xffff: + return true; + case TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff: + return false; + default: + assert(false); + return false; + } + + case ssl_compliance_policy_wpa3_192_202304: + switch (cipher_id) { + case TLS1_3_CK_AES_256_GCM_SHA384 & 0xffff: + return true; + case TLS1_3_CK_AES_128_GCM_SHA256 & 0xffff: + case TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff: + return false; + default: + assert(false); + return false; + } } + + assert(false); + return false; } const SSL_CIPHER *ssl_choose_tls13_cipher(CBS cipher_suites, bool has_aes_hw, uint16_t version, uint16_t group_id, - bool only_fips) { + enum ssl_compliance_policy_t policy) { if (CBS_len(&cipher_suites) % 2 != 0) { return nullptr; } @@ -728,7 +746,7 @@ const SSL_CIPHER *ssl_choose_tls13_cipher(CBS cipher_suites, bool has_aes_hw, } if (!ssl_tls13_cipher_meets_policy(SSL_CIPHER_get_protocol_id(candidate), - only_fips)) { + policy)) { continue; } diff --git a/ssl/ssl_lib.cc b/ssl/ssl_lib.cc index 6b45496335..838761af5c 100644 --- a/ssl/ssl_lib.cc +++ b/ssl/ssl_lib.cc @@ -536,7 +536,6 @@ ssl_ctx_st::ssl_ctx_st(const SSL_METHOD *ssl_method) false_start_allowed_without_alpn(false), handoff(false), enable_early_data(false), - only_fips_cipher_suites_in_tls13(false), aes_hw_override(false), aes_hw_override_value(false) { CRYPTO_MUTEX_init(&lock); @@ -658,10 +657,9 @@ SSL *SSL_new(SSL_CTX *ctx) { ssl->config->retain_only_sha256_of_client_certs = ctx->retain_only_sha256_of_client_certs; ssl->config->permute_extensions = ctx->permute_extensions; - ssl->config->only_fips_cipher_suites_in_tls13 = - ctx->only_fips_cipher_suites_in_tls13; ssl->config->aes_hw_override = ctx->aes_hw_override; ssl->config->aes_hw_override_value = ctx->aes_hw_override_value; + ssl->config->tls13_cipher_policy = ctx->tls13_cipher_policy; if (!ssl->config->supported_group_list.CopyFrom(ctx->supported_group_list) || !ssl->config->alpn_client_proto_list.CopyFrom( @@ -3175,7 +3173,7 @@ static const char kTLS12Ciphers[] = "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"; static int Configure(SSL_CTX *ctx) { - ctx->only_fips_cipher_suites_in_tls13 = true; + ctx->tls13_cipher_policy = ssl_compliance_policy_fips_202205; return // Section 3.1: @@ -3198,7 +3196,7 @@ static int Configure(SSL_CTX *ctx) { } static int Configure(SSL *ssl) { - ssl->config->only_fips_cipher_suites_in_tls13 = true; + ssl->config->tls13_cipher_policy = ssl_compliance_policy_fips_202205; // See |Configure(SSL_CTX)|, above, for reasoning. return SSL_set_min_proto_version(ssl, TLS1_2_VERSION) && @@ -3213,11 +3211,59 @@ static int Configure(SSL *ssl) { } // namespace fips202205 +namespace wpa202304 { + +// See WPA version 3.1, section 3.5. + +static const int kCurves[] = {NID_secp384r1}; + +static const uint16_t kSigAlgs[] = { + SSL_SIGN_RSA_PKCS1_SHA384, // + SSL_SIGN_RSA_PKCS1_SHA512, // + SSL_SIGN_ECDSA_SECP384R1_SHA384, // + SSL_SIGN_RSA_PSS_RSAE_SHA384, // + SSL_SIGN_RSA_PSS_RSAE_SHA512, // +}; + +static const char kTLS12Ciphers[] = + "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:" + "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"; + +static int Configure(SSL_CTX *ctx) { + ctx->tls13_cipher_policy = ssl_compliance_policy_wpa3_192_202304; + + return SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION) && + SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION) && + SSL_CTX_set_strict_cipher_list(ctx, kTLS12Ciphers) && + SSL_CTX_set1_curves(ctx, kCurves, OPENSSL_ARRAY_SIZE(kCurves)) && + SSL_CTX_set_signing_algorithm_prefs(ctx, kSigAlgs, + OPENSSL_ARRAY_SIZE(kSigAlgs)) && + SSL_CTX_set_verify_algorithm_prefs(ctx, kSigAlgs, + OPENSSL_ARRAY_SIZE(kSigAlgs)); +} + +static int Configure(SSL *ssl) { + ssl->config->tls13_cipher_policy = ssl_compliance_policy_wpa3_192_202304; + + return SSL_set_min_proto_version(ssl, TLS1_2_VERSION) && + SSL_set_max_proto_version(ssl, TLS1_3_VERSION) && + SSL_set_strict_cipher_list(ssl, kTLS12Ciphers) && + SSL_set1_curves(ssl, kCurves, OPENSSL_ARRAY_SIZE(kCurves)) && + SSL_set_signing_algorithm_prefs(ssl, kSigAlgs, + OPENSSL_ARRAY_SIZE(kSigAlgs)) && + SSL_set_verify_algorithm_prefs(ssl, kSigAlgs, + OPENSSL_ARRAY_SIZE(kSigAlgs)); +} + +} // namespace wpa202304 + int SSL_CTX_set_compliance_policy(SSL_CTX *ctx, enum ssl_compliance_policy_t policy) { switch (policy) { case ssl_compliance_policy_fips_202205: return fips202205::Configure(ctx); + case ssl_compliance_policy_wpa3_192_202304: + return wpa202304::Configure(ctx); default: return 0; } @@ -3227,6 +3273,8 @@ int SSL_set_compliance_policy(SSL *ssl, enum ssl_compliance_policy_t policy) { switch (policy) { case ssl_compliance_policy_fips_202205: return fips202205::Configure(ssl); + case ssl_compliance_policy_wpa3_192_202304: + return wpa202304::Configure(ssl); default: return 0; } diff --git a/ssl/test/runner/common.go b/ssl/test/runner/common.go index ce06779be0..cb974989a6 100644 --- a/ssl/test/runner/common.go +++ b/ssl/test/runner/common.go @@ -222,9 +222,13 @@ const ( // algorithms. var supportedSignatureAlgorithms = []signatureAlgorithm{ signatureRSAPSSWithSHA256, + signatureRSAPSSWithSHA384, signatureRSAPKCS1WithSHA256, signatureECDSAWithP256AndSHA256, + signatureECDSAWithP384AndSHA384, signatureRSAPKCS1WithSHA1, + signatureRSAPKCS1WithSHA256, + signatureRSAPKCS1WithSHA384, signatureECDSAWithSHA1, signatureEd25519, } diff --git a/ssl/test/runner/runner.go b/ssl/test/runner/runner.go index fc8c6ff585..b361e19531 100644 --- a/ssl/test/runner/runner.go +++ b/ssl/test/runner/runner.go @@ -19194,13 +19194,21 @@ func addCompliancePolicyTests() { isFIPSCipherSuite = true } + var isWPACipherSuite bool + switch suite.id { + case TLS_AES_256_GCM_SHA384, + TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, + TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: + isWPACipherSuite = true + } + var certFile string var keyFile string var certs []Certificate if hasComponent(suite.name, "ECDSA") { - certFile = ecdsaP256CertificateFile - keyFile = ecdsaP256KeyFile - certs = []Certificate{ecdsaP256Certificate} + certFile = ecdsaP384CertificateFile + keyFile = ecdsaP384KeyFile + certs = []Certificate{ecdsaP384Certificate} } else { certFile = rsaCertificateFile keyFile = rsaKeyFile @@ -19215,38 +19223,48 @@ func addCompliancePolicyTests() { maxVersion = VersionTLS12 } - testCases = append(testCases, testCase{ - testType: serverTest, - protocol: protocol, - name: "Compliance-fips202205-" + protocol.String() + "-Server-" + suite.name, - config: Config{ - MinVersion: VersionTLS12, - MaxVersion: maxVersion, - CipherSuites: []uint16{suite.id}, - }, - certFile: certFile, - keyFile: keyFile, - flags: []string{ - "-fips-202205", - }, - shouldFail: !isFIPSCipherSuite, - }) + policies := []struct { + flag string + cipherSuiteOk bool + }{ + {"-fips-202205", isFIPSCipherSuite}, + {"-wpa-202304", isWPACipherSuite}, + } - testCases = append(testCases, testCase{ - testType: clientTest, - protocol: protocol, - name: "Compliance-fips202205-" + protocol.String() + "-Client-" + suite.name, - config: Config{ - MinVersion: VersionTLS12, - MaxVersion: maxVersion, - CipherSuites: []uint16{suite.id}, - Certificates: certs, - }, - flags: []string{ - "-fips-202205", - }, - shouldFail: !isFIPSCipherSuite, - }) + for _, policy := range policies { + testCases = append(testCases, testCase{ + testType: serverTest, + protocol: protocol, + name: "Compliance" + policy.flag + "-" + protocol.String() + "-Server-" + suite.name, + config: Config{ + MinVersion: VersionTLS12, + MaxVersion: maxVersion, + CipherSuites: []uint16{suite.id}, + }, + certFile: certFile, + keyFile: keyFile, + flags: []string{ + policy.flag, + }, + shouldFail: !policy.cipherSuiteOk, + }) + + testCases = append(testCases, testCase{ + testType: clientTest, + protocol: protocol, + name: "Compliance" + policy.flag + "-" + protocol.String() + "-Client-" + suite.name, + config: Config{ + MinVersion: VersionTLS12, + MaxVersion: maxVersion, + CipherSuites: []uint16{suite.id}, + Certificates: certs, + }, + flags: []string{ + policy.flag, + }, + shouldFail: !policy.cipherSuiteOk, + }) + } } // Check that a TLS 1.3 client won't accept ChaCha20 even if the server @@ -19276,35 +19294,51 @@ func addCompliancePolicyTests() { isFIPSCurve = true } - testCases = append(testCases, testCase{ - testType: serverTest, - protocol: protocol, - name: "Compliance-fips202205-" + protocol.String() + "-Server-" + curve.name, - config: Config{ - MinVersion: VersionTLS12, - MaxVersion: VersionTLS13, - CurvePreferences: []CurveID{curve.id}, - }, - flags: []string{ - "-fips-202205", - }, - shouldFail: !isFIPSCurve, - }) + var isWPACurve bool + switch curve.id { + case CurveP384: + isWPACurve = true + } - testCases = append(testCases, testCase{ - testType: clientTest, - protocol: protocol, - name: "Compliance-fips202205-" + protocol.String() + "-Client-" + curve.name, - config: Config{ - MinVersion: VersionTLS12, - MaxVersion: VersionTLS13, - CurvePreferences: []CurveID{curve.id}, - }, - flags: []string{ - "-fips-202205", - }, - shouldFail: !isFIPSCurve, - }) + policies := []struct { + flag string + curveOk bool + }{ + {"-fips-202205", isFIPSCurve}, + {"-wpa-202304", isWPACurve}, + } + + for _, policy := range policies { + testCases = append(testCases, testCase{ + testType: serverTest, + protocol: protocol, + name: "Compliance" + policy.flag + "-" + protocol.String() + "-Server-" + curve.name, + config: Config{ + MinVersion: VersionTLS12, + MaxVersion: VersionTLS13, + CurvePreferences: []CurveID{curve.id}, + }, + flags: []string{ + policy.flag, + }, + shouldFail: !policy.curveOk, + }) + + testCases = append(testCases, testCase{ + testType: clientTest, + protocol: protocol, + name: "Compliance" + policy.flag + "-" + protocol.String() + "-Client-" + curve.name, + config: Config{ + MinVersion: VersionTLS12, + MaxVersion: VersionTLS13, + CurvePreferences: []CurveID{curve.id}, + }, + flags: []string{ + policy.flag, + }, + shouldFail: !policy.curveOk, + }) + } } for _, sigalg := range testSignatureAlgorithms { @@ -19321,6 +19355,16 @@ func addCompliancePolicyTests() { isFIPSSigAlg = true } + var isWPASigAlg bool + switch sigalg.id { + case signatureRSAPKCS1WithSHA384, + signatureRSAPKCS1WithSHA512, + signatureECDSAWithP384AndSHA384, + signatureRSAPSSWithSHA384, + signatureRSAPSSWithSHA512: + isWPASigAlg = true + } + if sigalg.cert == testCertECDSAP224 { // This can work in TLS 1.2, but not with TLS 1.3. // For consistency it's not permitted in FIPS mode. @@ -19335,38 +19379,48 @@ func addCompliancePolicyTests() { maxVersion = VersionTLS12 } - testCases = append(testCases, testCase{ - testType: serverTest, - protocol: protocol, - name: "Compliance-fips202205-" + protocol.String() + "-Server-" + sigalg.name, - config: Config{ - MinVersion: VersionTLS12, - MaxVersion: maxVersion, - VerifySignatureAlgorithms: []signatureAlgorithm{sigalg.id}, - }, - flags: []string{ - "-fips-202205", - "-cert-file", path.Join(*resourceDir, getShimCertificate(sigalg.cert)), - "-key-file", path.Join(*resourceDir, getShimKey(sigalg.cert)), - }, - shouldFail: !isFIPSSigAlg, - }) + policies := []struct { + flag string + sigAlgOk bool + }{ + {"-fips-202205", isFIPSSigAlg}, + {"-wpa-202304", isWPASigAlg}, + } - testCases = append(testCases, testCase{ - testType: clientTest, - protocol: protocol, - name: "Compliance-fips202205-" + protocol.String() + "-Client-" + sigalg.name, - config: Config{ - MinVersion: VersionTLS12, - MaxVersion: maxVersion, - SignSignatureAlgorithms: []signatureAlgorithm{sigalg.id}, - Certificates: []Certificate{getRunnerCertificate(sigalg.cert)}, - }, - flags: []string{ - "-fips-202205", - }, - shouldFail: !isFIPSSigAlg, - }) + for _, policy := range policies { + testCases = append(testCases, testCase{ + testType: serverTest, + protocol: protocol, + name: "Compliance" + policy.flag + "-" + protocol.String() + "-Server-" + sigalg.name, + config: Config{ + MinVersion: VersionTLS12, + MaxVersion: maxVersion, + VerifySignatureAlgorithms: []signatureAlgorithm{sigalg.id}, + }, + flags: []string{ + policy.flag, + "-cert-file", path.Join(*resourceDir, getShimCertificate(sigalg.cert)), + "-key-file", path.Join(*resourceDir, getShimKey(sigalg.cert)), + }, + shouldFail: !policy.sigAlgOk, + }) + + testCases = append(testCases, testCase{ + testType: clientTest, + protocol: protocol, + name: "Compliance" + policy.flag + "-" + protocol.String() + "-Client-" + sigalg.name, + config: Config{ + MinVersion: VersionTLS12, + MaxVersion: maxVersion, + SignSignatureAlgorithms: []signatureAlgorithm{sigalg.id}, + Certificates: []Certificate{getRunnerCertificate(sigalg.cert)}, + }, + flags: []string{ + policy.flag, + }, + shouldFail: !policy.sigAlgOk, + }) + } } } } diff --git a/ssl/test/test_config.cc b/ssl/test/test_config.cc index ba10a33190..0ee5580ecd 100644 --- a/ssl/test/test_config.cc +++ b/ssl/test/test_config.cc @@ -390,6 +390,7 @@ std::vector SortedFlags() { IntFlag("-early-write-after-message", &TestConfig::early_write_after_message), BoolFlag("-fips-202205", &TestConfig::fips_202205), + BoolFlag("-wpa-202304", &TestConfig::wpa_202304), }; std::sort(flags.begin(), flags.end(), [](const Flag &a, const Flag &b) { return strcmp(a.name, b.name) < 0; @@ -1765,11 +1766,20 @@ bssl::UniquePtr TestConfig::NewSSL( if (enable_ech_grease) { SSL_set_enable_ech_grease(ssl.get(), 1); } + if (static_cast(fips_202205) + static_cast(wpa_202304) > 1) { + fprintf(stderr, "Multiple policy options given\n"); + return nullptr; + } if (fips_202205 && !SSL_set_compliance_policy( ssl.get(), ssl_compliance_policy_fips_202205)) { fprintf(stderr, "SSL_set_compliance_policy failed\n"); return nullptr; } + if (wpa_202304 && !SSL_set_compliance_policy( + ssl.get(), ssl_compliance_policy_wpa3_192_202304)) { + fprintf(stderr, "SSL_set_compliance_policy failed\n"); + return nullptr; + } if (!ech_config_list.empty() && !SSL_set1_ech_config_list( ssl.get(), reinterpret_cast(ech_config_list.data()), diff --git a/ssl/test/test_config.h b/ssl/test/test_config.h index 5cc5926437..e8c473a169 100644 --- a/ssl/test/test_config.h +++ b/ssl/test/test_config.h @@ -195,6 +195,7 @@ struct TestConfig { std::string quic_early_data_context; int early_write_after_message = 0; bool fips_202205 = false; + bool wpa_202304 = false; int argc; char **argv; diff --git a/ssl/tls13_client.cc b/ssl/tls13_client.cc index 92e26f22a8..1971596c97 100644 --- a/ssl/tls13_client.cc +++ b/ssl/tls13_client.cc @@ -200,7 +200,7 @@ static enum ssl_hs_wait_t do_read_hello_retry_request(SSL_HANDSHAKE *hs) { SSL_CIPHER_get_max_version(cipher) < ssl_protocol_version(ssl) || !ssl_tls13_cipher_meets_policy( SSL_CIPHER_get_value(cipher), - ssl->config->only_fips_cipher_suites_in_tls13)) { + ssl->config->tls13_cipher_policy)) { OPENSSL_PUT_ERROR(SSL, SSL_R_WRONG_CIPHER_RETURNED); ssl_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_ILLEGAL_PARAMETER); return ssl_hs_error; diff --git a/ssl/tls13_server.cc b/ssl/tls13_server.cc index c97e3f5502..9d26f4e006 100644 --- a/ssl/tls13_server.cc +++ b/ssl/tls13_server.cc @@ -120,7 +120,7 @@ static const SSL_CIPHER *choose_tls13_cipher( cipher_suites, ssl->config->aes_hw_override ? ssl->config->aes_hw_override_value : EVP_has_aes_hardware(), - version, group_id, ssl->config->only_fips_cipher_suites_in_tls13); + version, group_id, ssl->config->tls13_cipher_policy); } static bool add_new_session_tickets(SSL_HANDSHAKE *hs, bool *out_sent_tickets) { From 9939e14cffc66f9b9f3374fb52c97bd8bfb0bfbe Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 26 Apr 2023 17:38:31 -0400 Subject: [PATCH 49/56] Invalidated cached RSA, DH, and DSA state when changing keys As part of getting a handle on RSA state, I would like for RSA keys created from parsing to come pre-"frozen". This reduces some contention on first use. But that potentially breaks an existing use case: today, you're allowed to parse a private key and then override one field without problems, because none of the cached state has materialized yet. If the caller modified the RSA key by reaching into the struct, it's hopeless. If they used the setters, we actually can handle it correctly, so go ahead and make this work. DH and DSA aren't of particular interest to us, but fix them while I'm at it. This also avoids having to later document that something doesn't work, just that it's a terrible API. Bug: 316 Change-Id: Idf02c777b932a62df9396e21de459381455950e0 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59385 Auto-Submit: David Benjamin Commit-Queue: David Benjamin Reviewed-by: Adam Langley --- crypto/dh_extra/dh_test.cc | 61 ++++++++++++++++++++++ crypto/dsa/dsa.c | 4 ++ crypto/dsa/dsa_test.cc | 74 ++++++++++++++++++++++++++ crypto/fipsmodule/dh/dh.c | 3 ++ crypto/fipsmodule/rsa/internal.h | 7 +++ crypto/fipsmodule/rsa/rsa.c | 18 ++----- crypto/fipsmodule/rsa/rsa_impl.c | 31 +++++++++++ crypto/rsa_extra/rsa_test.cc | 89 ++++++++++++++++++++++++++++++++ 8 files changed, 273 insertions(+), 14 deletions(-) diff --git a/crypto/dh_extra/dh_test.cc b/crypto/dh_extra/dh_test.cc index 7a17070276..8d2c5871e8 100644 --- a/crypto/dh_extra/dh_test.cc +++ b/crypto/dh_extra/dh_test.cc @@ -366,3 +366,64 @@ TEST(DHTest, LeadingZeros) { ASSERT_GT(len, 0); EXPECT_EQ(Bytes(buf.data(), len), Bytes(padded)); } + +TEST(DHTest, Overwrite) { + // Generate a DH key with the 1536-bit MODP group. + bssl::UniquePtr p(BN_get_rfc3526_prime_1536(nullptr)); + ASSERT_TRUE(p); + bssl::UniquePtr g(BN_new()); + ASSERT_TRUE(g); + ASSERT_TRUE(BN_set_word(g.get(), 2)); + + bssl::UniquePtr key1(DH_new()); + ASSERT_TRUE(key1); + ASSERT_TRUE(DH_set0_pqg(key1.get(), p.get(), /*q=*/nullptr, g.get())); + p.release(); + g.release(); + ASSERT_TRUE(DH_generate_key(key1.get())); + + bssl::UniquePtr peer_key(BN_new()); + ASSERT_TRUE(peer_key); + ASSERT_TRUE(BN_set_word(peer_key.get(), 42)); + + // Use the key to fill in cached values. + std::vector buf1(DH_size(key1.get())); + ASSERT_GT(DH_compute_key_padded(buf1.data(), peer_key.get(), key1.get()), 0); + + // Generate a different key with a different group. + p.reset(BN_get_rfc3526_prime_2048(nullptr)); + ASSERT_TRUE(p); + g.reset(BN_new()); + ASSERT_TRUE(g); + ASSERT_TRUE(BN_set_word(g.get(), 2)); + + bssl::UniquePtr key2(DH_new()); + ASSERT_TRUE(key2); + ASSERT_TRUE(DH_set0_pqg(key2.get(), p.get(), /*q=*/nullptr, g.get())); + p.release(); + g.release(); + ASSERT_TRUE(DH_generate_key(key2.get())); + + // Overwrite |key1|'s contents with |key2|. + p.reset(BN_dup(DH_get0_p(key2.get()))); + ASSERT_TRUE(p); + g.reset(BN_dup(DH_get0_g(key2.get()))); + ASSERT_TRUE(g); + bssl::UniquePtr pub(BN_dup(DH_get0_pub_key(key2.get()))); + ASSERT_TRUE(pub); + bssl::UniquePtr priv(BN_dup(DH_get0_priv_key(key2.get()))); + ASSERT_TRUE(priv); + ASSERT_TRUE(DH_set0_pqg(key1.get(), p.get(), /*q=*/nullptr, g.get())); + p.release(); + g.release(); + ASSERT_TRUE(DH_set0_key(key1.get(), pub.get(), priv.get())); + pub.release(); + priv.release(); + + // Verify that |key1| and |key2| behave equivalently. + buf1.resize(DH_size(key1.get())); + ASSERT_GT(DH_compute_key_padded(buf1.data(), peer_key.get(), key1.get()), 0); + std::vector buf2(DH_size(key2.get())); + ASSERT_GT(DH_compute_key_padded(buf2.data(), peer_key.get(), key2.get()), 0); + EXPECT_EQ(Bytes(buf1), Bytes(buf2)); +} diff --git a/crypto/dsa/dsa.c b/crypto/dsa/dsa.c index 8be01b9f61..5eb7894882 100644 --- a/crypto/dsa/dsa.c +++ b/crypto/dsa/dsa.c @@ -202,6 +202,10 @@ int DSA_set0_pqg(DSA *dsa, BIGNUM *p, BIGNUM *q, BIGNUM *g) { dsa->g = g; } + BN_MONT_CTX_free(dsa->method_mont_p); + dsa->method_mont_p = NULL; + BN_MONT_CTX_free(dsa->method_mont_q); + dsa->method_mont_q = NULL; return 1; } diff --git a/crypto/dsa/dsa_test.cc b/crypto/dsa/dsa_test.cc index cc02782a36..611b003470 100644 --- a/crypto/dsa/dsa_test.cc +++ b/crypto/dsa/dsa_test.cc @@ -336,3 +336,77 @@ Epvg EXPECT_FALSE(DSA_sign(0, fips_digest, sizeof(fips_digest), sig.data(), &sig_len, dsa.get())); } + +TEST(DSATest, Overwrite) { + // Load an arbitrary DSA private key and use it. + static const char kPEM[] = R"( +-----BEGIN DSA PRIVATE KEY----- +MIIDTgIBAAKCAQEAyH68EuravtF+7PTFBtWJkwjmp0YJmh8e2Cdpu8ci3dZf87rk +GwXzfqYkAEkW5H4Hp0cxdICKFiqfxjSaiEauOrNV+nXWZS634hZ9H47I8HnAVS0p +5MmSmPJ7NNUowymMpyB6M6hfqHl/1pZd7avbTmnzb2SZ0kw0WLWJo6vMekepYWv9 +3o1Xove4ci00hnkr7Qo9Bh/+z84jgeT2/MTdsCVtbuMv/mbcYLhCKVWPBozDZr/D +qwhGTlomsTRvP3WIbem3b5eYhQaPuMsKiAzntcinoxQXWrIoZB+xJyF/sI013uBI +i9ePSxY3704U4QGxVM0aR/6fzORz5kh8ZjhhywIdAI9YBUR6eoGevUaLq++qXiYW +TgXBXlyqE32ESbkCggEBAL/c5GerO5g25D0QsfgVIJtlZHQOwYauuWoUudaQiyf6 +VhWLBNNTAGldkFGdtxsA42uqqZSXCki25LvN6PscGGvFy8oPWaa9TGt+l9Z5ZZiV +ShNpg71V9YuImsPB3BrQ4L6nZLfhBt6InzJ6KqjDNdg7u6lgnFKue7l6khzqNxbM +RgxHWMq7PkhMcl+RzpqbiGcxSHqraxldutqCWsnZzhKh4d4GdunuRY8GiFo0Axkb +Kn0Il3zm81ewv08F/ocu+IZQEzxTyR8YRQ99MLVbnwhVxndEdLjjetCX82l+/uEY +5fdUy0thR8odcDsvUc/tT57I+yhnno80HbpUUNw2+/sCggEAdh1wp/9CifYIp6T8 +P/rIus6KberZ2Pv/n0bl+Gv8AoToA0zhZXIfY2l0TtanKmdLqPIvjqkN0v6zGSs+ ++ahR1QzMQnK718mcsQmB4X6iP5LKgJ/t0g8LrDOxc/cNycmHq76MmF9RN5NEBz4+ +PAnRIftm/b0UQflP6uy3gRQP2X7P8ZebCytOPKTZC4oLyCtvPevSkCiiauq/RGjL +k6xqRgLxMtmuyhT+dcVbtllV1p1xd9Bppnk17/kR5VCefo/e/7DHu163izRDW8tx +SrEmiVyVkRijY3bVZii7LPfMz5eEAWEDJRuFwyNv3i6j7CKeZw2d/hzu370Ua28F +s2lmkAIcLIFUDFrbC2nViaB5ATM9ARKk6F2QwnCfGCyZ6A== +-----END DSA PRIVATE KEY----- +)"; + bssl::UniquePtr bio(BIO_new_mem_buf(kPEM, sizeof(kPEM))); + ASSERT_TRUE(bio); + bssl::UniquePtr dsa( + PEM_read_bio_DSAPrivateKey(bio.get(), nullptr, nullptr, nullptr)); + ASSERT_TRUE(dsa); + + std::vector sig(DSA_size(dsa.get())); + unsigned sig_len; + ASSERT_TRUE(DSA_sign(0, fips_digest, sizeof(fips_digest), sig.data(), + &sig_len, dsa.get())); + sig.resize(sig_len); + EXPECT_EQ(1, DSA_verify(0, fips_digest, sizeof(fips_digest), sig.data(), + sig.size(), dsa.get())); + + // Overwrite it with the sample key. + bssl::UniquePtr p(BN_bin2bn(fips_p, sizeof(fips_p), nullptr)); + ASSERT_TRUE(p); + bssl::UniquePtr q(BN_bin2bn(fips_q, sizeof(fips_q), nullptr)); + ASSERT_TRUE(q); + bssl::UniquePtr g(BN_bin2bn(fips_g, sizeof(fips_g), nullptr)); + ASSERT_TRUE(g); + ASSERT_TRUE(DSA_set0_pqg(dsa.get(), p.get(), q.get(), g.get())); + // |DSA_set0_pqg| takes ownership on success. + p.release(); + q.release(); + g.release(); + bssl::UniquePtr pub_key(BN_bin2bn(fips_y, sizeof(fips_y), nullptr)); + ASSERT_TRUE(pub_key); + bssl::UniquePtr priv_key(BN_bin2bn(fips_x, sizeof(fips_x), nullptr)); + ASSERT_TRUE(priv_key); + ASSERT_TRUE(DSA_set0_key(dsa.get(), pub_key.get(), priv_key.get())); + // |DSA_set0_key| takes ownership on success. + pub_key.release(); + priv_key.release(); + + // The key should now work correctly for the new parameters. + EXPECT_EQ(1, DSA_verify(0, fips_digest, sizeof(fips_digest), fips_sig, + sizeof(fips_sig), dsa.get())); + + // Test signing by verifying it round-trips through the real key. + sig.resize(DSA_size(dsa.get())); + ASSERT_TRUE(DSA_sign(0, fips_digest, sizeof(fips_digest), sig.data(), + &sig_len, dsa.get())); + sig.resize(sig_len); + dsa = GetFIPSDSA(); + ASSERT_TRUE(dsa); + EXPECT_EQ(1, DSA_verify(0, fips_digest, sizeof(fips_digest), sig.data(), + sig.size(), dsa.get())); +} diff --git a/crypto/fipsmodule/dh/dh.c b/crypto/fipsmodule/dh/dh.c index 83435118a0..80940fdb13 100644 --- a/crypto/fipsmodule/dh/dh.c +++ b/crypto/fipsmodule/dh/dh.c @@ -177,6 +177,9 @@ int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g) { dh->g = g; } + // Invalidate the cached Montgomery parameters. + BN_MONT_CTX_free(dh->method_mont_p); + dh->method_mont_p = NULL; return 1; } diff --git a/crypto/fipsmodule/rsa/internal.h b/crypto/fipsmodule/rsa/internal.h index 12394a4454..b940f6801f 100644 --- a/crypto/fipsmodule/rsa/internal.h +++ b/crypto/fipsmodule/rsa/internal.h @@ -60,6 +60,7 @@ #include #include +#include #if defined(__cplusplus) @@ -116,6 +117,12 @@ int rsa_private_transform_no_self_test(RSA *rsa, uint8_t *out, int rsa_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in, size_t len); +// rsa_invalidate_key is called after |rsa| has been mutated, to invalidate +// fields derived from the original structure. This function assumes exclusive +// access to |rsa|. In particular, no other thread may be concurrently signing, +// etc., with |rsa|. +void rsa_invalidate_key(RSA *rsa); + // This constant is exported for test purposes. extern const BN_ULONG kBoringSSLRSASqrtTwo[]; diff --git a/crypto/fipsmodule/rsa/rsa.c b/crypto/fipsmodule/rsa/rsa.c index dffc8aa1ba..8f5cb5ff16 100644 --- a/crypto/fipsmodule/rsa/rsa.c +++ b/crypto/fipsmodule/rsa/rsa.c @@ -119,8 +119,6 @@ RSA *RSA_new_method(const ENGINE *engine) { } void RSA_free(RSA *rsa) { - unsigned u; - if (rsa == NULL) { return; } @@ -144,18 +142,7 @@ void RSA_free(RSA *rsa) { BN_free(rsa->dmp1); BN_free(rsa->dmq1); BN_free(rsa->iqmp); - BN_MONT_CTX_free(rsa->mont_n); - BN_MONT_CTX_free(rsa->mont_p); - BN_MONT_CTX_free(rsa->mont_q); - BN_free(rsa->d_fixed); - BN_free(rsa->dmp1_fixed); - BN_free(rsa->dmq1_fixed); - BN_free(rsa->inv_small_mod_large_mont); - for (u = 0; u < rsa->num_blindings; u++) { - BN_BLINDING_free(rsa->blindings[u]); - } - OPENSSL_free(rsa->blindings); - OPENSSL_free(rsa->blindings_inuse); + rsa_invalidate_key(rsa); CRYPTO_MUTEX_cleanup(&rsa->lock); OPENSSL_free(rsa); } @@ -244,6 +231,7 @@ int RSA_set0_key(RSA *rsa, BIGNUM *n, BIGNUM *e, BIGNUM *d) { rsa->d = d; } + rsa_invalidate_key(rsa); return 1; } @@ -262,6 +250,7 @@ int RSA_set0_factors(RSA *rsa, BIGNUM *p, BIGNUM *q) { rsa->q = q; } + rsa_invalidate_key(rsa); return 1; } @@ -285,6 +274,7 @@ int RSA_set0_crt_params(RSA *rsa, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp) { rsa->iqmp = iqmp; } + rsa_invalidate_key(rsa); return 1; } diff --git a/crypto/fipsmodule/rsa/rsa_impl.c b/crypto/fipsmodule/rsa/rsa_impl.c index dabcd2fc02..6eb44381d3 100644 --- a/crypto/fipsmodule/rsa/rsa_impl.c +++ b/crypto/fipsmodule/rsa/rsa_impl.c @@ -262,6 +262,36 @@ static int freeze_private_key(RSA *rsa, BN_CTX *ctx) { return ret; } +void rsa_invalidate_key(RSA *rsa) { + rsa->private_key_frozen = 0; + + BN_MONT_CTX_free(rsa->mont_n); + rsa->mont_n = NULL; + BN_MONT_CTX_free(rsa->mont_p); + rsa->mont_p = NULL; + BN_MONT_CTX_free(rsa->mont_q); + rsa->mont_q = NULL; + + BN_free(rsa->d_fixed); + rsa->d_fixed = NULL; + BN_free(rsa->dmp1_fixed); + rsa->dmp1_fixed = NULL; + BN_free(rsa->dmq1_fixed); + rsa->dmq1_fixed = NULL; + BN_free(rsa->inv_small_mod_large_mont); + rsa->inv_small_mod_large_mont = NULL; + + for (size_t i = 0; i < rsa->num_blindings; i++) { + BN_BLINDING_free(rsa->blindings[i]); + } + OPENSSL_free(rsa->blindings); + rsa->blindings = NULL; + rsa->num_blindings = 0; + OPENSSL_free(rsa->blindings_inuse); + rsa->blindings_inuse = NULL; + rsa->blinding_fork_generation = 0; +} + size_t rsa_default_size(const RSA *rsa) { return BN_num_bytes(rsa->n); } @@ -1229,6 +1259,7 @@ static int RSA_generate_key_ex_maybe_fips(RSA *rsa, int bits, goto out; } + rsa_invalidate_key(rsa); replace_bignum(&rsa->n, &tmp->n); replace_bignum(&rsa->e, &tmp->e); replace_bignum(&rsa->d, &tmp->d); diff --git a/crypto/rsa_extra/rsa_test.cc b/crypto/rsa_extra/rsa_test.cc index d3ee69b31c..e4fb12fc10 100644 --- a/crypto/rsa_extra/rsa_test.cc +++ b/crypto/rsa_extra/rsa_test.cc @@ -1022,6 +1022,95 @@ TEST(RSATest, KeygenInternalRetry) { EXPECT_TRUE(RSA_generate_key_ex(rsa.get(), 2048, e.get(), &cb)); } +// Test that, after a key has been used, it can still be modified into another +// key. +TEST(RSATest, OverwriteKey) { + // Make a key and perform public and private key operations with it, so that + // all derived values are filled in. + bssl::UniquePtr key1( + RSA_private_key_from_bytes(kKey1, sizeof(kKey1) - 1)); + ASSERT_TRUE(key1); + + ASSERT_TRUE(RSA_check_key(key1.get())); + size_t len; + std::vector ciphertext(RSA_size(key1.get())); + ASSERT_TRUE(RSA_encrypt(key1.get(), &len, ciphertext.data(), + ciphertext.size(), kPlaintext, kPlaintextLen, + RSA_PKCS1_OAEP_PADDING)); + ciphertext.resize(len); + + std::vector plaintext(RSA_size(key1.get())); + ASSERT_TRUE(RSA_decrypt(key1.get(), &len, plaintext.data(), + plaintext.size(), ciphertext.data(), ciphertext.size(), + RSA_PKCS1_OAEP_PADDING)); + plaintext.resize(len); + EXPECT_EQ(Bytes(plaintext), Bytes(kPlaintext, kPlaintextLen)); + + // Overwrite |key1| with the contents of |key2|. + bssl::UniquePtr key2( + RSA_private_key_from_bytes(kKey2, sizeof(kKey2) - 1)); + ASSERT_TRUE(key2); + + auto copy_rsa_fields = [](RSA *dst, const RSA *src) { + bssl::UniquePtr n(BN_dup(RSA_get0_n(src))); + ASSERT_TRUE(n); + bssl::UniquePtr e(BN_dup(RSA_get0_e(src))); + ASSERT_TRUE(e); + bssl::UniquePtr d(BN_dup(RSA_get0_d(src))); + ASSERT_TRUE(d); + bssl::UniquePtr p(BN_dup(RSA_get0_p(src))); + ASSERT_TRUE(p); + bssl::UniquePtr q(BN_dup(RSA_get0_q(src))); + ASSERT_TRUE(q); + bssl::UniquePtr dmp1(BN_dup(RSA_get0_dmp1(src))); + ASSERT_TRUE(dmp1); + bssl::UniquePtr dmq1(BN_dup(RSA_get0_dmq1(src))); + ASSERT_TRUE(dmq1); + bssl::UniquePtr iqmp(BN_dup(RSA_get0_iqmp(src))); + ASSERT_TRUE(iqmp); + ASSERT_TRUE(RSA_set0_key(dst, n.release(), e.release(), d.release())); + ASSERT_TRUE(RSA_set0_factors(dst, p.release(), q.release())); + ASSERT_TRUE(RSA_set0_crt_params(dst, dmp1.release(), dmq1.release(), + iqmp.release())); + }; + ASSERT_NO_FATAL_FAILURE(copy_rsa_fields(key1.get(), key2.get())); + + auto check_rsa_compatible = [&](RSA *enc, RSA *dec) { + ciphertext.resize(RSA_size(enc)); + ASSERT_TRUE(RSA_encrypt(enc, &len, ciphertext.data(), + ciphertext.size(), kPlaintext, kPlaintextLen, + RSA_PKCS1_OAEP_PADDING)); + ciphertext.resize(len); + + plaintext.resize(RSA_size(dec)); + ASSERT_TRUE(RSA_decrypt(dec, &len, plaintext.data(), + plaintext.size(), ciphertext.data(), + ciphertext.size(), RSA_PKCS1_OAEP_PADDING)); + plaintext.resize(len); + EXPECT_EQ(Bytes(plaintext), Bytes(kPlaintext, kPlaintextLen)); + }; + + ASSERT_NO_FATAL_FAILURE( + check_rsa_compatible(/*enc=*/key1.get(), /*dec=*/key2.get())); + ASSERT_NO_FATAL_FAILURE( + check_rsa_compatible(/*enc=*/key2.get(), /*dec=*/key1.get())); + + // If we generate a new key on top of |key1|, it should be usable and + // self-consistent. We test this by making a new key with the same parameters + // and checking they behave the same. + ASSERT_TRUE( + RSA_generate_key_ex(key1.get(), 1024, RSA_get0_e(key2.get()), nullptr)); + EXPECT_NE(0, BN_cmp(RSA_get0_n(key1.get()), RSA_get0_n(key2.get()))); + + key2.reset(RSA_new()); + ASSERT_TRUE(key2); + ASSERT_NO_FATAL_FAILURE(copy_rsa_fields(key2.get(), key1.get())); + ASSERT_NO_FATAL_FAILURE( + check_rsa_compatible(/*enc=*/key1.get(), /*dec=*/key2.get())); + ASSERT_NO_FATAL_FAILURE( + check_rsa_compatible(/*enc=*/key2.get(), /*dec=*/key1.get())); +} + #if !defined(BORINGSSL_SHARED_LIBRARY) TEST(RSATest, SqrtTwo) { bssl::UniquePtr sqrt(BN_new()), pow2(BN_new()); From b811a6c6ab09b8294f2e2ed0b8080874a7d8bef4 Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Mon, 1 May 2023 06:29:10 -0700 Subject: [PATCH 50/56] Add Kyber to runner tests Change-Id: I49920d3917f0aebf1b9efbd45d0bcd944d6c8117 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59405 Auto-Submit: Adam Langley Reviewed-by: David Benjamin Commit-Queue: Adam Langley --- crypto/kyber/kyber.c | 2 +- crypto/kyber/kyber_test.cc | 9 +- crypto/kyber/kyber_tests.txt | 201 ++++++++- ssl/test/runner/common.go | 2 +- ssl/test/runner/key_agreement.go | 92 ++++ ssl/test/runner/kyber/kyber.go | 625 ++++++++++++++++++++++++++++ ssl/test/runner/kyber/kyber_test.go | 128 ++++++ ssl/test/runner/runner.go | 3 +- 8 files changed, 1056 insertions(+), 6 deletions(-) create mode 100644 ssl/test/runner/kyber/kyber.go create mode 100644 ssl/test/runner/kyber/kyber_test.go diff --git a/crypto/kyber/kyber.c b/crypto/kyber/kyber.c index 010d9d4c7a..776c085f91 100644 --- a/crypto/kyber/kyber.c +++ b/crypto/kyber/kyber.c @@ -230,7 +230,7 @@ static void scalar_sub(scalar *lhs, const scalar *rhs) { static void scalar_mult(scalar *out, const scalar *lhs, const scalar *rhs) { for (int i = 0; i < DEGREE / 2; i++) { uint32_t real_real = (uint32_t)lhs->c[2 * i] * rhs->c[2 * i]; - uint32_t img_img = (uint32_t)rhs->c[2 * i + 1] * lhs->c[2 * i + 1]; + uint32_t img_img = (uint32_t)lhs->c[2 * i + 1] * rhs->c[2 * i + 1]; uint32_t real_img = (uint32_t)lhs->c[2 * i] * rhs->c[2 * i + 1]; uint32_t img_real = (uint32_t)lhs->c[2 * i + 1] * rhs->c[2 * i]; out->c[2 * i] = diff --git a/crypto/kyber/kyber_test.cc b/crypto/kyber/kyber_test.cc index ae51ac9597..eb76b5bd71 100644 --- a/crypto/kyber/kyber_test.cc +++ b/crypto/kyber/kyber_test.cc @@ -151,13 +151,17 @@ TEST(KyberTest, Basic) { static void KyberFileTest(FileTest *t) { std::vector seed, public_key_expected, private_key_expected, - ciphertext_expected, shared_secret_expected; + ciphertext_expected, shared_secret_expected, given_generate_entropy, + given_encap_entropy_pre_hash; t->IgnoreAttribute("count"); ASSERT_TRUE(t->GetBytes(&seed, "seed")); ASSERT_TRUE(t->GetBytes(&public_key_expected, "pk")); ASSERT_TRUE(t->GetBytes(&private_key_expected, "sk")); ASSERT_TRUE(t->GetBytes(&ciphertext_expected, "ct")); ASSERT_TRUE(t->GetBytes(&shared_secret_expected, "ss")); + ASSERT_TRUE(t->GetBytes(&given_generate_entropy, "generateEntropy")); + ASSERT_TRUE( + t->GetBytes(&given_encap_entropy_pre_hash, "encapEntropyPreHash")); KYBER_private_key priv; uint8_t encoded_private_key[KYBER_PRIVATE_KEY_BYTES]; @@ -183,6 +187,9 @@ static void KyberFileTest(FileTest *t) { KYBER_ENCAP_ENTROPY, nullptr, 0)); } + EXPECT_EQ(Bytes(gen_key_entropy), Bytes(given_generate_entropy)); + EXPECT_EQ(Bytes(encap_entropy), Bytes(given_encap_entropy_pre_hash)); + BORINGSSL_keccak(encap_entropy, sizeof(encap_entropy), encap_entropy, sizeof(encap_entropy), boringssl_sha3_256); diff --git a/crypto/kyber/kyber_tests.txt b/crypto/kyber/kyber_tests.txt index d3a1c47797..486b163eac 100644 --- a/crypto/kyber/kyber_tests.txt +++ b/crypto/kyber/kyber_tests.txt @@ -6,6 +6,8 @@ count = 0 seed = 061550234D158C5EC95595FE04EF7A25767F2E24CC2BC479D09D86DC9ABCFDE7056A8C266F9EF97ED08541DBD2E1FFA1 +generateEntropy = 7c9935a0b07694aa0c6d10e4db6b1add2fd81a25ccb148032dcd739936737f2d8626ed79d451140800e03b59b956f8210e556067407d13dc90fa9e8b872bfb8f +encapEntropyPreHash = 147c03f7a5bebba406c8fae1874d7f13c80efe79a3a9a874cc09fe76f6997615 pk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sk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ct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ss = 914CB67FE5C38E73BF74181C0AC50428DEDF7750A98058F7D536708774535B29 count = 1 seed = D81C4D8D734FCBFBEADE3D3F8A039FAA2A2C9957E835AD55B22E75BF57BB556AC81ADDE6AEEB4A5A875C3BFCADFA958F +generateEntropy = d60b93492a1d8c1c7ba6fc0b733137f3406cee8110a93f170e7a78658af326d9003271531cf27285b8721ed5cb46853043b346a66cba6cf765f1b0eaa40bf672 +encapEntropyPreHash = cde797df8ce67231f6c5d15811843e01eb2ab84c7490931240822adbddd72046 pk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sk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ct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ss = FE8AAA6558FD8087DD7CAB54B4BCE50FC625A369ECACE58B2EC36F3BC5BB4F5A count = 2 seed = 64335BF29E5DE62842C941766BA129B0643B5E7121CA26CFC190EC7DC3543830557FDD5C03CF123A456D48EFEA43C868 +generateEntropy = 4b622de1350119c45a9f2e2ef3dc5df50a759d138cdfbd64c81cc7cc2f513345e82fcc97ca60ccb27bf6938c975658aeb8b4d37cffbde25d97e561f36c219ade +encapEntropyPreHash = f43f68fbd694f0a6d307297110ecd4739876489fdf07eb9b03364e2ed0ff96e9 pk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sk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ct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ss = 86435AB2AFF9CEA1DC653CE819721A56933841F29330869B63E36604A6CEAFF2 count = 3 seed = 225D5CE2CEAC61930A07503FB59F7C2F936A3E075481DA3CA299A80F8C5DF9223A073E7B90E02EBF98CA2227EBA38C1A +generateEntropy = 050d58f9f757edc1e8180e3808b806f5bbb3586db3470b069826d1bb9a4efc2cde950541fd53a8a47aaa8cdfe80d928262a5ef7f8129ec3ef92f78d7cc32ef60 +encapEntropyPreHash = ea74fbc3c546500ed684bed6fe3c496d3b86d2d6dfaf223969b942e9a8c95e85 pk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sk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ct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ss = F9A2D73F0A81B5829E7C7CAD8FCF5F1AD55B384B2427C288BFBF4C29540F1DB6 count = 4 seed = EDC76E7C1523E3862552133FEA4D2AB05C69FB54A9354F0846456A2A407E071DF4650EC0E0A5666A52CD09462DBC51F9 +generateEntropy = 66b79b844e0c2adad694e0478661ac46fe6b6001f6a71ff8e2f034b1fd8833d3be2d3c64d38269a1ee8660b9a2beaeb9f5ac022e8f0a357feebfd13b06813854 +encapEntropyPreHash = 64efa87a12cb96f98b9b81a7e5128a959c74e5332aaab0444fca7b4a5e5e0216 pk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sk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ct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ss = 83E562482FCF5157C75D3D2F0A35DA861689A1009104A071A7BFB10BC4D8CD02 count = 5 seed = AA93649193C2C5985ACF8F9E6AC50C36AE16A2526D7C684F7A3BB4ABCD7B6FF790E82BADCE89BC7380D66251F97AAAAA +generateEntropy = 7ec408f52c9aa723d0c41d9987682a5f4ce6c9da7cd0215af60bbaf5484ab353a08ccf451b049fd51d7a9ad77ae14a81569df8c9bd3a8f1ebea86fdcfb823082 +encapEntropyPreHash = 8a95d71228acaa5f9ae6f9d9ca8ae55fde296463b41083a39e833e37c4c90f88 pk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sk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ct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ss = 445B60A142D4853702A102F9CC37FDFB1D0B14A9A7E210C7D290F9402F0A2F40 count = 6 seed = 2E014DC7C2696B9F6D4AF555CBA4B931B34863FF60E2341D4FDFE472FEF2FE2C33E0813FC5CAFDE4E30277FE522A9049 +generateEntropy = c121915bfef6abdfc177dae2f5a24218f9abda2559afc6741b08e0e61ab433eb84ef52db5eaa6df8ec3a0bc5ffa730db0dde8c5f38f266d5c680a78d264a7b96 +encapEntropyPreHash = 90d79d75d0bbb8921cf70d46bab497022a8e750efdc99e5f1bae653275441c7b pk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sk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ct = 7E2B3F001C83AFB604595634A841E0D71327502B46D289E4D5DD27ABBD0400206BC1CC315DAE0F8F9BB8C69676B5FD0DFAD5DD4D05609B5AC327F77EECED6D72139E4529574CBE4EFC1A796033DCE9DFF2436E18A627FF4B30748002AA858BF6B9F12ACCCA22088B727D74C1C3EF565956ED029B661FFAC19F00C54CDDE3D86EB59725EF82FAA2AB55BF3ABF0789E037CB95F233E93C7B73471EDCAC5CA8D5D94968EEC87E0D9CEA8F2ED79C3BFD8456FBB1727E576371264B22334CA4492D0EAE431AD6AEA4524F22C08F8C3928B703D7D7C23481622968AD7CC52D10E38F0B164C45F3742238555806283C1D781E8714030BF60D3CF414D00FA1C46F5528DB038618E918E98A6A36D7C092575E1EC5A6961485368147A38F52BEA70089244EE06DA2A814F0478299AE34896089EE6A7A2701512443E492E9FCFDE204B45965CCE878355E23A670779B140DEB556DBAC7448CAE69A90BF2359F8D6A8023233BFF39C195B16754CD1A43567B449742E643F16BADD4907922F9C7E3B333AE55F2B28D3FF896E83AD412ACE77AA18D76A50FFD417BBF2F5CAB1E23AE417E855F697E4937E988C0040DEA224BF0F99D3521252A4F8EA00F1311ADF4A61706610BB2A84D761A294806B03DE026096681A0D249BFFF4226F1CEE5164C3D54180E7123D2069663505014B0B445CC0ABF27AB73209E89A1FDE1BFC0229A6D2E9FCD9562B7BDC5D4E63A7955EA8CC5BB8FC0C2AA23E1D576269E4CC0696DF1A404BB9E6821BF0B541E1BC2EB643691EE390E662A8A8AF177DA61720336183CFE8B5963EFFBFB97CF9A12DF2B6FE59A613E693D25A672FFE633575D5A2E5B6F97C122D7E1823A299DC87956C0CC6E35F055BA9F08916E163D3D0609EF7225C9C507B8C3021A6FEDE3E48DF94B21E235A38A6A506C9436EB83B19B33EAD5649012CC3EB866493965E55B09024910DF0E45962E46C33DBFC7E1F7B854BB30197BEBE2956108F67243D52DAAEDF84AA65AF71373B8BFE221C70EF833ED27B2CAA2FA744B322A4AA7EDC1854ECB932BC4008A284F4C06EB87592068123E6A137F4D5FC216DE6B17C5C6F9819928C9ACB9E9054B101C320DF769B12D9ED4E0D1579781B91F9C97D2D55C34CF4309C33E26D7D616A3B52E3D3C59938BCF11F6BCD70FB420A6590A4BE120630ECD6C2368BCFD7632B522854947C0251ED4906BA4BDA3292019F1730A17003802A43562469E6EAA1C23E41CF88D2FE7AE803E4FBE44968EEBD1B714E25DA525349E941EB7B651AA391596E47AD9F3E298D1A748348FB6A322716DF3A027050501E5ADFAF41FCAC0D5F22AC5360A049F3638B0C90FF249FF1A6A1208BAA375DD19E79A6DCFC33BD9920D854C8EB12AD4C8806E3DE032A3751F005F59377D51D5E70012D318D553AF10162674DDCB19F11C1A9C07DFB948C700EC50F87802A9A18C8FCD5239CA762350CF436AC84CF467003035638D9D8B9B145F2D7F35BEE3BD00C59D6119B634111E1896DE86F5FBF359E9C86BACD73F9F432ABBBA @@ -55,6 +69,8 @@ ss = 71156980B8970FED7F2213594630CA825EA8EADE58CC8225DF8111460412B762 count = 7 seed = AEFB28FDD34E0AB403A703B535296E3A545CA479C1D8148E2D501B3C8DD8B1034BD986F13F1A7B4671BE769359FD2AAB +generateEntropy = d86634ecf96cc2603761e284c0e36734cedec64e7ff486469e38539c71141c5a99daf37400cfe59841afc412ec97f2929dc84a6f3c36f378ee84ce3e46cd1209 +encapEntropyPreHash = be8a32f97b9a8d596382c02fa2a0eeebc15c083e970ddaa4f2622b91d6718663 pk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sk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ct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ss = EFF5E4CE44FE0D0B77CF8109D46C8A888399D1608AD9E2248181BD205A0B23D9 count = 8 seed = CBE5161E8DE02DDA7DE204AEB0FBB4CA81344BA8C30FE357A4664E5D2988A03B64184D7DC69F8D367550E5FEA0876D41 +generateEntropy = 0610678ff4dc3128e1619f915dc192c220f8fad94da1943b90aaec401683a492da1804ddb5aa9b1c6a47a98f8505a49bae2affde5fe75e69e828e546a6771004 +encapEntropyPreHash = da2cfaf69e25b2a89ff2557bbb6f69e01d8e2e7bb27a7a1ce7e40fead16f33b2 pk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sk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ct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ss = 25C35F5858D03291C0132C970E6E072D8A7B33419B984B391A12891F878D981F count = 9 seed = B4663A7A9883386A2AE4CBD93787E247BF26087E3826D1B8DBEB679E49C0BB286E114F0E9F42F61F63DEC42B4F974846 +generateEntropy = d322d56d8ef067ba1f24c92492b9c56df3a6ef54a304adc1b69913766a1ce69756047447b810cc094d400ab204cf9ae71e3afa68b88586ecb6498c68ac0e51b9 +encapEntropyPreHash = 511c2ab40782322c06111e144e505328c4e5bfc890a5980a2bbc44aeda4c738b pk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sk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ct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ss = F9EB1C87813C712CC3054109ACB5F219FC1E29DB10FF33D093A5CD67DF995015 count = 10 seed = 980D0BA7C8F8B23D0E948A6029FF2659810EA1360064663A8994D0333C8543EE5FF5D6D5C9ACF446E61DC464F792B9D3 +generateEntropy = 2f1d8a3bebb34540324b9485fdf3d5be3b858f544abc3fc641b5728cafab03ba8d6c42e7270ee2b77b6045385f3d175984a0e260363166c73b0c70c971644363 +encapEntropyPreHash = dca92dbec9b260dd97e8886f876862d6effc3b91fcf3fbc986cf56ab93ae79a2 pk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sk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ct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ss = A2B1D4028AF3777BE109A51FAB5B7014681B0BE94A7C06E8C2100565667F21A7 count = 11 seed = 6C029462CA42ED520F10A579F52687101105E0B90C6E7BFA582A4C112B579D5AD0A0ABD38F72ABCFDCAAF5893A112BDC +generateEntropy = 31beda3462627f601cbc56f3ddf4424e1529c04737ef0ef2af6d7401f653b8a1812083bfa3b670e3eaf9b443702fb6db16ac1197656bbd61a8e25ed523b8d1e5 +encapEntropyPreHash = 57c170e691d7a914a901b9a11c62b8b569b3806427557a9dbac9faa720ec3641 pk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sk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ct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ss = 4A2BAC4D2A30597AA5B528D0E20B1630B20A36E8D747B5EC41EEB57950375A5D count = 12 seed = DB00120937570D62331F4C3F19A10465231EFF46465CDEE336A0D46AA1E7493DF80F18617F9FFD0476CF7784A403EF4F +generateEntropy = cbdff028766d558af4466ef14043a1a9cf765f7748c63cc09dceb59ab39a4e4d8e9a30597e4b52ffa87a54b83c91d12a5e9c2cd90fcac2c11b3a348240411a4c +encapEntropyPreHash = 6b5a14e1473abf5a33d44975ca2088bd8fa6fddcb3f80e8fd5c45b9d90c24a5c pk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sk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ct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ss = E09C8D7E5D104C0A42B47F031EFE22A79BA1008EFDFB80FFC7532F40FC9B3A94 count = 13 seed = BD26C0B9A33E3B9B4C5D7EA32D5BD1FC371015BE163C86F584E49BFD5362C8D8341161CD1308115B2A03B7E5EADDD418 +generateEntropy = 4c04310bea66305c6ca8ba6b8f61ca96257a67663afc11761f13fb5c7b324b6b8aec87a9a79204cee2986867a2906eb851b734b8b22b91d6749b1a5f07c44e3b +encapEntropyPreHash = 40e593754e6eddb7f9cf176ba2d5fd1087c90ad377556d0b0f686537b1a3165e pk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sk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ct = 9DC66C77C56800C40A5E71DC3CF139A83AC4308527DF4ADFBD930307EF72D020AEE3E44C3D548C67CAD24E04C21FDCFB69EF121985A565CC897A06CD2C7F4CDD767A5FF8F9353FFAED3363CF5F315ED386AF41BB5A3B0E395DBF12DD24FDAD29FBCD6056FBBC6D354739710EF74B1F4F7C212785F1451D3FA18443EA1F8E4357B7D0368C086C395B4FE548240F7F085DB4A361490412D034363F3514ACDA224E4F72FD7AC410FEC9D7E194FC9F074E8435D4A2049F9FA8663773D1087AC0721AF6665C1057AF23C2B5F3C478F16DAF711BFD0FA253DC1185F008FB8604568EE21C8B93CD1C0BE2CF4D7869C9DFBB94F4B7A1C038F834EF1B45144E8C1C4F3A7587CC0F9BFE3C6A2CF22AE9B835EE38B6D6CF89AB32316D307DE771DF9444B6B23E7054182CCF799CA0D0D0D3034DF22AB6FC27C507782E8196CEA3550A76B3246DDD1B9EB68AA110955C3F3FE19EF762CE5EBDA48A0B59DCE90550293AA4D550CBE5AC94E5FD79901D11B7C5BB261C598CF0C49AEEF25ED8ADB9042791B7377035C41638BB4D06551D80472D159A33854BCFA31555D95506466D118E6B2051E900EB7BA9B6DF3CB9E7D51BA93271DF965F274C4370266F8D0E1EE346D046250486173F96FFE819C231AE3E08EA12BDB2EE3B47434E6F68E19DF6043465D145AB978860DB6918995DC8E995069773ABB5F033EBC58DE26E6C4214177F1CEAAD65FF523FEED2761BDA7ACBA7340077FC0CDE9A938D3B333333FD32B9618459A180D55A34892E6B569810ACE45421980D9A1A2489BADC1E617F4E5A8B3B628DB737AB8668BF047598FC79FC74DD21FC783DF41833E033688CF3915F8328D557C1F482FC78EDE767EC705EE6767D25691DFAEF3A1EF7D076480CA1621888C6282FFD037FFA0128769A30530D92EB7FF4C4E1C86C0D5EA911C7AA2F2B37F1019B061CD6D6BF0F70E76E8139131EE149AA4197D2F2F284CAE33B96B5FE8C5F846D277C59F04DABA036DA670B821A4E5FB0532D0FE03F90AB8E223F06EE5FE9D982047DEEBFB69A02B145E703DC60AB95918971CA3A25DF7C32DCCEA0019F19D83E245F532F5207F8ED19D9A2F7F94F22FA60B1FB666DC21CCDEF046215C50095301D2902FC0D4882908A16B810FB44409B9A23D8228D7CCD0D510051256E4879395FAABECC95542C07E8A07458FCE35D1D882606B41794BC69481E22C53F7BAE8B5BF6492BA14AC16F8E80918360C3C7BE0F2E6985A2C32CDFD36EEEA99B2C5C140CD56E1AC51ACA07DFB53D58D8DB395A28057AB62EB16DE9DA139DA54D4934DD7E5E0997F35FA77FCF0E9C6387E854DE1D9DF06950FE039719B5F278FAB8BB81882EDAD67369D0D0FB1ED57BF36B00D961D87BDE080787729753A9ECF0A48F5B92A369FD71F8347E97170CD0F0A9CED646A120F73A414D6CB8217583BE56255628CBBB91F088C2CA1B1C0E0A302D573CE50D13F22D76AD4DD03908B9A84F4EDC74A234C16CD210E4A7D4880F96A43AC6C003D011CAA39CE78EFB2F8731FDEF17B6B4 @@ -104,6 +132,8 @@ ss = 1F8D087B541B57A9D85F0737C39E73FDE01DB5BBE539834D8F918426A57DF9E5 count = 14 seed = E2819EF86853BCA1B9DEE7EE1C1619988964F9A913E635AACF0D96CA6E0300D084329DABD8F149E24176D22757404260 +generateEntropy = 38a0d5f41d7dc1896efd1b45b0485634cef149828751b96087a0a6dd81b4d58aa2acf359556df4a2abaeb9dcee945829beb71185b4d6bd18b76e5668f253383a +encapEntropyPreHash = c152523abd8248bed40c3827bcf0f8e8127037a55c780695e2c28ea3e041a44c pk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sk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ct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ss = 0DA3B9B56FA25F4CA356D3206B99AC83FE84A09CF7FD55A33268C122A8FB51AB count = 15 seed = 669C4EF8A051CE201DA65FC4BC34D398EC1F806276FC5D987AD71D93BC12DC8F107B58BE6E8422A0795C88CB9A0E7488 +generateEntropy = 97b5665676e59e3538ebadaa8cd50df1f9fda1502d9894c616a946078e56b621df05318b5f655efe36f1b678cf4b875108a18db2fa312261caf839f84bd956c5 +encapEntropyPreHash = ad6466dd59f26b762fb02b19eedf5f79964da68bce0459b91c3a6ee5a7e01183 pk = 8452A77401C4E343BDCBDC985B70189EA976E3D65C47649593C9CFC112A4292238302253118CAB8EC52060305392E6A131F0445A0BB4E11A1A8D7465E704B3134C3807D9BE9F8B2ABD57A00758685392592FA0B01E116410706A669A0EC5ACB524D1561A265E307C24068B12897568490458121C572C2CC43B2464F2703212641202A40B27A41FAFC4B24BEA9F26711F28B1050645A38757708AD607FF6763F14C15A2CAADFC2BC4D23C576E5CAE6A20B10CC9CF610A5931AB4C59ECBE67EA079BC3911A96B24B86A0D6B99CF85AA44094B0F6C55924776C4E1BC9CFC88A127B8195145DA3515288F933DA602F1A2747A6856657B2102774BC1946163B534D02A1CE2E641CD9FC7F7D48B6F643AB53045BC690A249433553845B34A5953C873C1C686C83BA46ACEC4E91046F9E7590196C9C24A747C6D986B4B414C223A52A6C88475405232C78AB3AAE8861A45A817EBB16C3A3070B8E842527E965013244FE50907BAC3883122393340B1E06728FA0400791B1DC3BA103C8AADB6CB0328B5EFBC85694164D0934C207B63614CCA28ECA71E5F63A58604599EB6D1D248A37EBCB17335713C4C9A0500FBF893DF475CF7C19792FD56FE0A7505DE0158F34603E0071B2AA0BDC8A12376A1313F571D33686D505660C4BACE8EA40820918E05BC15B381B90D9B31BF52E1B18C422C3935D04140170542829CDCFC883BC344606E75A2EE7AF469C5A81DAA1071771FFF275F2358472B409B1EC31EC887FD6E76CEEC6812D40BA4469B3EEB028A0A6875A19B7ACA51465CC3FE78566A3EB1B98C621EB3BBDA4E7BEB5F2344B64013EC233FB5714BC68B767DA8B60A6B0FFC8565369C19877C16D7C70F17B85F7A228D28A5936968915D026CF683C762714830C1742AB4DFF789F1F43782622A070A4AB52633EFC52693B695DAB939BC24944733905AE86801C4577324C625159B141C5A1014A6E458B71A959001839C461E17A3AC46DA47AB687D2342FF63B83D3331510C98AC484F44B7FB6A31F6926CF047982C400008BB3B0D1EBBA3CB2345613680531B0708A64B937C88B2985C01A10EEA22FE5022912F9AD2BC667CEA16B0A091F3FA9BBB9B8C30160717B21CEF9D74458241BEEDC215D44900CF40709F6671F221D39C804EB6756C812364DF0503355B8B01102574AC3F07234BBB1B658EA822D52A452545DA3544C041C3A3F89BA30005A992B432178BFBA078686A07971601F8B12C22B23B69C05A89ADC2469287F052A6D4F58798E10A464DB4AA71AB30A94854D1B8C16893B432A8DC2859C66A168C8C5AD4D04559056C4588B0A8755013E378545B47EFBE90CA97552C9B8711D3281CC7B9057F78A68A59D5AA642D1E9233DE093DF5705D8639D702097F0DBC98451A46905AE72D876E1243546590599FC5923B37B4CF0A3F7CB47DFE8AF00F6A999127A256681A5705BF5100D7096713C49149C7C561C0783E048CC3444776BF8997671970535C2CAC5360C9B53E0D952AF348A28E4826DB9810F07110A48771C2C9B21DA3CA719C7A5407B92020AAA0180B4D6B3AE42A1C09CA38FA59D1ED02A3A0079F2E922D0B36D9795C1FA42354CA51DDC11A315515A45BC7E1E21BCD3287E18BB0AC3F8119A88D1FBCE1D3419BEF67B6694D9FA1BB309CC61C819176964DC sk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ct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ss = 806390146332DAF2AC2CE5499D2ABEC128137CF7DB02C27FB457663C18A0D7B0 count = 16 seed = 9DEBCCFE818F6B5204DB4EA09C03EC9A19DCF1629C1527685B8A29776BB1DAAEC45F8ABF8F0ADC9A8C8BD6E2DF6D8048 +generateEntropy = ef99224a03a85a46ef115474ec5b5d620da6795d6efcca4c9135d19958a9de62df7d92dda83e6b2ef4cce08c9134563063068a196d7b1a1a13623e48ae12528e +encapEntropyPreHash = 1a4d5dff5847cfb48333e33bb00ca7301b144aa89dcd412ff5a3b1081d775b7f pk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sk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ct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ss = 5C32A0ECC8FD7E70C1B389FE25C91899C37CE4CE672E299A41C7732F4F0D03B2 count = 17 seed = 8098AE7A92C10F707D405F7DEA02C2EFBEF44EFA132BA8AEFE81BD45E543ECEC74F10920AE48A40B0653D63532517F2A +generateEntropy = b12f6fd965ea9c5b947db80fc60c83d5e232dca82e7263027c19bd62e5a6ff550f6aa3e88f7fa8a96067f8cdaeceeac90c2d0b5e277e56e9c405ec9420c30252 +encapEntropyPreHash = 34f44ec2092eeaf686f2ea170591a98527cbb03a4fa9477a7aef6b41a54feeb2 pk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sk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ct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ss = 4FC71B4D0A7CD5D80824E137B93F8356AEDA6A13A55C0515AA74EEF21447CACA count = 18 seed = D5F23808871544E9C1D6EACE2028362B48E225312F77663E9F78CAFEB512B908CD9E25875D61A16EC615F4B8FF826856 +generateEntropy = 9f52af92ca165fdc38788f2b59ba02e01c8281ff7c1e60504688043a5fe814b04f3029e1be4e1c0258c3a22ff5b50b2674cc094ba7018da2a61569845c17d26f +encapEntropyPreHash = 6250c81126572eec2da330271db36ee591f060fc7e53eeefe2e1c476c675fa33 pk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sk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ct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ss = 5A864018C4C8C17C01C5EF38D7154668D9099994D92ED2EF55F02CF6B3623FD1 count = 19 seed = 822CB47BE2266E182F34546924D753A5E3369011047E6950B00BC392F8FEC19EA87C26D8021D377DF86DC76C24C5F827 +generateEntropy = 851ea90fd3854cbf28fe39fb81f68e4b14345cf0d6eee7ec4ce772513df8410d1c0ec046899a777655233e4e1b5ca44e9afbdc67964bfd5d5e3dbb45e60d03cf +encapEntropyPreHash = 35d470bcc5880872754810dfb3f2796da2fd7f397537146f6488c27804072b34 pk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sk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ct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ss = C8B9932975C3EF329424392DA29B103F367FFF38CF402B40A0299BCD2CF10FCA count = 20 seed = 81401DB81138D6874E91B7C11D59596E4ACE543F5A3471B6FB00999221765FEC3CA057ABE20F03B2D59003375FD71FE8 +generateEntropy = d304c9389cc973477f169788abcb9d511f843219d246a9b587822f422a70c2386590a2e5c7ed86cf2c5c2a898662bc9a81418720bbb632ef9cf0b845ed052d73 +encapEntropyPreHash = 8d667921c5db401a86fe1c35dfcf164a6bb2ab7400fd6a0b67eafd4a0ed11940 pk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sk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ct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ss = 578E4E308F2B426A7B1ED7D80C72396A914CE77A4A7A6D16B26E4AF3D59B491B count = 21 seed = 30B5DE5B73681EC08AAA03F6F2D2169525D25F4042A5E3695A20A52CA54927B85F8BB948FC21DF7DEFC3910B28674994 +generateEntropy = 89a6e3be304a3518fb82b18ca730f0b359cd6ba90664a493fb4f8edaf965b9c3b6591121e25d64010c25a18676033e1d7278ac5f2d0b43a31f3a4156ae710465 +encapEntropyPreHash = ec750b3939385a3f8df868119dc76f77ca845567ef068de6ada5478a56bc78b6 pk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sk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ct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ss = 70080E3BAAB3FA55E8A308E84FE9ABAE780BE8C09E211651F6EBF6053F8F264E count = 22 seed = E335DF8FC0D890588C3E305AC92C7160FF199E07C85760A828933750E3FED8C83B0DBE802234481ECF890A32D7A2884F +generateEntropy = d569b935ce015c85f792f8f7fb0d83c4f53b492959361dd4f75fb764d656450176eae84d11c4528382828f7a689a0d5cff87b8ca0bba97feacb39b935a8788cb +encapEntropyPreHash = 74f1d52af09b12c36eb062ea7528550cb4c18a3ce8e4f4ea9fac43ae383bc925 pk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sk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ct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ss = F804333E26C5981EB749E8E9FECBE8F8886E493CF8013A6760A1BF5D4A37200E count = 23 seed = FBEA1BC2C379F4F8FDCB0DE260D31CDB064C9EA9B1D6DFBE91B3692ADD1D34DEC9C9FFAE7BF5E72ED2743BA3F9F2E43D +generateEntropy = 5cbb141c2763425c274f7404fe530d9116e08c33f9f200a20b011cf563a28990fc9ebbe336dc464489861db8253606971bd0a9008a433ed17752d04023781552 +encapEntropyPreHash = 4b3a70d85f640d1a2a852fb6fe96704af56a7415a8ee4282e9207bc3a2dc116a pk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sk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ct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ss = EB9B44605E6B8FF3A59E567C1C16C6F96B6079F8E2C4D70F706D30DF82F09902 count = 24 seed = 7E87FB886BC3C7C9FC12569F465D2ECD12532E76CC27C65644C8D3DD603B0CB2D036C5974E675058F271D5C82AD7A813 +generateEntropy = 293abb6d1c207927945417cf84883ef010823e11b487ed55239e466e83696d0cff8563038aad865a817cab9ce98846ba75be9363718ecf5fea538aea90b2a558 +encapEntropyPreHash = 26e38ac804fb5b4d59ddf747715e7e6041d875f99c7b638024b4af82d622da60 pk = 04A592C364AACB2C89689106ABA29029C58DDF7050A2C78787358571AA506570288E747A4204C43E8C6020AA3E2D77B36C3440A618C55F3CAE6D43B979786E6A181D4107CB723BB6D0729CE3EB98E7A979CAEA9508563D5A0B7A7BA55B8985B71F3C489B370D37A66CE048A9DD27AD17B38C66880491985B2AF8916C547E9C6CB16B506170F29304C4393E8274EE254A3F13C6B0E31105442BF92799F21774BE9A0F64970E6AB581626115A1AA3EE4DA7936504D036B75BE6046E5778F58CABA93F8640BDB24982C17BA3445F2AB983B685644B596EF66ACF739039AD0A3CD61BB80B000F7E8BF53F60EBE235C0BF22C7873AECC6B3AE2F3B2CC3BB47D1B88423A188393C43C4999C32A886807CC4262BCD5A588C5E1BF8ED6A6EA9910C19A6042679926F314E7C7C85BF550482735E7FA088C857AC1578560A1A2F7E831223CBDE33A46632B7E24D400A82A8C7307C23D6CA25075B58E727673D7CB5554042CFB9B7F95B11A55A9FD63B1B9F0B60F6931A0BA1AD28B485753446B0005E8710D7189BF438407B8BA36A1687A48E550FA37CF4C6B591AFCB0AF6B8D2EA5A97B6C1729E7AE22E28F2082A5E653B5BABB0D147A8748F2606DDCC7847C24F0D32771B910CCBA85BEFCBD2B89C5035B2062E6B9BB40828902B82E12B752D48D52B7A6599AC014731E8DA091CB30186C849B61954DFF867899E5BF27428229376AC7D97FA03996160964ABE56D3D0278F9F91FEC6BC821FC822949AD5EC8A9D728B95B19052AD9442FA0527B3935F4697CFA3C7413CA2E81B32A57F69479E89760A46D710032EFBB662F9467F0D03C806B619B9228135076FA235D502230E56669E2354C1B412ECFD01A429B5C76B17AE2AB99C73B4110957AA38C22C8FA39C00261C78AA571B953D868690761655FF700803A477917AC8A6105CBFC220A30A0CC1466D7598B2058B3899C567A71A66D5C9DA75085686AA4AD4015100360C6102C84C336C13B229FF599DEE4CB2C90A1516682330722DA110F42F7C0A4F23A2089ADD65438DC66246671BE41E7766641B4C9139777E08CB4D5B953E602931A7DB3E1CE70D765516242AE8987454B898F19C5103BAD39207BB16771B5D4191ABBBDCA9B5BEA711081CA6521149B60975E02CC2250A355897960A8E203BA148F8BE76452420D2134B607976F7809CE97597D8CA57337FBBD6748C03227607FA082195B49753C43047B95A020C7D195B01DD3CDDC4C091916C37E447ACB606F2D232C37C9871831C1FB9A8D00717762F18E62E7995A7393E0A82617DA4674078D8F10065A28649E53377A88BB0F996D84FC83E9496564344D65B73AB96C4E887107D6C14488E604DFA15E55004FDA8B65AE19006EA7C8A7471B354A4E746703D5C79857A02EC222B78B966ECF161D97BA7CF39B37FE173485A0156C3712A6ECB14E629899DA9163709B672A243D1B87E15C0AD611419D85522252BB5A02AB725CB5EAEA5BDA73976D534A881B8C32C5328D117306FC5217AAB89CF51C6174489AD241D1CB261D449F24A235FCD46FC19A8D14A4281906236738A060061A494947BD91604431B1A2871080616EE2E915863B2BF2D9CD86743B0CC12A5D21C6C745B34247C17F9447579FCB9BD38AF3B64CC94782E299E1D98E68F8BCEFA20D1E8DB8552516 sk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ct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ss = 5635FED1A43168075134D0E6DD4C9CFF6E85F3860B3E9F1CAC06B249D62892DE count = 25 seed = AD1424E804F306C7FF513DA4C1E8D445AFCA7BC942FAC5C0B335733AAF70693712ECBDE26EA726EE0F9FD9D52A83B1A4 +generateEntropy = 74d87c7556f2671f2d666854a4d6e073e69f35421e6e1a428cccea49c37f972ce1fb7456ac0aa1b97068f452cba64ebdc138bcf5d36b0a0fada2a3b374141eb9 +encapEntropyPreHash = a319d2b8f114f1acd866478bcdeba6fd164dc4e37b0adfa8d8034afb3e197376 pk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sk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ct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ss = A920DF59AB127D563D7E7E96AFE8075D8A7242B0AD88D72F367545FAC6DAA4C5 count = 26 seed = 7C33CA0E987226C8524DD56C811FA4D1CCF9995B1E4E4DD5B1481974E88CFABFBF6787775C2611CEFB27ED4403EA9B46 +generateEntropy = 013bab0212d04ecd54b478daf72748003a25e2cb060ba6cc50bf95c292b8206b9da0c5da5f195b80fbb99c2e8b06926074f3f604b3f6195b5a5b9737876bba72 +encapEntropyPreHash = ff646071b2509e6b75790917e08e4f0b0d9f0116ec6291c0b59eaa4b583ad830 pk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sk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ct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ss = 462F8AE0143A9173E7FB5A0B476ADAC03F2600FFF5779CC1DF9DCAD9B1E7AB84 count = 27 seed = 54770EA1252EA2857D6635151194F5F520ADEA8A41E409FF498D40C271359858FE2B084D5B96BEE087B8E8F4DD4E00C5 +generateEntropy = ccb073c4b90be0ad746e26fb093b60c70110bd1dcbcddb566a8cffb7b3caf80e71600a8982c350df524cde514431ded7aec23576530894bcbf0ec0bfef0bb64f +encapEntropyPreHash = 0584270ec26f3b9818e4af074d17b2d51037cc8dfdcbe3b140fa4fed5deebc54 pk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sk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ct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ss = BAD63432A274BEC85E9C361191A3431D6F211F1FCC69173B9FB00C0517AC3B3C count = 28 seed = CD6CFE94E9C0A1CC4FFDCD2D7876504BE5F50F1D1CA5CF93482943465B268276056F2781F4DE805C138976CA72621387 +generateEntropy = 2e889f44e28901e9ac7ca6b2fffcb124c8979401b17064d7e1d51a7e3c3adbfa0e145e44aae52cfc609e6f47fd7a6f6af877190ff52256d0ac5b05b89c3f449f +encapEntropyPreHash = 51e05c7b4ca3079781e8293f4eccebeeb2f8c8b4c59468eddb62a21bcb4ab8a3 pk = A9C823EFC5C946DAB44B5B2068D61F00E7B0D87CA67706343927BFE4C12D20D69C4A5BA892F97EEEAB7B5A45742CC4AC4D37219AD72AC312051D31B8385CA2293415A13BB8983B8457B8AF9DCCA9E6322094CA68399AB77DBB9F6AA7CED5F224641C3FA07507DA9A08E0D180D52585DFB3B2FC95CDC733A573A888D403CBBB71C120BAAE2A195278370BF33299B9B2684ACCC5288A3CBA1277FD3999839A6ED29BB91D71A528BB2E4F953778BA23341CBA4B9B3C17F9A8366212AF3B722397419E24874B163470B3B2B7F24AE62258983B6161C6773B5AC90969C03D01CF4669B9D1F46E05705D4F676D464264D7549E1E2C3290C9B2BF5A71132057531714BEDBC7A91BC0AD56254D298908D33D588951333B3CB7924ABF14B0D70652C45AA62CC3062D851E45C866C6200DF4E74A9E559B9E6AB738F2B0DA9693CCEC3D968A866F0220CA95B7C6E8B04EC41D39C17EAFAB77444AAD4CA3A9D6B5B5D4611A6C074FDFB01F7DF68AD2440EFC5588F3B4A5C4106EFA3B9B6BB35C327465C7B656D1C1C6409993FD91CC20172E53190DAD63CE02691AC326904CBB6424C906BD091312C1BFE6969BA6AABEF954B5C8D439DA5064A248C92988961FD2254479946DEC829C76CBA61690E3C541648228B59805D7FB2ADB6AABA70718985279452A2FB1414E4704AC3DC84D3EB767101C8F4FEB24BC8148316609BF963AFA826A9B87638424052067CE8FB393D9AC579AB1080D1C549FD5103312A1FF9988DFE7805ED906FE9228E25942D49484A4510E0FF9A4A54A22CBA6BE945126EBE461C5940A74E1517C60603B2651E8371973DA7051EB7197713F5583BA51B92A9EB3179B45A8A8A5099B40C29F59146F25A563291364F236038C79B784BF09524FC6810F91B777BAE252E5B723E8059C06157653E335549784A15553FF9A7A29407D87725AA6B7A2A2669CC776BB810672967CB5B8B9A9BA751A9E69A8DDF796B1F324348712FF0C23F49A1DEBF210C027995B8A7CC5B288C4C74218E5086112237128CC57F4BFEDDC21ED23BAD00C58D835B5A3F0C8FDF1001E0AB26C2CAD47D5CAF2252CAFD3520E36AE21119E56FB456F277132059CA18623BFD994878C794545BA4A04436D804231F430B12808FB01647FA15D94B975BB6798AB7C3F6355B9BD50BC1CA00EE76342C8609BE0BC893DEB398B65A453BA08BEF83B805B61945229D98422F59C27E86022DA5620D737867828540C20B097076BC6C03E5435AEE1B9AF19958A7DFB921DA414280429DA389EEFE23FC9578B714B4F2E5B19B792903FF45ACA045BEC0B3D83C204747A2E24971B440C10119941D9316F45A87C4AB2AC0F7C4BDE9BC8EF73A7F42513BE3420C56720DDB984CB173587462AED9996D2A848D11344EAC02351E6C5A18CC7AE813BFDC50D5B143F4D07AC72A213A0577F9802043A585D95031D017B319358A24B06B7C2EA19F22B6634146CC0A123A8051C51E6AD6A956B1A935FFE00BC65C44A60534D1375570BC036EDFBCE66255F523BB377B2256C29B870DA2C870868299828F6FBBD8E0A109386B8D743A6E7A38384D5933E64565A037B9F520ECF8466F2073EEAF03D1B606F947CA2D2CA49E4B41DE9011FFBD23920C0D2D0CB20E3A9C63BFF3E047504A8965639E8FD0DB690FFA1E791FD sk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ct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ss = 50CD9D6042E7708F347B3D187430D070F0D8712E0BF68350AB47F4B50F04962E count = 29 seed = 265EB2DE7099E4BD5614E5DE7F0C2A05C78EF3E8E2DD4AE4CB70F3E5E59C8D1D88248303F07DE0C5508652DA66B47222 +generateEntropy = 174aaa36410566dc15a5e62874218d7abdde0b2c0f30d877bb80b1abd5f5a0a450a7a2354f7e5cefa6f4a4e9a1c411eb9364506e9e1204a8acb3cb77fbd2c4ed +encapEntropyPreHash = 9eca0fe36c80fc5eba171c3ae66a5b1c923faa50b4521bb055e7bf51005c93df pk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sk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ct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ss = 2E610015C6B440280D6F28D5E3CED35CBF65A70A171151363C4CC882D7899E0E count = 30 seed = 806BBD111F27C2668318387BD0830F65EC21A51AF01985EF48D03D64E1958FF7EE5133A4EBF6DBF36329BCAAF65F40EA +generateEntropy = 351fe4313e2da7fac83d509f3103caf7b4c64a4d458fefdf636785ac361a1390f072d9b5a99f9c7a0a011e4dc10f6b600d611f40bba75071e7bee61d23fd5eda +encapEntropyPreHash = 0c5719261caab51ae66b8c32e21c34e6d86ee4aa127d1b0195663c066497b2e9 pk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sk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ct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ss = 91961EFE34B53285433FA9F780A04B8E47261E7A6EF77D46658E7671D800E2F2 count = 31 seed = AD540A9CE816D6FB1661E5483C44F6FDD00C9E7BD1A8CEDA4B4C4D3697D4F78ED0A56954996CCB7DA96ECB8F5CB15809 +generateEntropy = 9bc5315580207c6c16dcf3a30c48daf278de12e8c27df6733e62f799068ad23d5a4d0a8a41c4f666854e9b13673071ceb2fd61def9a850c211e7c50071b1ddad +encapEntropyPreHash = 0e59f6f9047c784c1f00b24454aa4f1bd32c92ae7e626549972f86fab90e7e89 pk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sk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ct = CC162C96F45C1BFE20D4EC4930FA6BABCC176B7B28948F6B3723F9A652AED6B8814C7C2F2BF11BE0321AE217EF12836547C0DA7CA4E7881AFA5C13B089F00249746D4EF05731B7F0A9189F6D092D267F88BD6064B820C0A995D27EFEC31FEDEFFA29BD61E16F35564627B8C07FD5100CF4512AF33689E215D92635278ED6E6135E14ACB1C167C8C3E4B843F4DBF0549468FB047C837125E8E80D453E39C44FF524119149C55AA31C7CACB5088EEFE93B7D493809A85330A67AE11F188EED63821340FAB8A7E9321F53FA389635E800BA2F6209D36F79EB7099F43B98B484730E95B58CEF65DC8A751FF3CC07B7644C99C243F6A3F314B239233E458A2BCBB6FA612B764EB5051A8DF7343267A7FDEE9EAC48E9577AC389B7ADF2653791184B69942B6191918BB3D6F88B80E208261C8D393002979026E954559634DAA1700FB328327DAAE0FDB1097837E91263AF9EC3C1864B509D98E039B666C875BD5CD390B7219ABB32ADB52EA6C3FD81C52F1A31A3A77366F7A44EBC666F912FBC898EC79B7FE554753B7EA41E0EB5EA366A329CEBB3EEBD449639EB8E2ADE3E5E92C44A587CBCA397077A4B756EA4FD425E2B780CBB3C8104D5CC5DFFC7A38318506BB8993979E0F00897F5F3319526F049470A37C9BCF52B0426332B9717D6336B4E277C363186D1A8F58B6107E382C77B5E25141EB6F5DAF19DCFA95676D2037524772E804D3BEB87E75FFF624CA9F5BB6098E3239BCEC265A88D2D7870560888CDB6805E68177489C21C8B3A2FF9949764F1A8D9D80F91F27C180245A7046717917650FD6F550296D8655F4E546E0780036FD90652C02786910F230A5E2C6467E6EC1687FB6AAC12C06451FAF6B7B2AB3C8C0C1885451E04FD54E05956D2174099E5F691D690A48BF5DE1E67BB5D84288415E429184ADCE1DD7B00EB94C33ABF63F5AE80AF202E772EAA576CD65E65B63ECB1F98FCD96DA6C58D4985021A1EB5A953AA105C73CF9391AD3633919BA794A26F2052878E4607D4489AC7E084009A582731990E8CC087A459470042ACC5BF481DEEFF132C86615A5FB41E47C8D7D18C8CE3A478EF621F965099A1554597BC32FB119367C25DC0373739B8E228DBE85F688B005C9CE688E12142D51D4D06DAC00690C1076702D8BBDF608127F7745BBCCEEDA28CF9A067CF6235742A230506C5DD4B9FB38CB9EFFDB2E97C07316131F7A47FAB847EC5BC93C88275DCE4F1781590043208A838884778A58EC5296C1935DB4F8F32F11C209A697B40726293D18AA908D4D7BFC8C4258F4535295708DC80DAA68ADABED79FC459956E1A7BC277789FA94DFB5CB69EADCA03A0B9C0A21BD5A7DE051FF255D6DF229F306E75A8095A2A511DC372EF601AE9D8A4575A4043380ADDAFD25AC1D044A73722C0255974939D9FFC2B2658C5FFD7F1E7E0F33AC809A1B1648527AB57EE858109D30FD29356D74C79087CBD2FC436DB8DE5179483CF4CCF6511C2CB58FA7C5431C25D1EF9CE8C75891449D738BAF2457E1F8753485E38 @@ -230,6 +294,8 @@ ss = E4983D6021D6C10E71F474D76650F7B5E23E02805F755F57A1012882DAA77ABE count = 32 seed = 288A5F2684D862A86D2790AFDDDDBAC6FDA934EE7D2E6DA1508BB550838609E8107312B28E00A6C01706374CCD3AEFA7 +generateEntropy = d8b907b34d152ff8603b73051f772daa71eb902c47b7e2f070508269d757e02e36b817736cbc5f7b1dd6eef5fe6332fb1a598f3871e5470d440fd2ea631da28a +encapEntropyPreHash = a3963ade17d69debbc358dda82c7bebe2c39d25b36813058e7a161542e3f8c2b pk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sk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ct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ss = 807703887AD9601806D0BFD5F9D9B6CB01BEE01F82500F525CF4CCA6E4B21FD6 count = 33 seed = 4635DC5BB92EF98CDB6220DF0DD717C7F8158375EAA2B78FC3F0B58E9C9653E92684CAD3461D9158A481DA3D14694C44 +generateEntropy = 684a29e4e5480a5f2533e1526b5fac8cdf5927f3d85087c71f928c59690eb56575d12195ec32a8686d0600e45d4a7f54219b0d7a3826d193a51b9156ecf2edd6 +encapEntropyPreHash = 97beafabf2c8575586487c7a80e8af5fc50f94b6051c1bc66a5ae9f66be3cea7 pk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sk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ct = F145A8D9CE4F94ED02E2693AA6A5458962997E212A3DCC11C56BAF8DE75A68F67C69EBD87B212596C90201BEEAB5E2A0DD8FB0F9C3308EA0B0797A6921E7B7A036047A78F254ED699393FFC4B904EA2E00C7CE3D149BCA5D763C2CCDDD386EFA74DE0D1E42E1F7E96B1B92C346F5610612E30E970360DCDC541435974C33976B13B069270DC5D78072E9CBC434E92D7B30CE2459812D5A25D33AAC97D3DBA1A4ADBDD08DA548DDFC83D22EDCC5015B09AB361DF9AEE747572A4229E6BB5F5FA85579BF47DF4525880A6BE4D871D38E0354DB9FDD331F8A1591566938C747F14F388395043FEBA7678FFE17D712BF651D544E6F307E30DE4AA7022ED3B758D306C8D526C29048BE699A9E5D77EE1CFA5961AFDD94C867B46D74FFD16EE258E6E8D3F4BFCA7D810796A2BBF456CB5D00ED9C736286B2E57D10633227BF7B91BE1B08361C90A57D6D4AEF79271B1AC6E2295797671B7F0C7DBB5830D2EDDB2B7AF062BB73967964C0D740F7BF562648634B40E5F2DA69260FA4DF1CB9A99247157A8911B8C2916E6307CB684CED9FD738C05179931992BD64F7541699F8DB7DCDFF73085E9BA500FC1E7130CEA36E4C67183179654913E33D9C47D76A3FC74F553BF32CC2B0167C4D3357A7C5CB26428FDA06A3BFF9CEBA276F2A412B21E04216A052BC4C201E5D36BB704DE258D30E5CE1112D9AC8E0940C4035789A1C3C2194A3FDCCEA8F4FF9CFECC01CFFAE1334013113ABDBA5D6574167D1AAA2B95257AFE1DAA39B8EA30F7F3843CCBD2B0DD373E9CBC9CE254BDBAF462A0486CF38EB7F90B5A7FA77D007636641639C7BAAC4563CD27B44D9B104C04990EB0D45B9FEFB05D987B64A5FE8916F906720628961490A91252DBB44972B7FD2BD5C11292F40B6C92317BA3641B4DA563FAAC61972FB552553CC006945311B8C79F88F7A59103306565447ED94AF5C2D1C10DF6D5BA6754932FCB98F3AD1D47D39394AAA810739E1E326AF312D94605198FE30E7174EDAB76391D4956ED0E4C2AB6954D38E00DBD02E76F2357C350F7E93C1974D2C1CBB3C638604DBCAD41790E7E402B80261405A52C2A0F9F0CE637A769CEF5BD800CFFC976598869C24FD9F8C83C55AD840BEB08EABB33877C2CAF3F8328C2DB2E575254E4F129A1E969D91EA02C77000ACDBEC1CF6B1003CA9C8AF77B22F6F9E8E831E4196585450B61E0E9AB6ED12B703C990FAF295FEB56FE39AF4B9DBCB2447B250FF4C13078FAD781A6CD5703FB4DC4A49FFA0FCC342E3638C6FC407602818E0F3C557EA1E9455272929E63B6BF746882769C5C482A413901F04623DD386186392922E0CC3B051F87C4783A90702B0FF33DD37AA924A2557E7461652444C9DFCE842DED51BBE97336FFF712974A3B60344FD9A7898FDF1F5BCF9AA6F0F28EA66FF64A76EE2D6080AA47C8829E1E8292185DB9921A4F4B3FE28786AFA28B25E87BBD63087A08A9234C6F12351B7F622A00F81E46462882936219FD8434CEE7B5EC0F18ACA21B13B5C995918B13B852121 @@ -244,6 +312,8 @@ ss = 9D28091B20946B5507AE42BC4355A71ACD2B5EAD20D4181B22A5031EC53CA00F count = 34 seed = 5DA2C51B4ACF488C8BDED5E985CC4702E4A7BCB248B5AC18AABA529F7F9CBF30EFA776E99F76D5C1686E94F50FB57DAE +generateEntropy = d76b3573f596eb286ab5231feec7499686b13021be36cb126c7ebeb9d7030daf248c0a21ea0bb6d6f56f12300e8584d8e9a34e0e6f52227281151ae4c305fb8f +encapEntropyPreHash = 75461decd34c50d6a094b4a64fb75e5e9479f8f9250d82bb7d729dedeb2d4b65 pk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sk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ct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ss = 98498206D1F4D3C94A054C3C3A6087760B210D2F3628C71CCF3F0ADE9694ED7A count = 35 seed = 4D2239E84B052109A78DBAB6D80C51A86D38248105970476B74A0B78B9CFAB6283E30D5A406FAE1C7F54F8BAE1110EE4 +generateEntropy = b87439fde81c9e39eebe7cf741c685785532c1dd23e8ef868b9ce7a541010f3d1646460817a0fce5836bdfe124a7448e7adf7b8ecc2652ac6d280e986682df71 +encapEntropyPreHash = 2607dcf4fd6ca1c614c21b5e37c24981c32b91c8c3e6955777da8a3f5d9c9335 pk = 38E84DF3C6A2DC2389897C3745183E08C1681B5B9F57C16AA2C12778528510868964122C1747662CF97D8B0353BF23693A70B3B2A7C8CD5C5508A227261CB7C3022058E318D3DC39E320770724351AD78010EB423FFBAE6714999226895AC23735A9119622BBC0811516D617353C7F769628925BBD49629FE0AA333D1909A16C5C27604B7DB0B4E602AB27987DF23C3718630BA4C2846444B83FE914D840CC8ED79A85B645A32809CA069FFBB8B3201131CB129DB9282B73174F8D4A14A37393552B109D2271EDDA8D968AC3FF67AA3374A2355C2EC895441873325DB71C91020E91F19347D965F1410F606862F69643216B869673B5A70583FD1218639B5036CC11D051A13D219F3969C817326D2B60BA5C13CD8CBC9313AAB478833D73716A2A48438FC529084C241BCB4FD67179D1F5494B4BAC2B05A5767B9647EC8829A500D1365BCA7B8CE7B75BFEA0C68F8A28EDB7BC4A3817C0D32C4E10169832B9ABE271CB0B473AAC2C3DD39CE895551A297A61F47162D97C41F051D48B62E5A8882DA62FCEE16EACFB89B98A12AB626E69D77CEB3B6B02878CE346AE5CF754C3F6097E0B5EB7AC80B9B8CCD9418F63E545D01C7D17A71E45EA3A6D927484D4976CA936FE392CF2052535C201DE9464008C932617CAD94085C5816AA41973A8D21610430AC4B3080DD480169258E65B53E340759BFB70D68B15B868C4098847901A6B255938ECD15D5EA94232B2971E3BCD56205FC6F0425F50AB880821F56C7B25F51F2412CD7FA023852CAD04F2704D4103D4362E965473ADD3563D9B36E5097C982506865454BA30AF132BC17C807309723847257C697C525E27CC570A88A1688134F4193DB67EFF018F54751E578483A77A119210106FD03066C403B3303CE54B39493323C4334D4A7A20AAE04D8EF529A15CB7D0900FBC4236C717310246C9CBA14D6874BEAC61B566593B5EC5887272B914EA655D254D595824288A666F10C7DA583F933052F43B0B0FA59248B0584F193AD548A12A845FDF14A73A0A37ADFB4D1845AFE6B56EA50B00A5503CB542C254A26F456AA3286B0126350272638EF0B4A3ABC56FC8D0AEA2F7396D97B64C56817D58C32103996DB88345D377FB7B2644FC99A24258C50730045B897AC908F7FCCB81BC2B51C286899C8C499C1757C6B0A6AC0A8482159D564CDB746037A1224CA72177F79ED19A398040426664ABFBBB7B7BA99906E7982B665A551881E0F02A97409A3E2ACD37FA96A4F9293F786A11B21E1F0BB22CF400DA06081BF68111A9BB64469487D4CBC10578106B381B8B054EE29339E1830DD613E19A9BAF9A81C2B9AD1D121A47D40234BC9D4B79C2F5F165BAB5A2DB68C59C0737E0E4786990A92476AEA44105F3C77FEEFC342B458E4310B9B110A8B2C01593B512F069944828A3F6A219354BBDBB1C344F24AA0784160CA704BFD89C4933B6123C4434CB9A6CE16D3F042F1FC571DB728119F6A33E4A9F6981193D60BE6AB916818B8E1FF9A1D1A59DE8824F808043A1949A5520B675D8834EF65C1D47AFDE2710C6B63998D43AB47A681F0A856D166C24494081E076D5FC05B541145D3155E232A5AF0AB96ECC0B09C2C41E285D350500A4F8BB32E99B4B05D558EA7918A7881BCF516457AD2C3AB72EF2E04E3A4ACB85A987C2 sk = C6389F081CA0932AB66F658046C1278B38BC42B5C4E1A7C7A51B09D8A159773B67AAE1C2AA8666000C6E6A014B5C0369DFF147688AC6FD48C73D783E3025C92D782A479ACBDE8A7548384B763A868C46178345A773A9852016B9FE765DB0BBABA5751E8056B7564C53FEE8040D3C0125115D323C62A3F0A2B518330B6CC4ABCA84F62C792D07C1E1A0BBBD7C5B9A698CB683981F8828EE69912600311A0281DBF9C6C9E69DAA26A446D136E8B0310F236D7A5A49B2BC616FD346C3462AB09544998C8D5EF641E7B48C35BA7A68F25414F703FB02B501C69C58A9B798C8C76923272ED9BF432208BAB30F2DB45E1CDC56F6EC11792A33EC1A62B3FC992441527E63328A46003DB49B7DC07F73F705CA0220DE94BEA4967213D612B5A03B2C16A9BD4C66E0AC893263169A87AEAE67843944628E6374B5518BF40919840B8E6C64172BE3A35EE5A29777C035463380203072EA50E7DAA4F906D01C502560621137B91649C97417CC2D3E1677006226D4621073CB1AA213525199BBBFA78F1899A53CB2B8D00819869867A41B2F48C615EFE2C8DA15A4E6965BEF0C4207A499A2156EBFB611478182D85A71C9F8776D28051D1A6E4A104E54615992E0595CA9B0CB2A0AB0159575863F3145B3401498949502B2EA4392C77728215F8700C93F5846A1A8126EB6B72248BD1047BBE62AA58737268428509E53575F945735E75B42DB2BA2F21B24C990A847241D2C3533B10D50847C85D98143FBB2EB5138ACCB055A8B8BCEC8AFD7B5697306165AF982190821A14301EF0A90C3D829ED9035430725A99C67745CA415600D10D7C29B228998D7402EFC1F0D0476C4D74C34754AF9A1AA1213C9A0198065378DE2D023EB73B3A4BC5801D98213AB7040CB63318B8395DBAD6C7C604760CA679B301AB08EF1A948A5A83DEBB39651310B368C736A56977F78AF0916364F278A4E3973374213F7A28BA70296D1916FC65CAD3B33C4E1597F818CBC489BA970680999C373DBC246740C07D97C5E1EA5AA1D627757F4467E84AB9C5BAFD9BA484F1212706788CF5AC1829C7FF0A66F26C30AAE327BB7E167BDE95FB5829340B187162A5FDE3A7CC6A0A05FDB6F26902BDB0C6C4F75692E67AB1C8B1B46A40E53FC901DD892A3E612AFD1CB2CD52BC5B0C3191137E602B0A5872D3A961EF7168990B634F438B744375D75995943CAAA47E3CC5DC634432B6CF2DB29B637A5E22559A59971BE46004FE2A40F7C330610377A5B0EACF79D85F3C86223A4C90C31C2495314748601431FA1F49ABFF2575410AF33F7367C5540084B75D6736ECAA010290839EE2456EE16BBCB57C601F26AA104916254A689C24CAE98296E4BCEF8770ED7485511F55A46C75592C88D6F76005356C397EB1E61CAA04BF55A05C8409E644055759A7E60C1C8210221FB97780B92C2C8AAFB6B94C259A9CE6291E18A801A82456B93C221A625129A1720328F11574A5C35C3650A7B57619C61F47ED6319329F118F4C31358A26A7E9191CAB61012A71B27B47FA13CB0B2C959D913A2F4BBB3D106AB695A4C13D41256A0B442F0428DE78F90609A11B8CBB475083712539E1AB034903C30F6B73BB8229ED50F901B142A597E7FE48B38E84DF3C6A2DC2389897C3745183E08C1681B5B9F57C16AA2C12778528510868964122C1747662CF97D8B0353BF23693A70B3B2A7C8CD5C5508A227261CB7C3022058E318D3DC39E320770724351AD78010EB423FFBAE6714999226895AC23735A9119622BBC0811516D617353C7F769628925BBD49629FE0AA333D1909A16C5C27604B7DB0B4E602AB27987DF23C3718630BA4C2846444B83FE914D840CC8ED79A85B645A32809CA069FFBB8B3201131CB129DB9282B73174F8D4A14A37393552B109D2271EDDA8D968AC3FF67AA3374A2355C2EC895441873325DB71C91020E91F19347D965F1410F606862F69643216B869673B5A70583FD1218639B5036CC11D051A13D219F3969C817326D2B60BA5C13CD8CBC9313AAB478833D73716A2A48438FC529084C241BCB4FD67179D1F5494B4BAC2B05A5767B9647EC8829A500D1365BCA7B8CE7B75BFEA0C68F8A28EDB7BC4A3817C0D32C4E10169832B9ABE271CB0B473AAC2C3DD39CE895551A297A61F47162D97C41F051D48B62E5A8882DA62FCEE16EACFB89B98A12AB626E69D77CEB3B6B02878CE346AE5CF754C3F6097E0B5EB7AC80B9B8CCD9418F63E545D01C7D17A71E45EA3A6D927484D4976CA936FE392CF2052535C201DE9464008C932617CAD94085C5816AA41973A8D21610430AC4B3080DD480169258E65B53E340759BFB70D68B15B868C4098847901A6B255938ECD15D5EA94232B2971E3BCD56205FC6F0425F50AB880821F56C7B25F51F2412CD7FA023852CAD04F2704D4103D4362E965473ADD3563D9B36E5097C982506865454BA30AF132BC17C807309723847257C697C525E27CC570A88A1688134F4193DB67EFF018F54751E578483A77A119210106FD03066C403B3303CE54B39493323C4334D4A7A20AAE04D8EF529A15CB7D0900FBC4236C717310246C9CBA14D6874BEAC61B566593B5EC5887272B914EA655D254D595824288A666F10C7DA583F933052F43B0B0FA59248B0584F193AD548A12A845FDF14A73A0A37ADFB4D1845AFE6B56EA50B00A5503CB542C254A26F456AA3286B0126350272638EF0B4A3ABC56FC8D0AEA2F7396D97B64C56817D58C32103996DB88345D377FB7B2644FC99A24258C50730045B897AC908F7FCCB81BC2B51C286899C8C499C1757C6B0A6AC0A8482159D564CDB746037A1224CA72177F79ED19A398040426664ABFBBB7B7BA99906E7982B665A551881E0F02A97409A3E2ACD37FA96A4F9293F786A11B21E1F0BB22CF400DA06081BF68111A9BB64469487D4CBC10578106B381B8B054EE29339E1830DD613E19A9BAF9A81C2B9AD1D121A47D40234BC9D4B79C2F5F165BAB5A2DB68C59C0737E0E4786990A92476AEA44105F3C77FEEFC342B458E4310B9B110A8B2C01593B512F069944828A3F6A219354BBDBB1C344F24AA0784160CA704BFD89C4933B6123C4434CB9A6CE16D3F042F1FC571DB728119F6A33E4A9F6981193D60BE6AB916818B8E1FF9A1D1A59DE8824F808043A1949A5520B675D8834EF65C1D47AFDE2710C6B63998D43AB47A681F0A856D166C24494081E076D5FC05B541145D3155E232A5AF0AB96ECC0B09C2C41E285D350500A4F8BB32E99B4B05D558EA7918A7881BCF516457AD2C3AB72EF2E04E3A4ACB85A987C285441CBD71C18717E9DE7359B920A9A3BB7F32E619806F4E4718C585085BE6241646460817A0FCE5836BDFE124A7448E7ADF7B8ECC2652AC6D280E986682DF71 ct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ss = C93350D1F27F771801B7C3E03A2E7672146809D37F33BA262E9E0CE7809B2187 count = 36 seed = EE762F5C9021C36446706A88EF16312F4A12C725CD7AFFF1484337C91EDA8E89F7007F3705747D29907B3FB7500E5074 +generateEntropy = 056661b38038da4fdd7426f32a81576c73ed84843b305168a374f934e27a4e1b79238a80dcfd7c992d84b2dffa67493e669243d4fa38c46b090bdf86bc548411 +encapEntropyPreHash = 38c89bbe7145c29e9a831c11431eb9929cb24fb4992db20737e4687d397fd732 pk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sk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ct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ss = 387E023A733BBA407F35D4456A9EDEC3922B151C3B49C67BF3541BBEE5BDA18B count = 37 seed = D882BA69AC8BBC88715F1C6387531F53273A5DAB87E66FAA8221A7F628D2BDEEE1CBC59C0E08D0ADD84520A3A70C1389 +generateEntropy = a1b52d871612a1c611ae0944f9e71858f35d3bd14f20e96a931720668bdf0a6b1f135cf64b6403e103afae34da038613e2853bbfc36baafa3c6a95347193f37c +encapEntropyPreHash = b2c35e33c72d90182791f0e12a0324f5b216efcab2c8da1bee025dfbe13f4152 pk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sk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ct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ss = 4D91655D2BD77339BB81F82916A1A77329071B3919CFB35CC1D1655C2DA5A2F7 count = 38 seed = 6C3AFF39F5D097096D882F24717718C8A702382DC4AAFFD7629763FDA73C163CF084807BBB0C9F600CD31A7135F48AEC +generateEntropy = 952b49c803d6d6fba69f4375adce8594847a00bcae2179da49af2aed0423250262d7033947ae42ca53522a65fbafe18d3bc3e0cb66164e9a094fe4b44d8977ed +encapEntropyPreHash = afb7d6dc2b7eb6d84acc080c1be63c98afe7b07786b5801f716444a3e8e64800 pk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sk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ct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ss = 3D0D1AD5E2825DB1F539515AF2392F0D212E8166B34F3D8CF2EBE97E51785EC0 count = 39 seed = CF520B92A2E3677AFD003EC1EC6EF136A709D78F828C9C0DD4946EFBD451C5FAABFC83CA66F9D3D17EE4220553B7A69F +generateEntropy = 3c815e57e9233e975fa1630208aab206b71ae0db37a7a8789ac683d9f9b2d29801c8e376fdb140ee343106c093af7cb149b316ba79446ceb4e5e0cedb9b164f9 +encapEntropyPreHash = 28f5e9dbda122b2cf8f3754fe9e0c73a84ad4b0c093522e0b62cf815d60bbc3c pk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sk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ct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ss = FF9A0D1AE64C97E4C51512B315D044C14CA34771DF320BA0C16C8531D6A40D78 count = 40 seed = 197E5D562DE7E01BED4FC597DB28DC6EFDF0179F3A5BDA5F94CAA39D67BAE730540534D59A7A06C8448F628DA8B7859F +generateEntropy = 588760826dcfbd36d9abe6ae44a669bb3ebba6a218eab69e30f18a3bd536576e0e860576285483bb5fd36e2f944d32c4317bebc1e441470c1372046a790d79d4 +encapEntropyPreHash = b0d713cbef0bb1df70cbb425d1e9373e9f7790fdc7980cc96a240dfc53f1e8e2 pk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sk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ct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ss = 0E40BEF57DC97B87EF89E5308F9DB94FFF59A475DC35EAD3F2D5B6B89D24CA2D count = 41 seed = F170583CB451D8A45D105457C02C01A33A40350616ED8515BD49067142F61EFB00F07857E4FFF3FE11E7164C648C76ED +generateEntropy = 47550e9edacb6ddce3d9ab81f6b61080dd4f2693854acb05e0ccc7a4fb6390fbf89d7d99d5c3e0d10d6ef9af054d842375f695abb28e3b8eb495100f04306e92 +encapEntropyPreHash = 32bdcdb7059fe27f6409901980c080308951ffd90deffa8317b4d213a5f04495 pk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sk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ct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ss = 6134219801B78F6FA5A998377643F828C19AB6FEE69E7DBA03C7B8E20915DE13 count = 42 seed = 44A6774B2CAC02DFF210FF861A090561A453DB311F47B6FEDB81811872D5D9489F5FC4103010139AE53FCAED209DC9BE +generateEntropy = 610afb64be8cc1df288cfb016ee2f44c6c07113de7f6fee071fe0c3fe31c6215cd292e4c5f9e1a55e0489bceffb204d672a6215f4f3980a646d9f880817c52dd +encapEntropyPreHash = 4ed7c92d83bd03b2a25b567f17ae55542e2f6a4308ec0f3fe69f8ba5ae24331b pk = D5F135D06AA99635C9B53244E1F898D8494B681312BFD243C8EA5B7E71CCB7A5386E477D01FCA3EF4122A63934843450A446CAFF55184D052923A393FD887DF6B045659CC282D1424B19B17CC2A2384132EFF067A0347F88C6B392AA56A3519A440438D3F90F6941112124C91FC31187AB0CE6752D9B336A1E230F97837A657599E253B7798C912A66A48314447C352B84590941355C6BD1C0951374105858A46502EF39CBB58B8E63A64E2B99C4825912155695893A62AF6745E76058D551A946161F25F1B8FC045602344A7F342FACC50E9565C1D59A459D34233C1921CEAC6E0BD936B496C8FD6A619D8B0649EB458F8943EAC97293635092666688DB559D255CE9F280227755C3605D6ED007CA718527227FA1F40DBCD88792801D8DB6B2374A23178A72276C790F902D7E969F2686C9508186788905E77132DD909397F6B6BAD3CE77E8CD4C4A3B9686CAC35ABC86D57E911CB58B0C997C1935CA64918370809D3B1B70CB09641878E7C0A141573030AA2B687761BF43AC89A81E73376793ECB32DB53368EC9E079172E9AA482FD8652583B9155683DA3467E4546F26AC98371487527C37B6646CA582017892A188FB2440CA7240C3C22577230B59AB8EC038BB95CC49C2A2F59A4A22C0C482713544FBCA9D7404B3A6AD86E8764A601B7084289858BF62A2828D3091FF015089726CA23B1CA0F87195BA1ABF80B01F101F8584C15289196744500000B431A60267174F2CC56860BC5AB4EC20D19BA8ED47535EB42FE1D33F2980BA211805A3618F2FF64D1CC634CAA6B40FD23615538366DBAF41971D8B5857298C1E406A293C1B8B7F4A499A97BE8CC51B5382020EA9C7CF809FA7323134290FA461218F4A6F495CABA2D1511EA48B7E0905B0465F7A6711F2716B17DCBB4B9A1B31933D7D3622315C79F3F11A93C8058FBC01C4839A808A5D2D45B99F7918FAF52DB1D81D669C7988BA7EB8847187AC7B76404B1A139DC4E4917C9B4E29833FD9FBC36E4BBA96E25BDE691CE0C369ACE7183C762BD04785EFCC6B614165C014A0FC4B64B24B3B46418AC5B6B7BF69CBC75090B69AAE46B4A12FEABD4E134BCAF14922367B50F17976C6705E175FF34612CF7B086ED733DEAAB0CA815A53C99B2985963DB89BDC284D251340B0E3AE20990EE93344DEA18063DB6EF4374A331244EDE00B46676475937A9472C82E124B1751A9E4203BECC77ACE092B055ABF0892637B39C3A9A011219C88139277B8BB73B9508142421939380ACFC2B81523C72E923609A0505E2979E086AB85F9663E549F3350A694458CE7B02BD8716C0F8B8946A21D99D97632952BEE898989C1ADEB710E15BB25B0A22BE598A65465BF2B899719D00F9D16367E9436803BA8C17B6B3BF62A10A017C177125396BF6745163FE24C455319CEA69393CCBAE42508156167B28A1D1050BDEFA5A789BC389031BD86E72AF5F5BC80A215260737839654998295D5ABA8C11A5417B55D67201243393B7593400D46CCA1D321C027BFB09CB08A1738C88B7D47E876EF7517F8D96CC1C93B9E93B7062227A55996FA958A684AAEDA89587B015A6B336DFB610721298AC6AB713F3A2E37B2AA7B1CCD2A876F03C72546B861E351A73036F4B363137340EFA7764C439F68D3C8E0723683AA8254A66284F447 sk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ct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ss = 787ED075F818BE6A0EAE99B113DBA31002097E0B85A5480003C505A40793403F count = 43 seed = 49E1855588B6235DF2A400C4A70AEDF8AB17B6E5E2891AA745F132FA2E7AB0C8117C1DF37C39F5D57624EB77C2B4A091 +generateEntropy = e1953800acaa85ac02a906c72cb8e8d704e8d27820345f88f71e89c1f549afcc8c64c049c6dfc0f1476cffd520b055756162f7ec94243de6b14ac0b9e5fb366c +encapEntropyPreHash = 060ea5d2ed1dd88144a9885e79278590821c22917b55a48920f96b53ebe0e689 pk = 26AB73A3355199A1833A1268A37A087DDB57AB621046DB1F407C804C488E4196048CEB762B9024C2157E7DCCAA1A762881280715A1467E766DCCB159F4780A39BC4F4A59715700070318C2AE03706B639F79A8A81AF34FBF6C9ACE4843151AB5C3CC81AF08CE392335E4FA913052119904745EC68CF3502F4663BDA74522DDD61A318539E10A853BC90A5B06AA12018C6BAC4A8123719C567719CB723B420540EBCD84C2787F37A76C6C40FC983436C26F7FDB14DF17062BE752AF2C1F1CD1026856500F3831CCA75EFF7A08D4D9C819D295674550C1C951FF9A0155856C3CC143824556C09025D55B0DB7192D969926C18912BF5CA8629401B8C53E23832CEFDB369020583B360595541F48573BA1557FD0C1058A8CC5EA7CA7F092B7DC7B4B04490FA4E72A37AAC0E33B1746ACA327258D9D29ACF140C5F70B8F94A23195D60D30A498259C6F9D06BD69F82398953B4FD39ADECA972851431B59C9614B7867CB1228E2519AC130F003903D801F70BCCD776A9B916684CD89CD71723CA732A21FECBB90D547646B987155CF5425ABBB2406CDC1821AFA8DA120A540D1C3AF175032444E1FD85F43F47903665BE922636755B5E75A90931C66E89345F57CA4A032959BDB4521CB62BB1377DC5C99FBE36C71347B81A80B6B7251FAC3732475009A719F4374BD5FF01CCE4601E761A754E05756968F33FCAC4D6A540D93951D0BB4D0D838A3112872020C2DC67718888DBF408941B877EB6543432675C879AA85F102E608AEDF267E32D333CA9C3860F907F17B553580AEC75902EC304E6C7996EE34061B40A9F4F8BA2CCC55775490DC9C2A6D5C0134E809BD305D7445C9EBF7B89F9604146B2E55A1090597033BAB2A25A3886DC524F4908ADBE98DC2D74386806AD641712D9C23A19562E4AC7F57A86FC98663E455BD963C4E63D8471B504C14EB718D8BCD6475CC45687F55099F8FE2035F3812F081B6DF2A174999765CD69433E5312BE67698346FA1030A40943F8927B2CD8A1E2CF2514333BCE85A89A6A99D03C4A5C0B847550972F9D1448D1819B3582B99A50FF97C124398CFF30967013C4DC4D374379B4E8B037EB0E570AEC147A1C99CADBB651BFB576AD61BC5449C5737BC4BA4A01F24AAD80375ACBCBAAFEB564665A192211B4D6918260C1251EAA1014C6F41427465609310D8B665C6763639C71AD48019905CC0874BE438023936856017B5562A9EE79686BCB55E04A38EB9B3BBFC07ACD4865860A77AF3B5ACF7DB344F139F79D5953778124C2C92D29CBFEDC21678E54861ECA5CD350FA09B1365FB74435316F37386B9B510E2BC585DA30A71ECC7B9913921EC8D8FBA2DBC97807B693B1E306832507CAC90410E0576611BA79C1CA9C0B106D0147680790EC5051798592D3035AEF57A0174CBC70B435710C51695852841907D41A8180123A4D911787B674ACB513C84047BBD5851C3E83A8A046062C06BD84397858241C95B8D8D2A2C53038856247506065A70A5A29B701BAE1B488A68C2BF02472D86BCBFE263E7820902102C612747CD60344957A871C7774A0980B70B56F7BC45F8E2BD2085AF080CB923B55640BAB2AA2C30F206CCBAD17BC9F58C1CDA80399962268F2AE99C43BBC1FA7D8949CD772A745BD9AB018FD3F6ED02F32CD2BF845923 sk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ct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ss = B81E1EA69C6A6E1737C78FE18C36CFDCD26CEF62DEB805F22A92C49DF6596C0D count = 44 seed = DF0E41D2F6F86C1F79D31FD5878E7AB434FC0AF3A0D5F47D2AB3FEF31A42BD949B0E3629DF9F575BEFBB62E829E51DAE +generateEntropy = c719f9b2d16399b7326ce4eca30dabefe8fdaab18e9f6df888b0a134ef355570e40771856eb77e4633504899fcb86c6a3d433d0b8d60e26f07bd61f1d4ed69bd +encapEntropyPreHash = 10ef9426f8c4a13b52325c5bb4ead4596ecf2c6b5bd2d37d8350e90d4164fdd9 pk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sk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ct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ss = 5D014FDCC992FCFCBDF3AF29E8DBC9E5024F2AC41E71A3EF0EA43A063BF44E79 count = 45 seed = D3C9EBBA6EB03CCB5C9B9D2C8D7F0CFBBF50841E24396CDDF0E56525B38918C2FBE6C34CC1B93F7BCD4F4D5777E1A488 +generateEntropy = e9acbb774be970206c3a738e243b420805a509fa59fa902044be2f0d013650d2ded5edaec5de3bf5b4d7c2f2e18e87f499c1968993eff196753db8045e2c8ba8 +encapEntropyPreHash = a4bd30a64cbf29a4e290fa1cc1dfb99e68348713041e4409a1af23c5d80c15c4 pk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sk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ct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ss = 80548D4687DA93177D06D98C1E2DEF33FE85E770F8B871D2F74CAE533F654692 count = 46 seed = 6B3996E8BC6F52879F2B7BE012C44AD555707CB7E5FD8ABB3457A298336D6FDC9EB7853008FF13201D5969A315C7E493 +generateEntropy = c1b3cbffad4b306f9af0cdd3028876486dbe858875c9b6497fe20172a986c82b1c96249919cedc2369d8d739ab125e0d2ccb82dfebcd90240a545cdfe07511f2 +encapEntropyPreHash = f4b66a7d3b65b896dfe100b2cad24b175a1168cfd2ae11fd704b835f6bcd311a pk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sk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ct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ss = 2F2F58E23DBA54D8A44BA11AA4546EE3F1819C6243E986249B7102019DE3A777 count = 47 seed = 730B65ECE22DE27D573CE3AEA7CB021C415DF210D228808D91D4F380070FFCB0778B683C71D4853DEB569C822765F2A3 +generateEntropy = ff7495b8575b5a98e4fd21fb4c3e58cbb60f14bef21aa74cf8802e3153f14807bdc370460375a778d1a31d01c42b66367ed8d9e8f84551002f552f0e52102b5d +encapEntropyPreHash = 1d7b03d3c5eefb8ae5799dc569aa668f1bcb8c86607b089d3530cf61d6380147 pk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sk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ct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ss = 0936224EF45E29DFE9263C6237A22798E94E81A932796174271CECCB78188554 count = 48 seed = 5522A5A891A9A9B5514F4556AFD8DF40B9CEC63A01492F0CB8A1DB073A285A963E4A9FF2376C88662F7D8D241F8ACF17 +generateEntropy = bdc3fba1c32751139fc45bacffb3ea97f26573d804a5f27a459293d95190ed8efd5a08f656a6eb8cd20679930a31caa6a6331c4b133a6838c223ef9f769f6246 +encapEntropyPreHash = 554f3385b382f4a46314de37ee3885addfc5332bd4038785094e0a832e9e8c2c pk = 58718343322DB0162D26965D5E946B700AB88D702FD5A1376920B5BE702297AACDE28588DA91C719D40C1FAB0AF109742AC26C456961338C44C93C83AB58581635499545CCA66160E15A35BA4931E2B91FEE68A8734ACBF72755E8D452D17215457161284435EB6A7A2933C8D146A12679143B80740F68AE052087EEB988771A8FB43B34D6EC79868A0670551BDD19CB5313892BCAC9E4FB500D3375AE471A3ED551B2D9C76142B22607615454A910F8578E44B448AA9200D805CF4C15EB635013BB80A65593FF578C794066F05ABDDB850FF976C74ED6ACB4C41064FB5EEAB479A13BA57DCACF7F02421603194A3CB549F08C0D700790809EE0E585DCE4088F96A740320C57D5A632C8BF5DC173F0F841173AA47CA42004B808EBC2A6A1770AD9DC06027557F80420DB47B0158A1D1FF32007FC058875C4F5D21FABB67BFE8909E10B51BB35C76D0605D0E6A97E56CB93DCC58F722D95F33008B0A237B711420A20269A7097396A4A98BE20B8226E103CB1136EA3FA39D438B305B63FA049C420CC378392B9F911BD7800BBAAF2BDD7586780C7078DEA622DF51C7190841585BB16BAB9A0D83625D55826E3949AE018E7C4703CA082466B9A078393C30A4F6B7B1FC775C9DFF7CFB5909CAFBC66EA946E6F098F881B3039C251FD3AC142029E8728082F838A202CC3586672CB6285B021C41E3C16F5787CE6E319D849483FE40D989C246F7C36C11A991234AE7FEA68770C79D8290AAE3BB72BA014AA1279FD13977A49B0CDD494CA00C610CC2306059B695686399C1590F274F735142639425DD88026F8BE0F260CD66672A12B5C7B5C7323408A2711677F062625EB8F3541098D079C13208415DCCF3FF72D1999721DB3C271F7521DFB0F129B3CB6885310A0689166A3B97B09610347CEEA5579650720DB621DB20EEEC24EEC2144FB523ED2D30F64B9C6655928B3D06E1FD9B088AC8B7C964213E5674757C7BD48A3D066355F0249A50548F430C55A6CA0471953EB7C67E140AAF6322B7741225931622DB114ED46B9EA997974C9AE2F54B87125CE79E8621D712688B50C7A49877D52091643A4A43148550135F27BB30EA131521583F5B79255309465F4B9F2233027855CC0E7C93BB33705136C88392CCA717254640C540573D3A20032C9B297EB5B02C954C744C4C6143A56EB48F1D15439F885803BA5ACB524F3D54BED37145CD9173ED92A00F724273787CF1B89C788184DE0905BEA74FB331DDBA00CDA70C1547C634C706A8447145489752B0633628BA4F5286851E1B5FFB8A7FA2BBAD3F92C542ACE74E67AA07B467E70B6A7D3056592B36A7A37C6C7114C610721E9C6EA933742E43609C41F6F3803E99A8D5A27B069BB73C892BF07524A8B2989633C96CCF33791BA29F3D575F249C640093046D1684FBC701AC633381BB349BB7D351230A8BB1A22223DE3850258AC7043B887770A307C3746002CADA2826E47F7694EF51F94FB9E3645AECE6273298592BF00C0FDF14C07D8C9FCA401FF351D2E35491AEB55AED9B1B0EBC2424CC729AC7EB07630B8B11D0E47C323D6B3C0BA12DC235D5C310CE2C7BC1F0A8467D627568A185855750E12717760355A0B8A756468E95406D375F6A1289B8CDBFED9F6518D7031C57FD3455D4544735CF52680424C90F14F sk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ct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ss = 2073CEA69B598292F44EBF4AF3F7035E1738AFB7203AD67531A7140150176E5E count = 49 seed = 1853E72329353B3F89AE6A1B1EF700DA8ED3C10D19F9E61EE9252E28EBB0E15802EE43083A12A0B7527088832605E3AB +generateEntropy = 447f6076a627bbc5ad7773fbfeb14b4ba9ac43a0f8b99fb6dcd5e452aa3c47ec20a7237801f470fcc2bd9fd7bea8322859b850f7882d362947432913dd068c01 +encapEntropyPreHash = 38bf0033b779edf5367d9ebc01c988af90904c560970815837380650e4749eea pk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sk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ct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ss = 633D9672D83A112A260B9D4C17812359B5591900A3B80424B3590B403A5DFBA9 count = 50 seed = 027C3D5847ED4470931141104F25B19AE76117CBB64B224EE424FFB782E9A0E988839E0BDED0DF666FE8E5FCBB5DBC09 +generateEntropy = 2d5df64d62cb07fe630310bb801c658dbf3d97993e68626745de39d37fbfc2b27b534537addaba4ecf14f02ab317d36cb9f0f50222ced7cf029dff8a0d3d2fd9 +encapEntropyPreHash = 048ea516d0ebbd9f709b47eaac66f344c571cf50f0d01c9466aa061a50b66a24 pk = 41AA7B69158362A41767486EC3DA09AB4335FE2A25DD6C07366478CDA91C691C5ED9264F771124C1F3693050802F480F5DF89D5BE189DA765337A69C5C838488A0A4BA7880E91871FE346CF3ABB0AAEBADB211B5ACD3B773C9146CF97920E509DC202F79B14734C9777A567CD44A43500B5EB8005BF4C5A387701286639E6D9AC2574B33F2432B3A787039E34B2AE511A27825CBA7A8E09B401CFC6123D3B4C42318E7B032331230DA960A09F61A6A196DC185BB8BF1C1A6B691A06CB57F12BE1E45269C56490E256A83C13352A878C724242FF0681881160ED03166612D69894951D65B95E690DB46129D149AFBA2C835D3B138036931423D2F84CA51179466A1028D1601D5C397CC81B1B5E468869185B25095A0E5B5DD6A421B5C7ECEB58C4CF97B7FEB114FBC435C78857C65098D3017FF8A58F5927E5EE7712FA0C2962939B9D8C84BB6428B3902881188DF17479EC01E4709B7840235CCD77ACB0BB3A05995693781FB711D61F2883827A96DDACE29A9CD43EC6ABD4691BE1A758B72A629F6AAE1C795981C0D8BF8160BFB3B8F5047E1A410CDD49C6A42ADF0BCAFED1B21EEB95D504B1A48B1ACE228BB5E1508BF05128F0CB63F5597851B9DF4CAA5B6AC10F7F6188DC41B02761F840CAA42871C55205CD09771AC9125D6265DDC56A466249FBD774EE53756035349CA12A48237221BD53D7FF1AC18242442935BA818A3B50007A3FC14A2FA3ABE437FF14705DF0CB5AF97561A608A3FEA42A809A7A7D5491453C849DAB7ACD99636931C007A70D01655C7302F9A26012C494DE47839C1EA2951A87FF73968DAE83A86F392F021873BE4C75D2B0700A3B540F50CF6FB664A4627DDA9C75394032F434655755D12D4C781E2324AE00DD61744CEF6C5EC9680F379A26284BF9590A33350905E080E9B70547AC1CF3AD888F30232FDEA7BD2C184F9E1A9B6835401E737204C5EBF2B28F2B58EDD399F873C7849CBA8064B8A20C9C391841875B4963BBA2097B958D752739383BF26787E64EC215974B45848185F44B8780C0714B9651A7685E673CD1B6230C5D6639EA5629C20659802BC6F2B95DF274836241165A524EA99A941312FEFC7CDD2FA8016D69B652C3E94E73C70C97F65B3ADF14BBA2D31916522701D80252E9C7FBD7A17D306A4E1E02CDA405F3F07B38EB65824D5C9D8B91F7013784FBA0DF0348F21B00EF5A325C745A829714A5B9ABA16ACBDF029771D5415E867590CC5A57360A8969407F0749AB8A08A65E37E70146FC1B7BC40D789EAE83761E77749A07859BBC046B5A87E3A92A5368251127F12D27789318F8B9C3C1F79211922C852A0B0E10BBB631599190B49A66937920B3F113185D89C6E37DA5F7CE9C12D37C12CC24741CB9A79446606EABE8C9AB06D8963C959955F198E03A0BD127242DBF2A2180281A7B65F54C28EC9C6CAFE64881D6456C07607CDFB89E2CA2FB3BA8F8357720051C30952734932B08B508402A6A2F4F9C76B053C12A267618928032B5D9E41990A18C2C04BA7C2868AD9F4538FF1B494707EB9DA6B81374D7F9731F9A26089D7033A8C24600944D65871D313387B4101C0AAA27AE19D978653638577BCF4CAF48083EEEB57F401544D4DA3B73DC1C5C4A047B0A5EA85EDAC7BEC66F4D87FD2FE422E7DBCD02D1455 sk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ct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ss = 7EFDC40486793DCBC7C030273F8EDB4178075955EDBFBBF0F21B793206A172D4 count = 51 seed = 450751D4401737459C6D93E6C5F2FBCC4A3AF7CD7250CCF404BBB817A67BAB7B4C9D0EF4570BFE25CF919DA331C31D88 +generateEntropy = 25056d1b8113bb362dd979d98643d7a7ac9c4f95994c0ba060609b6d07002ff3f48a9254dd40b117941fa35a66bb50296327b725525deef70e128ca8045ec451 +encapEntropyPreHash = 686c921c9db1263e78ae753b1c9c2e7936b8229dca48c0942c56c6bca4f10917 pk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sk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ct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ss = A33BBCFF1EC8C4D3E3229AEC78463FFEAD5B96C6C1FA857921F8907A9180AF07 count = 52 seed = 5DE720F2D152BF4E1F96A61E7AE5F1BED6B8548E32638C2CCEC9F43B87D1BB43DFCF334F0582984D27E440D519AB662F +generateEntropy = e4d34e12982aeeb1d62fd488d9b9e28557ed3429292239fb4f76fa9098009acae6c45c7fc62329b13c8d29844405db8ff6860de474bf727ecd19e54e6e1a141b +encapEntropyPreHash = 2387772e50059cabda53cb93ba24b19ae529496c03b36584169451525c4a0e7e pk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sk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ct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ss = BBC0B0A4782E2BB9EB19257F5B80338D1E239AA6A08710CBCBA0ADB974D7DC64 count = 53 seed = D71729DCBB27D7CB39E9E905025D3E55C8602EFBCC483C9B866EBF82326157833169243C14550AD728BD1470F39C642E +generateEntropy = cd6a99396eb3539ca663a51e42063a3a262cc1c5a5fce1566f0597b52ad9fa325a3407f591791a5db4578b5972093a95bec3b8e70c1d542c9b5c9789729f8922 +encapEntropyPreHash = 155c29c5f0378df0cd0e847a80a07143cf7522fcd880c9229eb9feb1ce340cd2 pk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sk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ct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ss = 3EEA7528610DAE3539F5F81EFD9BEEDDA4D45EF0B9FF91D3D4F3561B4981D286 count = 54 seed = A7C2C8EDB3601396BEB2DF0657EC82FD5780A2723581A9E03DEE1CDB018440439BB1142CAB0487C5D136E9AF46338AB7 +generateEntropy = 6c8c53ed6f65e6b2e324b84364e10de42d1c26a106d4d1c99eee79c78586fb55b9402bf02481ce4b27a52e87feb92c4399c7f2988d40e942e7496ad15ad2aa88 +encapEntropyPreHash = a9cb9a61a3324b1ea5afe693b32784e2871096b2ca14a11acc9577c52359a241 pk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sk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ct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ss = C5E2F0C1EE4F13FA8FBF2D09A78B04A5E2069AAFA978598F96424ACBCF41AD44 count = 55 seed = 467F6158CB86B724039FF18C47950AE5C49170163C910FC9A9B30141F86E9C06EBCEC91497BCD156D95758C9F0C6EF91 +generateEntropy = 2107204cd995f1df14314d5381f8c5440f09a347502e161cffc0a2ec3dcfbc7324c3da70fe850e80aa818301d60c70f3038153866dcd5d179e22db59b8991bb4 +encapEntropyPreHash = e99fbae8a024ebbbdcef32ce213f6aa942e3eca925e5da4c09975d773b33a175 pk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sk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ct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ss = 0B642D9427CAAAB926DFC155993BCB41BFBFB91E6C6D1C4165D8750222CC3688 count = 56 seed = 687C02DE1041ABAC7B2C1E6EC2A7C3375552ED5EDB10E3A8139C24CC76BDA44D719D8121A81D47A0B762B4E9EEB85235 +generateEntropy = 63a925685a8ac5bbd918faa33ac397d1ffbcf99135d9da7c3d6ff7aa4c50af3d3afdb8a246a56ee71465591831c371f2eb87467b0559dedd776ba063ee6d2f93 +encapEntropyPreHash = 67a216f37d67f5e74f782f1badbce1cc8c80a6130aec305b421899a4faa0a6c3 pk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sk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ct = 909F5615AFD3C1E5BD517378A979CF9A4267592AE7A8A723314DCD337E5296E07C686EA98FB8FF29067C99D0C8214DF3E1A4A3CD694DD8F53F9B1ECEEFFC203A6BF9E7022ADD6374B08B0C009A0F2B57CB55221FD486E4787ECB8CDE273E980C25B831CE8504E9125B4C402F826EE5F4E2965FBA01771978EDACA1B9AE19E0E302CD019AFFA2FE3714B7C136FE5D3B6F9D7E6622493942323B33DE56202A94D4CF505DF02AF304CB7339460A2DA004D783024AEDE73BEEE0C388816B90B36449F84FB145D99FBED6D46A1B57369F2F1AF1B4887E5AD0B318B527E25F81B0A847188D0BCF722482B90B1E96B114CD0274C8D00401B0A39B29E4C6B07979199A547A27D9EC39DDC7B29FF2D7033CAF8463658113451FC604C0A01656A2968871E153D77D6A1C328EF92ABD4EEE745A3C58D518A0AF004F2C636E2F0BB636436B0517D6F8D6A4323727518B720F55D993E2C9E1653DB50A43F10C4A69FEE9B170C98DA672C1B21A9987E0A231AED4241114D605555955A4FFA66314853FE8E1E4306ADDDF09BFFF1F22EDD64448A2F59ADD8237A759C2B5112DC3AD69404C65C2CA5F97345B492F0100882C83CF33F15E6DC2459976FF8870507865F9616AF8F0AEEE21FC008C9EED3565100F7443A731A5D6392F0D5E88AFC84D6A3F3C3274187A39BEDEE638E5C56E9A1A17047303DB8920A77F17B322C9573FE0096CE446ED1457CEE4FB2BA448D9A9BD690D89C58E47816B08995A36ED6C1A965B4C78CC5D7E90D5EE1CF5FFFDD6874B6B2ABCE7EA3ADA69BEE4CCF3892E8DCC8538CAD74FCED9DC8AA13B976E891ACB8EDA3700BBA39091E4FCB25EBE17F011D392E54B98AB4743FB7DDCAF0840CA05E8691E1C6FF4F46B45663DE89F4BC9B4ABDA850563336C0B82FAD2815D879131F58C4C5850B98AB57EB36A4A3E540E80F7115186754F93719794FD73D7236059A4DBE8169C71F01DD7C4FA1E6E3B3E80E5551C29C428996169E863CA1EC09189138588FE85B759D75C6FAD53746F5B6A6CCD6C2A970D1860FCC12998A7E9CA3DE51050F3B9CEF4A303F80591683CA7FA17909099EB288BE46819EC8E93C54BAB05B67854D7A105AFA20E62DAD71C90924A7FE13C5B0FFCB47DE697B9CCF4F33ABEB151E63A02B1835AD4FB5D4D0D858CD9F0A857801A6AA316076A4ACBB4ADE6F55DEC9B9F77D1633CCB4B391A4F879336AF32C7B54D45DA9683BBD83AE8D8E1A87BAA2E98D1D5C8ACB8418A2BEF076B9C35C45B97B7E5EE24BEE56FEF50D7FE9F30449440EEA673D96F3DEF3FAD0009054C7F4B1F36FEE689BFE6907453F2D08830D7524E311ABA74DB389DF58EDFB4F3715C880779352388ED09E5378760C42105F023574CF146E6A88FD7CD42660DE906BC57DC7F49F6691378FB8575C637979D445E2E74D36961FE0BC675A84E638F8AC4CBB0B85F365B3A73EFA97A4BBBA437A6FFCFF21B50226741F19400751B5B47C1657A259B427FB44FEBE3442123FAEE30EB71EEEBDBDAA798FF7D4DF03B2E5F08B1F248 @@ -405,6 +519,8 @@ ss = 79462708F754BF842716F900E850C228B00996B0E3801B43F6A928BFD4AA9E50 count = 57 seed = 4142237070C216BCBE245A39BD9220533C97651D84832B26727855AD994A0760C52B9319AD404693E4248B8C5FF324B3 +generateEntropy = 6a1aee5e708c1b47f02bdacce4f56c860f74fc7cfec1ef3b58285b1c8ad7fec2230e05b7114ff0395cc6634db1eae8258072d09c09f291e92d6620b177dc50d7 +encapEntropyPreHash = 52b19fea232c9154a3e431e9d69cda40013cf2d485c3cd027ad24e645420420b pk = 5B668AE6721C79E07EE5D26233936D195B62B192058CFBCB0A5A73EA0154D78224EBE84B7B611CED7256D0726492A4B41D4A8D6B2CA73A3668F93A77294439B0D8CA9A725C5278C21D896CA5D706E5F03D71526CB175ADE2606E3C3A24D510B4D9816AA6846A77663A80F5AC0D364747307068DA942B15CD2E02A3EED2818F9056D697897B509BD5048B178240C841580BBB77A79423996072F39497869007B19442F401009BA1A039C18F191CCA42F9551713CD791C9FB847690CF6247BB752A17A9873E97BCC36B793B6AD827ACF418543054698D77693F9C38C84354CC81C7A3B6A43ACCCC32DA070FE29411F17A420521FC69C0D09A6425A20AFFC98681568B8CCEA88E54B8DD9F12AEF4B3C10F256EB1519671091984A1DBE972A901BB4B24246D7DB01B86665374BB6CB841B3CDB2593BA5C96E32C20936ECBC4ABFD24AF76158B36A2C752A9BBA8946B34C414EEDB355A3CCB87431221AA2E936B0BD7540E697142DA0817B1B51314FC71CF4017F50544474C572C70BD142C676B69AFBA4292F5F19E88163F2FFBA3B1685073C3BBCAC825B095B5D259228A459FA7E866E09735E4CAB8FA733D4DB6A98172846397883394059C635D23C09FBEE3CAB350B9976C6A8A900C8E1693C3704E779049CD1221CE767651BC23755A3A49C6BE0C314A8C501579F7A447070EFFE0314FA3687AB92090738434E55280A42F22A66EAB77A2932B07E6857A32E31A527A2A909865E053A32148B59CBAC224C12468E444916CA375DC204C600899F90BA7C854B3646F2AF3981797AFC4E261C7A93AABC40A93990DABC82564336D01B2447FD35E8E86A0CBF676CFE6C3D229B256E585D8373D26C3AD66161890325533818F845301D9311BC8035714A722ED9206967123E65410562A745FE28F90D50D772A9CDED6354132688DDB1AE6956EADD896CFAA71C44AA925FB3B2C6B7D5E47CBAE00A91040456F4023174C73DD8A4D50F9714AD1CFF718321677A6962587BA6CA82C341F02A7382BE9715B41994DB91E6D0B487207B9B660793E62470B806A7444B6FAAB38F48747484062FF443AE1DA9E7EF41F797398F0527406787E00E197AC3248EE4A0E5037CF6C754AB9A24D08936E9D3313B99AC18886CFA9972030F1A40E58B25939A21698C434391785A3A98F0445567A9DBC0B4284D49652BB1862BB76FCFC6ABE60831CAC9AEF6469464319411A30F7601B5358568B014E67A76EA42ACACD7C3FC2F983BCE1BC0667897B92590DC724B5284FECF7C36B3842C61C27AF1A2F2EC95899591E707272BEA384CB9C8C9409BB26D743FAF196D3B8B33119A379D5CBF6823D4176CA83BA4E2A426745F346A42861A7B5343AD3AC26EA8895F24A379C449156123ED91A4CA701BD789DA84BA0ED5C707D373634AB7A65680667191F806B6F62CACB4B40AFDD649CC9D1650C3A5E40C8346C91B27EC1B1A957C778EC9C968C670FC84645FC07881C54946B5AB0B6033F45AFCC6A61FBB99746F3991F5B827C22972939C5FF620BDC4B131EB393D108C56556719ABBB978452FF0A12A1D138C9065C304C8514658193232C832B05B0B21A10483C6FAAB378C6B1415B75B43796F314542B9D7C87C1CA5FC13A12E8459454D36096C3BA38E979A3D4C852032429BFE1E663E0C256C2E93 sk = D809438C90AEA78B897A528534FB009D716DE8D513D32168A1537489E52255D00F49C424BF5B5DB0E15A3A9B9845ECCF287776F9700FF5BB7AB9F40FFEAB7F148A9633546846B672CDA9AB8A37C8F9711B76474E7975AB7E16675A8626F8648B605066A4FB4A5C255A0A39387B03BB7F618C9ED1B37E488D4B7175B593860F6C97D637A2D8761D3B933291B2CCFA6BACC4DCC4DDBCA804C7C55EDB9FC5ABB503036059DA4D2929447CAB1BB1CB746AB01293A2B2F2638BEB06030D476BCD2C335DD5226B7450F8B5B2B130332DC9210640C10DAA5FAAC16C1381C2A0C4AAE3174BE4FAA53CA9CBF29769084715D6F8C163A0185030B0C7C9621336A9875946FBB73BDA9774C07615711451F5594A44313878204C291AB7550AAF981409D4D7CBEE727BA689400DAB7382605F03873F38566421A354B59A3B48BC8F62A09519D932AF5800A9A0C6EFD5783BD93483A0AAAC7853C890C3BA18835D1A2E8F14BD0768CC7D0B951909825C988648F797F5711FBC654380E661BBC41CF89B088E1410F19669AEF65FD817564A4A4F40281B5E16A69BE2B503495A4B6B680A08A54FE0B80AE668041AA120C7A363E38AAF2156CEE293BFD4396DCC503646ACB74B9460142E4476807C058D72C9610E3CBB50A29ED7244419C2C258659B3A8A23E7E69A3047298378424B7A12DF3CCE34F1364732B292B105EEE6A487126815BC0013D66FB7099EFD4931E4301D570BCF2FACBA0B433B9A03147242C298052650416651DB690CE81C268381032B17C429A8E418B7E2BB63D30B570DA588CBC36DC3798C65F81EF05530B9043310E182E88BB3E58356DE408898738C9B3C457FACA42B9B81ED7C4118869D5153338EF4260006C6BE294B528C779BD6C8FFCB16E2AAB439D3032B8AC45216282346200CF1C812033A4F9667AF842481D807F92245BB322E04343971A656087CCA8CE9BD3117013AE816BA745888A4AD51A167A17482EE5B88B0BBA455A565B1D97BD3B9BEEAEAC0B4F2879A727028D4A1C61900D0770F15451A01964366D8A6AD1B5BC520392D43BCA270CCF9A72DF3D68B955C4BED0352B3F78151C4716512097BC92F2CF0A2560923D01358AB1B5F8B7BC687F5C110B04C6512372F119FB23BB852398A6F599F4D145A8AFABAF8AC8726ABAEE569C4579B494A01C67E232B93080D5DF1542DD59F21760A24747E98E26466280C04D1784D9B581B4CABCAC1C3DDE1CA8E00588E0732F76B99EC844032D99EF65C8A9EF4A661E78A47B0542B3129E850647862132C208CB9B3986EB5B510EA1854300EE966B0D3BC09922260FFC96B894A181A95A41F1BB3ACB2572475B3FE8933FE3902C965678B95512289CFBAC30A2B159B8F2B3535E40881D81C204CBA9080B9A7B23190965EB660754368955C0C7929E9447B92AC78E7867C1B4770596047FA820C03A11CAA3C2BA48120E29AD46C289920222C511C9E18343AB20067F926435C6D6B040955F9394601B805E38A751BC8A1853FC05857EAE658A8A7CAD729373E73253E7728FDCA89E347BBFC48A7BAFA48CB167111367F40C93BF71CCF208A891C383BA3B593F2663148D779ED82B23F4B6796209D51425E9168CB22224F39F0695B668AE6721C79E07EE5D26233936D195B62B192058CFBCB0A5A73EA0154D78224EBE84B7B611CED7256D0726492A4B41D4A8D6B2CA73A3668F93A77294439B0D8CA9A725C5278C21D896CA5D706E5F03D71526CB175ADE2606E3C3A24D510B4D9816AA6846A77663A80F5AC0D364747307068DA942B15CD2E02A3EED2818F9056D697897B509BD5048B178240C841580BBB77A79423996072F39497869007B19442F401009BA1A039C18F191CCA42F9551713CD791C9FB847690CF6247BB752A17A9873E97BCC36B793B6AD827ACF418543054698D77693F9C38C84354CC81C7A3B6A43ACCCC32DA070FE29411F17A420521FC69C0D09A6425A20AFFC98681568B8CCEA88E54B8DD9F12AEF4B3C10F256EB1519671091984A1DBE972A901BB4B24246D7DB01B86665374BB6CB841B3CDB2593BA5C96E32C20936ECBC4ABFD24AF76158B36A2C752A9BBA8946B34C414EEDB355A3CCB87431221AA2E936B0BD7540E697142DA0817B1B51314FC71CF4017F50544474C572C70BD142C676B69AFBA4292F5F19E88163F2FFBA3B1685073C3BBCAC825B095B5D259228A459FA7E866E09735E4CAB8FA733D4DB6A98172846397883394059C635D23C09FBEE3CAB350B9976C6A8A900C8E1693C3704E779049CD1221CE767651BC23755A3A49C6BE0C314A8C501579F7A447070EFFE0314FA3687AB92090738434E55280A42F22A66EAB77A2932B07E6857A32E31A527A2A909865E053A32148B59CBAC224C12468E444916CA375DC204C600899F90BA7C854B3646F2AF3981797AFC4E261C7A93AABC40A93990DABC82564336D01B2447FD35E8E86A0CBF676CFE6C3D229B256E585D8373D26C3AD66161890325533818F845301D9311BC8035714A722ED9206967123E65410562A745FE28F90D50D772A9CDED6354132688DDB1AE6956EADD896CFAA71C44AA925FB3B2C6B7D5E47CBAE00A91040456F4023174C73DD8A4D50F9714AD1CFF718321677A6962587BA6CA82C341F02A7382BE9715B41994DB91E6D0B487207B9B660793E62470B806A7444B6FAAB38F48747484062FF443AE1DA9E7EF41F797398F0527406787E00E197AC3248EE4A0E5037CF6C754AB9A24D08936E9D3313B99AC18886CFA9972030F1A40E58B25939A21698C434391785A3A98F0445567A9DBC0B4284D49652BB1862BB76FCFC6ABE60831CAC9AEF6469464319411A30F7601B5358568B014E67A76EA42ACACD7C3FC2F983BCE1BC0667897B92590DC724B5284FECF7C36B3842C61C27AF1A2F2EC95899591E707272BEA384CB9C8C9409BB26D743FAF196D3B8B33119A379D5CBF6823D4176CA83BA4E2A426745F346A42861A7B5343AD3AC26EA8895F24A379C449156123ED91A4CA701BD789DA84BA0ED5C707D373634AB7A65680667191F806B6F62CACB4B40AFDD649CC9D1650C3A5E40C8346C91B27EC1B1A957C778EC9C968C670FC84645FC07881C54946B5AB0B6033F45AFCC6A61FBB99746F3991F5B827C22972939C5FF620BDC4B131EB393D108C56556719ABBB978452FF0A12A1D138C9065C304C8514658193232C832B05B0B21A10483C6FAAB378C6B1415B75B43796F314542B9D7C87C1CA5FC13A12E8459454D36096C3BA38E979A3D4C852032429BFE1E663E0C256C2E93CF754F2EE43694865A09CA7BEB0DEDA9B1328FD0ABDF30CA5C338E27E8BE04B5230E05B7114FF0395CC6634DB1EAE8258072D09C09F291E92D6620B177DC50D7 ct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ss = BF535EEBD3721E4D832FA4C11369808A154FAED4602220B4070B78900B008358 count = 58 seed = BD334D7B7EB14E00E68863F2E5551A095F8AF10681C28353FD19B9A7E70B8BFE266840860609008A567ABC66316C77CE +generateEntropy = 6396b328b100e4c7f4bcae69875edea1a1982421558c608c13c592bf7b5d0fef1100ced48add211a5c937b8d6079d8e271af3f949edc61f70e60453aef20dea9 +encapEntropyPreHash = 64440adb05db3308b189bf999f9ee16e8ee3a6ccbe11eebf0d3ae4b172da7d2f pk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sk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ct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ss = 3602269C7AF9FE28EA1019208DC3AB33BA09239D435C509903CA67345717E845 count = 59 seed = A0264C58AB1F2CBCB212077FD378D340307ACCB31F1312137CF84E3D3135044D4EAE8BD38BC3E540A0C14D46458F6179 +generateEntropy = a453bcacdd2b0d4646009e5ed451c3c45f08fb827ef733db3c517a9dc1af93e67a3cc8aa3239d4c52ce4c95afdeff6efbfacac10d294edc0e7cf4535059bfdba +encapEntropyPreHash = c8bb46b3a7344ad170c2052fb042b5a3b62e0590562ee82577b1081f6f114d16 pk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sk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ct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ss = 5E039D591CFB128E51D0804E0993084FC92B0BCA9C0F2D84E24F5FEA5EFB3B8B count = 60 seed = 99A9CDBFC674AB3FF2C64CDED7D697A6E27A767434A47AFF7C3FBF3C6A22D6043D27868955286A13EFE3DE36D22EC48E +generateEntropy = 47ca2b77c5b717f423222c2730ca5cb9c856bc951d01b2b2c80bd76ccb5539b78f1481d7cab000e33fa07de8dc9627a85e76fabb4428a3376e66300cf12a0787 +encapEntropyPreHash = 2e2b70609f3fe029a14d09d5d659871ac776ce2797a0355f16e2eb68f5613fd1 pk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sk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ct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ss = EAE95E643381DF7A1CA1954EB0D529DB88A8001B8C1ED98A4B055936BBC6C038 count = 61 seed = C799D57B41F28C5C446DFC58A5AC6499C4BCF3C162AFD2B09A16549826EC2A6F689E44BAFC4ACC82F5D6AEC23F4A3993 +generateEntropy = aaf6eb40e596a5e3e8218871e708b089240dcbe7fd3641f0e5e41e071ce49107e2f8d320ac3cb0c52efdc753282f092bc39baf4a18783a48ea031a191865eb78 +encapEntropyPreHash = 4725dd8fb314bfd8ee23731c2341dbe114606d9abe6434c471b5573e7df193bb pk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sk = 90D7129B79C095B3063F53058A4BAA74C262A99C822894254A050409215FE67773C26C7A6DCC739D8406A6055B388204604C7B065C0CDCCC16FA880858A36D6200C6CEC473BF81B245E09C6E5A55A8D8314334C23DC14FD6A9C011A2CA93753AFA8609320B1D01FB9A2A4263DDEAB8D5A00C40346B8F84AFC7B945F521321103A5219B533F52BEE42256EDD1B9A526013A00CE07D44EBFD66C0BB67775D1ACDE4AADB7C98731931E54F5C458264894971DF5D0CCD93817BB77A2E7D29CE47ABA205C0971F34096280CC725A3C22A4EE24A9938CC2FCD9A670272A463C852EFC04388CA8CE86A8E9F63273AA208610C2274709C55922AD371C197741AF0526218E84C3BCB61355AB94D5C94DCBB4BC08986AC075E01134B4029C8C1D78F829796C1CAB0EA2075BC25B797D82A8E0385EF1094D0A2B1731624308487991A7164D8A507F2390F354B4FA3A225D5A46463145EBB57B98724F1D3CABF11AD4FDC00BFA267D8F3107CEB7DA37C060AA23E247C28AD0069D30681E37807117AB841F23548CAA02212AFBC1BC54297202FA549DEF55DDEB5BA4D10ACE2650511366EBE9C1D61FA9D5574C86C0714AA523CDF946E1FD259148A7E2AB5C21884314E3B8082BC210B5209CCB6B95EAA2EF62203A0B707BF9C5DB1A155169B07D41C0EDB9709744CAAA36622F189773AD7A59DC142317454D9C81D55D1C637876F104B6836A6842B87174290125505461EEA77D63A8DAD03C7941B69D7F66E434922E13A8182FCC35E51C9CE81978E35818504CB32E4A6DFC777227A5484409A38B2A1E2243110E84D024B1FE0E0BB36D4AAC0622152599FEFA177B294BECE391D47553983E420DE5462C72AB588B2934680A399AC40EF35A5E8819458E0A7BED1AFBB29A446ECBCD4E45A50176EE201526E314CDE085AFDA30226039CEB41A14D87256BF566DB30AC77ACB80B29B1F9D602E919707C96863304372A353771E1CE994241A12369FBF42BCB4315592724CD5085A589B1B4CA46DC49CD65A1247178151E455741C8B5D7C9CAFCB75BF27A5B4ED05B22E932B1E3BFB0C93248400E5485486E0C39FD5CCEC680C78E6137BE96823DECA37C6306D31C9142FC03EC540AC0120EBBE9BD5237583E1972D0C4676708AD35B559FB89BD872428A3E0504350451DD65F58BCB292C0BA437394DAE55E6DF13A8F41827939016A081935D1788C4807A53A011B89528FB60F386632E725B163E83E105324C3914F26F389DAC199A926A25A02624D9A530BF0AFAFA4C5FFE6A5EF9422E422019FF337D1BC2FE16A07D9A046D183137D477DDA378E17A95FC7E02ECDDC0D551724A4F36EE7648C9AA771BD15AE29B7259ABB63D0983917156EDE6557BE445735EC539B2199F9816C562842627CC83BCAA659075F5179ABDD1A7056D27F7DD96A6813A940A9321CFB1946E95C16836EF028106BC26A3EE450D8E569EEB23B70722BCBF828821648B1668E6E47869AFB16C0E4B827C4CEC3C4C9948A6C7F874968DC80160A811CD06D58A885D033210341A6F7907F53A82C98468F6BDB7CC7A60107973DB0E70F9A387673234D6665019676215EE4597C65A13A2636CEE74266F373A4E48BB1DB019BF44EBFB0A5DB55C6CEC7B63C0721AAD84D2B6551FA941167C78A0C105ED9E5300A24BB2C8B2265251A38EC2B9D05A0635B2849A81A2A7C6F2660504D5602FD2763046820CA168D70B76E35B9641CE46A44F2A394F496DC32353C1A84302381E8D74CE4294A4A260A5B0704797567AE831D7C4410593CB7B9AB74D2042C84805C3AEA6EBD193A927C8189082333B3A5E96857E3970BE7DACA4C884D7BB0B3B9C250CB4135D0B8C90AE320DCB3C423E8A6DE79AD594240AE7AA036E320AD8807CCB7A1BC80C704C9532960864A9528347636B4123337DB7E2DE37823C6AE084418FDD05FF7E904211924FE5A370537762DFA012A2153AF96A46987776D245FDCB9434D66AA10524A3CA74E494C9DE919C8E23C3FF77C58CBD1CBAF5B8A69803A32E23959B2A7D9F808689906A0985AEFF5A8464A2AF64BA053A3C18D89B2CAE3814CD712484288ABF7655063C403F635D7A2AFB9D804E2E89677131BBBF7009C981548036726D25F05F004D605A24B7C2BCCC4294F065C013C8ECB242D25611B5C82BCABEB9E578758F2F3AD3F087BB6813DB1F3990C867A2E679F47F074FD012E87B3B6F51CB1707B9287D99FDBF43C8E58940109C376789E16C4A30B6BC34C870364192C555B81AF58962AE771DF477FF421A9B46C6E64BACD1A8A6D00DA4D9507212C910ED2C62D199C7E330A11982C514F27AAC092A5216B13AD54BEEBAA4049065A68D8CE9B1C969EA01599A71D633197BC33C2F6F958F72CCF14C7C09D973770F170F1F7BB9E458A00936D8677717F4A17655BC7A7EC56119779F7AA391D2356AE3A97D7CA04971CC2515154E148568C176A659A8DECBB2C5C449CCD914D3CB7431CB3A0A400A8C7B59B1CC770C5BB5B64E0932C61783C9979D6CBAC042216A0CC5800EA160C8C8556E0721D610FCE13992396C382E93BAD1514D780CEE046525C443FAE063C5882A01E5A73658A30864B1D6344A6CC46729BAB7810C46F5B480D309A263E30461769A55A2965BA6BA0B44054F211B98C6C2355150ACAB81881E5AC1E561A4BC4B39F9902D1027E56155F5D71B7CA67415185319BA769F88345611CA2C20B233DCACA9DDBA42EDB204576BD028A79BFCA57C9DBB0A54B933C970DE35032B9B51D00C9922ABB5106897CB896065FCA846AA486D9C27F5B616E99EA0ADA711729B75D86669645B9A223959B3C1C2F3AB6536D74295473C4C055AEF8C2CD2D321E9E73CBB872698B3A60667BC768014332083139D08C321157CFF1481F259ED56A7A3FF1717BB64FC951297C709A4AE3C05FE3910D6507AC947F944B970070570FDC9843A8A5BA564141F80F1654766F93048BE6297A1CB76C105A7BA3ADA06A42ED1AB3C17542201712F11824766C07BF14685AB0A9F69A15AD6574E59709D2411B37B509DE3B7FE5E8B0AC65922DF23E680C33141418F9551660467ACCC0C794A67CC530A5B130B4CF1C28747601D26983764ACBDDD30E42EB96125956A5870142574419977209A12E09AB3C5E8A22C1C5252527C90987A816B8830A757EC44B12E2E2BCBF19097D02B19AE47CC7BC99189370A1AACEF36415DED82FA7A63BE809B515F79F06612DABCA5768201C59E2C92EBA6D13B72C31648EE1D504EC3E89C8D796E77FA9A772499AEC973B63E864CE36A29DE99ECEC9695D12112CE2F60F27DA7F318EB94A74B437F8E0BC9513E9BCC38DAD99C174C1D75E0145F1E2F8D320AC3CB0C52EFDC753282F092BC39BAF4A18783A48EA031A191865EB78 ct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ss = DFFF52CA2AFC33401B4F72F5E6AB5D9BC21C08A6843FFB2CED24775D786B5A0C count = 62 seed = F7AE036A0176A9DE9A036A542DD2840033277C44AE936D10B768566216DE9D4395CD42B116873B69D9804BA6CCBC05D5 +generateEntropy = 6500f32c93415cfdbc0bd31d78d5be95cb9060c8cfa2013955b56f8b6868b322393308641a9a4647f230201e1389624a296b55192a9819fcb19ab77c25f95445 +encapEntropyPreHash = 818d3bb8ebfb32bf464775f7139bac0a5bddce80ec5798595992f9403002cd5d pk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sk = 0246C2025246911B525E6C3421584BFDBC83D73AB936E76A26236A85215C78DB7DDD010C2E038E3DDA69B5AA2E9F4997D8589BDBF918BE1C046CD518E6958AE6925146009D185B53456B5E16D59257F20CD0F6677535510D02602D5BA5B61C440FA07FABB1B5FBB38437E90522665776892EF205A41A1A2083902648844DC9D65E633266AF871481F036A2888D3FB9901355397F37875A4494777C781EC40478D09A820204A4115701D25A74B4BD91676EA6391FA160617C80CD05B0A80E040CDF22B29978CA55282F2C40316A35433DCC8FF7CCCF4280C0B11C548B5CC08FA45BD0760CE03A02F25689D0F057FAE44CB1574C42E760CB331C2CE4BE16823DBB2870592BA844F30DC407298590A088425E023B856E106437C6074547260A856E648CBA07E51A23E70D7CC65656B4692EC24277F04905C4AEEAAACD36341C705B504CFABA73201C2745AB06B056F1768447981E0D676EC904698EDB230F369190D8C1DADAA5CA59001EE8A68C302F04298DC5700C56B2B577D89CD9A585B239089847CD3E96CA80D928867B27F3657987724FF9031649C246CBCB4673F6CB8544150C9975A13938C89A68CD0B6DE5237FC8D2B7A6BB94E0C0856F00B821636801E9AC84F35276065EE4108BC1D755C1C428566A1CA3762D050458DBC7093567A4465453AB8656272A3C03B4A3C55929271437724471D5D4926109C9792BA49D117813948106D27C33069EB3C40AA8370B79E23F35934AC28666FE72B43F722151F3C26C96CC3B6A40D9E1876E55970F252811070FEFC00D70A009E4871F136A08515AB239C33E2DE638C4260D0C89CFE30B8F8E5927F2C59FEA3947FFD0BD636B10876C3C387C00E15469B42B80BFEB8681DC7715C2B248CA6FED92A9399B72D1023F9507229593BD9BD936A0F6ABBA09BC3367782370B60D9CBD0E8B3D5744101C8CA97EAB822FA4CC399B5BE3195CB1E3C9260030AF60BBE3295C4DE898C502543589142CF48DBC7505EC9A9D93CB6DD4C9678C1CC0A082C5631A255142603DCC01FC07C27D628D89F09B473816B5D5171C18A3F9737BD6D3420D4BCCBD3A5624A2686E54062CE4696E061C83BC2586F1A618639E51E63BC6C64825EB50D4F88334B29145BACC49E28DD564B7A578217FAC230AD00A44F3ACBF8753AA572D66E1AB9198CECDF9BC722455BD267FAF98424EBA4031C3BBEC8298A9388CABC6B3BEEC7A7FBB1C814811117A9D550407C9E6099CEA65ECE641F69454B6A0CA9BF86A3DD472F7C0A7703C6A5B25464C0B091B29258DE673220857878434EA14CF50054FB2E63547E9BE15107BEB7A78CD5C00CBB1462A0347E72B51A15CCB5C333894ABA511295B37C97C7F4C2EB6D97219559B40A67310F457108015AC1B8E3AE15ACF85689C4058EC8A0BB18B75615011F2701BDE8BA70986B39D3368E1F978675A49FBE8509F1239A1C88F1DF4ADF0AC8B68A87E2A403373FB808A7B1192371C7E68B80854B0E4335739090B953A2B67999F9878A32415B78C22289EEAAEFE3298FD38ABEB6ABCF5A55BCA388004E46375A729CC45926A7C3E3BC8B4E2A2B196AABE5651B642C1CB50F666A1BB6DA4D1CCE8C6344356A68DE044214453D03B5C7A2912329482F244226AE33507BA8FC8366736352380B346CA39A936190F09576C5188C5E82315E3532F34D41F1B50BCCC42C1138802CCD5B50A7846FFA7BCADD91FE757AB7FE30E873BA233E13B21D25461030593433F4F66482D94B916AA8D1B4B8D6786926E9364CB579F52236218F199C3925142B53500291A3164516FABB941F98F0DAAA1E2D619C9622D649A0408AC02D5CCB9B787C1F9B196DA37020E362ECDBAB03CCCB63B659C6347104074B1F8254499C8452364726B1294669A3A24AC8B487752175B30CBA68860184D5F78B845B107BEBA80F8750475D059DAD57CAF827878B926FACBC00B54388F24B7B431347E334FFA046C45E234124C958CF66023DCA620E1400CD5C08B89554A474D7D04086E5CBD0D051C03C4580D3442A575255C833026BC19DD301A70367FED300EF27779D2A49819A370519C7FC404ACB3FA441A931C67A3033799519C883BEA134242F35F92393DC134BCE15713DDB33E252B991AF10C7134A8ACD09408C8CB2ADA36BBC25224E8867A4138ED9B4DAF403A477321614B3EE5C7BC2281441936B0B05513C1525421871D007346BCF52D6E09B756B4529BB5480AA3165E617CEF41720167707F35A4415975A62114C7918AD83BBD8905A283D14D22B2400CB29FB1E102562CBEE5A9C10929229F8C60A4B153C430A361812E75B244E4C3954A945459F735D45572E83B505030C13867C720567FD681C539D7094F5558DC5A86DA79B38049B0A45A1259713AF2C1640EE0279BB7191F0C0EC59C2F91184CA70A2E8B7576CE493E32F2C549C4BAD6C925039C4C57114075281AC7631FF4D94EE0723C3400CB2D73C184489AA5B440AD470CDE548F2F70903D08B9B4CB6DB68A5D4FBB049A5A9727F50F9E6C59295C62BED7182CA96D6093578DD014F7EB0B121AC6FAF917FA9B47F6650C6C7336D8848DEDB92A0F70971E456E9AE625CFE266B1000C4EA6252DE1CE20C014BC161FEF405FF327CDDDA37BE4919C2A0C097D6995B0EB743FF66A548307CEE1080A13841ED12333E62EFF081514A5915022C550C6021A27889BB0421DF3A709AB2F9F3B0C0F6019FA8810CE3A9C37F53CD651ACB4E5BC1D8B231F373B7A4CA6723A9710681016943F29697B09F6ABFC1C60E8FC4C201A9AB05C260D2452C83B88423B904DF74F425A9B4D116DE0D059D96779D61017C2E984C2BCCD6159C82DFA5AE7BC63E59304B1105CA054A71D753E7E583742E715BFECC80E51245FF53C16854AE0AB41C581402221CC8834A5F4556A84C19F6172C7C80C759299A42C71BD67040A29185A45C14B91B56A4AF9178E0BBB0C4C197549B5C9765A8874686C63445DEA7A85D43AC4D0B979B4CA13A80BF8DB634A163FE3F4327210A7A128716B9805BC1920DD322B15C74FC722A126069ABB8C95BD090F84497D832A1AB72358D4193B6542BFD627A139374404DC1998416F46054D1B4B538E778D6D0507FBF5571BD01CE56362164793E58355366495AEC80EEA35463C4044B202451B3604D6AB96ACC3617ACC1015379564D6A5FF1A6AE4D802712A94422A99D90988206776055545172B0282B5162B479D748A2E9D22356AF11DAF2629036665EED0642044B76775CFD9417DDACFDCB371AAEF7ABB3C2CFDCA88891DBF808A90028D4F12C57E4985F7D4BF608793939ECBA27DFF5889D4D921C583999A57E20A48085AC549573E6ABF393308641A9A4647F230201E1389624A296B55192A9819FCB19AB77C25F95445 ct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ss = C870A7BE3DC7BBF5836727E5BD82CF977B1332E7DB276473E4029ED95204ACDA count = 63 seed = D995D38F934B6E1A7CA77C9522E3D037676CC939B0C8BD4B84394B3DC91A791F09D2D97199258C9943DA955E7F7B26FC +generateEntropy = 7643cef2d62cc5aaeecf754653ea62294cd2208e5bf3ddeea209e3dc45373d49eac9d531a532770837a854b4f5531f6e0c8d6c10183b30d3435498c2dd142951 +encapEntropyPreHash = c92aa5fb91c980d9cade9ce99d4c75b2ffa7d6a6ff9bd59def1aa701f2a0992b pk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sk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ct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ss = 3A14474E05DF3FF59C6105B1F2AF004A8B8164DD049EB6929B9C9881A873AB08 count = 64 seed = 5929F02A271725CB40200DE32D9D03D8BEA53B53AC83186C42C7F565CCB1CA508305D470850CF86E9B2C61A5B8CA1C93 +generateEntropy = f8ee95521060c03bb8dacc79f7eb7db640f545f315613a35d447a09e504cb4e13fc3d8392cb53f36ed647364a04e37278a0e0a45b720f4a75c580c9920eba98d +encapEntropyPreHash = 7e8086a01dc5b3bb9eda25bcc45d27f99874841b97237968495800e007696ac5 pk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sk = AB4545850434076342EAE8409FE0590C34955E860267305FCA05C347BB3E53BC714E3134A6E9B338674A9AABB02F021D1A09A190757F03D573C27687F7E35F2D77294D10CDED732218395B344523F1B704B27689DCC286B5C98217F239C159AE5D655436F00517A50C6DC6B7F4F111E7F37A0F319BF6ACC7B0E3345C9367B2A2B8D9D644936220C0A817FBB38CEB3469CD55C661E1C58D06807504443448C4E53204DC59C60A5153494478EB4056C9A85967A42EBBC287AFDA51FDD6B84B285523D41D80A56F7A68A168A4527D902311B18D5E381CFDD578BB7924FE687D3AEA5607906815181171A727E4DBCE1B678762A8B03C2A2BFF1635CA85332AE90F14B880C5EC4E5389B7816AB885C44A8D83C5EF0C4C754C7B6E673D984938D3CA4EB0F5B83B90BEC27172AC85154EF27B91623841E188D76B040F958C38C8A112C05B54103E55A159DE0954F2477E798A573339508B7C2AC3872A623429777BA3179060135C083E2198D1E0AA01967C39C27372A1A36A92BAC3BB13EE3C94B1F0391E2702C50253DD497F16F39BDCB9C68CCAAB6312084884B113E70F38555422767F4E613B2E87AFFC01395FCA37DF0A1AEF74263C1001392732D9D1047CC7C6FB910AE6136C33094526876A113514F2918909532A759617DBE2C97E72176490995DC82B663655DF65324B1996A42150BE41B2A1C90F03B2A6F04174DA1B1CC7FBB024C3C972B9714300C683C28A90F48B01C28607922C3ED25601A609673481B365544B7C36A9550EF20C37005B0E395A268E90CE1A5271E1421B46303B80CBCC81E2894D7569E82C2F5D8C6996C766BC505976628CADD84A3F468C67C209117C8254BBAA1BA584DC2661728A69E959949ED6C9F1B42F01EC8E55614AEB7168CFBB5E16504EB9F585C7789C48E59C17B5975C444BD6E32A6654BCE298A605043BD367400C14B1D8E1A592A034543C04A44C85711AA66C807FB07378FB525600C19D9A4A9A8C920BA7DB0B1D912A45F2B6D518B469E9121D25CF40499196376D3D92827E1B96AE255AFF288037793C7DB07E1D15533C07162AACAE3255C0CC368E2FBA3FEF09540952910EAC0FB2F3AE376AA666FC97A3E122570CCF797C79EC575835E0BE6E808B3CB1B72D8241C3679BF15020B6A63BE65B95A2C9147EB98C6553C71C550E37603E6B73C877C94E7B603A22ECA456C1409D5AA049673D0EA17C123B1835692253FCB589186BAA498F39481C3D0640A4D34931033B30F26EBED6CA9C49BA6FB219D6DC8461937284235A6417CC9C0CA0AD385B04B01C81D5A7B97A34977250E3679AC55C3D76D83B1F7B99DBA039DC179147223B5D6C11FC9109DC062A1E4B7C88C710C449320949BB4405B28EA2C04D48C58AABB46EDAA58E442F3AB6C9810B6D702855F7CA91AF71B0E574BAC1040DBE864DDAA76827874839414CF3418D1702C6F368A10714CB25E208C8A5779F639837A07E348841A11714F41399DA175C49678307D3634D6B9921880FD43CCB8D7842E5F34CE44A4923E7CE6B671C7A989AA748604D147CE7AC25A1533E80AB321B7AACB8D523A3A6298BEB0CFDA435D77714993173D080827FB07B7855769EBA987696AFDF58231F361D61101724795296A2499158C8E1B50E4C900D65C8AE65503932DCA40E058E8192CEC2A997CF12C8A1227567B12A1B21BB31D3198C85C4878C6EA1967668E3952D04B4123CBB9CD8C77F3A7397A9133D99654E6C56E7465D9B98BDBD624C12E36C62B60B6A32C9086A8EEB9B8919706F4573A33C393F74BB51D5609231F1707E152F23F36F6C6830EF28253C8CB81EC5C27ADB02FBDA5302212826F0B88AA4B4D72A509E29CB1BFC8177C019C60598E693BCE999AABC4621123415235208E7869F62AA7B50A51724C13DA2DB59D5BA5302C772F2C1820FB0882EF32F73321C17F40D019CAD39C3B12C57C3519CA0B38366AC4353B133C39262BE6EE47ECF660286F6CA8EB7090418ABA0D9833E22B46B761FA2872FB80972B551809C02775BE07C796636A2C619FC748B90D28E1E702FFB0653E250C8C3759178C39E42411327A81C7E7887B21915A5CC032C37A11382C4D9186221B1C66AFCAE8184559910201C8BAAACEC62BAB984E080433B9465E64A2D987028E9D9090CB2C41753742CD77F0998C672441E83D45F2D06C22899C2136362271B731F6BA3965B32E2517463E627AECA0AE5644BB8602F7FC599ABC120AA111E2E549A276A18D2A92C39502F6F9519CE76C0BCB514E8084C7122A321479338F59ECE08A0ACD30F0AD68F2091855D5980219083398A6C0A63C70D3743678A1C0202A69DC526DDB77E30B779C36AC2575704EAD94DDF1661A38B2624E733F2E2AE18467CE2C3083B75017411390314AB06ABB4D0FB58BFF99DC3949E92994703E85FB6B863AE1C29BDD6656CD75D9BA453AA115A32745F2DC1829881A9F4D5CC2CC053AB79B89D107E6054C69DC93F5AA9C8CA6CC1A7583F2E2739B102378D93990CB8280B21A5D5BA8415C48EC17288044623A9631577C16639922978258CEE0B6C51BBCFE3F70BE07CBAFB7C58111CC7F2F922AA023D5AD01D2D31A57E0469AC428B6FB88A97D957AE22BEB768C3CB7C9F02F583FA2513DB7C580D2986984314E8B346A06501D8972E31AB8EF5B983E9A15E8FFC624D0041FD523570960E09E57D616A06297BB3F9D938F5655628B06C4F6C4FA5F8136F8CC05DFAB7389237EA75AEF46117BF1B67AA978BA622491260128E743F28F95F533B708F3C59230B23FABA96FFB5C239B32B30A65B36FC5A0A76B76F04A60C9C7D5EB78EBE44B736EB56A0812F59D9B5812916246228F2523175242CD1F432F9FB054A8B52D824349DC0756091B2F7C21E2A899362157BF9F631287B90D6C80FB55B1469273F79892435D031B62982C49A1464E2274F815F56F3B6F8C949BE11388DF1151E7077F603AE592623E4259853A2B90159344B041AA29C8AFC5074BEE81959102E0C57A761F1B1AA65B1DCB66A18BBBBE12B2B2942A37D13C77C77B2BDE758EB1901F74C7D57D373A47737D6E23998E35DCEE70983359B4162C7135126E90A807604034D52ADD3530456B66F0DA64453150AFBB67D67D9B359137C2420250C279A1C537AB06952E4823F09372198C253D5B71A7E70A1C48B1DCAC3A85FEAAC35A11E670B2840A57F2A7C77B6A00CC80A282F0A1C8160080C702D619A6B6D68C757306C93A5B21BA8185B1A46C79B03C35880A7B265A3E05B2DB868482FCDBA0367177BBBCAD04F3A50ADEB85DED90BD59DABB8A3B8CF4709204A2FDB19889B0022EA655DFD58FF27E17D530510E1EEF457933FC3D8392CB53F36ED647364A04E37278A0E0A45B720F4A75C580C9920EBA98D ct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ss = 2D26F4DA925E01CAAEAF4A89F5CE81148A000F7A36DFEE74E059A933D973DDBB count = 65 seed = 905074033D7B75DEB2D06A2F29144EB377B452534C5710632989F02D45312D156557E96D4486020826DB200153BC4A8B +generateEntropy = b8bd0493a882e3a49b4e0f6256fb1fea0912562fd9ba26ec3d6c9cc12c8973abd7e4b5d8021c486b9c3114d7cbbeb7cd49eba8a61bc2bcae1f1bef30a1daf76d +encapEntropyPreHash = bb321ef14d44d8698df879fd52450567657f52a2df8d111185dcd7d4f30a72d4 pk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sk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ct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ss = 5012217B85A1E5DBA62A2476D7A441411D8ECDDBE2D3A291F658B7DC1D1197E9 count = 66 seed = A3E2E511AFA7BB560446BDADF67D2EE2E16FFC7BAEAE7EFB8C5455068BBD4E91BF9BE9D98B280072FABA7712C75B26D4 +generateEntropy = c0407e41ddf48d333978b89bcf2db01e4613425b456249e76a6f25b8a2827bf5b2dca81e3f5f748d23c9d356a2209f6b2d60247b2e45c9808de497f64f124643 +encapEntropyPreHash = 210a423dadd899b810f011794b79aa7f860823ac1962370e791287d3a1afa384 pk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sk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ct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ss = 0DCECAC51C5261E34023D2E04146CCEA10A0B39AE7EDC50736127184FECFC8D8 count = 67 seed = 074AB1A37BA5A0403D8F68D26FB787BC2C90F5EF88F2A6D286C3E6B168ABD85D393D8225618608B8EEB301D26AF53BC0 +generateEntropy = 334382d39164d1989696a2ff77b25a28af8bead9883b5365eb6fcca7c1781cc9aba5068af837be962f439f233593d193ce5e08f7d66efb3389885927b89d2523 +encapEntropyPreHash = bc856afe24213e3d14c3d6f9b89223bbcfb2c890722d770fa3492c1e46d1c302 pk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sk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ct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ss = 0D403F00C22FAB72899D302CB536854B934446B62F9DA6D9D6CF1C0F7ABAC2E6 count = 68 seed = CC0C86CC0ABF86FA21899BE1953913C00E7C46E6B5F730C4E88B3C034012763981D7F14459D3081638080378348856EA +generateEntropy = 6995143e8eb8a6e93840f76eec844f67d2b5f75b1839a5040337e61f9806764a0f4dff8e56f68440836a072412a30d851ace2c7c6f02d60e7a8420001a63e6c6 +encapEntropyPreHash = 5fc00f89563e44b24cd67d0ce684effe5731619fd08e7d72e2406eb016afb66b pk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sk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ct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ss = 8C0346216CC65F95D2E0CAAEEC4BFFAACCC49132CBA2DEE8F2A6CE1F922E6DB4 count = 69 seed = 6D5A7CC326ECF3983C4E7683F45263A37F692F3BCD2D920E1FD9584350119E74F9A3F905F70D3E20318C1413DE2A0DEA +generateEntropy = 995eff7e0d195c6d0533f3dc194d47e60f9ad14696144cde694d60a95f3e96b4b28f7e7a15a005f92400ce33db073d49b53871594a88fc45e0f94207b5f0f2dc +encapEntropyPreHash = ea22a76065db4b565ee1807fbd813b43bde72b0e08407fb867c6a18995025e50 pk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sk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ct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ss = 35151C059E5220D4ABAB9380FB0EBFA061148E6096D8F5678E4308CBA0226261 count = 70 seed = F68FC0314DEA88F66AFAA76E6C9B6804B13D4876924410D1F526FAC59A62E26C560B125B1D0F8B461F1FC2E351EFFB4F +generateEntropy = 3e809ec8dd0fec0d911a4e3fac20f70fbb128c5de94dc7184ca7310ae9157a98d8128601c28b1def8d393a0db283229f7c7383152a814e7cefe8ef9d9768c473 +encapEntropyPreHash = e9602b34fe73ad57f4bf6ead99743d645641553a5b9b9bf2e7016629e3e9bd76 pk = C0C8122855031D7BB0CA735042BB43B8EC6EE13061046ACAB9B873B13519C22678ACE2B59F92AA4E8269844B1DE5E3426D66C0451A8D78CC07E719033A536C2BF4C7397C64C6478BE5F42A06413B8B44111AD9742B8B020711446D63CDD64490C0917557B884EB429B05DBC0DF7ACEC032ADBBA55D3E104F7BF391CBA28B903A07712A8DA3A1A92F5682CD650A628573844032A307704FE77AF738696E974181A85C5CA1C14F7546F8713701115883480BE2CC686625A37B62292367B5E1546F4189592639CDA4CC20974C6A87C0377D15B8EC5C84B70233B64800B79C62E536553B43263532C6BC2B726970CC58BB20F0C0BD35B317D9B66B327BBEB5175D9611985AD799EBB19AD0587AEB856C288464D983256649827DE9AF0FC79AFA1AA5817C06D3447A25AB3EB8248167BA60A4462ED47C007107B1EECB630AC4707B837F24D26DA46BCDA77C4B6ED5B4118B79294744788B9A9C21B168565D9398B41EDB91517493F5FB48AE5CC04FB95BB13A8FCDB8615262408AE25C2985189BA8AB99643624B70557A984011474586C357F1C7551F0BB069336FE85BB903040F48C4A111113507055F2716D37EA6A6FFA48F40584914C4738397430D65756F298AAD345671077DA8A4173728364A493BDCA944B1879B114166CC3B8293937221257C2E78F8F1C7794ECCBF0368CE34921A2EBB01E32A92255A676E77C39564B575AA5D1F9C7D1388226D636F4F12C5636B2E2F712C59CA583A811BDFA56448C013CC820F21A36C3351AEC3C2C6F01243FF47BF17181ECAC752108C43A97729C6B9472270FCEF5A7C08665F7AA9FAA55B152163E8446C1BEE5082192B5ECEAB269EC13E7879DA3768BBEDC0A104C5E9496C63E9507881A4C8E758211076653F369E58B59BD7CAE5B9A64772C2A84329E43F492FECABBB56514CBE70970F361E6D3C6595065F6CC668C64BAE7D587FA8BBAD129136D5C9B6F757A51E653D2754AA0E35307845A55B80086D5A0E86302D306B9EE1550419B495D424F701A098220897FC47333D5A1E994C8584A00D79804E4989A1CF02DCF9A0AC2AC52BE1090BB149778235FF6091075A5360CE095CB705C81E3BE126984F51AA471F90FF98C21D3989FD936502A8A2B38C4A2320A618DF751C7099D1063495A6A5936C744A094CC1FF1B04BA8B56B0464E852BBE06176034CBF5239CD2C687FACC2CD37329ADBEC3A77B4842AEC40BE902E8AF72FA5805345668408CC7B6073097391921E765E4D76025FD5C78E246DA268A4DB21446F2CC3273861D2081DAACC2CC775631927B709DC1FA8993B1E92619590C08940342219682AF351495B2E0AAC74786C897FAB196ABB609E216997C2C7B283BFEFCA4B1F2B1B6E98991BB32424321AB7D61E4D13C44DC93295A75F6145BF2D4B8F1A03109BD7038EF4B16FC15F44CA6EA3411B68400EB20C46C11CBB98201D705A6CF4F4B792AAAE80D97A6AB830576AA651142793FA7DA0B8BEDD877217D54897375EC285849A79268BABACE85176842C601EF8C740A21C2C5321436A21CB968ECB5410E811912CB0962F713322021516535907914B86E9411D27CF164B580528768AD37B57300DC201557BB0A142D9416ED7AFEF52D284175DEC18F24979EF5BA8EDDF7CAA3880AEC7B42A147E75F0DD62B3D0 sk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ct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ss = FA4C0C7C5BBB803ACD4AE91E49CB8CC659A94490E8B786CABFD9B92E949FBB0B count = 71 seed = A229218B0D51F58D915DF549901548FB0722F352C7470900E7E4D8399205764A319BBDDBD06C00E8C5932722EE5A404D +generateEntropy = dbf1c465fff3d9f783bd9ee61a573715e45691147b8904439b5ffaa64f94ff7bb6d75eac6c76ced1b0a025b40a55440712ad8424672e761e9bc400d63812006f +encapEntropyPreHash = f72b9080a6c051bbdb9b0abc1949034be0f89a9f73fe277ec4d4740c78d04a83 pk = 80B3B92647A1DBEC6BB883A4B2160E4DCC84C89C6ADBD955CC055933D3238E325FA826ACEF899A555873A5B9C189117844202C65E40EABA07D9FA94D421BAFE8F3A5E3346B6B93CEF8B75628E4418E2885660B1D3DF32D1BD50CC50757C5227928B32E0C567872E66BCB58128B15C8696710A7B33BFDA469128996F6979F896B93D22910383C90D0D877A56B4B7C77C53C99128719C2995497DD36877276A25FA8B74A4947E223215A314A075585DA457DAAF17C41711363950EF9013A8AD95F9E07635546485A3568AA502D608321061A6999057E705C46B6691183874FA9EA38BC392F718C99DDBBA59A1865A135207A00058A408B6C61772CE777456C92B28A51CE823F7524A26639AC64AA49D6903CC2B2B5B60B59643BC950230362CABA6ABB5BA4F6964331B1F62099CF385BE3F5B43C2B8402006BB3386F5A16354E45118F0B759C3363AB4069EC2C4C15CAC4E07A24FAB0C682548337D157E6BA213C7801DC5A0A7045A442B4939D611469746E9DA665E2E910B51C56B77A035900B25490216C0BB53E04173B3BC454A7A17D77283EE278E7D30496301480C8C1AF6B3E1DCA213B174F968C8A45A3BA2044BDDB1492BEF2AF610B4ED2481AE0823DF53282BA7750FBC7A764DB58E3789CCAEA778083C27ED101E3C75BE5486249F9818A08047F97447773C7DEC3BA7C59AECB5778A09CB7F1182B2E0A01C182A1BD13AB7D72AF97F96F564607A9A970B35A6ADFF275C35C22C2444AD6E997D821C065EA49080900E766C0079B7ACAE7BC7CB3B31301656FD39591E0BFEC2C33F05A0DD633BBA463781F1C519D902342BC12BD16C1AC8305EA9769E489073297784EE45F99B248670749C728385F601FC84C1FFB298BCC447537785226BB5DE712B7BDD04A0CE39226919105F06ECF6BCDDB0CB5EC3B5505B5A169B05480B2587CE4934D2B232A44A6683920A81A6038C59497C9B47FAA62F4F2120B15C360616E6573BCC5A23A88887B50D1A7DBAA429BB00A9F87B63829B1B641922425016C979DB571BA0F1A139267BB362C68F47689715CAD6636402049C2B5C616C321CBA6E43C1C1A48A0E141CF3A71C0099BD183A5C0E59BCA9A2FB637C1B534CB6687493EAC495ACC7C5FCC4898A52E44094FB1B7014A15C88E11A9E7244EE53C2D5B16708C233ED37859268501630A296D63C094F563F0E559C59453ABF05A93722AED5AC0C3CC6A0BE7890F8C3191677C21F70C8153CED3E2BD96A4BFDCE27F86B809D8AB04DFAA837FE030F420B845D23C78CC82A2D7C440897C91C3B726B4622445899DE72BFA263B93C3CCEAA8500B4B0C240046387B25BD98B5901AA670180A2A8B27DE424F4D804A68DCA2E044430D701B67E9B4AF33C60FC54BB3A94A8B8604FA5882A401A5647B8DFBB20878E4B4094136BD4B5BC14288463C2E87F0CDF6D9497FDB5F42F26D2F9CA2E048A757A59B440C2C5642232E714D11FBA959AB9AC52126BF689864AC98CBD1A633BAA3ECF75C09C4C6878994CDCB3E882798EA02AEAF39915DCBCEBFE2BA14E620F53B3D83AB58BBF99509033DB99B0ACBAC29FB4674C95CB94982AC398C2771A8AB6DA1CE9B0771E3D5C2E7655B4BB99EBBB57ADBC7A540F228114639B811C5C1D3B614DAF84266BC4C312FA43C4109DAFDE79000AB39 sk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ct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ss = B7A8E7B3C6D244B6B0DCC45947DC91F795ED21A5B5AD545205CD5B210DF37325 count = 72 seed = 6960F21C7350DCF41B4770C551DC8692D8BA2C0B6E162C589166FF22E7A1AC0F94C2F48504A5F7EB0DA094DF427BC98A +generateEntropy = 1f7cfd2b70863154e8a69d1758532e86c20cfc763d67c758bd10a13b24e759b5273b38bddc18488024ec90e62a4110129a42a16d2a93c45439888e76008604c6 +encapEntropyPreHash = f1e5542190db8ecf4b8d617a04fd3783ad0df78bf8dab749afb57db8321d151b pk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sk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ct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ss = 70CF00481198A97F14E0870C268CA55B6EF787D130A4C32314EB7C0A531CD188 count = 73 seed = 53DF46012CAD4A745B7A3C06E18CA95E0B839FD8161E3025749A0887549EB0ED6A44EEEA08BD6060D6509DBF7E9DC864 +generateEntropy = 3a19577908efd37697b8edc7fdaf47d1bd3ad01a1b77faf794bee5b9c3192a6fa3729672816f3eba84c9638a79676eeac0f22c8a48e0c5d50a26ff0844c66b99 +encapEntropyPreHash = 74efa414ae171bf60b6f884cb7e5ce12028f49365daccfa23e845d551711660b pk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sk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ct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ss = 2E8FF9C053137CA6B6C31CE8BA7F14135A7E102C211E68EB99DE12B94273F9E2 count = 74 seed = DEB963F8B1D8FBDF499D564BA8D2D47915BB402DA02F17031B37B4039A842AFB9B7E48F37200605992BD2429427A7A4E +generateEntropy = ae0f65e29f38804a6759f70f4d01e2aaff7fe1c91ebc4f892dd0de3ab2e68ea5e03ff73e02a217659f53d8c47556bf3d8c94040f630d63605e2d0f923579370c +encapEntropyPreHash = 0b4c3cffb2ba4380ead13dc0d8acad2356b448a810da1df29f264c44aab6d24f pk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sk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ct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ss = FFE9448FE824EC92022890969F1FA8E2FA87E5B3E95A9A155839177CD3C8E359 count = 75 seed = 8E2995F1B3E43853B18916BB1212ACEB05898E2B177A87ABEB928AD7184E59695C56B2CCCF5DB80853C28A525E327D13 +generateEntropy = 6084a235f79dd093ef6d185b54e69df33dacee73a9bf2f379004421a10e3a79d9f684fb055ece19459eb464e91e126a7a6e3ed11ccee0046da234d964c985110 +encapEntropyPreHash = 1c82471dcdfca3a6942061ab4f3d5bf0d197321437c706d9cccccce449447002 pk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sk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ct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ss = E3F110E7D74400CB476B0E34141A107D874986A3732ECC103D9BDFE76BD492F1 count = 76 seed = 9218943C51FD2DE47E509AAC67EFF176795102F37D7A2017E3AFD768FCDA7877AF38739B00FCDF227C2FD62EB635942C +generateEntropy = acd1c0217fad5caa4235544dd9de153ab1880ccf4c76f16f236fae4e4bfda04cf03a8abb0a5010f400ae5722a75bdf5a2f6d5b546b34d73857cb1bfc7e587aa7 +encapEntropyPreHash = 46fe60a18124125ab93e0c578f1c02f1bd1301595013001c7f3c2fa56cde294e pk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sk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ct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ss = E26737292D1A1FC6772D9C14F9D74F0F4E830C0BA04253AEEA21E69830A3A360 count = 77 seed = 542E20078ADD5296050AF150360F057F6B9AB3BA835589DD56987DE805F900B906505B5390A0D86CBA28038992DFC59A +generateEntropy = 241191401a63afa750f05662e354dddbc683c776ce3222beb83e3cf913d7ed7ca59b3bd23b49a95bc1fad20070fec930b6060bd827d742b077092e422268e15d +encapEntropyPreHash = 52fb7cb6a633fd2e83f2892bd9441b48fe59ecee6d026f5246fa7f2a5e55ee3b pk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sk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ct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ss = 1D8DB19740E2F6BA7C8C04216CF2398FE9221B2404ADDFEF8996A03EC72EAD37 count = 78 seed = 6A85A61DD08C0733FCBC158ABB49FE0B0D96A50DCCA140A2E9F5A254F1901985844613B1C656C0CB0112620591B88AD0 +generateEntropy = b9a6b0c05677e957d41a34ba03bd06f2a9092e31f63389397d7e70fde6409d18e99c0e7b82be89bc3c1eaee6680aa4efd394e40c2b3f30523c8117f7c26a8969 +encapEntropyPreHash = 0f81a5f97082121244403da3feeb734f6084b314b8d94beb11627aa6ad1914e9 pk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sk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ct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ss = CB0026C186440C0744C1C1C708D8FBF2B7AA1126792A7363576BCB2E64384117 count = 79 seed = 7F4A56EDA151E7B097CFB8EF980440FFF707AFFBA91867C89522CED6C5FF3BD7F5F00BB49DDD615D9361A7E4EFA42851 +generateEntropy = 28a96c71577ba00c94f99fe965bc595a26db2b3ca6ab5cf8e443cdd8462b17929c35d165453e5fcdc6f9df64526d9de698f2bd3e6bac6c7fdd86601b9ba5f4a5 +encapEntropyPreHash = 31af9345365549ea0360169ed57daf98cc5444799d4c75d9f1f5d615e9df8a91 pk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sk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ct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ss = F855334CDE90E9E858863DBAED7BF4C45BF189861750EAA59355A3648B1CA1CB count = 80 seed = 09FC004519BCF85B20D25D314A0DFC79E00CB6262A7DDDF9C52473641AFB8CFA0F5DD5F53558184CAAE9EC34B459E98E +generateEntropy = c08ba2ef8c3a0a043afad931652d7a19e6e8cb670f840de5f1fa03309b2ca9ec5fe6141a25f7ab9f875f79e0a82d6ea5cde5a017ab637d5fdb7c42646a1d71df +encapEntropyPreHash = 774ae54093d694ef40b63b62c73e6c98295f606feb8699807eda1d030ffb996d pk = 724ABFCD15255F0A5EFB7783D909031ED02C52A203DE570873C7A7C556202D53A6C086899802BDC877BC6A813AB59B781BB95F4FCA9EE76028AECB9142A992DD7180BC1C15DBEBB66765C5ABBCC5EBF764D5234D89A378D5925FBAF63A00E35D568804B973450A045E55C7C5F4907FEE390FE6877963E386BC20CBE929C3D247611E346EAE401ACB972843DC204EEABB043644EEA29BA2C1A160B98F0D28CAF0677AB2ABA362B7BFADACA4E1197F54F03AC8033814A71E1CF407972B3F1D9A986637A972B46D3AC46509C053EFBCB9A475BC4055265961C79E1374C2159BD2409A84F22755A1B32E4B604783BCB2AC49A27A5B0B07AE346AC38F54A2943559F02270BBB19508E903888ACA4BAB72E332285837B9EBB466E5CBA74D5AB6BB3B2A0FA26209A97F959C905BB4B058BA8ABF30A5A6C190A018A9803AC29D84BA710B30DA9A0844CC1A1478C289C32737144812355E0D7589B9AB765CA3B23353A350876F05081F3E4B14D8F66C998B81F458A394CC68C3B7BFD37366EC93113DB928E5F9BF0E9AAAEAFC619E332A7EF3898A66020DFC64F671879691C023409B53686770F8148A2B6F7B62B6AA42981EA0CEA7753599585034B9AD99C9AC8B12872B1A47A088BD8AFCA2D42093928A4FB770198C4CC50B0214C4C94FC7B62B5E636423C6ADB553B138591F6372CA6D53343FF7C70782A2DDC4801B262F220A539181C13F3C3E8E0A0D7191A43A54AB008D326DF803FD8757F88AC9BDC8BC75CB83517AC71FF8613B3BA713377FDAD2199BFA332B8C22C136350ADB9553E3643D0C45413782F3BC9E941965DC051DF98738CF50113AB422E4A22759CA016BEA6FCBA390ED64540112842F5B1373A2847107A43403B4AA5CCAE154B9C54831E3911239B79F1FE997BAE30A542560FE6647A2E7C4916097FD484C3D040456EA2BF8B63DBCDCC8577B7AED99C05FA28D468272876B614045095E918600F7C94BB0944F62235C169B58789AE8BC3E6F677CA8D238602399E307553E235D11836BE120B3BAC41B0A668E0841AB11F49E27AABDFC27AFCAABBF542911B6A220CDD626D819C44C72556A3946DF86C43D1B8693944D399A3B5B1309B9780E34330CA387CDE8E4C9B2D0775A962F447828D6295873CC1629777FD93C062098B6149A3E7C383E2C33CC3FE7730537416FC1ADB6C09F4CAA736E4C796D2A97FA3807C9EAB72993B4B876136B856C7BC75AD054288EF491EFFA872247A99AA39A9C2B7602027D65A169317CAFCBB77C37D89ED32489E3C2557998A06689B06AB96615BB5752D439DA446354CB0640686AA794444A806C31D721B8C6B820810A5AFC00932A885107B5F968B5C8EC98207293D8851892A01DFAE4A99832326E3863BCDA75190C4A487B46E3914B702017B1B520CCC30A5C475FB2DA94EA217F76556BFEE825076533973BAD3AC7305B5C764CD040D723617090AF4A7811E9AB206C6A331A647D9385A5E7D8BAD6C89B390B617018C4A0691D262429BBA173598B37D7C245452853506437E756A399670AD8E292B0D820E3567047C82870E82236389D99D678CD9B49526AAC30D1B830B12F4E62407A59C8F88B7B5D088A2D08B9F114C3F158650F32C682EA6A76CB62D3AD7357CC617D597A3DBBDF515F6852D71220768859D599BBAA sk = 28BA2F24DB8E2A5B21092964F1871E97E10F2727C8B27916A5068EDD27670D26B91A93332157AC686205E23616EB0271B081B51923C5996743CC114F3AD310CD6791AEB05F77960991513EC655533921A8D14CB2589399EBF18F7BA89BB7D6CD2D7336ECE1B7B63B98F26A49D356578CE7275EE67677D1482E1BB3D85B88325BAE0A00CFD1288C34078D73965442B7B140705F0FB76EE3D0921112C400C7A4D1337D6A3A8CDFF9AF05C64C079C64DD143F1FD56C28096313E82D51836A2DC1B0F37A2E00545F802B417A9406E55420B4D71FBC2210D05A771CDC164AD50932EA40A876051828236153B4E1715EDB1453045721E89A60ACD0066227704B8AB991E8A06812226BC59943C0814C847A1865C19DF4B7FA13BA3EF95543E724EF854CCB28BC1DB49B75C1ACA3649F848BC6F32C139AA79197543C628238ADB755F4DA6BD67130772B4790B28C9F1544A4E9860E875E68C1CDD9CC0CF17451434C7C53F3A9BE39849720B1B80A836BA4C531D49BAD16077E90203C9120C23239CEA972454B08A5F10812443CA75B913DF98DBE29C3312157E156311F67354D414AA041833F8454ACA5B3898B3572E819FB2C4CADA43C9C5191D6F7AED8F310CF77CCAF0C478686952E71A8A8173D0C223B04462B96C04EA7B218A13519B90CBE3BE8C32B276F90D349ACBB6362706DCD54AAD0497A058AB0138A8E57D514D5D431043184BD1A07B77C3299BA6C7205938ECA8403F31A1C605A942B73775A1AC11C40D81988E69C15079719AA769B5F618052D5290D84714CA57418366C15B74DA4E98DF96ABDD19884EC1703F7978C4DD72B48528789D7148F16C23EF8BCD1F353CC4A76E7C238AEB1035424300F529ACD46926874190556133021A6A9283DDFE02EDADB7DE23A4D141B0787539B68110B4882A51F95403865BECEA06E2D7A1C1F534FA3366BC1AB387EB867477B92F00C0D09615BFCC1138137CEDE4098AD57894FF74982D71BA2ECA6A0F502CDC9C89BC6A44BD84FD8B62BB5D84332FAA830E2A732259945028D2830A8AA866F92C24E46D164C4F4658791C11F0703D906A82546C75F81285C24597BBA4B1BE3972F069D6B383D61CC32B9B66604B7CDC4BB39058C74CE770F04F758E6124543E13D2365A915802F75E90997B10B15E650AEE33A291C87030517B6C29CF10670D2DC5C8889AAB7518B4DC86D86E25C52ACC4DB175A5957118F983C3A4443B33803A3161AB24004B7A789778C8414A8AA8C819468EBC28B68AFE5333F7E666D44B5A961533280B0021BD3B24E2AA51BA58F2F45767A5722E918B1204656A2B44CE628A3A84125F918999A6311CB3569431C7B0D6B58ADAB6A30F9473B3747E33C7A2A9BAF87B709353A77743949277147928273F112B5E618167A5715157B49CED69A2492203A08730ED07B7AA14BAD136CFA969DFA68C28AF40B9763872ED1B05D4161489BCE1F473D4CC067A86258F6B664D2436D4856166CC60467887F9B97439F607D336114E46B2A2964C228A18EB532CC4C6813DFB841E60C3BAA59978234A06FC95AAAEABEC0123230AC33BDC48A4452403842BD6158C668F28F20BB5501984C5D3992594A9238E03798D178702B86973350724ABFCD15255F0A5EFB7783D909031ED02C52A203DE570873C7A7C556202D53A6C086899802BDC877BC6A813AB59B781BB95F4FCA9EE76028AECB9142A992DD7180BC1C15DBEBB66765C5ABBCC5EBF764D5234D89A378D5925FBAF63A00E35D568804B973450A045E55C7C5F4907FEE390FE6877963E386BC20CBE929C3D247611E346EAE401ACB972843DC204EEABB043644EEA29BA2C1A160B98F0D28CAF0677AB2ABA362B7BFADACA4E1197F54F03AC8033814A71E1CF407972B3F1D9A986637A972B46D3AC46509C053EFBCB9A475BC4055265961C79E1374C2159BD2409A84F22755A1B32E4B604783BCB2AC49A27A5B0B07AE346AC38F54A2943559F02270BBB19508E903888ACA4BAB72E332285837B9EBB466E5CBA74D5AB6BB3B2A0FA26209A97F959C905BB4B058BA8ABF30A5A6C190A018A9803AC29D84BA710B30DA9A0844CC1A1478C289C32737144812355E0D7589B9AB765CA3B23353A350876F05081F3E4B14D8F66C998B81F458A394CC68C3B7BFD37366EC93113DB928E5F9BF0E9AAAEAFC619E332A7EF3898A66020DFC64F671879691C023409B53686770F8148A2B6F7B62B6AA42981EA0CEA7753599585034B9AD99C9AC8B12872B1A47A088BD8AFCA2D42093928A4FB770198C4CC50B0214C4C94FC7B62B5E636423C6ADB553B138591F6372CA6D53343FF7C70782A2DDC4801B262F220A539181C13F3C3E8E0A0D7191A43A54AB008D326DF803FD8757F88AC9BDC8BC75CB83517AC71FF8613B3BA713377FDAD2199BFA332B8C22C136350ADB9553E3643D0C45413782F3BC9E941965DC051DF98738CF50113AB422E4A22759CA016BEA6FCBA390ED64540112842F5B1373A2847107A43403B4AA5CCAE154B9C54831E3911239B79F1FE997BAE30A542560FE6647A2E7C4916097FD484C3D040456EA2BF8B63DBCDCC8577B7AED99C05FA28D468272876B614045095E918600F7C94BB0944F62235C169B58789AE8BC3E6F677CA8D238602399E307553E235D11836BE120B3BAC41B0A668E0841AB11F49E27AABDFC27AFCAABBF542911B6A220CDD626D819C44C72556A3946DF86C43D1B8693944D399A3B5B1309B9780E34330CA387CDE8E4C9B2D0775A962F447828D6295873CC1629777FD93C062098B6149A3E7C383E2C33CC3FE7730537416FC1ADB6C09F4CAA736E4C796D2A97FA3807C9EAB72993B4B876136B856C7BC75AD054288EF491EFFA872247A99AA39A9C2B7602027D65A169317CAFCBB77C37D89ED32489E3C2557998A06689B06AB96615BB5752D439DA446354CB0640686AA794444A806C31D721B8C6B820810A5AFC00932A885107B5F968B5C8EC98207293D8851892A01DFAE4A99832326E3863BCDA75190C4A487B46E3914B702017B1B520CCC30A5C475FB2DA94EA217F76556BFEE825076533973BAD3AC7305B5C764CD040D723617090AF4A7811E9AB206C6A331A647D9385A5E7D8BAD6C89B390B617018C4A0691D262429BBA173598B37D7C245452853506437E756A399670AD8E292B0D820E3567047C82870E82236389D99D678CD9B49526AAC30D1B830B12F4E62407A59C8F88B7B5D088A2D08B9F114C3F158650F32C682EA6A76CB62D3AD7357CC617D597A3DBBDF515F6852D71220768859D599BBAA6D029BB2121C788B5B6EAD7226DF664490DAE362C4BEFB615717D81C656B32735FE6141A25F7AB9F875F79E0A82D6EA5CDE5A017AB637D5FDB7C42646A1D71DF ct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ss = 3030433313514EA95B5D6A2FDFB64D4225FC84EB70336323507AED63C5755481 count = 81 seed = E3C41CCA6F04CFE7732FD54DE30CC5CAAC93E2F80E76AED7D24A962A3969C1B6A311459A3EC3E510E3E9B1E4291D4D7D +generateEntropy = 0e3b30e102d707538c2671060f603bb0b8a014103f132d63b09ece07e4a4c75b11eafeca9e810796c34e8cfce9d59342884456007b01ddd12edce6d10ed87e4c +encapEntropyPreHash = 9f27a47604ab5146caaf0aafe6d149424f8d66e39ba3baf5e6c73b19221b7e21 pk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sk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ct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ss = B8B9F3AF55E8C616D07C7042CCC26BB4B83D20FD502BA5CC7B72310990EC50EC count = 82 seed = 373FDDE922CFC416ED96B444E445BDD0962E8989F6C50ADF9912A89937C57217D3600B06C95440448E3F601AE69CA5BE +generateEntropy = 2478f7d3de6041e7e5cd11c5e2ef483d1aa6218eb126444091535f6ae532fa7311136e2681df2ef881b51a092a9badbe72c9772c169808521c47149578621e28 +encapEntropyPreHash = 90044031b7597b5e60a4f946b713e8996d0426d2cb013243d9b7d8f8ef159a0f pk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sk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ct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ss = 2E4139C499A24CAA334754E10C6BBDDC7A0830499CA65E941AF8D87EE022D483 count = 83 seed = 16BEF67F7AC3A755C59C816478B75FCC16CE5844DB537791ACCD1EBD49D2824B105FD2E970F728C8F0CF16E439A9AE2F +generateEntropy = 9d405d3ebdaf35fa8722de431b669722acaaea2fd10b814310b17f78b66147d16ceb14f7662be0c42779459f69a145c0e2ce9f0bd9a0cd1bf32ed5694cc9ae32 +encapEntropyPreHash = a7a31e140891ea37d2b6424b59b1f84f89220f32dcb73e037eb912b389d34a48 pk = 690B34B6586039100E84215EDDB39AD2D40BA9F80165623122A2C5FAF3437AB0376894CE67397D32A67C3BFB9761850C1C68AD988348725C83A378143D504400F995157903B9D04EE43404AB2CC7C35B8E0E09CCE4559945F5640450703F81C35ED332746162F7B8328F78BFC3359E7C1B4FCF06155FC745C70245FFEC09ECA957C8475C62B05BFFF288A5E5A5C78206E48C3EF373658859C3D9636786980578C07B764641D6A87222224557D10436FC72B563883ECB0934E50B6EC89429D7792EC0BFCDA416FC2AC323A58DF3FBCDB6E023140478868055251B1C09FA023E240E109869C1D2967F598A529042D9859F97CCA2E85A635418707B3AA1835B77DF93AE4DC53F228083DE6A04BDF58655C59BF57B107987B88CBC001E010B9C2458BDF138288190F955B62C7013DD5784C809A7B1A29F8C3C33F0311A555306327392DDD44EC8F72FD5893F56F58BAF207F9EE98B7E31092F761C390763A8B57409C7C5C665A913E20C9B62A5E80646364AA8E3B95030FB2FB289991B8637EA57C7B324A25E0389CE979B5E816FF841456261BF042C85DAD84F80D788076B7C69CABB8E389A72657D7D63949657B934A468516C36674194DF1AC3F595A294C28D24C26E1B1B5AF5B542E025A182868E1555442E0B0D064865ED5CC1665074E55AAAD601779E591E1ED2AB07CC551437603D24CA743218FA846822B2857F871FA26834E0422746A6C7DAD256BC0B4BFFF21BD7309482D7669F8857543A0436140EC684C959D26F2F827A84B37534B7AA3BC0A08163689F01141B511E7D11A316D2AA7D73909E889DD000C20E38667DA048278B5EE87188607B4210642F5C38866FAC1549637C600C8BE8C60C11AA394E8344B6C6536E687EF6DABAC397ABF1CA7486F6AE87D8A3DC8070B5687F7C6A73225B9233685C6B703D33677998C24E40A72894193CCA1C5ACBE4A133D85A6912587AD4AD522214974CBB1F877E16164683021EA9C335D41B000CF52A3ED45B2D95B7E2D061B5213DB4C6BC36D76DF5DB9EE6984D31BCB1F6757DE7E51871F1AE7F388C5134956D3286A49BBA39967889C9A424772BF5DAB014C94893A4C8B74AB099687919243C7633CAF297B2B73AB15DF419F6EC22D15A95553831BE379ED0489749C495E3B6B8E190049A8065DBA8933FB21BA3A751CFF289A2E2772B06A4687338CA88C0EEF1488B848AFA1041F4F9607EB18BC0650055803041B728F2F1922CD984D228096FF29E71F097921423CB82254C40A615240A2482A3F5F095F5B399A8F9ADDEB6B726F43E3AF64D09038CAFEA26686CAA2CE2194CBA660EDBB083F92DC2A51142BBC922958C86C62CE7A4B3A4C95240D72244A912C3C193485208CDDC4514495B35863CFC6CB41FA721A78080FD7BA72669AC6B29ACCD3B832D35AD70F7584E197D695B78C832000C1C337FC019F0AAC04B2149A469420C15B2DAF5281DBA5DC3618E0135C043F139CC74B14E7451FC11328F06B73F124766403541131D94506628C30B7BA68564179FAED9C9D2A20F3B61793A33A65E92B699A47FDE974EECBACE22690273A757DA903A886778002D283A819CB1EA2D34B8462DCAB57C85653E363629D9270738434AB1BB46BB71890031FFECAF8FC027D2DFA2A4AD271DD702F055836F40CA137E5D0EF9 sk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ct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ss = E412F3AAC1C0284D999D5A7F8344B4053D10965FCBE1638F7EF666EF29C521D2 count = 84 seed = D0611F9AE5BE4DA5D7EADC9109944348E716CB3DAEE545721EEA8C892E7831CF2E54603146454CBFD92387739E9A78D8 +generateEntropy = 9a86490f0615f3edf789cb0654066e9ee339cc59f968281f3b89213f83c692edfaeb2ef44d2f608621e831187ce79b2d2f4a20f1568bbe76b0d3d5af36111714 +encapEntropyPreHash = 70eb3f791faa91f1f982fa477dbcddeb2c55691c07f93b04cd31b37544c94b42 pk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sk = 7934A9FABC835BF9A77BB807332251DAA00876E5500D2C59F07485ED01BC934911A336ACDE5527DD166476CA1D1AA558CD88CD7BD17CE1791958E851991867C0525C9472A953C8B04A730E2E132C6C26811CB86F3234229F4CAA2AEACD2E3C840E97B8F1805B94D7317B08354BCAB64887A4E6A98FFD90A7544562CEABBCCE6489C6E8534119C9589C405D7A96DE3230094A459549B6F37078F2C01FC9080F049464B0A969EB742419147C8B39B8065A769D400A17BB25DE51A699B69D54BA460D33AC6A6965916829B7A578D0B24BFF786CEF9963BF961ADCC20F9A0CB1C159865A344A0E36879C67852DF50ACA08A46E72A4A70C027CE283DE5BCB219808F2635BD7540915C5485AB70358CB017882B12ACB4426B22B02605873F2BD0DA59A658075136CBE15418CCA0A11386AAD43A52E3C5AC97F36BC7F648808C260643C325CF456E6166EEEC74EE8476AD62C73D7D334AC279D84B66B6C8AAC217A813DBB3DC6007317A165E6A1657D0277C1E683BECCC956D973C7624E959724FF9275C1AA2BB5ACA75159721B8C6D7B299C7ACB4704C654335982E83AB3724CCAB3709D20601C2A943D5BFBB3D384A7E83A7793905301B1704CF49992077B19F0204F3394717C9AB9A173113004FD325EDB797A30155D0D2A1E4984644F245F5B495B56A98FDC487B29B4A5C6DC4E3047A8DA2C9325F1705613705628458BD525FB333087CB4B967A61A994CBEFC504D18C1B8A62898AF32BC454A57E264722897D5DC71E32C2495CA857E1A234AE61C77083BA9B780342D7CFDFF8B7EC1257B79CAD017113A3238510C5683C3A8C396986ED392B0122C16E34A7249691EA7A931C44087FA1731746C1F3855BC72414FE3484D85B5E2586B6231B4BCF27831EA7B57070A815795F43E90B2112B235F5959EA253DB76192BCB11D4E16399D40C5DC0A15D98C3B3B0289F07839F7738ABA3281D45AA0A9CA1D349A64E79246C2C7770227F1E1CC74DB8AB7EA7B0E60A9DC0E45443B30CA656CD6A8897AB105BDA51B02179936F04374554A52992710F2A70972479462A2859736C2FE4359A474939AC3531B2905F90BC38860B5615ABFB1A1327814C01048BB93C9725C7C3B0547921975766A97E29D529E4D8A090C36820DB0FEC33277CC679CD4A51F7CA05F204BFF20ACF63EC403AC7CCAB951A8EC166C545ABFCE8734833274F724E77E68137967DA75515E3C270CE79838839721BF3A14C952085071D6B3A555CE62D96E7736A583F44F726AEB921CAA340D4BB788D63645DEB2621629DFF8A2C51D23BFEE95CAA7756F1884A0CD263039C37F7415E83D4908507C1B17A7308CB329D829C86953422B8B2F1786A4B86B980751255339258572A02AB22AD845632F859EAC223E1245AC3533D359246316A3CC1AC58B4E6386592859547171CE05DD7A76BF8E93901EB7F40114175AC45E0B35109AC57BE844C52D31A7BA60A24F30EF0E45581242C02E020EC86AF106836B3DBA8071BB8E8574FDF208100982E55F4B0DCA72521440A2AEA68C57B2039D14B21A56274972ECCAC7EED41C4B26CBE2C973507F1CDF4E618077406CCD3C8C5118545178351522485730B1A1CA7971B01766B914E835244BB530C48419ABC7578B33D6DB56C76179E9DA3808BA4C8D7C227BA5C64AFD5C87E01C1AD12A294758F45804719DC7369950E9E6398BFCB60A7819585A689462346AA5968DFA83BBB3B8A51BB59311C9D100A4A0C7586056201FFC3CBD92C3A42D6851EC064A89227B4D1551CA7AF6B5B3E892B4E44571669412E4240A08C42551DCC50086389F9E0C0290956B5AC58844A84BE308D0A5562B57B5CBC594CEAE87910A13167F27CE63B822F201AF5E9C33BCA746BA7C5E8541FFF17324228321C7A0EC976646A6B5615F80FB56351D319B31960AA8823426682A610652652994D4A78C25659B533F5B40E6236A6E704CD891502E9C2D1858CA64C94D3734AC0BBCAB2DB2F9E03450E721A38C82A4C26A487F006E1966FBF8063AB115E74F441837506559BA5B7266F62B17E4D959209B657193689A0354149880D08434FBC282713118D9DAA89C52186EA918CE2C170D8380E45A32E9F710CD6F89DAF91C9210B767D743F61655A9702051D7C8A46F17A681B136C0863CB62430D084D282099D1636C04D6B1EC212A74046D2D8108470123DD751DB685A1A1FB3A3B2C216F51302FA13AD73B919A439D424A4AD9E12994D1963B3C0E0316739CE50A1A7C23D65ACEA61423A5792321A84AD2E1B3F5B595F11637EACA77FC753260E04CEC9CCF55D70D4D567BB78749EFD005C9525F6E921F0630C25CB9A129781B9B864B7556272D5B4164E340D9464BF192979A073384F6A5E52AA0B6B74D43FAA5412C5914524974161AFCD91660705659DCA87BA482D67C8C1400B069E66A19905B331243701AC8261952C5B736B25290235669FBDCC254631294FA2E97C440D97A0211C35C2FF4B6009AA66E27CC09BC09307C7B3794A5D189892EA60B2B323E95057FF355114AB48613E2760E00BAEB82B0A763067E216AAB899E7CA06E195A5E92486CE8911BFD5C7D956318AC3B029436A9D88C56AAE2A3DC7B382F2C5E7265A037A827761447FC59A40A3C8693BC996CA786FA7AC1BBCC6AA404A1BFDB3D227C6ABE42CFC463C2F1542AE418CF4B38CC2C1595F9343D41B4A1967C7C94A7A0AE91CEC8235705805AF096CBEFD0CAD6DC0BB5130907D64E76E4BE957A117D121D66071598112EA7D02B9648CF53E57AF9E7CC3C9803AAB327D87C53E41CB9BBC42368D332E0A963C3385C18936AD7483A5F4292B625C844C2282F25AF0C86984DDC09371AB555D57DE146664FAAB59DFA514F8BB8D397A987BBC8DBE147EFC2A34DAAA712BAA1E36C9C5113A7F47BA8C4A83DB2DC79AE93688AF7C480DC8ADF0B12D7F5453E669BE2D805DD6961454BA8B40C6EFA961E53DA19EEA2243C998B504C8AB9EAA2DB11B2F9B591990040954A1567074E69154AD6E618D0830D3B554FE4C99F48B51CF6609952CC9693ACAB000C335B98126B4B45A9F317F80A6049558FE9D855A026AEFDC649D295387C530E075CCB32AAA202171C6F6907A4A2202A9C5FCF252D98328F12F927E31C596047140AF9B177E0352B120954D00529A07D6B2BCE5026A6D7CBA01231A85BA39B1692694788C9215B69FCD111FDC8934A1BA24CC7890EB479AEF01FF29161B0A7AD921BB72A8B495FFA74C62C880BF03F0BC175EB865A17ECB56E0AEA501BEF8E12D3025185BA4CF8EDD1B0F297471D58C26516F69BD52CB1D071F1CC7720F949D44F66F40C917EB30F3A4B0EB519ECAD2D03DCFAEB2EF44D2F608621E831187CE79B2D2F4A20F1568BBE76B0D3D5AF36111714 ct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ss = 4F9DE6E4CBD9948D2DE9250654D5DB97FFE24CF222F68BA51D6261F02F4DC5E7 count = 85 seed = FBC38D7614D7718E931EDB850D2C6F0C5EEA9EE889B3E25BD69AC255D5B91E885D93E808E66BF9C88C655DC594DA5792 +generateEntropy = 6dfd9b575872560c7bdc2732c4a28dac4db04e535eb8e402c3dffd145c09ce47a2985c1c4d203778597947d710dec806e36b0cd949fe460ef141213bfc525e5b +encapEntropyPreHash = 30f4095015ba88b6d969672ca3f438c395dacf7d476ea7a9e805ce932d270a13 pk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sk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ct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ss = DA6373247F33971B39D955418425EF1D1A233FAE7FB1985C0126F541AB8D58D7 count = 86 seed = 1722219CB5DB47374EB0AF0232C856A57F026F1CB09E5A5799F4C333DD422FF6A0A67C4DA502FAAE727FB2D45DAFCF35 +generateEntropy = 6fca9f4e384d8418075cc064c70730801bdb8249899d456a77130d5beeb3662cce7683f8a03d3cf04e46970ff7d6a12494ae12558346dfc8fd9370bf944a0102 +encapEntropyPreHash = cf31220f44de862e1719570e1b26e897790159366a385452334fe24cdcae28ba pk = 5C405485D51FB10CB0F150B9DB466C53E070F5849049D225047BC47AA15F630A6D62C5B179906EE6C067FA3384A4C22748F984EB31AB4CD69083DA31A5B45F586560371BC99113C44D05828FA7687AA649B261BEB0EB4EEBCB8548139BBD6A0A844CA1E4E59F3D7C4372EA8632B278A7E68B59032012C5518A8021BD5367557077C9C1B4A50944EA1A834BB61004B2CBA7F6401A57839A3CB85B326449A25457851B4A2BBA2E2187F040745FB608079C8B59D2B191813D51C5C3F329B1F5E40771E1B33F63CA400555CE5351CFFCA2DDD268D7855151618587C8B037E7CA290467E4A7C2C38290B84AB8DC4A839F57102DD559114092165B13B130B41BEA2F857C84AE45C1734375A3EA91021014D29AC58F12BD5A44B91CE986E094A66089479DCAC23A6275B864195DF24F2D4A97F1B26B508C3A5BB89B9F0A913867C1294C252D5022D9FC60FFEB3FF3C29B2DD1AA97F22271C5C8E749CACEA39F2C637FF4A235882747CECA1D95E093966462AD401510EC112026BF0FBC106270988B2C35CC7269DA693A7D67052F9156D30C916AD6552EACAA3AC2396BC56668686EA8A1578E46658A71B4B7365AE56A263C783973C1B63100B1AFF4C3FEB64856A781334C6E83519E541511B4D581914C697FF31239DAC56662A145316AC4D14E522480782C4EC52B1A2B8A85F657217ED11426A2A606C01C17171FD10824C07042B189225D40919AAC5CBE05B031689B1EA61041F6091D961A8910A205E62FF21909C6B4095B270D87C9727A2B611118C84AAC033EA9CAB5F40EFAD6117F2160A56505FD775D3F415AAE9271A9B2B1FD1964EDFB772A9C4875F06826A49C26E93F0B1846E006468DE71B98AC6FC0F81AB146236739C9A7B6C13952089D621936E8B265B50DD4016547A2ABD52339DAA0B459D265558A1D9B61C73E49346396B6155195C9C3A437614E68E23143F09FD28857AAEA50AA808600F5C5CA33C5963CC00C4B1C1CE2609486AC4F1B2DDB7B06ACB62398A32320F315DABCAF5D4A833E2A01A6E7C971CA15E40C459EF18DB8452AABE1584412B4C4DC52E6004CA56B5F48555041CC828A7A6DA77C435F05574E5C25EFC3C6057443EB77993C987CAC2363C3030D88E288F4D08966E624794078A39C53ECF273DF178CB022A5FB025A2687409A785CD6C019F5761B0A3087AE91844A69C2A89C1A00B1CAEC7C1F7A67425B87BE02D80B67CA6C7DC3B45BF425DFD33DC5A13E7531907ED6329593C333466D9628668B98422C985182F8C0952CBF5052225363398E516D23678B5320A9CCA38E21C6BE86822C4FCBB9094277BCE80992858C5498C6BCC57DB982C196B1A78C317975544FFDF33E57A30DD29A5CA4A22A918746FD9A84EE1008DB920432E39B6FF182C930243CF350C6F486832A807A36C8A9242A5C39140EAA7A45BACE0086A86FE36BE28ACEC756B5E9A47225638659B250C52B564751CE8C42C39BD1046D2B6CDA70B7951707B63073F0EB5EA3FC5229F816EBF4007CE97307C6607B4CA17CA30330570D4F39BF76998147060CC04B33D4B91294F85F4A717EF9C288E3741F70FA5823AB8329F56D9D0B05C996701A050A387362DB09427D5587E7751131953146EA3591818F0DDE74E33983C010419218B08822DA9C3C62EAE1F2284801B3E4 sk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ct = A4DB79E6DA55191F585544DD32928AC432171953F3A57EAF2FD786BF1641EF364CD03DCC519FE94C40AD5D3851A820B90C43EF631F15A48FEF9191281DDA67EF23C6AA3093B26C36A7B6F69A86DC1828498540AE4F6C1FB170387D62EAE9B73313D39D07E94A903BAF6DD09ED3BAF005A9E35C7C87CC6724B37BB80FA2153F150F9C811079D3D545BEF636476FDFCE30DC32561F41FDBA2EF7B4F21C58E1EBC033F5C457FDA302AE3D32FA0BCC4F3CB0897AF041C562D48AF1DA6C9EF4CCB651335A825394544BAF7D8914F0CE818E68D711CCF45B9873E108C48AD3876AE59DB02B553B6581B9A5BE72D31CA4033E4CBB767C1ED34D3356541A113D2CF60ED6BEBE3134F8C0A9BFE30C17E2F18FA8E308BBA726429282C7286D0904BF78925B09CD47973566DFCAAD7DB814A3500181EB93D438159358C075F4CDC270E14D74CBAD91A493F05AFD4C8AD851694676103FA00C156E5EE3CC4B9F3C6762E3E5D5AA4E245568BB730DE5C2E0E32EED4310D9FDFD30C68A67ACA0BB692BD5453BAF3056BB10E031CA15B342E6DA3D891FE40DC17CB6ADCF6B3B72943ADDE54D7B01A5BF3A129DE2846817D7C2D9054158D08117A69D5A7A0DB6ABA4286DA7D76E85AABEFD343BFEE54395B046AA35E3F7F5648C84B5C1B6610406FCEBBC01CE448BC8D533198BED851792582FB421C55C5FBC989983D978AA163CC88E01C12437CE22C58A6B5186DD0652417775500146236E12420DDB24054E607E11180A22687744226CEF0CC55D2CEB94E1C0675CE338F2537A3E60C126A91A81702DD3FE1FB7C2FB310571FA3DADC83DDC4B18B1AA5707E907142311FE4988196EC6B48814AD55A0EE7724BEAC278C7D68229B3F63357D81EF5FC16F2C7EE9E8A8E7FBF7FFF7B958F0592C5E1246C6AB95474DB7183FFD15CCD227DA5DD1A3DB842814AB5D4B515546BBEDACD42E4E9ABBEFA9416AD009BB072B5D691C1ADE296BE26F87FBCD82EDA2C93AE73AD7171D1EF1840F26014D8F152A720C47E24F15209E2A478DD7DB0EDDE040403A0655804720F8643B86F37776A2F7DC6B478D77A87EAC0194693787B6439F4B045732866237A8A2EBF9934070737B89DD2AF08C59BA182EB239FCDC476495AC756FAA7451C719156C1DBE099FA7BAA32C16156F4209C9F2C66544CC54DB33BBE0EDAD660CBC13E69F4D808BA98A7854CEFFBB2CD50A5B727762038A216B8B5E85DD01E138EDF154DCE1DE6E832374F0A0614390F76D1E658277FB909C1E95B4E81A9D6852DAA5368281AB21799C6898C07992BF5F7EED402522449461394C87AF555FADF1932DAB0CAB6CC80AEA73340181E91FD99EEB65A013B42F577D9436C75A7166BBF845EDE506AF88E6B1F915EF43043627CA208435E805D5588F4265346A7DAA1C9EFA72592FC999E84E49E6E0872AEBACAE9ED89BCF98CB40466AD61FEEC016E629527923430C13E8CA8C009EBA5D307D29BFAA6E1E6F56DED592573B75FEFDA3955317126A9B2869608C32701FF0F62447D1369765 @@ -615,6 +789,8 @@ ss = 037452D74A46B60F415DAD3498ADBAC608DCABE4EDC7070A358E7325C72CE76F count = 87 seed = AC139B78FD16CA0F26D6D7F9E15345C888D857B1910CF38D883339B37EAD2DCAC30F7CF10176F23FF34B4488EB79437C +generateEntropy = e58f71bf175c0550a67e00e0f7b3b7fc36bc2707bf0c93044a492626de36301a7f7054814869cf7625e45647bc1547aff288dbb90699b2ad84893f3b755d9722 +encapEntropyPreHash = bb5e65669a44e5d5c709bafa98c16ccba6ac2c4ae923334f69a11543eda64f5d pk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sk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ct = 9E0D9479CC0C6672A85DFCAF8C259CFA1CF68A93825FCAD76CBCE06FA3E40EFC821CA036B349FE50EA23E7E22E1C9CD7F8A930F2DC42F867E33884D0CCAABE685E7A7516CED70CAAE58FF50151AD1932F41AF9BDE629F2E96B3CBB7592B178699179E9CA85DF7FD2BBCA8DE9F30AFBE3F8724D77042DCFB19C31CF239BEDF529482BC947E85334ED7C541B2CCF368D2EFEAE1582A0622AA52C24905EC634D11BA0D1B20A946F2E571DB7F867E8EC9E3DEEB544C77D20CFFF9A0A44CDFDC42CD972A01AA8822E0BC728A66EBC0038A7ED1DD7BEC0E0E66CEC422385E0DFE33657EED638341F08BCD32C6BE72EAC5A378BCD02ADEA563734105C7EA803ED2D6260993182EECA13A4A3C999A209E78E4D64ED1E4D7BBBF91A72F02F760B654895C6398F3DD7D270D28133D66C13E899B8EC69A70F5983B539F975EF2294651305DCA09ED622CF151E337A7027145C9B3AF2849ADA810A96D391DC6F4FBDC1745DD30BD358EA3507A55F2E3C19A7F27D212397148C52698B59EB1477F8C6CA3FA829DF3447FFF20F6AB7F5EC445124F29C5F7B79CBAB1B1D23E8EC69EDE923AA3E734B9C999337014E813BC9E310C6850901993133F11019C95E1BD421896E3D2460E61DA9A6A64C7EBF0376395F509AFDB8460420F26ECD066F33EF121E41DFBE769BE03E25716D7F347D9E9BC0BC65A579F5508BD0562B9AAFB98A9B2E5986057632CB409FF5C10FC3D40CB5582231E5BBB4BE2871B8EAD348C1B9D9E81B876D70D03B9DDDAE0AF4DD5CC6F898817753B35EFB191004229B0754E69C9428AACA4DAAC582E1DA39B5983A5A4DE38998D26197A4171F5D6C28B90428522F50FC212A923E90D1E2005348A5E47E6E6F6D005788D2B455A3E35349AFB822AB5F4F1B9F696E0B186DD2B66A9236179763C639DF4CB6D4FF80D3B9942421D11DA771B184EDE6AC47F74A9250B7AE35B4BE975211A9E12972871F702216995DBE6E39688EAAE21EEA262AA89EAA8A8434120FA4252EAD0BA0FFC4F53EC1AB745A171A0F73A60D84B023A4C4E58F173F0C3455C1B056988897C2DA23D6CAAC0DE7A36334E5AEA093C5D6485CCF06F736CCB18DCDBE853FE6B9441545DFC3535F16D936ADC69B9D2BA08C8CC6DAD333190788EC3541E4C19B38D4319C0038F5BC41D4574141F819FF48385F45AA0DD7F6D5CD5E70E05D3A4366F9878E74BACEE5638B3AF0521A50399043C856E9F3E4ED2951BFD758662C82F8AC8325814349110D696B84ACC146AB30C00484B241FDF4BE8D179F6C8B618F8FB35340AC61FB9E221DC9226A1C59896389B3E24FD844197550016A53C5CF67D7A9F8FBA80B7E61B4E39D36CCD32C7EE8948820810811ADA941BE1EFF722EB83CC69B42C396F3AB0BAD3118C708C51B73D41C9C1DA494C0998C183AC5E592A9E0663753584C0364450847D906F5A261652BE33BC0CD359A732B9D1696E245FF04252635540996A57D8A625D37DE41A80EE1D51770777E709E673E31C83C739E2173381F4BA99D8E7FBD6D9D31 @@ -622,6 +798,8 @@ ss = 2CFCF5FA2B4C0AAA85C6069616E19E6715FEC913592D6B8F57EBA9CB4E3B162A count = 88 seed = CC7152849C98D5FED2813275D32069E44824ECB14EAEF425CE017448CD9A401C91C06D0F7EED6D22B7BBE8BA6C429EC3 +generateEntropy = e3fc575ed51513e62aba655d24cd9c8f1c6c848aaffa946c49a53ac3ea59e474d82c2f1bf2e6aebde5660fa73356982e12999d8fdafbb3cb186341d0386dead0 +encapEntropyPreHash = 9ddb3aa9c7905d1a438c93bcf78e3e321813580371ab4e1289e2dbf3701972c2 pk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sk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ct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ss = D3551ED0FD716E4887C82A6F24C5008BA80A9B5C3FC9E50F188EB224BE8102C8 count = 89 seed = 96D9A06F88FF2C2036FA8E914B89C765E4A510B468DEE40F914F78858C811857EFE9FD0E17C0048E7389E8D996B7E2B0 +generateEntropy = 470b4943f0fe7fd0d8ec5185aba0d1db09d112934e4fb4787e2bbc6b88466e7b8b2809fd40008be70a6b184981101724bc3d5ec5e1956b510b82fd5ad0668a5a +encapEntropyPreHash = 26d90b190a6c3d0d9a86cf66005154e7086749e966e7187c249ccb9329fd3b8b pk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sk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ct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ss = 03139CF9F20FB6BDAA4EE906AEEE834815FA924E05ED7E7E3BFB432AAD944D6F count = 90 seed = D26CE360D399BF7B89DC364AA7AC06BB513EAB8F527383E93E30727EDC3F22C262AA0EC70257B39EDFF0630DCDC1B79A +generateEntropy = 6df4385db978d27b27d2aa5e452e4152b36f097503d9581ac3390105c5727e7dc95fa08ed106ce84660e8a4c90bd2b22634e40769aa0090a101c5dddad45edc5 +encapEntropyPreHash = 7db6d1a129d6123f1f805b79ad3b413012ea86aed42a05e98e7b1f32f9fbbdec pk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sk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ct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ss = F87CFFE1A96BCDED4FE027DC8006065D67D0190B87D805135BDAFCB5EDB9803C count = 91 seed = C5856298C3CB6AC9787A0F30938537AB2635B96F6D19CC9522063360E7A5C88E644929D2879180E3E5BCAD2422B7CFC3 +generateEntropy = dbacba825728444921b227cdba54446b3f6881b47be9cd02832f78b023b1bee0e15274a8e2bc08fe818b117ba28c5dfae74d54fcdf6f20052f79be333edc8dde +encapEntropyPreHash = 1d129b27be7384c359d04311fe5c44917d1fde4bfb57314f483ac617edd5ac49 pk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sk = B1C127D24808FB2B9922332832131C4FD67FE8A1A070AC8D17100BF9F6291EFA0BC8114D98F65C8F4ABAC3AB17B4241DECCC37688B881BCB68503B54379838BBC100B5BAB306327E7965B694644C470A5148666C7FA89872D39AFF60BC533C83F280ABFBC26F073331EF40B694AB25FEEA5B2F55196798B70681CAA21537DFB5746C66129775852E5850F57C2DB2E8A0E90530A57B387B1C429101D04096C3E0BB6E9AF19F83B1B0B74C47BAC678B0F2269798573FBCA5D8E687965B13E495827ADBA63DA8A17564A3E68037B3A4991993401C1C6B149895FFBC03760C13595035A713140EB7A42FF6ADFE6BB371C9AF5A686EF858A8FB7A63FA137492B53305685205B08D44A3AC8F8948F2B7BED9CACE27AB6265722D8F2950E0C9ADE053A4C4CA8E3F80A907A39E33DB78E6065FE9DC050A5A730595AE5EA32E38C512EDB79DCF345F1D9C238A1732C552AB8DB2CCCCD11822972896B323CC43AA03633617F82E89D63D4A1003CF9C5CE3379B1D53A63EAC57ADBC91510316ACDC30FD74A1A2E6C23584AD1CB28444F9231661079B0913E20B3278D8A2E8B18556F336CB750694066B6C82C5D267A903B624CD440D8E187D9E438D178C8394706F016B835E1522AB6904F80CC24358B7DD3BB271039ACC174164021E8A522FAC473054D5B4CB3BC64BB107C6B637CD6360E312A85A3B1E3D2B64436A87E81016ACB763A23CA9B7463023148B0C4888BFB18D9441841F723B9436B77B09C79FC714385A3AE97B5BDE0A2A0C541DCD2B668C696281389EC270BC6D088FC42506CEC85BCB4B611342AF0A61B1B9D75E0DF43BE293CEE6EB0413363716EBBC48EC6C361A48B9D871BD5742FEF2AB286094A92B508CB794F2F69A8EE15C2D748D8FCA8CD2284719815E75B3B0DF76298E48280BF530E09A34D166CD5379777D472F0994BA8E5629EA7691FB973F45869635B61B277C375606B911AA1228271C85B047942A52187BB231412B50F5BE423476720240E62B9D3CFC5B7AF5CE9FB38E03349063741ADE945E994A2D6492A92B1250880318B9B9CE845BA29BD3733228AE960663050888BB98A0FDC21D6FB34CFB5C1AF6D9B98ED6AE454C09B89B6067401FB30A17DD331A845C713715B5BD4A087BBC14CBBC9D2EA83D0F9B0D56D939D01B7D590B3082D2405A20724E2C44B5123BC1407B11DA3DE5889AC52B7B7821C4AF1303D3959EEF3888B8847F3E0695B5B844E8E3C221718A25057E707A50E0159AF4462BB1D103B9057FF7FBC1740BAE1AFA44138AA2B7E3270CF80A6AC745CF701040C97253133EA195648E929E6C6394940B6ECEB18844F1C862DA6597A46F64E0CB5D2803EABA4A08110A011A32452185A6425D9D44B43463893369514957592F519C22D2B06BDC762C519D5CB84E9A68456AC60AEAE85AC6453DE2BCC103E32DD509309FDC08E3B3698A193D83D62DF74719703BB5F8CC5DB7B88B80110D74D6949D00469B840FF7FABDD4C0CEC1A097A6117C28046B06B82C8EE8204296428AB703840ACF7F3333D742726B114D3292B3154B2C4095B6D465657EC0780C488A0C60443717109363C45777271955135E60B46104BC18BAC09A18690B37C8078A22645532112B1DD09313B9A25B7094700639775F89B8D0314EEF0186ADF7CEABAC36CC9292C270717F27CAEA51B1AFE1CFE6B6A1CB1A7DA53C6715C9C9B2694BD5A581B733AD4841B229FB7A17BC213B969935C672D0993A94EC170BDC8B7C800E66BC6514F84FBC81C7D1C9417B79A82E5B3980ACC792A19C46D13A2E75A3AF791BEB401F7555793D94C0EE1B9E98A5B6C52777E537BFB287268CA9524A4438AD87A0E85279E474C5BE7740B7867D8B04781A2436A8D343F62274E236C736DC3C59D5B326563B9C86798AB14A6C9A0E67B36DB89A82AF690DA7016418BA2D6C435E39095BB81A0E49C01A73A31EC9159844D1A3EB233D16B932919421E6A342473A71DE629477183E8F34B2B7C8ABB7A3B6E516107CB5229D780B93417F9BC94C38BCAA58F34DD88835308C742875CCCF4928122199CD932148F48A94C5C2252295890BB4645761D3C2C0F33AB3E1021AA56B573E9C6FDAC37C83F678B97148CE573A244B0487F3CF771BC7B6A13FE53A6BA58854B87A67A6A17D6A301C85F7C061071B4DDB27B3F404DC402EBACB8254A0568D48B2D299BD831188886A65AEA5CD8D987F6017A2F4392F455C2B4F9B63E6CC1A27EA38F2588B0F8086D7A5C5E4B05B76D2B8918820CB8851704CA6D730861B512FEFB0A76B61401E23B01EA710C5E3B73FA716DFA6408A635423C61372592DBF174D6D811EEF7C4D885BCA5FE669233A141E43810AD10235CB59F824728BD7ACF17765BCD354A493AA60438F07D266D728B640CB07D50275BC2605FA6C964614B2C8143B37B184F3C30668662149BC18C6038706C12F0D31B896B69A7D588D0004497E4808D8C12253987F000168EA758A5B32C195F03F23A07C5A546A6607084CF79E073BC6CC1CB372E385CA827C490A42D900035BF735C6242031B8332BC57765ECCE4792706F1CBA0C7CC390E7BD3595AB876C4E397C58FC325C9607B0EE39692C31730EB4744E967E7FF8139FD1A545622EC870516B2925628BA782CAC845B2429C3CC0EBF7747F414E8D35CD4A91C959D2276404A5DF4790F4363104E6A0D1D60A48B65BBD92B417B51A5338CEBE36C0F218BF27968C05D99947E9B44B4B5B2934C538F85CD7C8B9E3C31637E14C5C0279CDD6386E20CA89A53671FB2F04249565491AC2F900AD380D1A68B67693B185F26A232AA1B43503398002085713CA4B2F94CBCF6E837B020404B7F519A2B520F93B901943C918393F26061346A0193CE9BA8A48B5C4B01B0EFA231EBA0528C5B38CD32CD5D22586494734FA746B411759303A51A12EC58B03FC99A1EDFB1CB01375032054878A6EC9DC4425945AAE387E7FC6CD399C90049854CF51B3DB690EB78A0A2DB04D05102DACAA9834620ABA427B5733BF1D1693643C88BD265AF0280ECC66344B81129C491B3998C6C70CCF03257C2D06115B72AEC35B4C8774CC7936C578B29FB3B0A5C66709363B73F41B08DB919CBE57AD817CBB5DF62B7836AF6FF4AB8CBB07C9FCB7E3D601B2117E6A7242ABB24EA96CA867B597E9E9B45C01ABA9B54D2D323DF8B38D3D37B72C2790E1041037355F274CCEAC2714A92955B31C55D4903A85BCA55B2BC22C536AAB22557D912FE2234423E7BC0894BB5F846A2DBC4A0DBB11C51840059EC11BF6CEFA3AB473E1CB0F0BD17EE0BC3C59175EB63C3144108548720CE7EE0F43A9FF3F52A9924EFE9F2F59318BB93C86B5E15274A8E2BC08FE818B117BA28C5DFAE74D54FCDF6F20052F79BE333EDC8DDE ct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ss = D2D4A23DEC18FD2C413D0C64D58C1D14E19D2A18AEF1CB038D14C3C2E79F6A69 count = 92 seed = A28EAD0A08E7228AEFF602B16A1E752278B8ED1E91DAC67994F5ADC372E1D82F95CC390CD97AB9212275E0566C833FD8 +generateEntropy = 690eb71fd7052b906eaec09937a8ed374e0b02afa27c2f14399932be5839fad281c38c2cb5cfafac81b96a810ab749b61806b6d54c9f8cf4bf1be0192423288f +encapEntropyPreHash = bbc773ebd2df42c36ae05952d6a64c63a5dfb82ceb3ef4f8d4df3a30ec8c0467 pk = DBF001BFA28B07E21ADC142C75111B9785AA2109A795AB792DE4CB7B6298A504200F8850D32CC44E54182761A1C9C9BA591A9FA6873A61025515B068099BB1E63751C5B887D283077F86B733E4344D13310CE12D22322F254A0E92779A87067D19C53C70DBB927E14E1F2892B5273949428EB4C70C49DA8AA7FB87048961DB4892A6F89F18F0BB69347B9575025A964047AC7BD2C7472838383A6072F8338B23AA07D6B7B221E18D4E3C62641916106694315A2FC5BB88C6D664667680DF556C3C046398A88328421F32ECB758BC64CF246815A25922021DCB67C995FC72CC6B46BF5CA9EF3998535AC5CFAB70AA54318F9532DCD138A4C03E2FF5024C52BB486BA7665B27610B822975C412331ED6C98E66721DAA1897936371113A4F17D96EA735A5CDC019809C3907C03FA950C00EBA9DFFC69A902151A39163F2931E1C0271D491562E0A87FDF7B7846C31151017EF08727DFB68F22A8585295659EA358CC1B85C9AB4D107413225B8259804B31850EB347E1FD37F5435617A7A07B15321CC204B1A6B7C30D67E91C088A458BEF5CB704E6B662189A9C0079E224A94E21502C0F1A4DFF6028EF6645CBA38C0C86EAF673E9B2613620BC216914A9781645FC48E33CB9EA06182637439F1D1A19FA50CFD3B5E2CB8310229B74ECBAEAD4B079D535521B8587A2995FA9B8C6694BE6E432343C97C16CA23BF53883E23CC38F10C38E54F5639B9FC0943A4F41CD0ACC8DB40CB12E644CB74B9D4B858F7D6767830B92381A42368476CF2602ADB9ED08B35FF5C4D1EA93C94AA75E218779825401D859902D19822E9820D86C7E57562795B89CDA97EBA773070BBC502884A6F437D7EA7A459C0764CD943E0B6A5B61B8358530459685E2842AE9AB867FA712172207E692A7AFFA872323779087547C3D8B89F368CE078ACECD55AAFD5305371A5BEF24FB255211B2169F4543927C845A3049F7A88513A682303960C2D12BC277656F15738C4368DEB70CFF2A32A1D179F4FDCA57812CEDB21B356E0AA63270788B510E58B4BF613473FE931DC80A9CB8BAFE63AAAC3913936C8A939C413CCA10A1277409250B5DA321EE5C24AD3D093C1C7095FBA34B81380E5DA561BC039E3A8C15FF3982A7938BC16446A3AB2679A50C2E5C1D1A08127DB4CEA30340B5589B2327988C97B78F003D1315DACB301520A11F9F0B4FB33CE7C0203FF11C6A66136C0AAB83928C145F4B968783B131281F2153925DC13AD133FCC5247B595CEF0F03FF0DA0A429C0DE9A54F66C03F1A616C7210B7ED3624FDD27E99F38472867A9283C6B294B0D7014CF9EB62F0D7B051B190F093450453C056081370B45F5EBC4C03808FBB5C6D8B659BD22612C2872DE9034B11C6AA6D356B2BACCEA0F909DA0C775969C12FD5BB0C8A9BED5172A9358E01C29D308636B5D668F5B2C9DEF1380BA23B5C84259D887D3DC4882702B41D99C72C800DD5B19935D7722610741A105C1D227C38C5665CD5A6DAAA991A9868499830C1697FA430BF4F95B03004126FAC283A167281E4B847EBA8487B0032914EDB0B67B1E320C25BAB50499378115CB07A9000E0156C9C93C1D90693B9C22623A3EB15618FA1C470481C4CF292B7462410D057C2E5851E08E31FD88AF2F84B0CF79A88DE834C1F17C7A5FA17D329CAA0 sk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ct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ss = 52E36F81DD9A23FB9BB2363C31B715106D38520A31A3304CF754A9432E757224 count = 93 seed = 92877D706DAF88EF3412EB143DB8CD91BC047A9A43B7ACDAA42523560DEE4C172697BE4332042FCAB91135839BF74AB2 +generateEntropy = 32e0ea9089fa928482c0770da545af1bb871a03ce38604138b0d08ea2a10ca2bc06c5bef7b6508409daf847a64c8d30d0974fd3ba7476dc76c46b458a036d884 +encapEntropyPreHash = 5b17a6adad541efcbf5ae4b0c0452cd2ce32e4f0f8701801c5b63e197c1fcbf4 pk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sk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ct = 4C5CE3680E598066FFE1EE7645E55CED8C9A55B6902A491AEB9B6447F58B6184343638F13F4F79D067A0A8A4F10CA355188FDE778B848886E2F38979B5AEF4F14DD0B47E7A95AE839F6A1945D9B32D830189F3994C43DE711F71E8439BCF957B62A8F97CD869EE551D167B4C97E209B972E175947E7C5423EA86B5FF5D4004BBEA6163EE2858FDC9D8A04180D01AEE7E75B8616BD1E37EF33DB050FF02674C3D9C58AF7C1A76D79F4940E29B3DD1365C8259B2DA36E8B8A7D05887BFD3E145E8C78F01CDB63FEDF457A1AF4746828734F23B947F68D217E3FAD14D7CF15B26651915C371D3CD4C58094F15DABD0013E7878EB8ACAAB33EFDD47B2B20688A85A3F92C6A4D90F6045127A17AF0F8643B064A4A30A983F7DDDCE4D8893A3F964578D0529113D9D248E09A41792D4053B8B04942E866AD0DE54F8FE31B64024E647EAB8A10C87526899C6FCE476314ACA7B9B5E2F809721D2660DCDF9FBA5734714592BE7157ED459BFA0500B94242C48E2EFAA774E0F78B0EFEE997658CC82C2DFC8C686C3406A6D997296F2FD3281D3E44750DEBA5B22CBCF7E45BA3663F2909A643838C9E7D5FFDA9AB840C9A0AF6D6FE29BE8A7615D896D8879EC16BCB9999559A645627553BF231FAA4344F6258FC4679C790668D09AB7393CDE99170A770E3BC4491C35F22BC7234C346191E09CAC7CE819B8E43DA70880BD3563622196D860DB3FD4B1E1E814660A024EDC779BDEB38CB686318EE950AAF42AA3B0042716D5365A102C5FEA90A7C0DBE71CEF891F12CA3D20F0A35F7D59E8EC5B35972FDB474D52D780C54B5C79D1C165DB237AC235528A42B21E3D667968418019AFE9F68F44D46DC96EB87A7DA38F2B0B943C9C6C2E87C724C99C65E5CCA40D6C85E32778CE1065F65C95795E0F1ABE400A4C78F22303D8ED54F9BE517CE2EEAE1AE6DBC04E9604DE79952DC74758027C616ACB8F586EE0F7BB7274D3E1E147E27039A44E3C1E0A5A874BB0E70A60F897AAE005701DAE3A9696652869F541EE178EAB5118D3115C923321BD28F9D6358FA012633076754110877C00376C5CCD57E6917DF937AF1C6F449993088D01993E4B470E98CF8F42F7A81120D175CA4CFAF063F76950D2E75046AFE842BDC15FE4CDB69369CC112050B62369D4820C97F407D8355CEE5D8C4B682E7D184F6FA02992BAE0FBBD2ABDAABFF5BA49F4571FED93789E52ACE387AD29A7A6EB8C0FFAB868A4542A42C1B35FD3D42E426714C01F82C8B11D77D768CB5908E60934678140524922EE339D3783C912151EAB2F051C1E61EEA79148F442FB7715855A0C9D6B857412D5CC3526584131180EC763AFF11813EB16446E876F48A25B8FE13EFB071991FF1DEF484AA00A976C4CA8D65B4AF8AB6D59EEB6957932F218DACE7BA7D57D402A9EDA506220A22F03BB70CB60134BC3334B005AAA26A7EA14808F13DCB1EB11BB40DF9A8CAA714A5F0B076F1C64BEF4A0607B174406155E77E531307EB8C5FE2A53D1BE40301EC59AA2CD995FFD5E55708 @@ -664,6 +852,8 @@ ss = D072CB81AFF4AA5712E56F0E9567DD89F2B03488735BA4751A7F0DF1C786402A count = 94 seed = BB4C0082CA4044B1FF60B036C9B0E0495D58667156786C530BC69D949A13BFAFF53798E456423D7A0E162A60039367D7 +generateEntropy = 6fb2ec719f2a0dea152bf3f64b9d148f8ab8ba88f64e61f5db53e12d59f525574f797c007e4061f95c7d56cfc7ee5c49e849dde3fea8f25e7876df2a18515c34 +encapEntropyPreHash = 61ab87659525de9656af41246f20e1dbe85c24e335e7ecf9493f46168bc14e94 pk = FED53D194419C06B92E51498AC2601869A1024EB0370CA3A420C48A765A5B99BAB88A759251CB83259A628603C54A831AC0147F3A97B8329474258B7BD6067476605A2B2B8311252FE54565C865E2DD96EA9E43B23121C27AB02C348310ACC38D9D583B0D8105DC87896C238069C689027910F9BCB5D29AEEBF57C2B9C78F76866768C0699C6BF743C0B43108C128A5277F39B32C351926369FB8754CD0197EB9AB602F391C4BA564BE2C3423005266229A10B21D31A7CC3D40C2E7192CB6628AFA692D3E75AACE66E7BB1169893C8EE45BDA5560E7F79C711D32D52C0C783EB40BF8977C3063CB114B6368A8D1486A86CB108D146A648E080751440F4D8087116701987C328D8547D0573F8C03D321AC07138A60954297CD832DFB989FD99ABA8B213E7501CB3D25B384C023F66776EFA3AD4981037A54400729634A782ADFC24404BBB4F2405A27A8500CD79E8521DAEE48848E485F53A28DE91089D849EBFB54D97D0CFB3CBA46A27438F426EEA1A0122F2180630864AE46CC5F3A828725CAE89331D540B5B3633EEBC0228000D75908F21277104D7816F56854C3289AD1A5C72C1655830089CFB9C90B1306724CB2828BE679B989A3565758B058AE983C1EA9B71F10553795537D454EED50F50A40274592AE165C846D85527E479E3FA8D8865047BF68D200287C0A5B8A6A78C4769BB3A795979B774713A522DBB723F3628F2F4126B639E3B4C5C4B076D321A208A123D82852AA0DB6FF8457E745B6B710B396C8106E635A379E22C59F17DF7B7070EAAB38D5448E4AB67E6B21078D5B9F9979C6D7365CD1423CEF6B4C2B186AC6B792EF9351B6040F423CA22E7A1455A0473273E3B53B92A132D7C44556477907FB41F981A06CAC9BEEB9655FE90C4FE93CC33337D78294F7C128FFEE82B0D4211E550342C599C9932A201F3CB8BB253A0559FD667A3D2CB46A4936F5CF9C4D0D105880A446066AE06841E12F259E4E6220D932633F77F9A6B463E180778D53C37E0BF423717F4D476ECAB6BFBDA7E461AC3CC9806FF4B38FB80C0AC9B0DCEF56E9B27881D1AA0892657B12A913A8AB84037A6C78399F53816D79C6A1FB40F1CE200334A7E74760999F8A0294C3029BB23EE0CB81700B95BA20140CC5DE537ACA62C9808240E74D508A93263EB14B7D202A31DDC2147747192BA1F38932538241AD1DB35CAA40097393038957B64E716D4CB3675AA9EA46257BF55A6D1FBC2C356B020073E16EBCBDDB3692515BE92DBA54CB62C702165C74864C3A7CE67D8AF92EB78496C4E8EB78B55DB7963B016A252A85E655C95936D6006BC07BA6250E458A387BD7BB43A3F5A16CD8733B66565377C1A74D5488C1A0DBFD7A6DFB474EAF29FA80AADC83267D0B98EB7A8AD3AEABA977A0A5E55B8937AB68E385F94DB13FBC6C26BC23B0B8BA331A578B99B493D875F206C278A3B4F63E156FD386FC13104D6DC96AE9BB3055481B846183DE71ECA09273E58C466EA225B1824246C799AB8B045FB844572882299BD6F1B2787E1094BCA102FB20E0A274257062385DAC60F37A15B0496ED23C465A3BA46BCC0BA9B5B78C93B45CAC0151687859B155AD62A8539CC6B872AEED63847CA64797460FF5F477504DF1B1894FEE3E6BBF8218590936E0102DCE8ADF459D590355576E1 sk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ct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ss = DA1085CBC7452CF2AC98CA36631C6EBCFFF02E60485F9E807CDB3DB77BC92243 count = 95 seed = 121D90E70AF6204445D0DEB28AC0C108262719E9FD3476ACA74BBFDE89FAF04D8D5F89A624E8A75DB80431F0D10AD28F +generateEntropy = 527fb88c8bd9a4d6031dad15e63878abd2b559e7e08d61f69e8e78fca964ee6ae32d432b4f9f751bde0496c580a181ffed762aa35454a02d3f1f47ee0394c89c +encapEntropyPreHash = eca2adc3da1fb15f34033405ec08ef2f46163df4bfcccf8842c600ce0bc2026c pk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sk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ct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ss = ACA83F1DC628FA87B20133BED4C2EEE34B98021F295AB585DFDCEFC9E3C032F5 count = 96 seed = B3AC6503206ACCC2A92CBC210D020A2654726911D11CE676AA04FEAA08AF1D20C654E4105883AE470EC3AB299075D420 +generateEntropy = ac6fcfaeeef795b6ef9e062f02bf42975fa01e7d91ba832f74e05269a72684d05aeda108ea4d6c6bc0fb958286850422bc357ca67b83c986048e0d0087fa11ec +encapEntropyPreHash = c4f15bec2d7701339d0ade4835193bea3632edcf89e74992620d9eb623a0d0d4 pk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sk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ct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ss = 3CC0EF85A74184338A10FFBFAD5F6D04860D51E7DACF3EE73033B70969785AF8 count = 97 seed = 59EFF60B1EF6185DB34EE1E3B1DD2F159106CECEAA79BEB74923B4F5623D5BC52DBF5D2594A1F7C6C64D12CF144E9ED4 +generateEntropy = ba2fb9318d4dbe7488057c33e95e6f054583a2800c41bb83083c330a914a12cfe63f8ffda3565c2424c89b20974b748a65a5aba75133fcb3156dfb6626a83bab +encapEntropyPreHash = 28878249e2ac2b6263422993923a0c8bd05ce56e385ed13c943b03d226856947 pk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sk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ct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ss = 1DB6E99F80628E170260354EE6F3854F905D198E9669B4FAAB478F4B39CC2F0E count = 98 seed = DDDCA9DC31BEA737D3F474E7560B37FACB2F53C803E768FFAADE7669FF94B1D4FBD17068CFFD5DFDD24AADADA4EF6B12 +generateEntropy = aa6dd1e5799cdf7af9c4fc632b3eb9d51d66e85c8e0a21ec98664fc51ab63c7dfda268813efab5204efa60f78bf81d320d01ac09ac06244f7afbd2d80fd356d9 +encapEntropyPreHash = 17fc65f7fbd7c75ceec421dee84dff5a8cb22764a182db17e0ebe857f54d60eb pk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sk = FA198BB15B4278509DC232002C75A8BBF1853C474C8248B5062821E4D77FD5880979922016D17377F76A89AB9477A1024C9780FB728F6DF3295666828143C52FE817B9688C70EBA292D2716AB4970840ABC4603F597B5FCDEB0144813602242625A067EA48B426738DAD0AB986369AA5326DD199C72212C59AB20C8F63429683721A2C682C5AA853B86542698732AB86FE39C340DB2D452286FDD599336B9923599B66C144C0C7848C20A6979133FB7B5EFA3726A4F44389CB93D6A9C1B7E300CB852698C236AC00B2855861C88BAD062A25423362C7774C1626834EE59880762508FB518F926A3F475D01AA8E5C8C4140537091D494AF66B0E9426359032A2264AF67E63541C2408B1853F87C68C28C8C13417F94D77F6AC3315F23405C233E14F7762C152609AC34842553DE175A6FE1C08B44BAA9D15CF09A6049B05B69F71DF322171701AE91D050778A6754E374878169181A2E1336677889318CB54218AC055491B918BC2553023167151C98B30E1340403E0C59B3252F4D0C85EBAC1877798C41AA43C5C7B738B7CE116428C049370BA6665BE646B3125AEB947B1F3B2EC5357C7566C13EAB148C453D6B2274A9295A06C822DF9222CB2026F19603B5602D08D46D4C71384E776AF2A441894826E4559F5975C586E47BC0236B4897622AE4396160334CC97ACA101805814AE44786D1E445147A4728275C32554B9BD148AE9605E10C5A6B556704F1C17297A32EB311F1E92EE5F160E8522E06554B93B5C796E44086E75D236CA88ECC533C3B348091891E35639BD6CBDB3A408720B6E3A328C4268454169267A5C5348703C412C58846C192E0A162014600DBB351424FA8D0599775BD2D851DB4B07438F655AAD6402628563DB3A435F75D440636CD64041DE162D178C923490839F190F106BE0020AB63E7B3EB718A4FB59E01057C416C330CC26E485A6D9C72B707DA0B297C0A25247D26D40F044844C2DB883A5BBFC2B06F1BFBCCC6D10B65C9BDBFB806D7A04CD71774DD60BC423C1DFA897A0512365CD54A90BA6AC509298BF6455363583843925281AA405C291F11695CDA995A9AC5F742351560B38F8720D66327B4DCC47626744241679247CBE42695B8D81C37C718CAD53D1B318F9F900757267C43B982F26639901028F8F636C35091F1CA90A1E329D5CB069A918F45A078F33AB4DFD248390627926AADDFF47ECEF1718B2B048304CD40E72FB0872B6207856A61BD764034E82BB426747405E1AE5B93C63CB12C7BF09E47E27117D26ACBC102B043616E60B714316DFC17306A77800EE87E03E4B74759794EE6943DC274AEC1A08197A841E68F258202B1124803064F6E3295DD51AD18949A5A383A81363BB00118A8569A38D138BF8835362C723E999402D3CF728B0E11F647CE2B9390615B9E50487E23CEE6F9CEFC4A1CE5E83D28D642E3C16934B43931158CCEF3832A457A5E833F317918858807AB084F687A394C257ABCD8435CD717D1E6B79E78A37BB71A236729839B89A9905B5D935AFDC2C1E6C71C597898C6A69765BA05E9784B7849C685AB5B6DE3358C6299D8A4B075045D6EE15B639601AA95603A67378157B54889C3021453E373208CD06C0DEB77BC962535672A8D77C9EAF9726CC1A8B8D87D61B1461F33B7F7F5A003A8657297CD100324FEA561BA879FFA75287D9A838275734593ABC2B842D9353906334D3F9324C7D00EED794C78310421DB45CAB6900817348D67490BF1485E85A3DFA255694915D286AB5243B62D3A91F8493F0B19626FB89C0B9109C6E1084BD8C848C06B3472A65A2646DD89BE2D922A0D2C5E816652C826854AB36F44809EE56C9F7E26A1DC30823535997A05255756704AA1029B86601E2853C2D34A192A9B2B76B31C69C1A048A76A6A58E48BC8E512B1C767347AE28AE046076C20179D0977D2D54A3F78ADD2EC6BC06071D9447F0461846FB1A5E91A760112424082C2994A98D07AAB29E818FD15134DE437C7FBC59469CE8BA80545A4A5BF337FE142B72E602D8A1B3009CC95975759AD38274E234AEF0552B8AA65CDFCAC975495A84C124F8426A9C87D8DB03CE48B0382642CB9E31CE210B774724912B09B16D88AE007AC4542C092F9BBED9C262D823D9D5719B357821D4C245F384FC923CD334B9DFF579E324A0BCFBCBA61FB7AE9F69B3AB88693E005EE32BD1A6A3CA950A22421125391A060276B07242A795085D0098906969C421CBC469128FB5393B72590FD391DCDFA3CF87B9F7A4C6CC3A1791AE1717478A5280A3B7580BBEDF88F0DD7C1C09AA67D6B284334049398BA983BCBACB8C56237BC3EFB3FBFDCB358A006457832DF7A01EFD937E68B3299580CBE1C9F69E165D22683B3721E4189ADAAA91846B7717D41BAF8D9A1DC76C387F0B55C2552533326597466ECF06ACA624FBF73226E471D835B0EE4A24A8F1C5FBE359C61D974A4D57C2F7C49822286CA27116839B784D6782C13B606B87804BA0969C7C47C7A29CE16CECFF5514028C3D84944EC8CAB4B4ACB5B681723511087E25B8AE84F3741A2DE6CC21E7A370B35C255C34555F29645D4B420494C4D993BA3F092EE240F1D3691753420891ACFC9421C361CA2186B563ED63456096227EAA738A33AB56029976C1125DCA790114AEB83AEBCF271ED59BBC2E8377301B53D697CFABB4C6B40BAE19B6CECD421A1109F9CAC7B71C749E60A2005A30179C393D5033CB4F8795DE4C98D91538FB9A8CB1654B1E6A82918471470461F54CC71FBA50DEB3E1221C55AA616AD5262E352ADB7A89CA04557A2090FB05704B9521809B8CABFA325892AB46765CEE83850586918422212C812373A1C6217BA890B4C5310F7B0D5D8275B884AA9E4914C85023AB53BEA88AD4281A7F501A87534AC1D806B0F8691E9F1BC7171001043015B391CFAC09B5FA88F840C63194632BD5A012B34B50441BA08C879C44654F136CCCBB7114F7B4099016E0193CBBAE63522927DF4B740B3CA5B32B741EA15A47370B98926A1F90618F5235357E8087443C93444803DD22BBDD5340C876D41F3AC1DB59E9EF17DB71369A315600FC6801A54483FB015AD3766284A97CBC241AD73461F4B2A0F6645EF428805762A6E57474D29288404AD98FAB63AE95E25436626BC66EE10C01E55103597288AC521B463886F863833948455319D3455110B68BF7BC495D1A922191A1A230A5F036C3C4AC05EE2609D09891CE368C01F037D818805A566193A433E924B30F4E86DC76AE2B345932A0E7025F8CE6101884469E31AEACAF4D77E3F1201BC75919A696301240CD6129F66BE58E19D99B0D827D9932785CD9EA3D92F7BA54463FDA268813EFAB5204EFA60F78BF81D320D01AC09AC06244F7AFBD2D80FD356D9 ct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ss = EF8DE288A7CE14CCD5172A4A2F91588559E3780A75B1DF329A53B1E400C4C7F5 count = 99 seed = 2A6F7386B815366F572AEB6C79E272CC21B7095FE09575F18072C9D677DA23BC9C8A4BC393B7524604D299BEDD260C8B +generateEntropy = 195d6c86a3df4c21e3007d7f2768b43c74cb3060e0eca77f0a5d3271542b9a84ae77e0f9f21eabd8c0c6eea7767f4e10fde5c2d79b8400bf96b19014b457ec21 +encapEntropyPreHash = fa0489f3730100609488e951e6aaa15c0f193bc1dbcfcd013bc418d6c507b176 pk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sk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ct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ss = 4793F705AED572ACE61DB13BEDE3900F2538EADDB904988C1F015BAC605A1093 - diff --git a/ssl/test/runner/common.go b/ssl/test/runner/common.go index cb974989a6..0262a19c6c 100644 --- a/ssl/test/runner/common.go +++ b/ssl/test/runner/common.go @@ -2000,7 +2000,7 @@ func (c *Config) maxVersion(isDTLS bool) uint16 { return ret } -var defaultCurvePreferences = []CurveID{CurveX25519, CurveP256, CurveP384, CurveP521} +var defaultCurvePreferences = []CurveID{CurveX25519Kyber768, CurveX25519, CurveP256, CurveP384, CurveP521} func (c *Config) curvePreferences() []CurveID { if c == nil || len(c.CurvePreferences) == 0 { diff --git a/ssl/test/runner/key_agreement.go b/ssl/test/runner/key_agreement.go index 5739888f78..95ef531775 100644 --- a/ssl/test/runner/key_agreement.go +++ b/ssl/test/runner/key_agreement.go @@ -17,6 +17,7 @@ import ( "io" "math/big" + "boringssl.googlesource.com/boringssl/ssl/test/runner/kyber" "golang.org/x/crypto/curve25519" ) @@ -340,6 +341,95 @@ func (e *x25519KEM) decap(ciphertext []byte) (secret []byte, err error) { return out[:], nil } +// kyberKEM implements Kyber combined with X25519. +type kyberKEM struct { + x25519PrivateKey [32]byte + kyberPrivateKey *kyber.PrivateKey +} + +func (e *kyberKEM) generate(rand io.Reader) (publicKey []byte, err error) { + if _, err := io.ReadFull(rand, e.x25519PrivateKey[:]); err != nil { + return nil, err + } + var x25519Public [32]byte + curve25519.ScalarBaseMult(&x25519Public, &e.x25519PrivateKey) + + var kyberEntropy [64]byte + if _, err := io.ReadFull(rand, kyberEntropy[:]); err != nil { + return nil, err + } + var kyberPublic *[kyber.PublicKeySize]byte + e.kyberPrivateKey, kyberPublic = kyber.NewPrivateKey(&kyberEntropy) + + var ret []byte + ret = append(ret, x25519Public[:]...) + ret = append(ret, kyberPublic[:]...) + return ret, nil +} + +func (e *kyberKEM) encap(rand io.Reader, peerKey []byte) (ciphertext []byte, secret []byte, err error) { + if len(peerKey) != 32+kyber.PublicKeySize { + return nil, nil, errors.New("tls: bad length Kyber offer") + } + + if _, err := io.ReadFull(rand, e.x25519PrivateKey[:]); err != nil { + return nil, nil, err + } + + var x25519Shared, x25519PeerKey, x25519Public [32]byte + copy(x25519PeerKey[:], peerKey) + curve25519.ScalarBaseMult(&x25519Public, &e.x25519PrivateKey) + curve25519.ScalarMult(&x25519Shared, &e.x25519PrivateKey, &x25519PeerKey) + + // Per RFC 7748, reject the all-zero value in constant time. + var zeros [32]byte + if subtle.ConstantTimeCompare(zeros[:], x25519Shared[:]) == 1 { + return nil, nil, errors.New("tls: X25519 value with wrong order") + } + + kyberPublicKey, ok := kyber.UnmarshalPublicKey((*[kyber.PublicKeySize]byte)(peerKey[32:])) + if !ok { + return nil, nil, errors.New("tls: bad Kyber offer") + } + + var kyberShared, kyberEntropy [32]byte + if _, err := io.ReadFull(rand, kyberEntropy[:]); err != nil { + return nil, nil, err + } + kyberCiphertext := kyberPublicKey.Encap(kyberShared[:], &kyberEntropy) + + ciphertext = append(ciphertext, x25519Public[:]...) + ciphertext = append(ciphertext, kyberCiphertext[:]...) + secret = append(secret, x25519Shared[:]...) + secret = append(secret, kyberShared[:]...) + + return ciphertext, secret, nil +} + +func (e *kyberKEM) decap(ciphertext []byte) (secret []byte, err error) { + if len(ciphertext) != 32+kyber.CiphertextSize { + return nil, errors.New("tls: bad length Kyber reply") + } + + var x25519Shared, x25519PeerKey [32]byte + copy(x25519PeerKey[:], ciphertext) + curve25519.ScalarMult(&x25519Shared, &e.x25519PrivateKey, &x25519PeerKey) + + // Per RFC 7748, reject the all-zero value in constant time. + var zeros [32]byte + if subtle.ConstantTimeCompare(zeros[:], x25519Shared[:]) == 1 { + return nil, errors.New("tls: X25519 value with wrong order") + } + + var kyberShared [32]byte + e.kyberPrivateKey.Decap(kyberShared[:], (*[kyber.CiphertextSize]byte)(ciphertext[32:])) + + secret = append(secret, x25519Shared[:]...) + secret = append(secret, kyberShared[:]...) + + return secret, nil +} + func kemForCurveID(id CurveID, config *Config) (kemImplementation, bool) { switch id { case CurveP224: @@ -352,6 +442,8 @@ func kemForCurveID(id CurveID, config *Config) (kemImplementation, bool) { return &ecdhKEM{curve: elliptic.P521(), sendCompressed: config.Bugs.SendCompressedCoordinates}, true case CurveX25519: return &x25519KEM{setHighBit: config.Bugs.SetX25519HighBit}, true + case CurveX25519Kyber768: + return &kyberKEM{}, true default: return nil, false } diff --git a/ssl/test/runner/kyber/kyber.go b/ssl/test/runner/kyber/kyber.go new file mode 100644 index 0000000000..dd113f0b32 --- /dev/null +++ b/ssl/test/runner/kyber/kyber.go @@ -0,0 +1,625 @@ +/* Copyright (c) 2023, Google Inc. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ + +package kyber + +// This code is ported from kyber.c. + +import ( + "crypto/subtle" + "golang.org/x/crypto/sha3" + "io" +) + +const( + CiphertextSize = 1088 + PublicKeySize = 1184 + PrivateKeySize = 2400 +) + +const ( + degree = 256 + rank = 3 + prime = 3329 + log2Prime = 12 + halfPrime = (prime - 1) / 2 + du = 10 + dv = 4 + inverseDegree = 3303 + encodedVectorSize = log2Prime * degree / 8 * rank + compressedVectorSize = du * rank * degree / 8 + barrettMultiplier = 5039 + barrettShift = 24 +) + +func reduceOnce(x uint16) uint16 { + if x >= 2*prime { + panic("reduce_once: value out of range") + } + subtracted := x - prime + mask := 0 - (subtracted >> 15) + return (mask & x) | (^mask & subtracted) +} + +func reduce(x uint32) uint16 { + if x >= prime+2*prime*prime { + panic("reduce: value out of range") + } + product := uint64(x) * barrettMultiplier + quotient := uint32(product >> barrettShift) + remainder := uint32(x) - quotient*prime + return reduceOnce(uint16(remainder)) +} + +// lt returns 0xff..f if a < b and 0 otherwise +func lt(a, b uint32) uint32 { + return uint32(0 - int32(a^((a^b)|((a-b)^a)))>>31) +} + +// Compresses (lossily) an input |x| mod 3329 into |bits| many bits by grouping +// numbers close to each other together. The formula used is +// round(2^|bits|/prime*x) mod 2^|bits|. +// Uses Barrett reduction to achieve constant time. Since we need both the +// remainder (for rounding) and the quotient (as the result), we cannot use +// |reduce| here, but need to do the Barrett reduction directly. +func compress(x uint16, bits int) uint16 { + product := uint32(x) << bits + quotient := uint32((uint64(product) * barrettMultiplier) >> barrettShift) + remainder := product - quotient*prime + + // Adjust the quotient to round correctly: + // 0 <= remainder <= halfPrime round to 0 + // halfPrime < remainder <= prime + halfPrime round to 1 + // prime + halfPrime < remainder < 2 * prime round to 2 + quotient += 1 & lt(halfPrime, remainder) + quotient += 1 & lt(prime+halfPrime, remainder) + return uint16(quotient) & ((1 << bits) - 1) +} + +func decompress(x uint16, bits int) uint16 { + product := uint32(x) * prime + power := uint32(1) << bits + // This is |product| % power, since |power| is a power of 2. + remainder := product & (power - 1) + // This is |product| / power, since |power| is a power of 2. + lower := product >> bits + // The rounding logic works since the first half of numbers mod |power| have a + // 0 as first bit, and the second half has a 1 as first bit, since |power| is + // a power of 2. As a 12 bit number, |remainder| is always positive, so we + // will shift in 0s for a right shift. + return uint16(lower + (remainder >> (bits - 1))) +} + +type scalar [degree]uint16 + +func (s *scalar) zero() { + for i := range s { + s[i] = 0 + } +} + +// This bit of Python will be referenced in some of the following comments: +// +// p = 3329 +// +// def bitreverse(i): +// ret = 0 +// for n in range(7): +// bit = i & 1 +// ret <<= 1 +// ret |= bit +// i >>= 1 +// return ret + +// kNTTRoots = [pow(17, bitreverse(i), p) for i in range(128)] +var nttRoots = [128]uint16{ + 1, 1729, 2580, 3289, 2642, 630, 1897, 848, 1062, 1919, 193, 797, + 2786, 3260, 569, 1746, 296, 2447, 1339, 1476, 3046, 56, 2240, 1333, + 1426, 2094, 535, 2882, 2393, 2879, 1974, 821, 289, 331, 3253, 1756, + 1197, 2304, 2277, 2055, 650, 1977, 2513, 632, 2865, 33, 1320, 1915, + 2319, 1435, 807, 452, 1438, 2868, 1534, 2402, 2647, 2617, 1481, 648, + 2474, 3110, 1227, 910, 17, 2761, 583, 2649, 1637, 723, 2288, 1100, + 1409, 2662, 3281, 233, 756, 2156, 3015, 3050, 1703, 1651, 2789, 1789, + 1847, 952, 1461, 2687, 939, 2308, 2437, 2388, 733, 2337, 268, 641, + 1584, 2298, 2037, 3220, 375, 2549, 2090, 1645, 1063, 319, 2773, 757, + 2099, 561, 2466, 2594, 2804, 1092, 403, 1026, 1143, 2150, 2775, 886, + 1722, 1212, 1874, 1029, 2110, 2935, 885, 2154, +} + +func (s *scalar) ntt() { + offset := degree + for step := 1; step < degree/2; step <<= 1 { + offset >>= 1 + k := 0 + for i := 0; i < step; i++ { + stepRoot := uint32(nttRoots[i+step]) + for j := k; j < k+offset; j++ { + odd := reduce(stepRoot * uint32(s[j+offset])) + even := s[j] + s[j] = reduceOnce(odd + even) + s[j+offset] = reduceOnce(even - odd + prime) + } + k += 2 * offset + } + } +} + +// kInverseNTTRoots = [pow(17, -bitreverse(i), p) for i in range(128)] +var inverseNTTRoots = [128]uint16{ + 1, 1600, 40, 749, 2481, 1432, 2699, 687, 1583, 2760, 69, 543, + 2532, 3136, 1410, 2267, 2508, 1355, 450, 936, 447, 2794, 1235, 1903, + 1996, 1089, 3273, 283, 1853, 1990, 882, 3033, 2419, 2102, 219, 855, + 2681, 1848, 712, 682, 927, 1795, 461, 1891, 2877, 2522, 1894, 1010, + 1414, 2009, 3296, 464, 2697, 816, 1352, 2679, 1274, 1052, 1025, 2132, + 1573, 76, 2998, 3040, 1175, 2444, 394, 1219, 2300, 1455, 2117, 1607, + 2443, 554, 1179, 2186, 2303, 2926, 2237, 525, 735, 863, 2768, 1230, + 2572, 556, 3010, 2266, 1684, 1239, 780, 2954, 109, 1292, 1031, 1745, + 2688, 3061, 992, 2596, 941, 892, 1021, 2390, 642, 1868, 2377, 1482, + 1540, 540, 1678, 1626, 279, 314, 1173, 2573, 3096, 48, 667, 1920, + 2229, 1041, 2606, 1692, 680, 2746, 568, 3312, +} + +func (s *scalar) inverseNTT() { + step := degree / 2 + for offset := 2; offset < degree; offset <<= 1 { + step >>= 1 + k := 0 + for i := 0; i < step; i++ { + stepRoot := uint32(inverseNTTRoots[i+step]) + for j := k; j < k+offset; j++ { + odd := s[j+offset] + even := s[j] + s[j] = reduceOnce(odd + even) + s[j+offset] = reduce(stepRoot * uint32(even-odd+prime)) + } + k += 2 * offset + } + } + for i := range s { + s[i] = reduce(uint32(s[i]) * inverseDegree) + } +} + +func (s *scalar) add(b *scalar) { + for i := range s { + s[i] = reduceOnce(s[i] + b[i]) + } +} + +func (s *scalar) sub(b *scalar) { + for i := range s { + s[i] = reduceOnce(s[i] - b[i] + prime) + } +} + +// kModRoots = [pow(17, 2*bitreverse(i) + 1, p) for i in range(128)] +var modRoots = [128]uint16{ + 17, 3312, 2761, 568, 583, 2746, 2649, 680, 1637, 1692, 723, 2606, + 2288, 1041, 1100, 2229, 1409, 1920, 2662, 667, 3281, 48, 233, 3096, + 756, 2573, 2156, 1173, 3015, 314, 3050, 279, 1703, 1626, 1651, 1678, + 2789, 540, 1789, 1540, 1847, 1482, 952, 2377, 1461, 1868, 2687, 642, + 939, 2390, 2308, 1021, 2437, 892, 2388, 941, 733, 2596, 2337, 992, + 268, 3061, 641, 2688, 1584, 1745, 2298, 1031, 2037, 1292, 3220, 109, + 375, 2954, 2549, 780, 2090, 1239, 1645, 1684, 1063, 2266, 319, 3010, + 2773, 556, 757, 2572, 2099, 1230, 561, 2768, 2466, 863, 2594, 735, + 2804, 525, 1092, 2237, 403, 2926, 1026, 2303, 1143, 2186, 2150, 1179, + 2775, 554, 886, 2443, 1722, 1607, 1212, 2117, 1874, 1455, 1029, 2300, + 2110, 1219, 2935, 394, 885, 2444, 2154, 1175, +} + +func (s *scalar) mult(a, b *scalar) { + for i := 0; i < degree/2; i++ { + realReal := uint32(a[2*i]) * uint32(b[2*i]) + imgImg := uint32(a[2*i+1]) * uint32(b[2*i+1]) + realImg := uint32(a[2*i]) * uint32(b[2*i+1]) + imgReal := uint32(a[2*i+1]) * uint32(b[2*i]) + s[2*i] = reduce(realReal + uint32(reduce(imgImg))*uint32(modRoots[i])) + s[2*i+1] = reduce(imgReal + realImg) + } +} + +func (s *scalar) innerProduct(left, right *vector) { + s.zero() + var product scalar + for i := range left { + product.mult(&left[i], &right[i]) + s.add(&product) + } +} + +func (s *scalar) fromKeccakVartime(keccak io.Reader) { + var buf [3]byte + for i := 0; i < len(s); { + keccak.Read(buf[:]) + d1 := uint16(buf[0]) + 256*uint16(buf[1]%16) + d2 := uint16(buf[1])/16 + 16*uint16(buf[2]) + if d1 < prime { + s[i] = d1 + i++ + } + if d2 < prime && i < len(s) { + s[i] = d2 + i++ + } + } +} + +func (s *scalar) centeredBinomialEta2(input *[33]byte) { + var entropy [128]byte + sha3.ShakeSum256(entropy[:], input[:]) + + for i := 0; i < len(s); i += 2 { + b := uint16(entropy[i/2]) + + value := uint16(prime) + value += (b & 1) + ((b >> 1) & 1) + value -= ((b >> 2) & 1) + ((b >> 3) & 1) + s[i] = reduceOnce(value) + + b >>= 4 + value = prime + value += (b & 1) + ((b >> 1) & 1) + value -= ((b >> 2) & 1) + ((b >> 3) & 1) + s[i+1] = reduceOnce(value) + } +} + +var masks = [8]uint16{0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff} + +func (s *scalar) encode(out []byte, bits int) []byte { + var outByte byte + outByteBits := 0 + + for i := range s { + element := s[i] + elementBitsDone := 0 + + for elementBitsDone < bits { + chunkBits := bits - elementBitsDone + outBitsRemaining := 8 - outByteBits + if chunkBits >= outBitsRemaining { + chunkBits = outBitsRemaining + outByte |= byte(element&masks[chunkBits-1]) << outByteBits + out[0] = outByte + out = out[1:] + outByteBits = 0 + outByte = 0 + } else { + outByte |= byte(element&masks[chunkBits-1]) << outByteBits + outByteBits += chunkBits + } + + elementBitsDone += chunkBits + element >>= chunkBits + } + } + + if outByteBits > 0 { + out[0] = outByte + out = out[1:] + } + + return out +} + +func (s *scalar) decode(in []byte, bits int) ([]byte, bool) { + var inByte byte + inByteBitsLeft := 0 + + for i := range s { + var element uint16 + elementBitsDone := 0 + + for elementBitsDone < bits { + if inByteBitsLeft == 0 { + inByte = in[0] + in = in[1:] + inByteBitsLeft = 8 + } + + chunkBits := bits - elementBitsDone + if chunkBits > inByteBitsLeft { + chunkBits = inByteBitsLeft + } + + element |= (uint16(inByte) & masks[chunkBits-1]) << elementBitsDone + inByteBitsLeft -= chunkBits + inByte >>= chunkBits + + elementBitsDone += chunkBits + } + + if element >= prime { + return nil, false + } + s[i] = element + } + + return in, true +} + +func (s *scalar) compress(bits int) { + for i := range s { + s[i] = compress(s[i], bits) + } +} + +func (s *scalar) decompress(bits int) { + for i := range s { + s[i] = decompress(s[i], bits) + } +} + +type vector [rank]scalar + +func (v *vector) zero() { + for i := range v { + v[i].zero() + } +} + +func (v *vector) ntt() { + for i := range v { + v[i].ntt() + } +} + +func (v *vector) inverseNTT() { + for i := range v { + v[i].inverseNTT() + } +} + +func (v *vector) add(b *vector) { + for i := range v { + v[i].add(&b[i]) + } +} + +func (out *vector) mult(m *matrix, v *vector) { + out.zero() + var product scalar + for i := 0; i < rank; i++ { + for j := 0; j < rank; j++ { + product.mult(&m[i][j], &v[j]) + out[i].add(&product) + } + } +} + +func (out *vector) multTranspose(m *matrix, v *vector) { + out.zero() + var product scalar + for i := 0; i < rank; i++ { + for j := 0; j < rank; j++ { + product.mult(&m[j][i], &v[j]) + out[i].add(&product) + } + } +} + +func (v *vector) generateSecretEta2(counter *byte, seed *[32]byte) { + var input [33]byte + copy(input[:], seed[:]) + for i := range v { + input[32] = *counter + *counter++ + v[i].centeredBinomialEta2(&input) + } +} + +func (v *vector) encode(out []byte, bits int) []byte { + for i := range v { + out = v[i].encode(out, bits) + } + return out +} + +func (v *vector) decode(out []byte, bits int) ([]byte, bool) { + var ok bool + for i := range v { + out, ok = v[i].decode(out, bits) + if !ok { + return nil, false + } + } + + return out, true +} + +func (v *vector) compress(bits int) { + for i := range v { + v[i].compress(bits) + } +} + +func (v *vector) decompress(bits int) { + for i := range v { + v[i].decompress(bits) + } +} + +type matrix [rank][rank]scalar + +func (m *matrix) expand(rho *[32]byte) { + shake := sha3.NewShake128() + + var input [34]byte + copy(input[:], rho[:]) + + for i := 0; i < rank; i++ { + for j := 0; j < rank; j++ { + input[32] = byte(i) + input[33] = byte(j) + + shake.Reset() + shake.Write(input[:]) + m[i][j].fromKeccakVartime(shake) + } + } +} + +type PublicKey struct { + t vector + rho [32]byte + publicKeyHash [32]byte + m matrix +} + +func UnmarshalPublicKey(data *[PublicKeySize]byte) (*PublicKey, bool) { + var ret PublicKey + ret.publicKeyHash = sha3.Sum256(data[:]) + in, ok := ret.t.decode(data[:], log2Prime) + if !ok { + return nil, false + } + copy(ret.rho[:], in) + ret.m.expand(&ret.rho) + return &ret, true +} + +func (pub *PublicKey) Marshal() *[PublicKeySize]byte { + var ret [PublicKeySize]byte + out := pub.t.encode(ret[:], log2Prime) + copy(out, pub.rho[:]) + return &ret +} + +func (pub *PublicKey) encryptCPA(message, entropy *[32]byte) *[CiphertextSize]byte { + var counter uint8 + var secret, error vector + secret.generateSecretEta2(&counter, entropy) + error.generateSecretEta2(&counter, entropy) + secret.ntt() + + var input [33]byte + copy(input[:], entropy[:]) + input[32] = counter + var scalarError scalar + scalarError.centeredBinomialEta2(&input) + + var u vector + u.mult(&pub.m, &secret) + u.inverseNTT() + u.add(&error) + + var v scalar + v.innerProduct(&pub.t, &secret) + v.inverseNTT() + v.add(&scalarError) + + out := make([]byte, CiphertextSize) + var expandedMessage scalar + expandedMessage.decode(message[:], 1) + expandedMessage.decompress(1) + v.add(&expandedMessage) + u.compress(du) + it := u.encode(out, du) + v.compress(dv) + v.encode(it, dv) + return (*[CiphertextSize]byte)(out) +} + +func (pub *PublicKey) Encap(outSharedSecret []byte, entropy *[32]byte) *[CiphertextSize]byte { + var input [64]byte + copy(input[:], entropy[:]) + copy(input[32:], pub.publicKeyHash[:]) + prekeyAndRandomness := sha3.Sum512(input[:]) + ciphertext := pub.encryptCPA(entropy, (*[32]byte)(prekeyAndRandomness[32:])) + ciphertextHash := sha3.Sum256(ciphertext[:]) + copy(prekeyAndRandomness[32:], ciphertextHash[:]) + sha3.ShakeSum256(outSharedSecret, prekeyAndRandomness[:]) + return ciphertext +} + +type PrivateKey struct { + PublicKey + s vector + foFailureSecret [32]byte +} + +func NewPrivateKey(entropy *[64]byte) (*PrivateKey, *[PublicKeySize]byte) { + hashed := sha3.Sum512(entropy[:32]) + rho := (*[32]byte)(hashed[:32]) + sigma := (*[32]byte)(hashed[32:]) + ret := new(PrivateKey) + copy(ret.foFailureSecret[:], entropy[32:]) + copy(ret.rho[:], rho[:]) + ret.m.expand(rho) + counter := uint8(0) + ret.s.generateSecretEta2(&counter, sigma) + ret.s.ntt() + var error vector + error.generateSecretEta2(&counter, sigma) + error.ntt() + ret.t.multTranspose(&ret.m, &ret.s) + ret.t.add(&error) + + marshalledPublicKey := ret.PublicKey.Marshal() + ret.publicKeyHash = sha3.Sum256(marshalledPublicKey[:]) + + return ret, marshalledPublicKey +} + +func (priv *PrivateKey) decryptCPA(ciphertext *[CiphertextSize]byte) [32]byte { + var u vector + u.decode(ciphertext[:], du) + u.decompress(du) + u.ntt() + + var v scalar + v.decode(ciphertext[compressedVectorSize:], dv) + v.decompress(dv) + + var mask scalar + mask.innerProduct(&priv.s, &u) + mask.inverseNTT() + v.sub(&mask) + v.compress(1) + var out [32]byte + v.encode(out[:], 1) + return out +} + +func (priv *PrivateKey) Decap(outSharedSecret []byte, ciphertext *[CiphertextSize]byte) { + decrypted := priv.decryptCPA(ciphertext) + h := sha3.New512() + h.Write(decrypted[:]) + h.Write(priv.publicKeyHash[:]) + prekeyAndRandomness := h.Sum(nil) + expectedCiphertext := priv.encryptCPA(&decrypted, (*[32]byte)(prekeyAndRandomness[32:])) + equal := subtle.ConstantTimeCompare(ciphertext[:], expectedCiphertext[:]) + var secret [32]byte + for i := range secret { + secret[i] = byte(subtle.ConstantTimeSelect(equal, int(prekeyAndRandomness[i]), int(priv.foFailureSecret[i]))) + } + ciphertextHash := sha3.Sum256(ciphertext[:]) + + shake := sha3.NewShake256() + shake.Write(secret[:]) + shake.Write(ciphertextHash[:]) + shake.Read(outSharedSecret) +} + +func (priv *PrivateKey) Marshal() *[PrivateKeySize]byte { + var ret [PrivateKeySize]byte + out := priv.s.encode(ret[:], log2Prime) + publicKey := priv.PublicKey.Marshal() + n := copy(out, publicKey[:]) + out = out[n:] + n = copy(out, priv.publicKeyHash[:]) + out = out[n:] + copy(out, priv.foFailureSecret[:]) + return &ret +} diff --git a/ssl/test/runner/kyber/kyber_test.go b/ssl/test/runner/kyber/kyber_test.go new file mode 100644 index 0000000000..6ff33e9bc8 --- /dev/null +++ b/ssl/test/runner/kyber/kyber_test.go @@ -0,0 +1,128 @@ +/* Copyright (c) 2023, Google Inc. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ + +package kyber + +import ( + "bufio" + "bytes" + "encoding/hex" + "golang.org/x/crypto/sha3" + "os" + "strings" + "testing" +) + +func TestVectors(t *testing.T) { + in, err := os.Open("../../../../crypto/kyber/kyber_tests.txt") + if err != nil { + t.Error(err) + return + } + defer in.Close() + + scanner := bufio.NewScanner(in) + var priv *PrivateKey + var encodedPublicKey *[PublicKeySize]byte + var ciphertext *[CiphertextSize]byte + sharedSecret := make([]byte, 32) + + lineNo := 0 + for scanner.Scan() { + lineNo++ + line := scanner.Text() + + parts := strings.Split(line, "=") + if len(parts) != 2 || strings.HasPrefix(line, "count ") { + continue + } + key := strings.TrimSpace(parts[0]) + value, err := hex.DecodeString(strings.TrimSpace(parts[1])) + if err != nil { + t.Errorf("bad hex value on line %d: %q", lineNo, parts[1]) + return + } + + switch key { + case "generateEntropy": + priv, encodedPublicKey = NewPrivateKey((*[64]byte)(value)) + case "encapEntropyPreHash": + hashedEntropy := sha3.Sum256(value) + ciphertext = priv.Encap(sharedSecret, &hashedEntropy) + decapSharedSecret := make([]byte, len(sharedSecret)) + priv.Decap(decapSharedSecret, ciphertext) + if !bytes.Equal(sharedSecret, decapSharedSecret) { + t.Errorf("instance on line %d did not round trip", lineNo) + return + } + case "pk": + if !bytes.Equal(encodedPublicKey[:], value) { + t.Errorf("bad 'pk' value on line %d:\nwant: %x\ncalc: %x", lineNo, value, encodedPublicKey) + return + } + case "sk": + encodedPrivateKey := priv.Marshal() + if !bytes.Equal(encodedPrivateKey[:], value) { + t.Errorf("bad 'sk' value on line %d:\nwant: %x\ncalc: %x", lineNo, value, encodedPrivateKey) + return + } + case "ct": + if !bytes.Equal(ciphertext[:], value) { + t.Errorf("bad 'ct' value on line %d:\nwant: %x\ncalc: %x", lineNo, value, ciphertext[:]) + return + } + case "ss": + if !bytes.Equal(sharedSecret[:], value) { + t.Errorf("bad 'ss' value on line %d:\nwant: %x\ncalc: %x", lineNo, value, sharedSecret[:]) + return + } + } + } +} + +func TestIteration(t *testing.T) { + h := sha3.NewShake256() + + for i := 0; i < 4096; i++ { + var generateEntropy [64]byte + h.Read(generateEntropy[:]) + var encapEntropy [32]byte + h.Read(encapEntropy[:]) + + priv, encodedPublicKey := NewPrivateKey(&generateEntropy) + h.Reset() + h.Write(encodedPublicKey[:]) + encodedPrivateKey := priv.Marshal() + h.Write(encodedPrivateKey[:]) + + var sharedSecret [32]byte + ciphertext := priv.Encap(sharedSecret[:], &encapEntropy) + h.Write(ciphertext[:]) + h.Write(sharedSecret[:]) + + var decapSharedSecret [32]byte + priv.Decap(decapSharedSecret[:], ciphertext) + if !bytes.Equal(decapSharedSecret[:], sharedSecret[:]) { + t.Errorf("Decap failed on iteration %d", i) + return + } + } + + var result [16]byte + h.Read(result[:]) + const expected = "18c6cd04eaebb33b20bb1e8e2762d30d" + if hex.EncodeToString(result[:]) != expected { + t.Errorf("iteration test produced %x, but should be %v", result, expected) + } +} diff --git a/ssl/test/runner/runner.go b/ssl/test/runner/runner.go index b361e19531..a4887afa5a 100644 --- a/ssl/test/runner/runner.go +++ b/ssl/test/runner/runner.go @@ -11386,6 +11386,7 @@ var testCurves = []struct { {"P-384", CurveP384}, {"P-521", CurveP521}, {"X25519", CurveX25519}, + {"Kyber", CurveX25519Kyber768}, } const bogusCurve = 0x1234 @@ -11964,8 +11965,6 @@ func addCurveTests() { "-curves", strconv.Itoa(int(CurveX25519Kyber768)), "-expect-curve-id", strconv.Itoa(int(CurveX25519Kyber768)), }, - shouldFail: true, - expectedLocalError: "no curve supported by both client and server", }) // As a server, Kyber is not yet supported by default. From 048d21cc1412429f2fa3c470ac95d2e4b2d2abf9 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Mon, 1 May 2023 15:25:18 -0400 Subject: [PATCH 51/56] Disable BlindingCacheConcurrency on FreeBSD. Per the bug discussion, FreeBSD seems to default to a cap of 1500 threads per process. Just turn the test off. But enable the test unconditionally if building with TSan. With TSan on, we only spawn two threads, which should be within everyone's bounds. Fixed: 603 Change-Id: Ic8c49e5ce7c3f2d09487debc72b7e4c54b04a77c Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59445 Reviewed-by: Adam Langley Auto-Submit: David Benjamin Commit-Queue: David Benjamin --- crypto/rsa_extra/rsa_test.cc | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/crypto/rsa_extra/rsa_test.cc b/crypto/rsa_extra/rsa_test.cc index e4fb12fc10..b6ab5b864f 100644 --- a/crypto/rsa_extra/rsa_test.cc +++ b/crypto/rsa_extra/rsa_test.cc @@ -1215,8 +1215,10 @@ TEST(RSATest, Threads) { // platforms when running tests standalone via all_tests.go. // // Additionally, even when running disabled tests standalone, limit this to -// x86_64. On other platforms, this test hits resource limits or is too slow. -#if defined(OPENSSL_X86_64) +// x86_64. On other platforms, this test hits resource limits or is too slow. We +// also disable on FreeBSD. See https://crbug.com/boringssl/603. +#if defined(OPENSSL_TSAN) || \ + (defined(OPENSSL_X86_64) && !defined(OPENSSL_FREEBSD)) TEST(RSATest, DISABLED_BlindingCacheConcurrency) { bssl::UniquePtr rsa( RSA_private_key_from_bytes(kKey1, sizeof(kKey1) - 1)); @@ -1251,6 +1253,6 @@ TEST(RSATest, DISABLED_BlindingCacheConcurrency) { thread.join(); } } -#endif // X86_64 +#endif // TSAN || (X86_64 && !FREEBSD) #endif // THREADS From 86ada1ea2f51ff41baa2919337e5d721bd27f764 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Wed, 26 Apr 2023 17:06:17 -0400 Subject: [PATCH 52/56] Add new APIs for creating RSA keys This adds APIs for constructing RSA keys given all the parameters. This is much less tedious than the set0 functions, and also avoids issues caused by deferred initialization. It doesn't quite finish initializing the keys on construction, as that is tied up in the rest of this mess. But later work, probably after Conscrypt is moved to these APIs, will do this. As part of this, add APIs that explicitly create RSA keys with no e. There is actually no way to do this right now without reaching into library internals, because RSA_set0_key refuses to accept an e-less private key. Handle this by adding a flag. I also had to add a path for Conscrypt to make an RSA_METHOD-backed key with n but no e. (They need n to compute RSA-PSS padding.) I think that all wants to be rethought but, for now, just add an API for it. This bumps BORINGSSL_API_VERSION so Conscrypt can have an easier time switching to the new APIs. Bug: 316 Change-Id: I81498a7d0690886842016c3680ea27d1ee0fa490 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59386 Commit-Queue: David Benjamin Reviewed-by: Adam Langley --- crypto/fipsmodule/rsa/rsa.c | 88 ++++++++++++++ crypto/fipsmodule/rsa/rsa_impl.c | 38 ++++-- crypto/rsa_extra/rsa_crypt.c | 5 + crypto/rsa_extra/rsa_test.cc | 192 +++++++++++++++++++++---------- include/openssl/base.h | 2 +- include/openssl/rsa.h | 66 ++++++++++- 6 files changed, 319 insertions(+), 72 deletions(-) diff --git a/crypto/fipsmodule/rsa/rsa.c b/crypto/fipsmodule/rsa/rsa.c index 8f5cb5ff16..5b687b7a93 100644 --- a/crypto/fipsmodule/rsa/rsa.c +++ b/crypto/fipsmodule/rsa/rsa.c @@ -83,6 +83,83 @@ OPENSSL_DECLARE_ERROR_REASON(RSA, BLOCK_TYPE_IS_NOT_02) DEFINE_STATIC_EX_DATA_CLASS(g_rsa_ex_data_class) +static int bn_dup_into(BIGNUM **dst, const BIGNUM *src) { + if (src == NULL) { + OPENSSL_PUT_ERROR(RSA, ERR_R_PASSED_NULL_PARAMETER); + return 0; + } + + BN_free(*dst); + *dst = BN_dup(src); + return *dst != NULL; +} + +RSA *RSA_new_public_key(const BIGNUM *n, const BIGNUM *e) { + RSA *rsa = RSA_new(); + if (rsa == NULL || // + !bn_dup_into(&rsa->n, n) || // + !bn_dup_into(&rsa->e, e) || // + !RSA_check_key(rsa)) { + RSA_free(rsa); + return NULL; + } + + return rsa; +} + +RSA *RSA_new_private_key(const BIGNUM *n, const BIGNUM *e, const BIGNUM *d, + const BIGNUM *p, const BIGNUM *q, const BIGNUM *dmp1, + const BIGNUM *dmq1, const BIGNUM *iqmp) { + RSA *rsa = RSA_new(); + if (rsa == NULL || // + !bn_dup_into(&rsa->n, n) || // + !bn_dup_into(&rsa->e, e) || // + !bn_dup_into(&rsa->d, d) || // + !bn_dup_into(&rsa->p, p) || // + !bn_dup_into(&rsa->q, q) || // + !bn_dup_into(&rsa->dmp1, dmp1) || // + !bn_dup_into(&rsa->dmq1, dmq1) || // + !bn_dup_into(&rsa->iqmp, iqmp) || // + !RSA_check_key(rsa)) { + RSA_free(rsa); + return NULL; + } + + return rsa; +} + +RSA *RSA_new_private_key_no_crt(const BIGNUM *n, const BIGNUM *e, + const BIGNUM *d) { + RSA *rsa = RSA_new(); + if (rsa == NULL || // + !bn_dup_into(&rsa->n, n) || // + !bn_dup_into(&rsa->e, e) || // + !bn_dup_into(&rsa->d, d) || // + !RSA_check_key(rsa)) { + RSA_free(rsa); + return NULL; + } + + return rsa; +} + +RSA *RSA_new_private_key_no_e(const BIGNUM *n, const BIGNUM *d) { + RSA *rsa = RSA_new(); + if (rsa == NULL) { + return NULL; + } + + rsa->flags |= RSA_FLAG_NO_PUBLIC_EXPONENT; + if (!bn_dup_into(&rsa->n, n) || // + !bn_dup_into(&rsa->d, d) || // + !RSA_check_key(rsa)) { + RSA_free(rsa); + return NULL; + } + + return rsa; +} + RSA *RSA_new(void) { return RSA_new_method(NULL); } RSA *RSA_new_method(const ENGINE *engine) { @@ -118,6 +195,17 @@ RSA *RSA_new_method(const ENGINE *engine) { return rsa; } +RSA *RSA_new_method_no_e(const ENGINE *engine, const BIGNUM *n) { + RSA *rsa = RSA_new_method(engine); + if (rsa == NULL || + !bn_dup_into(&rsa->n, n)) { + RSA_free(rsa); + return NULL; + } + rsa->flags |= RSA_FLAG_NO_PUBLIC_EXPONENT; + return rsa; +} + void RSA_free(RSA *rsa) { if (rsa == NULL) { return; diff --git a/crypto/fipsmodule/rsa/rsa_impl.c b/crypto/fipsmodule/rsa/rsa_impl.c index 6eb44381d3..e9379d9946 100644 --- a/crypto/fipsmodule/rsa/rsa_impl.c +++ b/crypto/fipsmodule/rsa/rsa_impl.c @@ -74,7 +74,7 @@ int rsa_check_public_key(const RSA *rsa) { - if (rsa->n == NULL || rsa->e == NULL) { + if (rsa->n == NULL) { OPENSSL_PUT_ERROR(RSA, RSA_R_VALUE_MISSING); return 0; } @@ -102,13 +102,17 @@ int rsa_check_public_key(const RSA *rsa) { // [2] https://www.imperialviolet.org/2012/03/17/rsados.html // [3] https://msdn.microsoft.com/en-us/library/aa387685(VS.85).aspx static const unsigned kMaxExponentBits = 33; - unsigned e_bits = BN_num_bits(rsa->e); - if (e_bits > kMaxExponentBits || - // Additionally reject e = 1 or even e. e must be odd to be relatively - // prime with phi(n). - e_bits < 2 || - !BN_is_odd(rsa->e)) { - OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_E_VALUE); + if (rsa->e != NULL) { + unsigned e_bits = BN_num_bits(rsa->e); + if (e_bits > kMaxExponentBits || + // Additionally reject e = 1 or even e. e must be odd to be relatively + // prime with phi(n). + e_bits < 2 || !BN_is_odd(rsa->e)) { + OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_E_VALUE); + return 0; + } + } else if (!(rsa->flags & RSA_FLAG_NO_PUBLIC_EXPONENT)) { + OPENSSL_PUT_ERROR(RSA, RSA_R_VALUE_MISSING); return 0; } @@ -120,7 +124,7 @@ int rsa_check_public_key(const RSA *rsa) { OPENSSL_PUT_ERROR(RSA, RSA_R_KEY_SIZE_TOO_SMALL); return 0; } - assert(BN_ucmp(rsa->n, rsa->e) > 0); + assert(rsa->e == NULL || BN_ucmp(rsa->n, rsa->e) > 0); return 1; } @@ -183,7 +187,7 @@ static int freeze_private_key(RSA *rsa, BN_CTX *ctx) { goto err; } - if (rsa->p != NULL && rsa->q != NULL) { + if (rsa->e != NULL && rsa->p != NULL && rsa->q != NULL) { // TODO: p and q are also CONSTTIME_SECRET but not yet marked as such // because the Montgomery code does things like test whether or not values // are zero. So the secret marking probably needs to happen inside that @@ -478,6 +482,11 @@ static int mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx); int rsa_verify_raw_no_self_test(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, const uint8_t *in, size_t in_len, int padding) { + if (rsa->n == NULL || rsa->e == NULL) { + OPENSSL_PUT_ERROR(RSA, RSA_R_VALUE_MISSING); + return 0; + } + if (!rsa_check_public_key(rsa)) { return 0; } @@ -617,13 +626,18 @@ int rsa_default_private_transform(RSA *rsa, uint8_t *out, const uint8_t *in, goto err; } - const int do_blinding = (rsa->flags & RSA_FLAG_NO_BLINDING) == 0; + const int do_blinding = + (rsa->flags & (RSA_FLAG_NO_BLINDING | RSA_FLAG_NO_PUBLIC_EXPONENT)) == 0; if (rsa->e == NULL && do_blinding) { // We cannot do blinding or verification without |e|, and continuing without // those countermeasures is dangerous. However, the Java/Android RSA API // requires support for keys where only |d| and |n| (and not |e|) are known. - // The callers that require that bad behavior set |RSA_FLAG_NO_BLINDING|. + // The callers that require that bad behavior must set + // |RSA_FLAG_NO_BLINDING| or use |RSA_new_private_key_no_e|. + // + // TODO(davidben): Update this comment when Conscrypt is updated to use + // |RSA_new_private_key_no_e|. OPENSSL_PUT_ERROR(RSA, RSA_R_NO_PUBLIC_EXPONENT); goto err; } diff --git a/crypto/rsa_extra/rsa_crypt.c b/crypto/rsa_extra/rsa_crypt.c index 97afa3db34..c9d29fc170 100644 --- a/crypto/rsa_extra/rsa_crypt.c +++ b/crypto/rsa_extra/rsa_crypt.c @@ -376,6 +376,11 @@ int RSA_private_encrypt(size_t flen, const uint8_t *from, uint8_t *to, RSA *rsa, int RSA_encrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out, const uint8_t *in, size_t in_len, int padding) { + if (rsa->n == NULL || rsa->e == NULL) { + OPENSSL_PUT_ERROR(RSA, RSA_R_VALUE_MISSING); + return 0; + } + if (!rsa_check_public_key(rsa)) { return 0; } diff --git a/crypto/rsa_extra/rsa_test.cc b/crypto/rsa_extra/rsa_test.cc index b6ab5b864f..4a450e596a 100644 --- a/crypto/rsa_extra/rsa_test.cc +++ b/crypto/rsa_extra/rsa_test.cc @@ -396,68 +396,108 @@ struct RSAEncryptParam { class RSAEncryptTest : public testing::TestWithParam {}; TEST_P(RSAEncryptTest, TestKey) { + // Construct an RSA key in different ways. const auto ¶m = GetParam(); - bssl::UniquePtr key( + bssl::UniquePtr parsed( RSA_private_key_from_bytes(param.der, param.der_len)); - ASSERT_TRUE(key); - - EXPECT_TRUE(RSA_check_key(key.get())); + ASSERT_TRUE(parsed); + EXPECT_TRUE(RSA_get0_e(parsed.get())); + EXPECT_TRUE(RSA_get0_d(parsed.get())); + + bssl::UniquePtr constructed(RSA_new_private_key( + RSA_get0_n(parsed.get()), RSA_get0_e(parsed.get()), + RSA_get0_d(parsed.get()), RSA_get0_p(parsed.get()), + RSA_get0_q(parsed.get()), RSA_get0_dmp1(parsed.get()), + RSA_get0_dmq1(parsed.get()), RSA_get0_iqmp(parsed.get()))); + ASSERT_TRUE(constructed); + EXPECT_TRUE(RSA_get0_e(constructed.get())); + EXPECT_TRUE(RSA_get0_d(constructed.get())); + + bssl::UniquePtr no_crt(RSA_new_private_key_no_crt( + RSA_get0_n(parsed.get()), RSA_get0_e(parsed.get()), + RSA_get0_d(parsed.get()))); + ASSERT_TRUE(no_crt); + EXPECT_TRUE(RSA_get0_e(no_crt.get())); + EXPECT_TRUE(RSA_get0_d(no_crt.get())); + + bssl::UniquePtr no_e(RSA_new_private_key_no_e(RSA_get0_n(parsed.get()), + RSA_get0_d(parsed.get()))); + ASSERT_TRUE(no_e); + EXPECT_FALSE(RSA_get0_e(no_e.get())); + EXPECT_TRUE(RSA_get0_d(no_e.get())); - uint8_t ciphertext[256]; - - // Test that PKCS#1 v1.5 encryption round-trips. - size_t ciphertext_len = 0; - ASSERT_TRUE(RSA_encrypt(key.get(), &ciphertext_len, ciphertext, - sizeof(ciphertext), kPlaintext, kPlaintextLen, - RSA_PKCS1_PADDING)); - EXPECT_EQ(RSA_size(key.get()), ciphertext_len); - - uint8_t plaintext[256]; - size_t plaintext_len = 0; - ASSERT_TRUE(RSA_decrypt(key.get(), &plaintext_len, plaintext, - sizeof(plaintext), ciphertext, ciphertext_len, - RSA_PKCS1_PADDING)); - EXPECT_EQ(Bytes(kPlaintext, kPlaintextLen), Bytes(plaintext, plaintext_len)); - - // Test that OAEP encryption round-trips. - ciphertext_len = 0; - ASSERT_TRUE(RSA_encrypt(key.get(), &ciphertext_len, ciphertext, - sizeof(ciphertext), kPlaintext, kPlaintextLen, - RSA_PKCS1_OAEP_PADDING)); - EXPECT_EQ(RSA_size(key.get()), ciphertext_len); - - plaintext_len = 0; - ASSERT_TRUE(RSA_decrypt(key.get(), &plaintext_len, plaintext, - sizeof(plaintext), ciphertext, ciphertext_len, - RSA_PKCS1_OAEP_PADDING)); - EXPECT_EQ(Bytes(kPlaintext, kPlaintextLen), Bytes(plaintext, plaintext_len)); - - // |oaep_ciphertext| should decrypt to |kPlaintext|. - plaintext_len = 0; - ASSERT_TRUE(RSA_decrypt(key.get(), &plaintext_len, plaintext, - sizeof(plaintext), param.oaep_ciphertext, - param.oaep_ciphertext_len, RSA_PKCS1_OAEP_PADDING)); - EXPECT_EQ(Bytes(kPlaintext, kPlaintextLen), Bytes(plaintext, plaintext_len)); - - // Try decrypting corrupted ciphertexts. - OPENSSL_memcpy(ciphertext, param.oaep_ciphertext, param.oaep_ciphertext_len); - for (size_t i = 0; i < param.oaep_ciphertext_len; i++) { - SCOPED_TRACE(i); - ciphertext[i] ^= 1; - EXPECT_FALSE(RSA_decrypt( - key.get(), &plaintext_len, plaintext, sizeof(plaintext), ciphertext, - param.oaep_ciphertext_len, RSA_PKCS1_OAEP_PADDING)); - ERR_clear_error(); - ciphertext[i] ^= 1; - } + bssl::UniquePtr pub( + RSA_new_public_key(RSA_get0_n(parsed.get()), RSA_get0_e(parsed.get()))); + ASSERT_TRUE(pub); + EXPECT_TRUE(RSA_get0_e(pub.get())); + EXPECT_FALSE(RSA_get0_d(pub.get())); + + for (RSA *key : + {parsed.get(), constructed.get(), no_crt.get(), no_e.get(), pub.get()}) { + EXPECT_TRUE(RSA_check_key(key)); + + uint8_t ciphertext[256], plaintext[256]; + size_t ciphertext_len = 0, plaintext_len = 0; + + if (RSA_get0_e(key) != nullptr) { + // Test that PKCS#1 v1.5 encryption round-trips. + ASSERT_TRUE(RSA_encrypt(key, &ciphertext_len, ciphertext, + sizeof(ciphertext), kPlaintext, kPlaintextLen, + RSA_PKCS1_PADDING)); + EXPECT_EQ(RSA_size(key), ciphertext_len); + + ASSERT_TRUE(RSA_decrypt(parsed.get(), &plaintext_len, plaintext, + sizeof(plaintext), ciphertext, ciphertext_len, + RSA_PKCS1_PADDING)); + EXPECT_EQ(Bytes(kPlaintext, kPlaintextLen), + Bytes(plaintext, plaintext_len)); + + // Test that OAEP encryption round-trips. + ciphertext_len = 0; + ASSERT_TRUE(RSA_encrypt(key, &ciphertext_len, ciphertext, + sizeof(ciphertext), kPlaintext, kPlaintextLen, + RSA_PKCS1_OAEP_PADDING)); + EXPECT_EQ(RSA_size(key), ciphertext_len); + + plaintext_len = 0; + ASSERT_TRUE(RSA_decrypt(parsed.get(), &plaintext_len, plaintext, + sizeof(plaintext), ciphertext, ciphertext_len, + RSA_PKCS1_OAEP_PADDING)); + EXPECT_EQ(Bytes(kPlaintext, kPlaintextLen), + Bytes(plaintext, plaintext_len)); + } - // Test truncated ciphertexts. - for (size_t len = 0; len < param.oaep_ciphertext_len; len++) { - SCOPED_TRACE(len); - EXPECT_FALSE(RSA_decrypt(key.get(), &plaintext_len, plaintext, - sizeof(plaintext), ciphertext, len, - RSA_PKCS1_OAEP_PADDING)); - ERR_clear_error(); + if (RSA_get0_d(key) != nullptr) { + // |oaep_ciphertext| should decrypt to |kPlaintext|. + plaintext_len = 0; + ASSERT_TRUE(RSA_decrypt(key, &plaintext_len, plaintext, sizeof(plaintext), + param.oaep_ciphertext, param.oaep_ciphertext_len, + RSA_PKCS1_OAEP_PADDING)); + EXPECT_EQ(Bytes(kPlaintext, kPlaintextLen), + Bytes(plaintext, plaintext_len)); + + // Try decrypting corrupted ciphertexts. + OPENSSL_memcpy(ciphertext, param.oaep_ciphertext, + param.oaep_ciphertext_len); + for (size_t i = 0; i < param.oaep_ciphertext_len; i++) { + SCOPED_TRACE(i); + ciphertext[i] ^= 1; + EXPECT_FALSE(RSA_decrypt( + key, &plaintext_len, plaintext, sizeof(plaintext), ciphertext, + param.oaep_ciphertext_len, RSA_PKCS1_OAEP_PADDING)); + ERR_clear_error(); + ciphertext[i] ^= 1; + } + + // Test truncated ciphertexts. + for (size_t len = 0; len < param.oaep_ciphertext_len; len++) { + SCOPED_TRACE(len); + EXPECT_FALSE(RSA_decrypt(key, &plaintext_len, plaintext, + sizeof(plaintext), ciphertext, len, + RSA_PKCS1_OAEP_PADDING)); + ERR_clear_error(); + } + } } } @@ -1111,6 +1151,42 @@ TEST(RSATest, OverwriteKey) { check_rsa_compatible(/*enc=*/key2.get(), /*dec=*/key1.get())); } +// Test that RSA keys do not support operations will cleanly fail them. +TEST(RSATest, MissingParameters) { + bssl::UniquePtr sample( + RSA_private_key_from_bytes(kKey1, sizeof(kKey1) - 1)); + ASSERT_TRUE(sample); + + // Make a sample signature. + const uint8_t kZeros[32] = {0}; + std::vector sig(RSA_size(sample.get())); + unsigned len_u; + ASSERT_TRUE(RSA_sign(NID_sha256, kZeros, sizeof(kZeros), sig.data(), &len_u, + sample.get())); + sig.resize(len_u); + + // A public key cannot perform private key operations. + bssl::UniquePtr rsa( + RSA_new_public_key(RSA_get0_n(sample.get()), RSA_get0_e(sample.get()))); + ASSERT_TRUE(rsa); + std::vector out(RSA_size(sample.get())); + EXPECT_FALSE(RSA_sign(NID_sha256, kZeros, sizeof(kZeros), out.data(), &len_u, + rsa.get())); + size_t len; + EXPECT_FALSE(RSA_decrypt(rsa.get(), &len, out.data(), out.size(), + kOAEPCiphertext1, sizeof(kOAEPCiphertext1) - 1, + RSA_PKCS1_OAEP_PADDING)); + + // A private key without e cannot perform public key operations. + rsa.reset(RSA_new_private_key_no_e(RSA_get0_n(sample.get()), + RSA_get0_d(sample.get()))); + ASSERT_TRUE(rsa); + EXPECT_FALSE(RSA_verify(NID_sha256, kZeros, sizeof(kZeros), sig.data(), + sig.size(), rsa.get())); + EXPECT_FALSE(RSA_encrypt(rsa.get(), &len, out.data(), out.size(), kPlaintext, + kPlaintextLen, RSA_PKCS1_OAEP_PADDING)); +} + #if !defined(BORINGSSL_SHARED_LIBRARY) TEST(RSATest, SqrtTwo) { bssl::UniquePtr sqrt(BN_new()), pow2(BN_new()); diff --git a/include/openssl/base.h b/include/openssl/base.h index 80d18a78d8..ee26627447 100644 --- a/include/openssl/base.h +++ b/include/openssl/base.h @@ -193,7 +193,7 @@ extern "C" { // A consumer may use this symbol in the preprocessor to temporarily build // against multiple revisions of BoringSSL at the same time. It is not // recommended to do so for longer than is necessary. -#define BORINGSSL_API_VERSION 19 +#define BORINGSSL_API_VERSION 20 #if defined(BORINGSSL_SHARED_LIBRARY) diff --git a/include/openssl/rsa.h b/include/openssl/rsa.h index a1c03cd3b3..49a6aa6d15 100644 --- a/include/openssl/rsa.h +++ b/include/openssl/rsa.h @@ -79,7 +79,22 @@ extern "C" { // documented, functions which take a |const| pointer are non-mutating and // functions which take a non-|const| pointer are mutating. -// RSA_new returns a new, empty |RSA| object or NULL on error. +// RSA_new_public_key returns a new |RSA| object containing a public key with +// the specified parameters, or NULL on error or invalid input. +OPENSSL_EXPORT RSA *RSA_new_public_key(const BIGNUM *n, const BIGNUM *e); + +// RSA_new_private_key returns a new |RSA| object containing a private key with +// the specified parameters, or NULL on error or invalid input. All parameters +// are mandatory and may not be NULL. +// +// This function creates standard RSA private keys with CRT parameters. +OPENSSL_EXPORT RSA *RSA_new_private_key(const BIGNUM *n, const BIGNUM *e, + const BIGNUM *d, const BIGNUM *p, + const BIGNUM *q, const BIGNUM *dmp1, + const BIGNUM *dmq1, const BIGNUM *iqmp); + +// RSA_new returns a new, empty |RSA| object or NULL on error. Prefer using +// |RSA_new_public_key| or |RSA_new_private_key| to import an RSA key. OPENSSL_EXPORT RSA *RSA_new(void); // RSA_new_method acts the same as |RSA_new| but takes an explicit |ENGINE|. @@ -148,6 +163,20 @@ OPENSSL_EXPORT void RSA_get0_crt_params(const RSA *rsa, const BIGNUM **out_dmp1, const BIGNUM **out_dmq1, const BIGNUM **out_iqmp); + +// Setting individual properties. +// +// These functions allow setting individual properties of an |RSA| object. This +// is typically used with |RSA_new| to construct an RSA key field by field. +// Prefer instead to use |RSA_new_public_key| and |RSA_new_private_key|. These +// functions defer some initialization to the first use of an |RSA| object. This +// means invalid inputs may be caught late. +// +// TODO(crbug.com/boringssl/316): This deferred initialization also causes +// performance problems in multi-threaded applications. The preferred APIs +// currently have the same issues, but they will initialize eagerly in the +// future. + // RSA_set0_key sets |rsa|'s modulus, public exponent, and private exponent to // |n|, |e|, and |d| respectively, if non-NULL. On success, it takes ownership // of each argument and returns one. Otherwise, it returns zero. @@ -570,6 +599,28 @@ OPENSSL_EXPORT int RSA_private_key_to_bytes(uint8_t **out_bytes, size_t *out_len, const RSA *rsa); +// Obscure RSA variants. +// +// These functions allow creating RSA keys with obscure combinations of +// parameters. + +// RSA_new_private_key_no_crt behaves like |RSA_new_private_key| but constructs +// an RSA key without CRT coefficients. +// +// Keys created by this function will be less performant and cannot be +// serialized. +OPENSSL_EXPORT RSA *RSA_new_private_key_no_crt(const BIGNUM *n, const BIGNUM *e, + const BIGNUM *d); + +// RSA_new_private_key_no_e behaves like |RSA_new_private_key| but constructs an +// RSA key without CRT parameters or public exponent. +// +// Keys created by this function will be less performant, cannot be serialized, +// and lack hardening measures that protect against side channels and fault +// attacks. +OPENSSL_EXPORT RSA *RSA_new_private_key_no_e(const BIGNUM *n, const BIGNUM *d); + + // ex_data functions. // // See |ex_data.h| for details. @@ -600,6 +651,11 @@ OPENSSL_EXPORT void *RSA_get_ex_data(const RSA *rsa, int idx); // RSA_FLAG_EXT_PKEY is deprecated and ignored. #define RSA_FLAG_EXT_PKEY 0x20 +// RSA_FLAG_NO_PUBLIC_EXPONENT indicates that private keys without a public +// exponent are allowed. This is an internal constant. Use +// |RSA_new_private_key_no_e| to construct such keys. +#define RSA_FLAG_NO_PUBLIC_EXPONENT 0x40 + // RSA public exponent values. @@ -688,6 +744,14 @@ OPENSSL_EXPORT int RSA_print(BIO *bio, const RSA *rsa, int indent); // the id-RSASSA-PSS key encoding. OPENSSL_EXPORT const RSA_PSS_PARAMS *RSA_get0_pss_params(const RSA *rsa); +// RSA_new_method_no_e returns a newly-allocated |RSA| object backed by +// |engine|, with a public modulus of |n| and no known public exponent. +// +// Do not use this function. It exists only to support Conscrypt, whose use +// should be replaced with a more sound mechanism. See +// https://crbug.com/boringssl/602. +OPENSSL_EXPORT RSA *RSA_new_method_no_e(const ENGINE *engine, const BIGNUM *n); + struct rsa_meth_st { struct openssl_method_common_st common; From 77b6f2593543474bf5d2fb4821dfe31b32c7fc22 Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Tue, 2 May 2023 10:14:11 -0400 Subject: [PATCH 53/56] Replace interface{} with any Satisfy a go lint. As of Go 1.18, any is the preferred spelling of interface{}. Also remove an instance of redundant types in util/fipstools/acvp/acvptool/acvp.go because my editor warned about it. (A []map[string]any{map[string]any{...}, map[string]any{...}} literal can omit the inner copy of the type because it's implicit from the outer one.) Change-Id: I2251b2285c16c19bc779fa41d1011f7fa1392563 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59465 Auto-Submit: David Benjamin Reviewed-by: Adam Langley Commit-Queue: Adam Langley --- ssl/test/runner/cipher_suites.go | 8 ++-- ssl/test/runner/common.go | 8 ++-- ssl/test/runner/conn.go | 8 ++-- ssl/test/runner/handshake_client.go | 6 +-- ssl/test/runner/handshake_server.go | 2 +- ssl/test/runner/prf.go | 2 +- ssl/test/runner/sign.go | 2 +- util/convert_wycheproof/convert_wycheproof.go | 24 +++++------ util/fipstools/acvp/acvptool/acvp.go | 20 +++++----- util/fipstools/acvp/acvptool/acvp/acvp.go | 40 +++++++++---------- util/fipstools/acvp/acvptool/interactive.go | 8 ++-- .../acvp/acvptool/subprocess/aead.go | 2 +- .../acvp/acvptool/subprocess/block.go | 2 +- .../acvp/acvptool/subprocess/drbg.go | 2 +- .../acvp/acvptool/subprocess/ecdsa.go | 2 +- .../acvp/acvptool/subprocess/hash.go | 2 +- .../acvp/acvptool/subprocess/hkdf.go | 2 +- .../acvp/acvptool/subprocess/hmac.go | 2 +- .../fipstools/acvp/acvptool/subprocess/kas.go | 2 +- .../acvp/acvptool/subprocess/kasdh.go | 2 +- .../fipstools/acvp/acvptool/subprocess/kdf.go | 2 +- .../acvp/acvptool/subprocess/keyedMac.go | 2 +- .../fipstools/acvp/acvptool/subprocess/rsa.go | 8 ++-- .../acvp/acvptool/subprocess/subprocess.go | 4 +- .../acvp/acvptool/subprocess/tls13.go | 2 +- .../acvp/acvptool/subprocess/tlskdf.go | 2 +- .../fipstools/acvp/acvptool/subprocess/xts.go | 2 +- .../acvp/acvptool/test/trim_vectors.go | 12 +++--- util/read_symbols.go | 2 +- 29 files changed, 91 insertions(+), 91 deletions(-) diff --git a/ssl/test/runner/cipher_suites.go b/ssl/test/runner/cipher_suites.go index b86f515f54..f7dcb9bf47 100644 --- a/ssl/test/runner/cipher_suites.go +++ b/ssl/test/runner/cipher_suites.go @@ -84,7 +84,7 @@ type cipherSuite struct { ka func(version uint16) keyAgreement // flags is a bitmask of the suite* values, above. flags int - cipher func(key, iv []byte, isRead bool) interface{} + cipher func(key, iv []byte, isRead bool) any mac func(version uint16, macKey []byte) macFunction aead func(version uint16, key, fixedNonce []byte) *tlsAead } @@ -150,11 +150,11 @@ func ivLen3DES(vers uint16) int { type nullCipher struct{} -func cipherNull(key, iv []byte, isRead bool) interface{} { +func cipherNull(key, iv []byte, isRead bool) any { return nullCipher{} } -func cipher3DES(key, iv []byte, isRead bool) interface{} { +func cipher3DES(key, iv []byte, isRead bool) any { block, _ := des.NewTripleDESCipher(key) if isRead { return cipher.NewCBCDecrypter(block, iv) @@ -162,7 +162,7 @@ func cipher3DES(key, iv []byte, isRead bool) interface{} { return cipher.NewCBCEncrypter(block, iv) } -func cipherAES(key, iv []byte, isRead bool) interface{} { +func cipherAES(key, iv []byte, isRead bool) any { block, _ := aes.NewCipher(key) if isRead { return cipher.NewCBCDecrypter(block, iv) diff --git a/ssl/test/runner/common.go b/ssl/test/runner/common.go index 0262a19c6c..d0279c6f72 100644 --- a/ssl/test/runner/common.go +++ b/ssl/test/runner/common.go @@ -2191,11 +2191,11 @@ type lruSessionCache struct { type lruSessionCacheEntry struct { sessionKey string - state interface{} + state any } // Put adds the provided (sessionKey, cs) pair to the cache. -func (c *lruSessionCache) Put(sessionKey string, cs interface{}) { +func (c *lruSessionCache) Put(sessionKey string, cs any) { c.Lock() defer c.Unlock() @@ -2223,7 +2223,7 @@ func (c *lruSessionCache) Put(sessionKey string, cs interface{}) { // Get returns the value associated with a given key. It returns (nil, // false) if no value is found. -func (c *lruSessionCache) Get(sessionKey string) (interface{}, bool) { +func (c *lruSessionCache) Get(sessionKey string) (any, bool) { c.Lock() defer c.Unlock() @@ -2337,7 +2337,7 @@ func initDefaultCipherSuites() { } } -func unexpectedMessageError(wanted, got interface{}) error { +func unexpectedMessageError(wanted, got any) error { return fmt.Errorf("tls: received unexpected handshake message of type %T when waiting for %T", got, wanted) } diff --git a/ssl/test/runner/conn.go b/ssl/test/runner/conn.go index ad77b665dc..2e9114dba1 100644 --- a/ssl/test/runner/conn.go +++ b/ssl/test/runner/conn.go @@ -174,13 +174,13 @@ type halfConn struct { version uint16 // protocol version wireVersion uint16 // wire version isDTLS bool - cipher interface{} // cipher algorithm + cipher any // cipher algorithm mac macFunction seq [8]byte // 64-bit sequence number outSeq [8]byte // Mapped sequence number bfree *block // list of free blocks - nextCipher interface{} // next encryption state + nextCipher any // next encryption state nextMac macFunction // next MAC algorithm nextSeq [6]byte // next epoch's starting sequence number in DTLS @@ -207,7 +207,7 @@ func (hc *halfConn) error() error { // prepareCipherSpec sets the encryption and MAC states // that a subsequent changeCipherSpec will use. -func (hc *halfConn) prepareCipherSpec(version uint16, cipher interface{}, mac macFunction) { +func (hc *halfConn) prepareCipherSpec(version uint16, cipher any, mac macFunction) { hc.wireVersion = version protocolVersion, ok := wireToVersion(version, hc.isDTLS) if !ok { @@ -1336,7 +1336,7 @@ func (c *Conn) doReadHandshake() ([]byte, error) { // readHandshake reads the next handshake message from // the record layer. // c.in.Mutex < L; c.out.Mutex < L. -func (c *Conn) readHandshake() (interface{}, error) { +func (c *Conn) readHandshake() (any, error) { data, err := c.doReadHandshake() if err != nil { return nil, err diff --git a/ssl/test/runner/handshake_client.go b/ssl/test/runner/handshake_client.go index 42f0534fd0..a51ed558e8 100644 --- a/ssl/test/runner/handshake_client.go +++ b/ssl/test/runner/handshake_client.go @@ -925,7 +925,7 @@ func (hs *clientHandshakeState) encryptClientHello(hello, innerHello *clientHell return nil } -func (hs *clientHandshakeState) checkECHConfirmation(msg interface{}, hello *clientHelloMsg, finishedHash *finishedHash) bool { +func (hs *clientHandshakeState) checkECHConfirmation(msg any, hello *clientHelloMsg, finishedHash *finishedHash) bool { var offset int var raw, label []byte if hrr, ok := msg.(*helloRetryRequestMsg); ok { @@ -950,7 +950,7 @@ func (hs *clientHandshakeState) checkECHConfirmation(msg interface{}, hello *cli return bytes.Equal(confirmation, raw[offset:offset+echAcceptConfirmationLength]) } -func (hs *clientHandshakeState) doTLS13Handshake(msg interface{}) error { +func (hs *clientHandshakeState) doTLS13Handshake(msg any) error { c := hs.c // The first message may be a ServerHello or HelloRetryRequest. @@ -1897,7 +1897,7 @@ func (hs *clientHandshakeState) establishKeys() error { clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV := keysFromMasterSecret(c.vers, hs.suite, hs.masterSecret, hs.hello.random, hs.serverHello.random, hs.suite.macLen, hs.suite.keyLen, hs.suite.ivLen(c.vers)) - var clientCipher, serverCipher interface{} + var clientCipher, serverCipher any var clientHash, serverHash macFunction if hs.suite.cipher != nil { clientCipher = hs.suite.cipher(clientKey, clientIV, false /* not for reading */) diff --git a/ssl/test/runner/handshake_server.go b/ssl/test/runner/handshake_server.go index 4f3cf7546a..4130d9bc9b 100644 --- a/ssl/test/runner/handshake_server.go +++ b/ssl/test/runner/handshake_server.go @@ -2076,7 +2076,7 @@ func (hs *serverHandshakeState) establishKeys() error { clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV := keysFromMasterSecret(c.vers, hs.suite, hs.masterSecret, hs.clientHello.random, hs.hello.random, hs.suite.macLen, hs.suite.keyLen, hs.suite.ivLen(c.vers)) - var clientCipher, serverCipher interface{} + var clientCipher, serverCipher any var clientHash, serverHash macFunction if hs.suite.aead == nil { diff --git a/ssl/test/runner/prf.go b/ssl/test/runner/prf.go index 5731be0331..fc67d7503b 100644 --- a/ssl/test/runner/prf.go +++ b/ssl/test/runner/prf.go @@ -451,7 +451,7 @@ var ( // deriveTrafficAEAD derives traffic keys and constructs an AEAD given a traffic // secret. -func deriveTrafficAEAD(version uint16, suite *cipherSuite, secret []byte, side trafficDirection) interface{} { +func deriveTrafficAEAD(version uint16, suite *cipherSuite, secret []byte, side trafficDirection) any { key := hkdfExpandLabel(suite.hash(), secret, keyTLS13, nil, suite.keyLen) iv := hkdfExpandLabel(suite.hash(), secret, ivTLS13, nil, suite.ivLen(version)) diff --git a/ssl/test/runner/sign.go b/ssl/test/runner/sign.go index da6452ac00..70541a1ec1 100644 --- a/ssl/test/runner/sign.go +++ b/ssl/test/runner/sign.go @@ -272,7 +272,7 @@ func (e *ed25519Signer) verifyMessage(key crypto.PublicKey, msg, sig []byte) err return nil } -func getSigner(version uint16, key interface{}, config *Config, sigAlg signatureAlgorithm, isVerify bool) (signer, error) { +func getSigner(version uint16, key any, config *Config, sigAlg signatureAlgorithm, isVerify bool) (signer, error) { // TLS 1.1 and below use legacy signature algorithms. if version < VersionTLS12 || (!isVerify && config.Bugs.AlwaysSignAsLegacyVersion) { if config.Bugs.SigningAlgorithmForLegacyVersions == 0 || isVerify { diff --git a/util/convert_wycheproof/convert_wycheproof.go b/util/convert_wycheproof/convert_wycheproof.go index 076f8e480d..cf1e64985f 100644 --- a/util/convert_wycheproof/convert_wycheproof.go +++ b/util/convert_wycheproof/convert_wycheproof.go @@ -33,10 +33,10 @@ type wycheproofTest struct { Header []string `json:"header"` // encoding/json does not support collecting unused keys, so we leave // everything past this point as generic. - TestGroups []map[string]interface{} `json:"testGroups"` + TestGroups []map[string]any `json:"testGroups"` } -func sortedKeys(m map[string]interface{}) []string { +func sortedKeys(m map[string]any) []string { keys := make([]string, 0, len(m)) for k, _ := range m { keys = append(keys, k) @@ -45,8 +45,8 @@ func sortedKeys(m map[string]interface{}) []string { return keys } -func printAttribute(w io.Writer, key string, valueI interface{}, isInstruction bool) error { - switch value := valueI.(type) { +func printAttribute(w io.Writer, key string, valueAny any, isInstruction bool) error { + switch value := valueAny.(type) { case float64: if float64(int(value)) != value { panic(key + "was not an integer.") @@ -73,14 +73,14 @@ func printAttribute(w io.Writer, key string, valueI interface{}, isInstruction b return err } } - case map[string]interface{}: + case map[string]any: for _, k := range sortedKeys(value) { if err := printAttribute(w, key+"."+k, value[k], isInstruction); err != nil { return err } } default: - panic(fmt.Sprintf("Unknown type for %q: %T", key, valueI)) + panic(fmt.Sprintf("Unknown type for %q: %T", key, valueAny)) } return nil } @@ -154,9 +154,9 @@ func convertWycheproof(f io.Writer, jsonPath string) error { } } fmt.Fprintf(f, "\n") - tests := group["tests"].([]interface{}) - for _, testI := range tests { - test := testI.(map[string]interface{}) + tests := group["tests"].([]any) + for _, testAny := range tests { + test := testAny.(map[string]any) if _, err := fmt.Fprintf(f, "# tcId = %d\n", int(test["tcId"].(float64))); err != nil { return err } @@ -173,10 +173,10 @@ func convertWycheproof(f io.Writer, jsonPath string) error { return err } } - if flagsI, ok := test["flags"]; ok { + if flagsAny, ok := test["flags"]; ok { var flags []string - for _, flagI := range flagsI.([]interface{}) { - flag := flagI.(string) + for _, flagAny := range flagsAny.([]any) { + flag := flagAny.(string) flags = append(flags, flag) } if len(flags) != 0 { diff --git a/util/fipstools/acvp/acvptool/acvp.go b/util/fipstools/acvp/acvptool/acvp.go index c294eb8de5..fd009f5a55 100644 --- a/util/fipstools/acvp/acvptool/acvp.go +++ b/util/fipstools/acvp/acvptool/acvp.go @@ -80,7 +80,7 @@ func isCommentLine(line []byte) bool { return false } -func jsonFromFile(out interface{}, filename string) error { +func jsonFromFile(out any, filename string) error { in, err := os.Open(filename) if err != nil { return err @@ -131,7 +131,7 @@ func TOTP(secret []byte) string { type Middle interface { Close() Config() ([]byte, error) - Process(algorithm string, vectorSet []byte) (interface{}, error) + Process(algorithm string, vectorSet []byte) (any, error) } func loadCachedSessionTokens(server *acvp.Server, cachePath string) error { @@ -198,7 +198,7 @@ func looksLikeVectorSetHeader(element json.RawMessage) bool { // processFile reads a file containing vector sets, at least in the format // preferred by our lab, and writes the results to stdout. -func processFile(filename string, supportedAlgos []map[string]interface{}, middle Middle) error { +func processFile(filename string, supportedAlgos []map[string]any, middle Middle) error { jsonBytes, err := os.ReadFile(filename) if err != nil { return err @@ -267,7 +267,7 @@ func processFile(filename string, supportedAlgos []map[string]interface{}, middl return fmt.Errorf("while processing vector set #%d: %s", i+1, err) } - group := map[string]interface{}{ + group := map[string]any{ "vsId": commonFields.ID, "testGroups": replyGroups, "algorithm": algo, @@ -562,13 +562,13 @@ func main() { log.Fatalf("failed to get config from middle: %s", err) } - var supportedAlgos []map[string]interface{} + var supportedAlgos []map[string]any if err := json.Unmarshal(configBytes, &supportedAlgos); err != nil { log.Fatalf("failed to parse configuration from Middle: %s", err) } if *dumpRegcap { - nonTestAlgos := make([]map[string]interface{}, 0, len(supportedAlgos)) + nonTestAlgos := make([]map[string]any, 0, len(supportedAlgos)) for _, algo := range supportedAlgos { if value, ok := algo["acvptoolTestOnly"]; ok { testOnly, ok := value.(bool) @@ -582,9 +582,9 @@ func main() { nonTestAlgos = append(nonTestAlgos, algo) } - regcap := []map[string]interface{}{ - map[string]interface{}{"acvVersion": "1.0"}, - map[string]interface{}{"algorithms": nonTestAlgos}, + regcap := []map[string]any{ + {"acvVersion": "1.0"}, + {"algorithms": nonTestAlgos}, } regcapBytes, err := json.MarshalIndent(regcap, "", " ") if err != nil { @@ -637,7 +637,7 @@ func main() { } } - var algorithms []map[string]interface{} + var algorithms []map[string]any for _, supportedAlgo := range supportedAlgos { algoInterface, ok := supportedAlgo["algorithm"] if !ok { diff --git a/util/fipstools/acvp/acvptool/acvp/acvp.go b/util/fipstools/acvp/acvptool/acvp/acvp.go index b5a01f0c35..9d20ed88e7 100644 --- a/util/fipstools/acvp/acvptool/acvp/acvp.go +++ b/util/fipstools/acvp/acvptool/acvp/acvp.go @@ -195,7 +195,7 @@ func parseReplyToBytes(in io.Reader) ([]byte, error) { // parseReply parses the contents of an ACVP reply (after removing the header // element) into out. See the documentation of the encoding/json package for // details of the parsing. -func parseReply(out interface{}, in io.Reader) error { +func parseReply(out any, in io.Reader) error { if out == nil { // No reply expected. return nil @@ -379,7 +379,7 @@ func (server *Server) newRequestWithToken(method, endpoint string, body io.Reade return req, nil } -func (server *Server) Get(out interface{}, endPoint string) error { +func (server *Server) Get(out any, endPoint string) error { req, err := server.newRequestWithToken("GET", endPoint, nil) if err != nil { return err @@ -417,7 +417,7 @@ func (server *Server) GetBytes(endPoint string) ([]byte, error) { return parseReplyToBytes(resp.Body) } -func (server *Server) write(method string, reply interface{}, endPoint string, contents []byte) error { +func (server *Server) write(method string, reply any, endPoint string, contents []byte) error { var buf bytes.Buffer buf.WriteString(requestPrefix) buf.Write(contents) @@ -442,7 +442,7 @@ func (server *Server) write(method string, reply interface{}, endPoint string, c return parseReply(reply, resp.Body) } -func (server *Server) postMessage(reply interface{}, endPoint string, request interface{}) error { +func (server *Server) postMessage(reply any, endPoint string, request any) error { contents, err := json.Marshal(request) if err != nil { return err @@ -450,11 +450,11 @@ func (server *Server) postMessage(reply interface{}, endPoint string, request in return server.write("POST", reply, endPoint, contents) } -func (server *Server) Post(out interface{}, endPoint string, contents []byte) error { +func (server *Server) Post(out any, endPoint string, contents []byte) error { return server.write("POST", out, endPoint, contents) } -func (server *Server) Put(out interface{}, endPoint string, contents []byte) error { +func (server *Server) Put(out any, endPoint string, contents []byte) error { return server.write("PUT", out, endPoint, contents) } @@ -481,7 +481,7 @@ var ( // GetPaged returns an array of records of some type using one or more requests to the server. See // https://pages.nist.gov/ACVP/draft-fussell-acvp-spec.html#paging_response -func (server *Server) GetPaged(out interface{}, endPoint string, condition Query) error { +func (server *Server) GetPaged(out any, endPoint string, condition Query) error { output := reflect.ValueOf(out) if output.Kind() != reflect.Ptr { panic(fmt.Sprintf("GetPaged output parameter of non-pointer type %T", out)) @@ -618,22 +618,22 @@ type OperationalEnvironment struct { Dependencies []Dependency `json:"dependencies,omitempty"` } -type Dependency map[string]interface{} +type Dependency map[string]any -type Algorithm map[string]interface{} +type Algorithm map[string]any type TestSession struct { - URL string `json:"url,omitempty"` - ACVPVersion string `json:"acvpVersion,omitempty"` - Created string `json:"createdOn,omitempty"` - Expires string `json:"expiresOn,omitempty"` - VectorSetURLs []string `json:"vectorSetUrls,omitempty"` - AccessToken string `json:"accessToken,omitempty"` - Algorithms []map[string]interface{} `json:"algorithms,omitempty"` - EncryptAtRest bool `json:"encryptAtRest,omitempty"` - IsSample bool `json:"isSample,omitempty"` - Publishable bool `json:"publishable,omitempty"` - Passed bool `json:"passed,omitempty"` + URL string `json:"url,omitempty"` + ACVPVersion string `json:"acvpVersion,omitempty"` + Created string `json:"createdOn,omitempty"` + Expires string `json:"expiresOn,omitempty"` + VectorSetURLs []string `json:"vectorSetUrls,omitempty"` + AccessToken string `json:"accessToken,omitempty"` + Algorithms []map[string]any `json:"algorithms,omitempty"` + EncryptAtRest bool `json:"encryptAtRest,omitempty"` + IsSample bool `json:"isSample,omitempty"` + Publishable bool `json:"publishable,omitempty"` + Passed bool `json:"passed,omitempty"` } type Vectors struct { diff --git a/util/fipstools/acvp/acvptool/interactive.go b/util/fipstools/acvp/acvptool/interactive.go index 384206cedc..1c040aea6b 100644 --- a/util/fipstools/acvp/acvptool/interactive.go +++ b/util/fipstools/acvp/acvptool/interactive.go @@ -142,7 +142,7 @@ func (set ServerObjectSet) Action(action string, args []string) error { return nil } - var result map[string]interface{} + var result map[string]any if err := set.env.server.Post(&result, "acvp/v1/"+set.name, newContents); err != nil { return err } @@ -308,7 +308,7 @@ type Algorithms struct { func (algos Algorithms) String() (string, error) { var result struct { - Algorithms []map[string]interface{} `json:"algorithms"` + Algorithms []map[string]any `json:"algorithms"` } if err := algos.env.server.Get(&result, "acvp/v1/algorithms"); err != nil { return "", err @@ -360,7 +360,7 @@ func (s stringLiteral) Action(action string, args []string) error { return fmt.Errorf("found %d arguments but %q takes none", len(args), action) } - var results map[string]interface{} + var results map[string]any if err := s.env.server.Get(&results, s.contents); err != nil { return err } @@ -379,7 +379,7 @@ type results struct { } func (r results) String() (string, error) { - var results map[string]interface{} + var results map[string]any if err := r.env.server.Get(&results, "acvp/v1/"+r.prefix+"/results"); err != nil { return "", err } diff --git a/util/fipstools/acvp/acvptool/subprocess/aead.go b/util/fipstools/acvp/acvptool/subprocess/aead.go index e6585d1b6a..f773546600 100644 --- a/util/fipstools/acvp/acvptool/subprocess/aead.go +++ b/util/fipstools/acvp/acvptool/subprocess/aead.go @@ -61,7 +61,7 @@ type aeadTestResponse struct { Passed *bool `json:"testPassed,omitempty"` } -func (a *aead) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (a *aead) Process(vectorSet []byte, m Transactable) (any, error) { var parsed aeadVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/block.go b/util/fipstools/acvp/acvptool/subprocess/block.go index 1b1e93b998..0387e09085 100644 --- a/util/fipstools/acvp/acvptool/subprocess/block.go +++ b/util/fipstools/acvp/acvptool/subprocess/block.go @@ -288,7 +288,7 @@ type blockCipherMCTResult struct { Key3Hex string `json:"key3,omitempty"` } -func (b *blockCipher) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (b *blockCipher) Process(vectorSet []byte, m Transactable) (any, error) { var parsed blockCipherVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/drbg.go b/util/fipstools/acvp/acvptool/subprocess/drbg.go index d2f7572f07..6db8a64a31 100644 --- a/util/fipstools/acvp/acvptool/subprocess/drbg.go +++ b/util/fipstools/acvp/acvptool/subprocess/drbg.go @@ -73,7 +73,7 @@ type drbg struct { modes map[string]bool // the supported underlying primitives for the DRBG } -func (d *drbg) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (d *drbg) Process(vectorSet []byte, m Transactable) (any, error) { var parsed drbgTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/ecdsa.go b/util/fipstools/acvp/acvptool/subprocess/ecdsa.go index 4f688d3837..619323c7df 100644 --- a/util/fipstools/acvp/acvptool/subprocess/ecdsa.go +++ b/util/fipstools/acvp/acvptool/subprocess/ecdsa.go @@ -72,7 +72,7 @@ type ecdsa struct { primitives map[string]primitive } -func (e *ecdsa) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (e *ecdsa) Process(vectorSet []byte, m Transactable) (any, error) { var parsed ecdsaTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/hash.go b/util/fipstools/acvp/acvptool/subprocess/hash.go index b58c6f66e7..33cea043ad 100644 --- a/util/fipstools/acvp/acvptool/subprocess/hash.go +++ b/util/fipstools/acvp/acvptool/subprocess/hash.go @@ -62,7 +62,7 @@ type hashPrimitive struct { size int } -func (h *hashPrimitive) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (h *hashPrimitive) Process(vectorSet []byte, m Transactable) (any, error) { var parsed hashTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/hkdf.go b/util/fipstools/acvp/acvptool/subprocess/hkdf.go index b124d790e7..555646a6ae 100644 --- a/util/fipstools/acvp/acvptool/subprocess/hkdf.go +++ b/util/fipstools/acvp/acvptool/subprocess/hkdf.go @@ -116,7 +116,7 @@ type hkdfTestResponse struct { type hkdf struct{} -func (k *hkdf) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (k *hkdf) Process(vectorSet []byte, m Transactable) (any, error) { var parsed hkdfTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/hmac.go b/util/fipstools/acvp/acvptool/subprocess/hmac.go index 2fd90eac90..185988670f 100644 --- a/util/fipstools/acvp/acvptool/subprocess/hmac.go +++ b/util/fipstools/acvp/acvptool/subprocess/hmac.go @@ -76,7 +76,7 @@ func (h *hmacPrimitive) hmac(msg []byte, key []byte, outBits int, m Transactable return result[0][:outBytes] } -func (h *hmacPrimitive) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (h *hmacPrimitive) Process(vectorSet []byte, m Transactable) (any, error) { var parsed hmacTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/kas.go b/util/fipstools/acvp/acvptool/subprocess/kas.go index cb1eb9151c..9625334830 100644 --- a/util/fipstools/acvp/acvptool/subprocess/kas.go +++ b/util/fipstools/acvp/acvptool/subprocess/kas.go @@ -68,7 +68,7 @@ type kasTestResponse struct { type kas struct{} -func (k *kas) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (k *kas) Process(vectorSet []byte, m Transactable) (any, error) { var parsed kasVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/kasdh.go b/util/fipstools/acvp/acvptool/subprocess/kasdh.go index a21d4ee418..a9de2e3845 100644 --- a/util/fipstools/acvp/acvptool/subprocess/kasdh.go +++ b/util/fipstools/acvp/acvptool/subprocess/kasdh.go @@ -59,7 +59,7 @@ type kasDHTestResponse struct { type kasDH struct{} -func (k *kasDH) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (k *kasDH) Process(vectorSet []byte, m Transactable) (any, error) { var parsed kasDHVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/kdf.go b/util/fipstools/acvp/acvptool/subprocess/kdf.go index a80a53fd5d..e61d26b59c 100644 --- a/util/fipstools/acvp/acvptool/subprocess/kdf.go +++ b/util/fipstools/acvp/acvptool/subprocess/kdf.go @@ -60,7 +60,7 @@ type kdfTestResponse struct { type kdfPrimitive struct{} -func (k *kdfPrimitive) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (k *kdfPrimitive) Process(vectorSet []byte, m Transactable) (any, error) { var parsed kdfTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/keyedMac.go b/util/fipstools/acvp/acvptool/subprocess/keyedMac.go index 94be186025..a722ac9a13 100644 --- a/util/fipstools/acvp/acvptool/subprocess/keyedMac.go +++ b/util/fipstools/acvp/acvptool/subprocess/keyedMac.go @@ -57,7 +57,7 @@ type keyedMACPrimitive struct { algo string } -func (k *keyedMACPrimitive) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (k *keyedMACPrimitive) Process(vectorSet []byte, m Transactable) (any, error) { var vs keyedMACTestVectorSet if err := json.Unmarshal(vectorSet, &vs); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/rsa.go b/util/fipstools/acvp/acvptool/subprocess/rsa.go index 2f5197e960..d29dd23d90 100644 --- a/util/fipstools/acvp/acvptool/subprocess/rsa.go +++ b/util/fipstools/acvp/acvptool/subprocess/rsa.go @@ -117,7 +117,7 @@ type rsaSigVerTestResponse struct { Passed bool `json:"testPassed"` } -func processKeyGen(vectorSet []byte, m Transactable) (interface{}, error) { +func processKeyGen(vectorSet []byte, m Transactable) (any, error) { var parsed rsaKeyGenTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err @@ -158,7 +158,7 @@ func processKeyGen(vectorSet []byte, m Transactable) (interface{}, error) { return ret, nil } -func processSigGen(vectorSet []byte, m Transactable) (interface{}, error) { +func processSigGen(vectorSet []byte, m Transactable) (any, error) { var parsed rsaSigGenTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err @@ -209,7 +209,7 @@ func processSigGen(vectorSet []byte, m Transactable) (interface{}, error) { return ret, nil } -func processSigVer(vectorSet []byte, m Transactable) (interface{}, error) { +func processSigVer(vectorSet []byte, m Transactable) (any, error) { var parsed rsaSigVerTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err @@ -268,7 +268,7 @@ func processSigVer(vectorSet []byte, m Transactable) (interface{}, error) { type rsa struct{} -func (*rsa) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (*rsa) Process(vectorSet []byte, m Transactable) (any, error) { var parsed rsaTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/subprocess.go b/util/fipstools/acvp/acvptool/subprocess/subprocess.go index 84152cf9af..ee1cb87d41 100644 --- a/util/fipstools/acvp/acvptool/subprocess/subprocess.go +++ b/util/fipstools/acvp/acvptool/subprocess/subprocess.go @@ -211,7 +211,7 @@ func (m *Subprocess) Config() ([]byte, error) { } // Process runs a set of test vectors and returns the result. -func (m *Subprocess) Process(algorithm string, vectorSet []byte) (interface{}, error) { +func (m *Subprocess) Process(algorithm string, vectorSet []byte) (any, error) { prim, ok := m.primitives[algorithm] if !ok { return nil, fmt.Errorf("unknown algorithm %q", algorithm) @@ -224,7 +224,7 @@ func (m *Subprocess) Process(algorithm string, vectorSet []byte) (interface{}, e } type primitive interface { - Process(vectorSet []byte, t Transactable) (interface{}, error) + Process(vectorSet []byte, t Transactable) (any, error) } func uint32le(n uint32) []byte { diff --git a/util/fipstools/acvp/acvptool/subprocess/tls13.go b/util/fipstools/acvp/acvptool/subprocess/tls13.go index b8b6e51a50..6e1494262f 100644 --- a/util/fipstools/acvp/acvptool/subprocess/tls13.go +++ b/util/fipstools/acvp/acvptool/subprocess/tls13.go @@ -69,7 +69,7 @@ type tls13TestResponse struct { type tls13 struct{} -func (k *tls13) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (k *tls13) Process(vectorSet []byte, m Transactable) (any, error) { var parsed tls13TestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/tlskdf.go b/util/fipstools/acvp/acvptool/subprocess/tlskdf.go index ad27b542f3..5b28e3f298 100644 --- a/util/fipstools/acvp/acvptool/subprocess/tlskdf.go +++ b/util/fipstools/acvp/acvptool/subprocess/tlskdf.go @@ -55,7 +55,7 @@ type tlsKDFTestResponse struct { type tlsKDF struct{} -func (k *tlsKDF) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (k *tlsKDF) Process(vectorSet []byte, m Transactable) (any, error) { var parsed tlsKDFVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/subprocess/xts.go b/util/fipstools/acvp/acvptool/subprocess/xts.go index e3546a33b2..50eb6fdb24 100644 --- a/util/fipstools/acvp/acvptool/subprocess/xts.go +++ b/util/fipstools/acvp/acvptool/subprocess/xts.go @@ -59,7 +59,7 @@ type xtsTestResponse struct { // encrypt/decrypt with AES-XTS. type xts struct{} -func (h *xts) Process(vectorSet []byte, m Transactable) (interface{}, error) { +func (h *xts) Process(vectorSet []byte, m Transactable) (any, error) { var parsed xtsTestVectorSet if err := json.Unmarshal(vectorSet, &parsed); err != nil { return nil, err diff --git a/util/fipstools/acvp/acvptool/test/trim_vectors.go b/util/fipstools/acvp/acvptool/test/trim_vectors.go index 703f75fd20..d3402109bc 100644 --- a/util/fipstools/acvp/acvptool/test/trim_vectors.go +++ b/util/fipstools/acvp/acvptool/test/trim_vectors.go @@ -25,7 +25,7 @@ import ( ) func main() { - var vectorSets []interface{} + var vectorSets []any decoder := json.NewDecoder(os.Stdin) if err := decoder.Decode(&vectorSets); err != nil { panic(err) @@ -33,18 +33,18 @@ func main() { // The first element is the metadata which is left unmodified. for i := 1; i < len(vectorSets); i++ { - vectorSet := vectorSets[i].(map[string]interface{}) - testGroups := vectorSet["testGroups"].([]interface{}) + vectorSet := vectorSets[i].(map[string]any) + testGroups := vectorSet["testGroups"].([]any) for _, testGroupInterface := range testGroups { - testGroup := testGroupInterface.(map[string]interface{}) - tests := testGroup["tests"].([]interface{}) + testGroup := testGroupInterface.(map[string]any) + tests := testGroup["tests"].([]any) keepIndex := 10 if keepIndex >= len(tests) { keepIndex = len(tests) - 1 } - testGroup["tests"] = []interface{}{tests[keepIndex]} + testGroup["tests"] = []any{tests[keepIndex]} } } diff --git a/util/read_symbols.go b/util/read_symbols.go index ab2184c0cc..1d8ec85955 100644 --- a/util/read_symbols.go +++ b/util/read_symbols.go @@ -61,7 +61,7 @@ func defaultObjFileFormat(goos string) string { } } -func printAndExit(format string, args ...interface{}) { +func printAndExit(format string, args ...any) { s := fmt.Sprintf(format, args...) fmt.Fprintln(os.Stderr, s) os.Exit(1) From 051f891b2691be03da92d516c9f739823ef0541e Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Tue, 2 May 2023 15:03:45 -0400 Subject: [PATCH 54/56] Update references to draft-irtf-cfrg-gcmsiv It is now RFC 8452. The final RFC also has a few more test vectors, so import those too. Change-Id: Ib7667802973df7733ba981f16ef6a129cb4f62e7 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59485 Commit-Queue: David Benjamin Auto-Submit: David Benjamin Reviewed-by: Adam Langley Commit-Queue: Adam Langley --- .../test/aes_128_gcm_siv_tests.txt | 60 ++++++++++++++++++- .../test/aes_256_gcm_siv_tests.txt | 58 +++++++++++++++++- crypto/fipsmodule/modes/internal.h | 2 +- crypto/fipsmodule/modes/polyval.c | 2 +- include/openssl/aead.h | 6 +- 5 files changed, 119 insertions(+), 9 deletions(-) diff --git a/crypto/cipher_extra/test/aes_128_gcm_siv_tests.txt b/crypto/cipher_extra/test/aes_128_gcm_siv_tests.txt index 8587eea1fc..38655fdfb1 100644 --- a/crypto/cipher_extra/test/aes_128_gcm_siv_tests.txt +++ b/crypto/cipher_extra/test/aes_128_gcm_siv_tests.txt @@ -1,5 +1,5 @@ # This is the example from -# https://tools.ietf.org/html/draft-irtf-cfrg-gcmsiv-04#section-8 +# https://www.rfc-editor.org/rfc/rfc8452.html#section-8 KEY: ee8e1ed9ff2540ae8f2ba9f50bc2f27c NONCE: 752abad3e0afb5f434dc4310 @@ -9,7 +9,7 @@ CT: 5d349ead175ef6b1def6fd TAG: 4fbcdeb7e4793f4a1d7e4faa70100af1 # Test vectors from -# https://tools.ietf.org/html/draft-irtf-cfrg-gcmsiv-04#appendix-C +# https://www.rfc-editor.org/rfc/rfc8452.html#appendix-C KEY: 01000000000000000000000000000000 NONCE: 030000000000000000000000 @@ -123,6 +123,62 @@ AD: 0100000000000000000000000000000002000000 CT: 44d0aaf6fb2f1f34add5e8064e83e12a2ada TAG: bff9b2ef00fb47920cc72a0c0f13b9fd +KEY: e66021d5eb8e4f4066d4adb9c33560e4 +NONCE: f46e44bb3da0015c94f70887 +IN: +AD: +CT: +TAG: a4194b79071b01a87d65f706e3949578 + +KEY: 36864200e0eaf5284d884a0e77d31646 +NONCE: bae8e37fc83441b16034566b +IN: 7a806c +AD: 46bb91c3c5 +CT: af60eb +TAG: 711bd85bc1e4d3e0a462e074eea428a8 + +KEY: aedb64a6c590bc84d1a5e269e4b47801 +NONCE: afc0577e34699b9e671fdd4f +IN: bdc66f146545 +AD: fc880c94a95198874296 +CT: bb93a3e34d3c +TAG: d6a9c45545cfc11f03ad743dba20f966 + +KEY: d5cc1fd161320b6920ce07787f86743b +NONCE: 275d1ab32f6d1f0434d8848c +IN: 1177441f195495860f +AD: 046787f3ea22c127aaf195d1894728 +CT: 4f37281f7ad12949d0 +TAG: 1d02fd0cd174c84fc5dae2f60f52fd2b + +KEY: b3fed1473c528b8426a582995929a149 +NONCE: 9e9ad8780c8d63d0ab4149c0 +IN: 9f572c614b4745914474e7c7 +AD: c9882e5386fd9f92ec489c8fde2be2cf97e74e93 +CT: f54673c5ddf710c745641c8b +TAG: c1dc2f871fb7561da1286e655e24b7b0 + +KEY: 2d4ed87da44102952ef94b02b805249b +NONCE: ac80e6f61455bfac8308a2d4 +IN: 0d8c8451178082355c9e940fea2f58 +AD: 2950a70d5a1db2316fd568378da107b52b0da55210cc1c1b0a +CT: c9ff545e07b88a015f05b274540aa1 +TAG: 83b3449b9f39552de99dc214a1190b0b + +KEY: bde3b2f204d1e9f8b06bc47f9745b3d1 +NONCE: ae06556fb6aa7890bebc18fe +IN: 6b3db4da3d57aa94842b9803a96e07fb6de7 +AD: 1860f762ebfbd08284e421702de0de18baa9c9596291b08466f37de21c7f +CT: 6298b296e24e8cc35dce0bed484b7f30d580 +TAG: 3e377094f04709f64d7b985310a4db84 + +KEY: f901cfe8a69615a93fdf7a98cad48179 +NONCE: 6245709fb18853f68d833640 +IN: e42a3c02c25b64869e146d7b233987bddfc240871d +AD: 7576f7028ec6eb5ea7e298342a94d4b202b370ef9768ec6561c4fe6b7e7296fa859c21 +CT: 391cc328d484a4f46406181bcd62efd9b3ee197d05 +TAG: 2d15506c84a9edd65e13e9d24a2a6e70 + # Random vectors generated by the reference code. KEY: e66021d5eb8e4f4066d4adb9c33560e4 diff --git a/crypto/cipher_extra/test/aes_256_gcm_siv_tests.txt b/crypto/cipher_extra/test/aes_256_gcm_siv_tests.txt index 057b7587a0..f20188cca5 100644 --- a/crypto/cipher_extra/test/aes_256_gcm_siv_tests.txt +++ b/crypto/cipher_extra/test/aes_256_gcm_siv_tests.txt @@ -1,5 +1,5 @@ # Test vectors from -# https://tools.ietf.org/html/draft-irtf-cfrg-gcmsiv-04#appendix-C +# https://www.rfc-editor.org/rfc/rfc8452.html#appendix-C KEY: 0100000000000000000000000000000000000000000000000000000000000000 NONCE: 030000000000000000000000 @@ -113,6 +113,62 @@ AD: 0100000000000000000000000000000002000000 CT: 462401724b5ce6588d5a54aae5375513a075 TAG: cfcdf5042112aa29685c912fc2056543 +KEY: e66021d5eb8e4f4066d4adb9c33560e4f46e44bb3da0015c94f7088736864200 +NONCE: e0eaf5284d884a0e77d31646 +IN: +AD: +CT: +TAG: 169fbb2fbf389a995f6390af22228a62 + +KEY: bae8e37fc83441b16034566b7a806c46bb91c3c5aedb64a6c590bc84d1a5e269 +NONCE: e4b47801afc0577e34699b9e +IN: 671fdd +AD: 4fbdc66f14 +CT: 0eaccb +TAG: 93da9bb81333aee0c785b240d319719d + +KEY: 6545fc880c94a95198874296d5cc1fd161320b6920ce07787f86743b275d1ab3 +NONCE: 2f6d1f0434d8848c1177441f +IN: 195495860f04 +AD: 6787f3ea22c127aaf195 +CT: a254dad4f3f9 +TAG: 6b62b84dc40c84636a5ec12020ec8c2c + +KEY: d1894728b3fed1473c528b8426a582995929a1499e9ad8780c8d63d0ab4149c0 +NONCE: 9f572c614b4745914474e7c7 +IN: c9882e5386fd9f92ec +AD: 489c8fde2be2cf97e74e932d4ed87d +CT: 0df9e308678244c44b +TAG: c0fd3dc6628dfe55ebb0b9fb2295c8c2 + +KEY: a44102952ef94b02b805249bac80e6f61455bfac8308a2d40d8c845117808235 +NONCE: 5c9e940fea2f582950a70d5a +IN: 1db2316fd568378da107b52b +AD: 0da55210cc1c1b0abde3b2f204d1e9f8b06bc47f +CT: 8dbeb9f7255bf5769dd56692 +TAG: 404099c2587f64979f21826706d497d5 + +KEY: 9745b3d1ae06556fb6aa7890bebc18fe6b3db4da3d57aa94842b9803a96e07fb +NONCE: 6de71860f762ebfbd08284e4 +IN: 21702de0de18baa9c9596291b08466 +AD: f37de21c7ff901cfe8a69615a93fdf7a98cad481796245709f +CT: 793576dfa5c0f88729a7ed3c2f1bff +TAG: b3080d28f6ebb5d3648ce97bd5ba67fd + +KEY: b18853f68d833640e42a3c02c25b64869e146d7b233987bddfc240871d7576f7 +NONCE: 028ec6eb5ea7e298342a94d4 +IN: b202b370ef9768ec6561c4fe6b7e7296fa85 +AD: 9c2159058b1f0fe91433a5bdc20e214eab7fecef4454a10ef0657df21ac7 +CT: 857e16a64915a787637687db4a9519635cdd +TAG: 454fc2a154fea91f8363a39fec7d0a49 + +KEY: 3c535de192eaed3822a2fbbe2ca9dfc88255e14a661b8aa82cc54236093bbc23 +NONCE: 688089e55540db1872504e1c +IN: ced532ce4159b035277d4dfbb7db62968b13cd4eec +AD: 734320ccc9d9bbbb19cb81b2af4ecbc3e72834321f7aa0f70b7282b4f33df23f167541 +CT: 626660c26ea6612fb17ad91e8e767639edd6c9faee +TAG: 9d6c7029675b89eaf4ba1ded1a286594 + # Random vectors generated by the reference code. KEY: e66021d5eb8e4f4066d4adb9c33560e4f46e44bb3da0015c94f7088736864200 diff --git a/crypto/fipsmodule/modes/internal.h b/crypto/fipsmodule/modes/internal.h index d77efcaac4..5a1421032c 100644 --- a/crypto/fipsmodule/modes/internal.h +++ b/crypto/fipsmodule/modes/internal.h @@ -380,7 +380,7 @@ size_t CRYPTO_cts128_encrypt_block(const uint8_t *in, uint8_t *out, size_t len, // // POLYVAL is a polynomial authenticator that operates over a field very // similar to the one that GHASH uses. See -// https://tools.ietf.org/html/draft-irtf-cfrg-gcmsiv-02#section-3. +// https://www.rfc-editor.org/rfc/rfc8452.html#section-3. typedef union { uint64_t u[2]; diff --git a/crypto/fipsmodule/modes/polyval.c b/crypto/fipsmodule/modes/polyval.c index 857dc0e368..833c75dc0c 100644 --- a/crypto/fipsmodule/modes/polyval.c +++ b/crypto/fipsmodule/modes/polyval.c @@ -48,7 +48,7 @@ static void reverse_and_mulX_ghash(polyval_block *b) { // ByteReverse(GHASH(mulX_GHASH(ByteReverse(H)), ByteReverse(X_1), ..., // ByteReverse(X_n))). // -// See https://tools.ietf.org/html/draft-irtf-cfrg-gcmsiv-02#appendix-A. +// See https://www.rfc-editor.org/rfc/rfc8452.html#appendix-A. void CRYPTO_POLYVAL_init(struct polyval_ctx *ctx, const uint8_t key[16]) { polyval_block H; diff --git a/include/openssl/aead.h b/include/openssl/aead.h index 26338800a3..2219c211e9 100644 --- a/include/openssl/aead.h +++ b/include/openssl/aead.h @@ -138,12 +138,10 @@ OPENSSL_EXPORT const EVP_AEAD *EVP_aead_aes_128_ctr_hmac_sha256(void); // authentication. See |EVP_aead_aes_128_ctr_hmac_sha256| for details. OPENSSL_EXPORT const EVP_AEAD *EVP_aead_aes_256_ctr_hmac_sha256(void); -// EVP_aead_aes_128_gcm_siv is AES-128 in GCM-SIV mode. See -// https://tools.ietf.org/html/draft-irtf-cfrg-gcmsiv-02 +// EVP_aead_aes_128_gcm_siv is AES-128 in GCM-SIV mode. See RFC 8452. OPENSSL_EXPORT const EVP_AEAD *EVP_aead_aes_128_gcm_siv(void); -// EVP_aead_aes_256_gcm_siv is AES-256 in GCM-SIV mode. See -// https://tools.ietf.org/html/draft-irtf-cfrg-gcmsiv-02 +// EVP_aead_aes_256_gcm_siv is AES-256 in GCM-SIV mode. See RFC 8452. OPENSSL_EXPORT const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void); // EVP_aead_aes_128_gcm_randnonce is AES-128 in Galois Counter Mode with From 4c8bcf0da2951cacd8ed8eaa7fd2df4b22fca23b Mon Sep 17 00:00:00 2001 From: David Benjamin Date: Fri, 28 Apr 2023 17:59:18 -0400 Subject: [PATCH 55/56] Implement the AuthEncap/AuthDecap HPKE modes Relevant spec bits: https://www.rfc-editor.org/rfc/rfc9180.html#section-4.1 https://www.rfc-editor.org/rfc/rfc9180.html#section-5.1.3 Change-Id: Iddb151afc92f7a91beb9ca52caceec6cb5383206 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/59387 Reviewed-by: Adam Langley Auto-Submit: David Benjamin Commit-Queue: David Benjamin --- crypto/hpke/hpke.c | 168 +- crypto/hpke/hpke_test.cc | 205 +- crypto/hpke/hpke_test_vectors.txt | 4213 +++++++++++++++++++++---- crypto/hpke/translate_test_vectors.py | 9 +- include/openssl/hpke.h | 28 + 5 files changed, 4032 insertions(+), 591 deletions(-) diff --git a/crypto/hpke/hpke.c b/crypto/hpke/hpke.c index 3dfdb29b07..144b1278c5 100644 --- a/crypto/hpke/hpke.c +++ b/crypto/hpke/hpke.c @@ -53,6 +53,17 @@ struct evp_hpke_kem_st { int (*decap)(const EVP_HPKE_KEY *key, uint8_t *out_shared_secret, size_t *out_shared_secret_len, const uint8_t *enc, size_t enc_len); + int (*auth_encap_with_seed)(const EVP_HPKE_KEY *key, + uint8_t *out_shared_secret, + size_t *out_shared_secret_len, uint8_t *out_enc, + size_t *out_enc_len, size_t max_enc, + const uint8_t *peer_public_key, + size_t peer_public_key_len, const uint8_t *seed, + size_t seed_len); + int (*auth_decap)(const EVP_HPKE_KEY *key, uint8_t *out_shared_secret, + size_t *out_shared_secret_len, const uint8_t *enc, + size_t enc_len, const uint8_t *peer_public_key, + size_t peer_public_key_len); }; struct evp_hpke_kdf_st { @@ -211,6 +222,76 @@ static int x25519_decap(const EVP_HPKE_KEY *key, uint8_t *out_shared_secret, return 1; } +static int x25519_auth_encap_with_seed( + const EVP_HPKE_KEY *key, uint8_t *out_shared_secret, + size_t *out_shared_secret_len, uint8_t *out_enc, size_t *out_enc_len, + size_t max_enc, const uint8_t *peer_public_key, size_t peer_public_key_len, + const uint8_t *seed, size_t seed_len) { + if (max_enc < X25519_PUBLIC_VALUE_LEN) { + OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_BUFFER_SIZE); + return 0; + } + if (seed_len != X25519_PRIVATE_KEY_LEN) { + OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR); + return 0; + } + X25519_public_from_private(out_enc, seed); + + uint8_t dh[2 * X25519_SHARED_KEY_LEN]; + if (peer_public_key_len != X25519_PUBLIC_VALUE_LEN || + !X25519(dh, seed, peer_public_key) || + !X25519(dh + X25519_SHARED_KEY_LEN, key->private_key, peer_public_key)) { + OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_PEER_KEY); + return 0; + } + + uint8_t kem_context[3 * X25519_PUBLIC_VALUE_LEN]; + OPENSSL_memcpy(kem_context, out_enc, X25519_PUBLIC_VALUE_LEN); + OPENSSL_memcpy(kem_context + X25519_PUBLIC_VALUE_LEN, peer_public_key, + X25519_PUBLIC_VALUE_LEN); + OPENSSL_memcpy(kem_context + 2 * X25519_PUBLIC_VALUE_LEN, key->public_key, + X25519_PUBLIC_VALUE_LEN); + if (!dhkem_extract_and_expand(key->kem->id, EVP_sha256(), out_shared_secret, + SHA256_DIGEST_LENGTH, dh, sizeof(dh), + kem_context, sizeof(kem_context))) { + return 0; + } + + *out_enc_len = X25519_PUBLIC_VALUE_LEN; + *out_shared_secret_len = SHA256_DIGEST_LENGTH; + return 1; +} + +static int x25519_auth_decap(const EVP_HPKE_KEY *key, + uint8_t *out_shared_secret, + size_t *out_shared_secret_len, const uint8_t *enc, + size_t enc_len, const uint8_t *peer_public_key, + size_t peer_public_key_len) { + uint8_t dh[2 * X25519_SHARED_KEY_LEN]; + if (enc_len != X25519_PUBLIC_VALUE_LEN || + peer_public_key_len != X25519_PUBLIC_VALUE_LEN || + !X25519(dh, key->private_key, enc) || + !X25519(dh + X25519_SHARED_KEY_LEN, key->private_key, peer_public_key)) { + OPENSSL_PUT_ERROR(EVP, EVP_R_INVALID_PEER_KEY); + return 0; + } + + uint8_t kem_context[3 * X25519_PUBLIC_VALUE_LEN]; + OPENSSL_memcpy(kem_context, enc, X25519_PUBLIC_VALUE_LEN); + OPENSSL_memcpy(kem_context + X25519_PUBLIC_VALUE_LEN, key->public_key, + X25519_PUBLIC_VALUE_LEN); + OPENSSL_memcpy(kem_context + 2 * X25519_PUBLIC_VALUE_LEN, peer_public_key, + X25519_PUBLIC_VALUE_LEN); + if (!dhkem_extract_and_expand(key->kem->id, EVP_sha256(), out_shared_secret, + SHA256_DIGEST_LENGTH, dh, sizeof(dh), + kem_context, sizeof(kem_context))) { + return 0; + } + + *out_shared_secret_len = SHA256_DIGEST_LENGTH; + return 1; +} + const EVP_HPKE_KEM *EVP_hpke_x25519_hkdf_sha256(void) { static const EVP_HPKE_KEM kKEM = { /*id=*/EVP_HPKE_DHKEM_X25519_HKDF_SHA256, @@ -222,6 +303,8 @@ const EVP_HPKE_KEM *EVP_hpke_x25519_hkdf_sha256(void) { x25519_generate_key, x25519_encap_with_seed, x25519_decap, + x25519_auth_encap_with_seed, + x25519_auth_decap, }; return &kKEM; } @@ -373,8 +456,10 @@ static int hpke_build_suite_id(const EVP_HPKE_CTX *ctx, } #define HPKE_MODE_BASE 0 +#define HPKE_MODE_AUTH 2 -static int hpke_key_schedule(EVP_HPKE_CTX *ctx, const uint8_t *shared_secret, +static int hpke_key_schedule(EVP_HPKE_CTX *ctx, uint8_t mode, + const uint8_t *shared_secret, size_t shared_secret_len, const uint8_t *info, size_t info_len) { uint8_t suite_id[HPKE_SUITE_ID_LEN]; @@ -407,7 +492,7 @@ static int hpke_key_schedule(EVP_HPKE_CTX *ctx, const uint8_t *shared_secret, size_t context_len; CBB context_cbb; CBB_init_fixed(&context_cbb, context, sizeof(context)); - if (!CBB_add_u8(&context_cbb, HPKE_MODE_BASE) || + if (!CBB_add_u8(&context_cbb, mode) || !CBB_add_bytes(&context_cbb, psk_id_hash, psk_id_hash_len) || !CBB_add_bytes(&context_cbb, info_hash, info_hash_len) || !CBB_finish(&context_cbb, NULL, &context_len)) { @@ -507,8 +592,8 @@ int EVP_HPKE_CTX_setup_sender_with_seed_for_testing( if (!kem->encap_with_seed(kem, shared_secret, &shared_secret_len, out_enc, out_enc_len, max_enc, peer_public_key, peer_public_key_len, seed, seed_len) || - !hpke_key_schedule(ctx, shared_secret, shared_secret_len, info, - info_len)) { + !hpke_key_schedule(ctx, HPKE_MODE_BASE, shared_secret, shared_secret_len, + info, info_len)) { EVP_HPKE_CTX_cleanup(ctx); return 0; } @@ -528,8 +613,79 @@ int EVP_HPKE_CTX_setup_recipient(EVP_HPKE_CTX *ctx, const EVP_HPKE_KEY *key, uint8_t shared_secret[MAX_SHARED_SECRET_LEN]; size_t shared_secret_len; if (!key->kem->decap(key, shared_secret, &shared_secret_len, enc, enc_len) || - !hpke_key_schedule(ctx, shared_secret, shared_secret_len, info, - info_len)) { + !hpke_key_schedule(ctx, HPKE_MODE_BASE, shared_secret, shared_secret_len, + info, info_len)) { + EVP_HPKE_CTX_cleanup(ctx); + return 0; + } + return 1; +} + + +int EVP_HPKE_CTX_setup_auth_sender( + EVP_HPKE_CTX *ctx, uint8_t *out_enc, size_t *out_enc_len, size_t max_enc, + const EVP_HPKE_KEY *key, const EVP_HPKE_KDF *kdf, const EVP_HPKE_AEAD *aead, + const uint8_t *peer_public_key, size_t peer_public_key_len, + const uint8_t *info, size_t info_len) { + uint8_t seed[MAX_SEED_LEN]; + RAND_bytes(seed, key->kem->seed_len); + return EVP_HPKE_CTX_setup_auth_sender_with_seed_for_testing( + ctx, out_enc, out_enc_len, max_enc, key, kdf, aead, peer_public_key, + peer_public_key_len, info, info_len, seed, key->kem->seed_len); +} + +int EVP_HPKE_CTX_setup_auth_sender_with_seed_for_testing( + EVP_HPKE_CTX *ctx, uint8_t *out_enc, size_t *out_enc_len, size_t max_enc, + const EVP_HPKE_KEY *key, const EVP_HPKE_KDF *kdf, const EVP_HPKE_AEAD *aead, + const uint8_t *peer_public_key, size_t peer_public_key_len, + const uint8_t *info, size_t info_len, const uint8_t *seed, + size_t seed_len) { + if (key->kem->auth_encap_with_seed == NULL) { + // Not all HPKE KEMs support AuthEncap. + OPENSSL_PUT_ERROR(EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); + return 0; + } + + EVP_HPKE_CTX_zero(ctx); + ctx->is_sender = 1; + ctx->kem = key->kem; + ctx->kdf = kdf; + ctx->aead = aead; + uint8_t shared_secret[MAX_SHARED_SECRET_LEN]; + size_t shared_secret_len; + if (!key->kem->auth_encap_with_seed( + key, shared_secret, &shared_secret_len, out_enc, out_enc_len, max_enc, + peer_public_key, peer_public_key_len, seed, seed_len) || + !hpke_key_schedule(ctx, HPKE_MODE_AUTH, shared_secret, shared_secret_len, + info, info_len)) { + EVP_HPKE_CTX_cleanup(ctx); + return 0; + } + return 1; +} + +int EVP_HPKE_CTX_setup_auth_recipient( + EVP_HPKE_CTX *ctx, const EVP_HPKE_KEY *key, const EVP_HPKE_KDF *kdf, + const EVP_HPKE_AEAD *aead, const uint8_t *enc, size_t enc_len, + const uint8_t *info, size_t info_len, const uint8_t *peer_public_key, + size_t peer_public_key_len) { + if (key->kem->auth_decap == NULL) { + // Not all HPKE KEMs support AuthDecap. + OPENSSL_PUT_ERROR(EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE); + return 0; + } + + EVP_HPKE_CTX_zero(ctx); + ctx->is_sender = 0; + ctx->kem = key->kem; + ctx->kdf = kdf; + ctx->aead = aead; + uint8_t shared_secret[MAX_SHARED_SECRET_LEN]; + size_t shared_secret_len; + if (!key->kem->auth_decap(key, shared_secret, &shared_secret_len, enc, + enc_len, peer_public_key, peer_public_key_len) || + !hpke_key_schedule(ctx, HPKE_MODE_AUTH, shared_secret, shared_secret_len, + info, info_len)) { EVP_HPKE_CTX_cleanup(ctx); return 0; } diff --git a/crypto/hpke/hpke_test.cc b/crypto/hpke/hpke_test.cc index 87c72a8156..03b23b52f8 100644 --- a/crypto/hpke/hpke_test.cc +++ b/crypto/hpke/hpke_test.cc @@ -66,11 +66,26 @@ class HPKETestVector { // Test the sender. ScopedEVP_HPKE_CTX sender_ctx; uint8_t enc[EVP_HPKE_MAX_ENC_LENGTH]; - size_t enc_len; - ASSERT_TRUE(EVP_HPKE_CTX_setup_sender_with_seed_for_testing( - sender_ctx.get(), enc, &enc_len, sizeof(enc), kem, kdf, aead, - public_key_r_.data(), public_key_r_.size(), info_.data(), info_.size(), - secret_key_e_.data(), secret_key_e_.size())); + size_t enc_len = 0; + switch (mode_) { + case Mode::kBase: + ASSERT_TRUE(EVP_HPKE_CTX_setup_sender_with_seed_for_testing( + sender_ctx.get(), enc, &enc_len, sizeof(enc), kem, kdf, aead, + public_key_r_.data(), public_key_r_.size(), info_.data(), + info_.size(), secret_key_e_.data(), secret_key_e_.size())); + break; + case Mode::kAuth: { + ScopedEVP_HPKE_KEY sender_key; + ASSERT_TRUE(EVP_HPKE_KEY_init( + sender_key.get(), kem, secret_key_s_.data(), secret_key_s_.size())); + ASSERT_TRUE(EVP_HPKE_CTX_setup_auth_sender_with_seed_for_testing( + sender_ctx.get(), enc, &enc_len, sizeof(enc), sender_key.get(), kdf, + aead, public_key_r_.data(), public_key_r_.size(), info_.data(), + info_.size(), secret_key_e_.data(), secret_key_e_.size())); + break; + } + } + EXPECT_EQ(Bytes(enc, enc_len), Bytes(public_key_e_)); VerifySender(sender_ctx.get()); @@ -101,9 +116,18 @@ class HPKETestVector { // Set up the recipient. ScopedEVP_HPKE_CTX recipient_ctx; - ASSERT_TRUE(EVP_HPKE_CTX_setup_recipient(recipient_ctx.get(), key, kdf, - aead, enc, enc_len, info_.data(), - info_.size())); + switch (mode_) { + case Mode::kBase: + ASSERT_TRUE(EVP_HPKE_CTX_setup_recipient(recipient_ctx.get(), key, + kdf, aead, enc, enc_len, + info_.data(), info_.size())); + break; + case Mode::kAuth: + ASSERT_TRUE(EVP_HPKE_CTX_setup_auth_recipient( + recipient_ctx.get(), key, kdf, aead, enc, enc_len, info_.data(), + info_.size(), public_key_s_.data(), public_key_s_.size())); + break; + } VerifyRecipient(recipient_ctx.get()); } @@ -168,6 +192,11 @@ class HPKETestVector { } } + enum class Mode { + kBase = 0, + kAuth = 2, + }; + struct Encryption { std::vector aad; std::vector ciphertext; @@ -180,6 +209,7 @@ class HPKETestVector { std::vector exported_value; }; + Mode mode_; uint16_t kdf_id_; uint16_t aead_id_; std::vector context_; @@ -188,6 +218,8 @@ class HPKETestVector { std::vector secret_key_e_; std::vector public_key_r_; std::vector secret_key_r_; + std::vector public_key_s_; + std::vector secret_key_s_; std::vector encryptions_; std::vector exports_; }; @@ -227,7 +259,6 @@ bool FileTestReadInt(FileTest *file_test, T *out, const std::string &key) { bool HPKETestVector::ReadFromFileTest(FileTest *t) { uint8_t mode = 0; if (!FileTestReadInt(t, &mode, "mode") || - mode != 0 /* mode_base */ || !FileTestReadInt(t, &kdf_id_, "kdf_id") || !FileTestReadInt(t, &aead_id_, "aead_id") || !t->GetBytes(&info_, "info") || @@ -238,6 +269,21 @@ bool HPKETestVector::ReadFromFileTest(FileTest *t) { return false; } + switch (mode) { + case static_cast(Mode::kBase): + mode_ = Mode::kBase; + break; + case static_cast(Mode::kAuth): + mode_ = Mode::kAuth; + if (!t->GetBytes(&secret_key_s_, "skSm") || + !t->GetBytes(&public_key_s_, "pkSm")) { + return false; + } + break; + default: + return false; + } + for (int i = 1; t->HasAttribute(BuildAttrName("aad", i)); i++) { Encryption encryption; if (!t->GetBytes(&encryption.aad, BuildAttrName("aad", i)) || @@ -282,14 +328,25 @@ TEST(HPKETest, RoundTrip) { Span info_values[] = {{nullptr, 0}, info_a, info_b}; Span ad_values[] = {{nullptr, 0}, ad_a, ad_b}; + const EVP_HPKE_KEM *kem = EVP_hpke_x25519_hkdf_sha256(); + // Generate the recipient's keypair. ScopedEVP_HPKE_KEY key; - ASSERT_TRUE(EVP_HPKE_KEY_generate(key.get(), EVP_hpke_x25519_hkdf_sha256())); + ASSERT_TRUE(EVP_HPKE_KEY_generate(key.get(), kem)); uint8_t public_key_r[X25519_PUBLIC_VALUE_LEN]; size_t public_key_r_len; ASSERT_TRUE(EVP_HPKE_KEY_public_key(key.get(), public_key_r, &public_key_r_len, sizeof(public_key_r))); + // Generate the sender's keypair, for auth modes. + ScopedEVP_HPKE_KEY sender_key; + ASSERT_TRUE( + EVP_HPKE_KEY_generate(sender_key.get(), kem)); + uint8_t public_key_s[X25519_PUBLIC_VALUE_LEN]; + size_t public_key_s_len; + ASSERT_TRUE(EVP_HPKE_KEY_public_key(sender_key.get(), public_key_s, + &public_key_s_len, sizeof(public_key_r))); + for (const auto kdf : kAllKDFs) { SCOPED_TRACE(EVP_HPKE_KDF_id(kdf())); for (const auto aead : kAllAEADs) { @@ -298,45 +355,70 @@ TEST(HPKETest, RoundTrip) { SCOPED_TRACE(Bytes(info)); for (const Span &ad : ad_values) { SCOPED_TRACE(Bytes(ad)); - // Set up the sender. - ScopedEVP_HPKE_CTX sender_ctx; - uint8_t enc[X25519_PUBLIC_VALUE_LEN]; - size_t enc_len; - ASSERT_TRUE(EVP_HPKE_CTX_setup_sender( - sender_ctx.get(), enc, &enc_len, sizeof(enc), - EVP_hpke_x25519_hkdf_sha256(), kdf(), aead(), public_key_r, - public_key_r_len, info.data(), info.size())); - - // Set up the recipient. - ScopedEVP_HPKE_CTX recipient_ctx; - ASSERT_TRUE(EVP_HPKE_CTX_setup_recipient( - recipient_ctx.get(), key.get(), kdf(), aead(), enc, enc_len, - info.data(), info.size())); - - const char kCleartextPayload[] = "foobar"; - - // Have sender encrypt message for the recipient. - std::vector ciphertext( - sizeof(kCleartextPayload) + - EVP_HPKE_CTX_max_overhead(sender_ctx.get())); - size_t ciphertext_len; - ASSERT_TRUE(EVP_HPKE_CTX_seal( - sender_ctx.get(), ciphertext.data(), &ciphertext_len, - ciphertext.size(), - reinterpret_cast(kCleartextPayload), - sizeof(kCleartextPayload), ad.data(), ad.size())); - - // Have recipient decrypt the message. - std::vector cleartext(ciphertext.size()); - size_t cleartext_len; - ASSERT_TRUE(EVP_HPKE_CTX_open(recipient_ctx.get(), cleartext.data(), - &cleartext_len, cleartext.size(), - ciphertext.data(), ciphertext_len, - ad.data(), ad.size())); - - // Verify that decrypted message matches the original. - ASSERT_EQ(Bytes(cleartext.data(), cleartext_len), - Bytes(kCleartextPayload, sizeof(kCleartextPayload))); + + auto check_messages = [&](EVP_HPKE_CTX *sender_ctx, + EVP_HPKE_CTX *recipient_ctx) { + const char kCleartextPayload[] = "foobar"; + + // Have sender encrypt message for the recipient. + std::vector ciphertext( + sizeof(kCleartextPayload) + + EVP_HPKE_CTX_max_overhead(sender_ctx)); + size_t ciphertext_len; + ASSERT_TRUE(EVP_HPKE_CTX_seal( + sender_ctx, ciphertext.data(), &ciphertext_len, + ciphertext.size(), + reinterpret_cast(kCleartextPayload), + sizeof(kCleartextPayload), ad.data(), ad.size())); + + // Have recipient decrypt the message. + std::vector cleartext(ciphertext.size()); + size_t cleartext_len; + ASSERT_TRUE(EVP_HPKE_CTX_open(recipient_ctx, cleartext.data(), + &cleartext_len, cleartext.size(), + ciphertext.data(), ciphertext_len, + ad.data(), ad.size())); + + // Verify that decrypted message matches the original. + ASSERT_EQ(Bytes(cleartext.data(), cleartext_len), + Bytes(kCleartextPayload, sizeof(kCleartextPayload))); + }; + + // Test the base mode. + { + ScopedEVP_HPKE_CTX sender_ctx; + uint8_t enc[X25519_PUBLIC_VALUE_LEN]; + size_t enc_len; + ASSERT_TRUE(EVP_HPKE_CTX_setup_sender( + sender_ctx.get(), enc, &enc_len, sizeof(enc), kem, kdf(), + aead(), public_key_r, public_key_r_len, info.data(), + info.size())); + + ScopedEVP_HPKE_CTX recipient_ctx; + ASSERT_TRUE(EVP_HPKE_CTX_setup_recipient( + recipient_ctx.get(), key.get(), kdf(), aead(), enc, enc_len, + info.data(), info.size())); + + check_messages(sender_ctx.get(), recipient_ctx.get()); + } + + // Test the auth mode. + { + ScopedEVP_HPKE_CTX sender_ctx; + uint8_t enc[X25519_PUBLIC_VALUE_LEN]; + size_t enc_len; + ASSERT_TRUE(EVP_HPKE_CTX_setup_auth_sender( + sender_ctx.get(), enc, &enc_len, sizeof(enc), sender_key.get(), + kdf(), aead(), public_key_r, public_key_r_len, info.data(), + info.size())); + + ScopedEVP_HPKE_CTX recipient_ctx; + ASSERT_TRUE(EVP_HPKE_CTX_setup_auth_recipient( + recipient_ctx.get(), key.get(), kdf(), aead(), enc, enc_len, + info.data(), info.size(), public_key_s, public_key_s_len)); + + check_messages(sender_ctx.get(), recipient_ctx.get()); + } } } } @@ -352,6 +434,11 @@ TEST(HPKETest, X25519EncapSmallOrderPoint) { 0xfa, 0xf1, 0x9f, 0xc4, 0x6a, 0xda, 0x09, 0x8d, 0xeb, 0x9c, 0x32, 0xb1, 0xfd, 0x86, 0x62, 0x05, 0x16, 0x5f, 0x49, 0xb8, }; + static const uint8_t kValidPoint[32] = { + 0xe6, 0xdb, 0x68, 0x67, 0x58, 0x30, 0x30, 0xdb, 0x35, 0x94, 0xc1, + 0xa4, 0x24, 0xb1, 0x5f, 0x7c, 0x72, 0x66, 0x24, 0xec, 0x26, 0xb3, + 0x35, 0x3b, 0x10, 0xa9, 0x03, 0xa6, 0xd0, 0xab, 0x1c, 0x4c, + }; ScopedEVP_HPKE_KEY key; ASSERT_TRUE(EVP_HPKE_KEY_generate(key.get(), EVP_hpke_x25519_hkdf_sha256())); @@ -364,16 +451,32 @@ TEST(HPKETest, X25519EncapSmallOrderPoint) { ScopedEVP_HPKE_CTX sender_ctx; uint8_t enc[X25519_PUBLIC_VALUE_LEN]; size_t enc_len; - ASSERT_FALSE(EVP_HPKE_CTX_setup_sender( + EXPECT_FALSE(EVP_HPKE_CTX_setup_sender( sender_ctx.get(), enc, &enc_len, sizeof(enc), EVP_hpke_x25519_hkdf_sha256(), kdf(), aead(), kSmallOrderPoint, sizeof(kSmallOrderPoint), nullptr, 0)); + // Likewise with auth. + EXPECT_FALSE(EVP_HPKE_CTX_setup_auth_sender( + sender_ctx.get(), enc, &enc_len, sizeof(enc), key.get(), kdf(), + aead(), kSmallOrderPoint, sizeof(kSmallOrderPoint), nullptr, 0)); + // Set up the recipient, passing in kSmallOrderPoint as |enc|. ScopedEVP_HPKE_CTX recipient_ctx; - ASSERT_FALSE(EVP_HPKE_CTX_setup_recipient( + EXPECT_FALSE(EVP_HPKE_CTX_setup_recipient( recipient_ctx.get(), key.get(), kdf(), aead(), kSmallOrderPoint, sizeof(kSmallOrderPoint), nullptr, 0)); + + // Likewise with auth. With auth, a small-order point could appear as + // either |enc| or the peer public key. + EXPECT_FALSE(EVP_HPKE_CTX_setup_auth_recipient( + recipient_ctx.get(), key.get(), kdf(), aead(), kSmallOrderPoint, + sizeof(kSmallOrderPoint), nullptr, 0, kValidPoint, + sizeof(kValidPoint))); + EXPECT_FALSE(EVP_HPKE_CTX_setup_auth_recipient( + recipient_ctx.get(), key.get(), kdf(), aead(), kValidPoint, + sizeof(kValidPoint), nullptr, 0, kSmallOrderPoint, + sizeof(kSmallOrderPoint))); } } } diff --git a/crypto/hpke/hpke_test_vectors.txt b/crypto/hpke/hpke_test_vectors.txt index bb708b373f..f99ee236de 100644 --- a/crypto/hpke/hpke_test_vectors.txt +++ b/crypto/hpke/hpke_test_vectors.txt @@ -1047,1009 +1047,2060 @@ exporter_context = 54657374436f6e74657874 L = 32 exported_value = e9e43065102c3836401bed8c3c3c75ae46be1639869391d62c61f1ec7af54931 -mode = 0 +mode = 2 kdf_id = 1 -aead_id = 2 +aead_id = 1 info = 4f6465206f6e2061204772656369616e2055726e -skRm = 497b4502664cfea5d5af0b39934dac72242a74f8480451e1aee7d6a53320333d -skEm = 179d4b53b6365c45b600c4163b61d95cbc2f4d9e36f1695558dce265ab8bab11 -pkRm = 430f4b9859665145a6b1ba274024487bd66f03a2dd577d7753c68d7d7d00c00c -pkEm = 6c93e09869df3402d7bf231bf540fadd35cd56be14f97178f0954db94b7fc256 +skRm = fdea67cf831f1ca98d8e27b1f6abeb5b7745e9d35348b80fa407ff6958f9137e +skEm = ff4442ef24fbc3c1ff86375b0be1e77e88a0de1e79b30896d73411c5ff4c3518 +pkRm = 1632d5c2f71c2b38d0a8fcc359355200caa8b1ffdf28618080466c909cb69b2e +pkEm = 23fb952571a14a25e3d678140cd0e5eb47a0961bb18afcf85896e5453c312e76 +pkSm = 8b0c70873dc5aecb7f9ee4e62406a397b350e57012be45cf53b7105ae731790b +skSm = dc4a146313cce60a278a5323d321f051c5707e9c45ba21a3479fecdf76fc69dd # encryptions[0] aad = 436f756e742d30 -ct = e5d84cd531cfb583096e7cfa9641bd3079cf3a91cda813c52deb5f512be9931980a41de125a925cdad859d5b7a +ct = 5fd92cc9d46dbf8943e72a07e42f363ed5f721212cd90bcfd072bfd9f44e06b80fd17824947496e21b680c141b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[1] aad = 436f756e742d31 -ct = 2c43aff25343fdbff864506f0818b9d87df84ea01b1a2144d23b4d40c26bf655fdf197fe40297a8aebeed5cc2d +ct = d3736bb256c19bfa93d79e8f80b7971262cb7c887e35c26370cfed62254369a1b52e3d505b79dd699f002bc8ed pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[2] aad = 436f756e742d32 -ct = e0a8f2cf92ff61215edbb8c55dc31fe9e2eb42a5685867bb6854211542099f9e940c4b41c192bc390835b1a5f7 +ct = 122175cfd5678e04894e4ff8789e85dd381df48dcaf970d52057df2c9acc3b121313a2bfeaa986050f82d93645 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[3] aad = 436f756e742d33 -ct = a8ea1deafbe4935d0d484a026301a339d4668c43c37f5e289bf758c7aeb3e2812d0321c12b71978855883420c0 +ct = 81448cec70230638b6c6b8fab63b430f3ee3d506a96229bd825fe8139f3231c6e1db349beb18bdcd8bcf796ff9 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[4] aad = 436f756e742d34 -ct = 448a8892f261cbb6bf5b7b64a4fae8a2c86492494b069c10525895d871c27c2f12cd17e0588fedaba9f7b0cd4c +ct = dae12318660cf963c7bcbef0f39d64de3bf178cf9e585e756654043cc5059873bc8af190b72afc43d1e0135ada pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[5] aad = 436f756e742d35 -ct = 97c746402aa3728594f8c4f217d1e4059dae56c5fb401025ff601a61da903f2706355685954b2fdd518b81ef79 +ct = f998abcc1c84c6e421d6b7049fddf1839e7c5464645b7c5376edbfcd4d74352648645b08f6803a56ea624158e3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[6] aad = 436f756e742d36 -ct = 91fe133508fe3fa6905ce19e6c8aba53994c168664088a2cd4300238236dcc90b5d2510d4315dfa8dc34bca821 +ct = e0b80588421e345c607b6dcf7485dfa28ecba51c083a5e4c748deabf49cd8ce8ad64ab16a818d97c94f5cbcba4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[7] aad = 436f756e742d37 -ct = 641346e222a57bd4cf1f0e6a6039c77c1684e6d01c8983b568552d338f080f1bf22d022a5ae863e12191aebc7f +ct = ad7d5a8737c52c89521932e36470236e171c6e0e020983b4e8f7bd443a743f616220c23ad15b6eba04a0490f7a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[8] aad = 436f756e742d38 -ct = fc8446f5867c639c4c3f64079b2bee8987180b88e789a64297b91107886d739ec8f492e252bcdfb008cd6e061a +ct = 12990eadd503e2684efd367ef6eb7c10bd901a8db1d7cbd76f1eab25b1770fda29756f2432334b7cb59ddc5ad7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[9] aad = 436f756e742d39 -ct = c21ce89d9947297e1de30d9a59c0815ff1508a8930f63a91d29ed89bf2a20029830728045cd54d8a00b06f3520 +ct = 6df5a172c5ed16fc3d4c7e55e3bc931a359282ba7142f3fa7da6d7feea0ae0c8071a081876df3d38cfaea8089b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[10] aad = 436f756e742d3130 -ct = 8c26159d7fb4c50cf29b0fd2d005d9a04dd42402f8e4e1dc9e2dd7cd0cf807f5b5a230554127c85510f95d945f +ct = ac214db460440110a9874b512e41384d7960711016d470a9e8059e6f4d46338742a4e0c8190e51b0c8a7d3322b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[11] aad = 436f756e742d3131 -ct = 75af5386f4a2d4a27dd20a490d1feb261dae8206a3201c02ab48ede53d2a92523a6105ab80bda1dbc1fe8e8deb +ct = 8ecc6adb36ae93e951da72468b99141e38103e5d5e872577d1d5e4a7fb9d12729a678c4905471fd2b767b2cdac pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[12] aad = 436f756e742d3132 -ct = 1c8873e7af703e1e8f8085ee385e694173c9fe2d66cbdec2bdce1b3ace52c13d0ff321b41d8ce95bdce73c38ba +ct = d5ae8d2f471d28ae1ec85a0ea544ccf9d828bdf76946556d705d0900f4f52edabe8b1b86f760d5b27ede114bb4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[13] aad = 436f756e742d3133 -ct = 10ce2c23ffa22de0f547b33afa2f34552200ae764c65d2acf6a5366e4d2c6dbd6614d964574b97687963b93400 +ct = d2d736316eb91cb3a019402f1ea2f95601e16a5f7cf2aa0493b9a0a9822e8a0c5ff701e2dc4dd98c7a4361eae1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[14] aad = 436f756e742d3134 -ct = fb0e6d7705e829ab6509668862e65136cd0fd2cbe83a158c832ba630a2eceac6042019ec726aaee793961c663e +ct = c98347b851ad8570f2a6e25a7d8ffbaa0514fad0a67a567cafb7f2f16bd185a2d366fbaeb993aade524c288c11 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[15] aad = 436f756e742d3135 -ct = 4bd36bb99b6035a3ccd5f41998b6d49d5562c72225ddbdc82e38d5be180e6b0e69abe68d12be85239a664ac672 +ct = a6ec1b6537df7d82ddd411da2fd2d6c80a6e1a81a94c14a04f928cc43f6595dbfb9820e201034b69d4361fa294 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[16] aad = 436f756e742d3136 -ct = 1a1916713004d3a90c8651e9781a759e63eb70bf1d74db5d3871e01f4664ea5241035f9a09c50c7c64b877a2ce +ct = 64136b023c77e329b6c0585cbef0ef139b7da50fb37ef0d465687be24da10465e1a4dcb9f9d10ff8d4b8b2adf6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[17] aad = 436f756e742d3137 -ct = 510ffbb00d709b3ce27bea8b8202f2fad82632d6429992b4c0f71728bb3291f20f696c4d2abd942dc9a8960b39 +ct = 4781db96aaca00e95d6a33a87b5aa4d4febc7a11cf984365651e793b96bb2fca0a5c5addeb0a4eda8558eb4639 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[18] aad = 436f756e742d3138 -ct = 25695fc573d452c33f7bb8f61a30d1719c75637cef9bd9c11e4b48583d926fed3a31ecacf54bcdaf42d7927f98 +ct = efbcd0926dddc95b33bca922dbadf82df2d928f211cd1a95059bca159cbb2ad1ae4b44983c15079c3f3e5548a6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[19] aad = 436f756e742d3139 -ct = 913948ede40a023565bfd70f5f47c37ba2506e09b22d4784374659c90da556d3ecdef17e89b8f749e266f11b46 +ct = b00418a10ed979ddc5f733c8d6e1feac93398f99a03ba258ec3ce46b801028ca218de871dbf35a9f90230a2d28 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[20] aad = 436f756e742d3230 -ct = 3fd6c17dba8dbb2a4a0a5cd99aa0f1288f0f5bb02b720243d6b7c1cc92621c1efd0dae437ca54a67e2b3127f76 +ct = 9a69b169ef765433fe6ec1414ee5c7aa84974d2dd47c7ca95eca39cc3016730656fbc2632dd8b0fac86bdb36e8 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[21] aad = 436f756e742d3231 -ct = a42358de18cb5495cff2729069fe0eb7996dbaf2138ec00f570107eca2a7c6950b9670b4ec66795de04685c2a7 +ct = 781645d997518600d2d331939f4306c2f4ab72b4b8b6aac3d0bae922518821f5f3eef7356ede837d706c9e0ad8 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[22] aad = 436f756e742d3232 -ct = 18b1f565922a8e9d58959adcf3cb25a3a907d2adb69d71e19c09268f173157f569b1d4279c93f840d08b746b4a +ct = c7ab847bda8e799ce31cb751d8d8b40a44a69a797c61de5b4b26b5083ffd6ead2dc6c9c85e044ae953d59e9226 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[23] aad = 436f756e742d3233 -ct = 34355c72a3581d4eacb5269e76f920a77242cf7525c8d734afe8921c87deaa0780ecf5998af6e5f84ecd689048 +ct = e598a17f69b9f2516abea3602756f864cceb7e75c292e152c0fcafbe006321d6d7229d8eb7d7a5bc233daeb93e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[24] aad = 436f756e742d3234 -ct = ca6ded0b04e98db9bf3e62a3cd5604678e805c3ea8a8c5c390b29977662a344791b443d0aba785bd8b9fec65dd +ct = 6c93a379fe85e3cb345d3f3c78983003900283ac7cb685796b739b77eb15da62834c87169fca6da3f33f12782e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[25] aad = 436f756e742d3235 -ct = d9065c203b0782caeb631af2ad08d685fe121033ba52b94608557bcfc8007adf68e2c77a4b6a475ce1171b70d5 +ct = 62be42591a5e2cdcf43ee38d4a01e36a46dd349ae5e25f0cf0f9d1d303a49788b2d782abce7a9015983eaac1de pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[26] aad = 436f756e742d3236 -ct = 27d600688c31400608c332d1af2bfadc89d22739e3cc06d6f0f1b356a61e214f5b0ddbf7caf47b71d2be8cefb1 +ct = 88ffba9f0cb873174ce8467e4f0101e1b4408ac8dc6cdd9f924551ba9eee57c96901ca19c592cc0e7aee3652d4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[27] aad = 436f756e742d3237 -ct = 9ed3e280b8605d721509cedbce556ee4429aeb48c0fcd400e30d21074ed902ce77589ac1f5d282ff1bddfa8cfc +ct = ab98458f4280faa8a00d5bf65846ea270ce47b05e887fdb48b2ecc17e62d1399ba45eb23a370dbde5067b7ac27 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[28] aad = 436f756e742d3238 -ct = 3eb0855fa879f7dc8335b5d426a440f19acdc0fc721532304de51323464707643b40d54812599670936eed2208 +ct = 4181af4e773e309ce7a4ac04ad08828378b4644e8a33b8be02776659d1c13c25d1cf3d95de95d15e4f251098eb pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[29] aad = 436f756e742d3239 -ct = fffd265116539bf8b564f012fe3ec3a9dfccd9a5b9dc4ad9e2964e794c764ed63a759dcdef61ad043f7588a11b +ct = 566c4c023069ac3a2e9ad94e29819d0846fcb023614f04fcc107b825a6004dd48082173da952b9466b898e9514 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[30] aad = 436f756e742d3330 -ct = 9e7fd0052e15aa19e46050a2661febaf6c5f326caa52dc439eef425662661388fb9a9be58ed989760a7494d3b1 +ct = 14e76dca587889d13c87b6f9198e40bf708b59eeb7524a3330acde681414f0b563bb73681077ab2c3e49a34b2c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[31] aad = 436f756e742d3331 -ct = 3693b73981435ddc8b081186f7a7f06fb4a20eb7c39c147f6db5cddb47e2f29f60f909c4504b2b789ddfb8e40b +ct = 02be122d5b3fa62dd45baacc13c060c726da0ed95e6cb64b75d91abd08c237a0e0f48b7442737c403a470ef86e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[32] aad = 436f756e742d3332 -ct = 78fb4fbcb3de5bf9230fd0e41aab0b2899f331a4d806423d2a7cf91110b06ed76146a9b815fc0f5b1941d24de6 +ct = 608ceaf60a18be198b8b3ef4772a550f5803412108a8fbb97dfe7ddbb34900774f4c22056c48f9abec995be7ef pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[33] aad = 436f756e742d3333 -ct = 8030cb70867979059a6e5848feb3c25f7504458da998c831594371141c868715578f3a62ed71dff8aff1afa2c9 +ct = c229036df4aff67458d0779e2d9a4a50ff775ff64dc73acde6abb01098c2b25b7e7075707d3ffaaa696fa2db2a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[34] aad = 436f756e742d3334 -ct = 89488d044633eebb4a41f649bf3a5f1d17affd9d5d9baf5132c71f8ad057aea36fd31ff72fc78d6880444696f1 +ct = b5d56ebb67daa05ca9b6c8d65742a8ef164b2ad5a108d61a77af584897ee41d349903af4e1c9a2a0f16d16ac52 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[35] aad = 436f756e742d3335 -ct = 4ef51de05e1e02e6a15e30d313a8905ec12e35adb3fdc6ce79ae56dc348e1a636531fabf5e2c78962d492bc0f6 +ct = a9406787523a3fc63adf9a04a1df6fffe90a8f8251a623bc144aa3ee0efa0d5aee37d95f0cb769d49293e154c1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[36] aad = 436f756e742d3336 -ct = 2242a8228e57ca15267e01abfe430f1d6e4aabada7e38f17f20df015657d81aa898d2291c631773628f8833e9d +ct = 9ed258258a8f8bf329162d322a3edb75ed1799e0543f39fe168bb1aae05ccc1a5532a3c4df7aae26fcd39513dd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[37] aad = 436f756e742d3337 -ct = 8d71a286ec6f330462aebcfe15a2e3b3382eee9fd2e57123565bb1aeb319112e9e53418a2bd48d16f68a59ca5c +ct = 958ff65e212d9dcfe399ee93a921bd0235fca5a8e4836bf854ecc5e2fdbb664fa7d9ebd5d3bd52018290b793c6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[38] aad = 436f756e742d3338 -ct = 87e2b695e365860db3f4653bc16bbe0389dcf225838cfb1c480442899d38a204c474565039e3e120848257c1a3 +ct = 329831514fd6313f44895b2acc15657966fd6b800e63f7a53fe5198d34e30df848de3068b1921661ddf05681c2 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[39] aad = 436f756e742d3339 -ct = 86adae7eee8d06e9a8855672e7cb80276deba65f0b5d17e5e8ef0cf80189e69c62187605ec2329330264127063 +ct = dc37ec0e2c08be44d9ec709138e811b116a2bdff4f89c8a0639783165ca3da21967e4d2c08927e5beb446662c6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[40] aad = 436f756e742d3430 -ct = ce603ee533d23f2f902aa82adf76c98a30d0c5865079840acc8ff62e7c774db66b3cb758137efd3134d790ec13 +ct = 7b8c1fd6061641cef0913dcb80dec12274352bd94eaf46b631b1968daf5b3db6aa21336c9878a194957b466058 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[41] aad = 436f756e742d3431 -ct = 904d3c71ad0a4f8d6a0f087fcd93059cc19da7c9983b59da32f83a614ffdd9cf65f0eb8bc2fe3ee64a4f5c4981 +ct = 09227ba8d90dafd0948dcb79cc661011b022ae576102c7ba67cfbc4b04fecd6cc7edd86718a23a11bf97100631 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[42] aad = 436f756e742d3432 -ct = 71dfd30756f262628af5e5293a624eb219d2ef6d323d37096a2a94db6308e752f9659cba28d9072b71946d7868 +ct = 86ca60e820b54fb1d39b4c23d3f390e9cdbbd4220e24267cea51bfd90021b2f16762a7bf44a66e79040c63933b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[43] aad = 436f756e742d3433 -ct = 4f0d84759f83d02f49152f5852121e863ff3732bff98915799be5c8d5cfebfa2048ed83c0380888028f7dc081b +ct = e9108564d752c2c56faecfdf36ac2c849c8d1e923ad6bf331a60bc5bbb45aff7ea7c334193bbd7f4143b61c185 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[44] aad = 436f756e742d3434 -ct = dbb775112c824b1ff0689cb13ee056d84615d7c0604de71a825bf6998c41623d66124e7b871c7fc2ad4887ecda +ct = 87ffaa9446a4a80fad33fdab7e397b9376f8ca33e20e48a500446b60204f2937bae2836798735a3dac0ff5a880 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[45] aad = 436f756e742d3435 -ct = db01d24f44d167d78a9bff68828aa4340f99ff89e045476c4e918438801a02bfae77ad4161c298d958702535e9 +ct = 0da994a818399e05a41f120b7b84c1470bb33828908876b9bee7754a52b6487b092da01ca67cb021eeed43c223 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[46] aad = 436f756e742d3436 -ct = 59ae01cfcc784d69f25c005e9dec4b7f74bc05f284166ed5a056918eae0d9e1a83fd028a52f9e6dc6ded369941 +ct = 0217ccaf0e54da8efbbad4948d54e90ca3c3b60ad39e54ac9f716ef0dd33cacdb897f6973ec66024862829b0e2 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[47] aad = 436f756e742d3437 -ct = 8a5e074f9f14ffcaead4aaf599a97a8dd791c44833bd6676a09b7b87e29f1237ee926550d80a44378f025f650f +ct = b700163bb5c7b11c8e8808199cd8a6cc82db500abaf3a2facfaf678431ec5bf7783d9395e450bb7d107463618e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[48] aad = 436f756e742d3438 -ct = c86b3b47535fd4c11610a1830a2847c6f7c7338d96656f8d04453edd1f5842af3397c6f762bbb39d4730f043fa +ct = 8fccbfb3882371b7a04af739edb48c87f1f1d34621563ce766815ff4a049da9045943860e5cf2cd1cc02bfb8b4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[49] aad = 436f756e742d3439 -ct = 053e3ec87d82425c627ed4c2d84ada5cc0b5253d6ae1cfbacff5c78f377f3c09ac89257d551772f6d2e053b344 +ct = 13813c57857656d5dea3730a4e6430b300a1dc2942a5b1400cb45776533a407143224af56785e9149bf072721a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[50] aad = 436f756e742d3530 -ct = 73a145c830aee75e0fea9e3c7bfa24c9a5b1c0602683a5502fc83dc4a087e0a9c9b142dccdbd3205fa22cad268 +ct = 975c0845a0955774ba4ae6386218491084b22a721d4bfb977ab50611fb5fe579fbd041beb05c04566feb1a7a69 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[51] aad = 436f756e742d3531 -ct = 98d8fb2a4bf5f772880010e4cdfdd992360189f45fe418f3736255423e60657a2a01c3e60b54d3efa932d090c5 +ct = a5b8ac851160bdea05e5d85f5c4ff730c967edb4665134633dd2ca26a802760a8ff0f64096814698ed5eb0e546 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[52] aad = 436f756e742d3532 -ct = b8abe4d887990e1e527a8b7c2ffd661dd4b65c618d7afe742281bddcb39c8be07c143b061bc607b4a8f41a3fd5 +ct = 1da6e12454409f9ae5560fdc8274069345307c9b719d54d42c8053b18fad3b369aeaa6a27126aa846776b06c15 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[53] aad = 436f756e742d3533 -ct = 1090be42c502b75570c25a9b74777a4f3c981992156a9dae81c1f3a637c388ad55a42782f3785eda7fc00ed9bb +ct = 50de3f90d54c98ca5e52d854d107b7f52c22576f1a9e77973baa6e9e9e4a69430e504094a1818294645f475cbe pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[54] aad = 436f756e742d3534 -ct = 2ed5cd3dd937bcc54bc8193cd81420350e5a94f233bf52428dade8033de59a4bd0d461c7680fee19d3eaa49790 +ct = e8460cf57d8bb3ab36a6b577f1c24d4a7d55c71e0b47422b950ff046ae25ed41a66d89d70bb4b40edae7666cd7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[55] aad = 436f756e742d3535 -ct = da16bc9c2b04ac234af1d2bbd11bb4bbfe6b32864e7381ac73604b2a870e7b8aaf10b128d8ca39b4e3f0ece26b +ct = df0a371a1a83bcbc24105317a97e134f4ca95c2aa875ac86b99b36347159c25d84d84882e48bbc7942fc25047f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[56] aad = 436f756e742d3536 -ct = f0d9acf36f857f86e02b06348e94d0fed7fb010d4e6365177ceba970c1a17e7f472240dbc585ee0cb137cd3b70 +ct = 5eeceae1e61e5ee09bab6d6c793226a642bf5dfc281ab2f8a6da7bbdaf44578b3fcbd3386685ed8e28b7af9aa7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[57] aad = 436f756e742d3537 -ct = 32199e20199904c07595fc6e9307022a0548f8f56ccf664497b840ca50176a05c72469c3231e4220544114054a +ct = fa6dcdca295a350c7614f14b491ac3b25ee40241ae6ee36a2b416e1a46a6b3806ada8b7a525921e6b98b085498 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[58] aad = 436f756e742d3538 -ct = 257884a96d90d927de623709a39cb34a5981007676ba96b2e1e4e3ff7dfc499acb265dbb4e1812428d5ae31514 +ct = 439423232f496bb252d246e44c7bfcb1f8a62c8fd3a97ca98107dad5632d17fd423e6b36265a67764f08db8fe6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[59] aad = 436f756e742d3539 -ct = 6e37fd96cc41de256d9363d9eb27868304ed5d979da469fcac98b4509719b10a8ed0c205abb05c7d2c9afb34bb +ct = fc9eb541b325893b4a4818619b00b5988356bf07af8fe4c34c6dd0eca427a829fef7a3dbcf0172e868b0353d16 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[60] aad = 436f756e742d3630 -ct = 7bfb5b966d1a92d893c0bc4ac5526a8a104ad929053d09481538b731c3e164ec46b4a6e6849ff1b6f732f3109f +ct = 23e5725b20a8b5db67fb9b64861718c1f148c1927533e2b499891f33c66b46700fb0c6e99f37b98aa278c1044a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[61] aad = 436f756e742d3631 -ct = 8a70b13706ba38fb0b279449984a4df5203c05d242bd7e6af70c9e96cb556abd9088f8e9b28121d050ed74908d +ct = db051cd509ded5ba54169f883df5ec36dcf155242c24cb999aace1c2d05805814af27b5ac85bf5201282c5437f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[62] aad = 436f756e742d3632 -ct = 44dd0d86d69344f086f4bbc3b75f04b1a5eade98e4d22ff130a28b4f0c60f7db23fe2c30c3e2f8269719b57dc1 +ct = 63436a676cb38ed9f79cef1a7a255e6ea5aeddcb23187a43628990dc4810049c3ceb87b0b603d9f0671ca17023 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[63] aad = 436f756e742d3633 -ct = 946181d28098f47928bef7199f777dd0d2653f08c326bfd10090b47bcd294735dca636428bad26d0c186ff56dc +ct = 3cc01a55b16ba7baeff8b99bad41156c284f12876e288ef0706f0bafccb6e1a02c9dba61e766a7992073f2267a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[64] aad = 436f756e742d3634 -ct = e080406e00c83bed2e94537263727d65ce99534cad2279dbf119eeb614cc5ba0b9103b7497fddd7b149579bad1 +ct = ece18db78b48e32e9880fd5bcdc69ba51b7d4d1f9fd3aab4542c87260d15f86bacafee4f59aa743a38c0b15355 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[65] aad = 436f756e742d3635 -ct = a86551ee5f2b9cced52e1fe1cca9a8f7e63065515787ea7f4f9f4ff51bbd7698a79bfb853913c96fd714694b8e +ct = a0523c4744573ac4900f9945c36bb8d85c36e890b302a53f310805f59295e66dc5276a9b4a3a2c320b957a1384 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[66] aad = 436f756e742d3636 -ct = f450c832f51334c08e08461d087ea1d3b475ea1964e3075e41b227a57b6f8cf2b9ea8838d54784d0c533d5b5c8 +ct = 4fdf4ade68a050e46002772274f44d948aa705798279fa4404e42b2e4edcac0b09f0099514e3a93bd7a0f8b68d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[67] aad = 436f756e742d3637 -ct = c25e6034c2c2283f5b8e6b7f659ee33eeaf3401ef43a81dc3d8ffbb9e7a32370311ceeba97c6a6287d3786321e +ct = 63acdebd758d7776c0de540d44de08fac33a9eeff15b6c06e9ee74d52416e7c791e407486c82c88f46b4d50b62 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[68] aad = 436f756e742d3638 -ct = 5c30e2053f7f1501eb430edccca9cbc90f01b03200ece329b232fe0a4a9baf418adf846d402c2443fbd72aa360 +ct = f86f589944e090e7bcad7eca46ff36e976a464145d3991d4ddf3381fd8683177d5ee87b1c8178c86dc183bae81 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[69] aad = 436f756e742d3639 -ct = 9df08200e50ce71aaa016d6f18768803a8bfd20ad405345f4cbe60cb28164eb897e5ad2675c90595d0df83b662 +ct = 05f5471471b5b660deb10c97bddd25dd194f7f43f256725f055110b25bbccf4033cc99da41dab17b650b6a88d0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[70] aad = 436f756e742d3730 -ct = 56fb1c4a86f4642fe820f60b440e59be913ab632de2027defee6161e627ebd78fd30a606f119070460cba0aacd +ct = 5fff11dd9778ac87d60b20639d261508326ddbb935a6f9fa71c58d20678bb71356ad42f0110f62a798b0941e02 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[71] aad = 436f756e742d3731 -ct = a8163438d8ea48dfdaa8ee0286efb83747796263c11e97cf910f8b56adef3f6bcc12c2aa885323d641985116ee +ct = 80b2e9bba9e59d89c86251450b7bd08a53aa618a0b555e74224642d43924f5b46d4e40efc5291178bd162cc38a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[72] aad = 436f756e742d3732 -ct = 10a66fd85dee2f3179efe704174f2fa4fdf0dc3839c6ba06a39f947dcd9422a32fb5b7df5d6a467bb0c5035d32 +ct = c31baa7d0246c32738420a7c848f998be00e155022636b90a4e2f5957fe7d41ca78005d5562e1a2ed06e3f80ea pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[73] aad = 436f756e742d3733 -ct = 50384f9efe0ae3adb9c834114862e989995ce080f353f0727c4ab2d41911755d154b4eb0a693b0e72124c465b4 +ct = a0bd8668746dd5718d0890b32df5a7edff64a31917f2174e124c64f2a9e454f9cbba573cd6a338f85c6570c437 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[74] aad = 436f756e742d3734 -ct = f74ad7b18fee3ca88f91c653102e6b877e1f8ceb73a3a5bd44323ba5194ac722e87e0656121001c39653bf2822 +ct = bf893670d1f7b8fc9980b0dcdfc7245bc8b27fb894f9607f0e2fb4cf09b50951ddab19165579b00421696ac21f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[75] aad = 436f756e742d3735 -ct = 3d0b638910c26c035444b494342b5059eaa485d51d49a7526bf5a76cf18ce92be1e88922f1ba27db8f29a3bc17 +ct = aedf69ddaf28dae07110560ebb7d1ff2f20949ca874009b7c99c6c316f1592e72e48c877a859dbc506cf99e76b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[76] aad = 436f756e742d3736 -ct = 4d17c2da2c4688c5ae15be76b2fedab1d677065ea79a452f3cd01c12926ef4991cbe8be7e7e5e69cf2666121d6 +ct = 41e85cbcc31f046537ca10d1e0a66e3b6056a1f46a27cc96645d885aa6eeff6bb0a4ea4edab73fb544dfe58581 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[77] aad = 436f756e742d3737 -ct = 7aa7ebe84cf4c35dccf15682fdca996164f1ec056455ace8b9544b9c1b1571b8bcfc104fc5e91f5d68d7738707 +ct = f9e5f909b0a75b5d92b586597d4de6e740b5a83fa2d78ed1f32bc11e147c85496a16fcc85b66fce6ba94e6c67c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[78] aad = 436f756e742d3738 -ct = c8300629a6cac3b1a7b408bb50e503191cbb79f102256d0bf3f25e33af30ae12e430af1bc9e44753a0e25a824e +ct = 9baf794b4d654aeea56be02d01bcb21d2b186809e138724cb6114d49a7a6fc3803cd4d864de78665d12c5a6425 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[79] aad = 436f756e742d3739 -ct = 37c428339a389e8ce35daa03a99f5c07fbeebdcfc3e695434f2eaff8f90cae8902fef683e2ad238f2ba037b5a5 +ct = 2f224c7f088822260ad71775444c01c71bc871a7f56803b95c13c9f159a523ae53c000d5c21f12fc76763d2074 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[80] aad = 436f756e742d3830 -ct = 39e65faf2c41d0bfeeceb28699042b62e976fbc3836e6a8a41ce5a5a85f9c428887792f725baf7ac68db824c9b +ct = b8047bf627a69f930658561d2d005a7e2f12e90292dc16a9c629645409a4de2e86679db9faf011901a69269e1f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[81] aad = 436f756e742d3831 -ct = 0a478a818d4fc9da07c90487cef008949818fcaeeb5c1cc83f45d487321fd491ad58aa1863c4a5bb75e9db1b66 +ct = 64e7d452410b8d53713677ad165fe962cc08952f10f9d278f16f73806b64b14f8780834a1338a19924c4fec4a3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[82] aad = 436f756e742d3832 -ct = 32cf849851e83b92db5eccef5ad9464af0133d588fb0ecdc4a43ef0c03b1dad9889d673900e95c7e0051035426 +ct = a47b2785274a366fcfb0444ab8efd960194d6ca56d43c982c6b0b50fde16a9ee95a22cf54c985e2429b2c21a61 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[83] aad = 436f756e742d3833 -ct = ba1e5814a83a84dada756914f38e7069718ce13e97442003ee37bcdfcb54032f8cc3e50bec78c2b8c2e6402d65 +ct = 200afde88045125efb6515a23c8caf595f05a35509095a967378bd84e5383a306f72f6d5cef6af15c4563b554f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[84] aad = 436f756e742d3834 -ct = 3b91fac4f67af1a93f5ee312fe5c39bfa915a2317c2268b594e363d368d9df09022468a5719a3cc91d07f3c36f +ct = 4b4843954a9e2ba61595c5d2b71b4feff5c84232e53d6593a702dca7cd0a5ccb5d0d3725d7f9795ba1e7689b49 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[85] aad = 436f756e742d3835 -ct = 5888dab7e84869c9ad8d5a80db2e89da750780da4e3fd59f317c4440ab2ade53aa855254f534e8abf7b030e1ba +ct = dfb69ecc70667ad3d2adf8d263d012cb44235778a61ccd579863c6bb8b2d2582cf1a391de20f155b2fbb84ef2d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[86] aad = 436f756e742d3836 -ct = 9f8d979e4c9965a2e135e0e85849e8e51cb9edf27c5a48713c0342f78c6eb42f89c246884f42b925d508ac1118 +ct = da056aeeac653289bbbab6a1aca568ae68103d1cb1295f7fd5491b2e285d26e0ce4502786495cdd6dea5119050 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[87] aad = 436f756e742d3837 -ct = 1a3fe6ad4387133e6dde596102384e034984b26ea9c2518690e43bfcbba241b8991b1fc22f5301f50a6c067b18 +ct = 51a2ddf0c656fb01e203dd54bd80f2626727c33a37aad2414e3fe5e07a9d9c53f7f035924c89ae068bf8005aec pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[88] aad = 436f756e742d3838 -ct = 35ec707cfbebcd8d29a94b2a53279f06d6dad1d67a85d26515b33805cbe9c8054de90590d90ecfa2e75b319426 +ct = 95a1a85f709d79b0a58e7116b6323ddad572c165ffaadac7ffa9598a262e30522603d4fe1761e42408c595d0f2 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[89] aad = 436f756e742d3839 -ct = 98b90ba87c954ef7a61833679d2d9634cf6c9e0e2bd346b9240cfee3cae141f3bb886ebc195019bf61ea174fd2 +ct = c4c2c129dbbfe2b327352ef4a137159de3a85802c4930b744134a62e35868f3722053fbaa9a5f1cb16d49592ac pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[90] aad = 436f756e742d3930 -ct = 29d4773ca7566d5e9e32701d6c46c70111d615f150663e76c62c8afbf3cde30395b424530e71fdcd91abad8235 +ct = e5992c2caf9e0596fcd502a4b554300fb454a26ba2a99e5fca0e8c0f2a1d640726e322e41986b600b94f82e8ea pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[91] aad = 436f756e742d3931 -ct = a3ddd151493934a6d056bfb33c3cdfb872204b2e40494b2c12c298aa2443563eba9baa7a984b4627a1aef12b35 +ct = 27887d96745fa8c476b816c1e8de4fc7389079baed2c0c291af27f9b802d49d768ab7ee7d8b8ad6a4b4efdf081 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[92] aad = 436f756e742d3932 -ct = 97fee29b1aecb67490fa440db94e8edb9d44da3db59466700235cd0613bd7f385621ef78bbd1a61207f61d58d7 +ct = 49f4ab17cc03b6e18d393b56a3860e9d88f7177fad47678c94e15da52f3aabbba208803c1d3ebe630385a612da pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[93] aad = 436f756e742d3933 -ct = bcf3f399b75f170a59b61b5a8e381f1254d4599bfaf906ec035aaa89b862616163b32c0078ee65f57e372921c9 +ct = 0aa5ff588989b5f855c507fbe0b002108bfa9aba5d3459041c6282216baa58b82a54e81ea4cd7ab8a6fc5d239c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[94] aad = 436f756e742d3934 -ct = b4fb4b40243ff48b3af21b81f86742faf71e9a2006c0dada26824262d3fddc428575c2b3fdebf84f777e6ea7b8 +ct = 98b19c082e948172ea6a0c2e7bd1b99adbf828936f6d2b1b356fc4bb7545839bc56d81f7754f32110a768a908d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[95] aad = 436f756e742d3935 -ct = 3e4774d43410c80bdd17e94276dc4c9e593dfe1be6e7e512fb0ec7e8321f0825ae52cec95ec88e0a73cee34632 +ct = af857d081486a28209db9124f78e6bebb651854092483d7b74e0c26b076e8d848918ecb6c7ebb0a3b86f31b54f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[96] aad = 436f756e742d3936 -ct = 149628f5c0a0c7a83a255124b93bae9acb5566caf56e2a44d425a045f5de8d8b99fdb859853195048e9a2c6838 +ct = 7fb0ebececaafa792613ffc21ddd744cce2c117a7fb4f7dd98630d5aa588557502835d75375fce13af191f2c1b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[97] aad = 436f756e742d3937 -ct = 23353f67794a1ab146b07737c42dcbaf16fe80f5fe275808900ba8b64f7c277710f99887617c315749db003750 +ct = f5c519e52b8ff3f45f42eb20df56c11da4c44f65b14518b7d8fd663517cc33121f2606d7d0ebd28965ca7c79f7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[98] aad = 436f756e742d3938 -ct = 7f682e36cd661cd0604d0d161b6747c9116fb2155698a880390b170c95a1a4ac56281296c3f92b643a43bd7bbb +ct = e215ae3bc8168ae5c1e24cd9ed4ddefee8a663813c98aaa94c97fc7299e27b749e30b63e8a63ba7d66a397c8f5 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[99] aad = 436f756e742d3939 -ct = 5060bd31673101670052d60db668ba50e577282f2d04ac7f55a968df8f1e656f3e54c042bc376dff57881449f2 +ct = d3fc389d3a47d3b4f57ec7bebe6df29561d5fd0d08fe087db6bcf11c3859cce5e31a43d123d3a765ae425db2e3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[100] aad = 436f756e742d313030 -ct = a1a9e8eba75c2d5492de5ac21b96067d86db723ca40446043d6b518ed99e546adc70e872b389c8b252f968ecca +ct = d559c490d3bf31b205c1c24df652bee186bebcc9bf2798f3e3839a171765d4fd6064cfcab00d0a4fa924bd77db pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[101] aad = 436f756e742d313031 -ct = 265c2fd6d576240fedc1e9d2e54ea85d4c6f948ccae75dbdf5131ab9e34e6b7c546fcd2799fd70bbbd80f4a403 +ct = d94b85acd8b65f6c30d0928c4ab64cfd20b68cd32b6e9c66085255d3adfddff964f21f6a6a0de506b3d0e60afa pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[102] aad = 436f756e742d313032 -ct = e5cd249047639b55351adec7054b4bad49ba504dfd012c24e6664b174aa7a96a8f43e3e74c24c72a2084a30f54 +ct = 844d58bd48a973956b27134c63c95abc6ed159671601f69b49e07d372a9df1c754c68ea906c4826d40979bf6cb pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[103] aad = 436f756e742d313033 -ct = 718f45fba90a6d7fe762a963a3afddd422bcfb69b4d67f68a07f0963542d11a9f93fa7becbe1467a6d4ba2bd59 +ct = 98032e309da113a76dcd4ed0a1a4c1f912701b39a744070bebe648395d67cb4d7e45862a8b1e0bccc068da3658 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[104] aad = 436f756e742d313034 -ct = 83317a03f6e6f5c8a70c2ab5a13e594f71de479e37041bb665f2f7a1222cf3f989dba32842bcbc2e9d104eeb6b +ct = 80586eb97612a4216cc17ae8a28e0f53ecc59c09cb51d48b59c546e067db7ca9080656297d797d1861b3f31aa6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[105] aad = 436f756e742d313035 -ct = abb06a322a83405b85f2921f0faa10d142e7957cf39c0f61efe8d4ef7aa408dee8af86032f3c16a2e103753a75 +ct = d881138799714f3c37801f45169a681cab1ca82c05f7ec3bbcf9dc46268129dd6d06696fcd0441bccd0fecd084 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[106] aad = 436f756e742d313036 -ct = 1846787cb992d807a28985c645ab2752cec1059250224f49da67cec65ff51d9ea1edaf496c1e35d74a39746296 +ct = e22d4de220344386a58c2c9227c390d64c629c896db4983c719117a3b296db4b8167d022416dae6e2577a1c831 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[107] aad = 436f756e742d313037 -ct = 5c272f93edda401fb918c03179478563bf812a7012faf8662002e4e8d0c45b4faf1f8f1345b3cf93efbf0c3590 +ct = 1dc52775bf6b3039aff1c911e795d0ff4ff8d33e11a22af4ded075c5d9c3d32082fb29e30b219776ace8e9108d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[108] aad = 436f756e742d313038 -ct = b93b55d7382c44f03f7d5c376fb325f009ffa705b785922525f83d81226259cbf27d5cd1d5657eb18ab49c8f57 +ct = 319f7752f2922e1998b657deef0d60fdf8be55774ef2e092d0b14cda85b53fba177892cda90eeb8484f209ff67 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[109] aad = 436f756e742d313039 -ct = 78f36217e54bba52f594bb8f0ea26e189abb484421b838e983d5432151f5ee702310a7da43b3f3477b6446e42a +ct = 6bffdd2a91a76ef016820755729dd1cc762e3b96dd4e21a1a07522384dd59d027f4fbbade6bea645ceedb7cf3a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[110] aad = 436f756e742d313130 -ct = 98b9e8dd6a2e8dc8e2011ce879b160554365afb06bc62db992131c2ca3ccc83d83aac8157816921da8cd54933e +ct = 11e601289456e29cadb4573105efe2d186915d7f1c45b77dbd2fc21d1ad78b9ba57d5a48f0713c46275eb61e9d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[111] aad = 436f756e742d313131 -ct = 4cf48574b0986e1b19c19af1254c62403ba242ca7e379407095bffa6e65baae539bb9fcbcab8a915d3c633013c +ct = 4fc545841eb688bec47b35667bfca116d95f075e710fb3480441c4e0182f7d70b87fdcc4325c79b36ce6a46c8d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[112] aad = 436f756e742d313132 -ct = 94da1edb651a79419cb2c0ea1a89c14fa3a725335e3b3b10b71e97eca026526c9d61669ddef6fd5f71f15fb930 +ct = f7097d2cdb98ee9eda11bf59d64b43aa10fb8b81b027df316488664f6720cf582b2ed8748aa1b76bf476056d68 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[113] aad = 436f756e742d313133 -ct = aba2968f77b8170707f3b7affa945289ea56986a10070956efcbb48b6512e22f960f7a07e05c77d5debd69daef +ct = 3af5a80b57cf7fdc0fe58c1d86ba214d79c5ef1412948d8eaa4047613b5b4e6bb65808fe2fcc559aa0fd6c0ce6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[114] aad = 436f756e742d313134 -ct = 258e1acdaa6c7ba5e31bc1098ca42d844531b0039c399e05fac4c0c22a75fd4e308b288a24127334fdb1900b0c +ct = 073638839b556b5f816e00d901a84eaed65a1d0f7fe71bfd1c25d09a44a03cb89cea8c194bb497eb04293ccba2 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[115] aad = 436f756e742d313135 -ct = 6a6d65cf15054487bc8f4840b86d3de127c1a90080051cb0242f4b730d4a526659a7c059fafb0a83d937d62e48 +ct = 9cbeb946854deb363f3019e125cb4eafcbf05e29355736fd3c46358db24a63a97c727a49f49d89ae0b8e5c19a3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[116] aad = 436f756e742d313136 -ct = b8bf351fbdabc9a5c4843b6ababef5ca9faf95868cec99c04d1d555e615005dffc6ad3e4eb84cf7379242575ec +ct = 02aa1edf942b970989451f81f00521cbde12a481a59ca407a5b0ab61ad25f861535af165f4c09dcdf8cbe6f4f3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[117] aad = 436f756e742d313137 -ct = 5a042d64ab6da7841bfe83766b66d10c272ee4dd3b9cf9bad9d8980f8b1d191e495ecedd6b28444bb6431c0457 +ct = 6f37b8476decd18a872a1662eae5906c0ef03bf6d1c6c33965723de049c54ddb7075c67b1330ebe3ac9ed69cfe pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[118] aad = 436f756e742d313138 -ct = 7198f5b0e7d9a041570522a57cfa5db3d488504339762fdba72e1593e164a7df5316c674a592c064cddc9a6c05 +ct = e4b262588afcabc486d0dbcd4b84ce500bd171e88487766bb4d63e6572c2c614ea75cbd81818c42f30b26232a1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[119] aad = 436f756e742d313139 -ct = fed6055b80361e2493dbcc48b658a35afaf6247ac4532063fa5812f10b7e4f259d557bac0f049b1b88577dd67e +ct = 662e4486489c51c83574350ae1f76eeea80ef585d7232a4db6f2ea5fb818d59e5219a754b6b5a4d86012e9389e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[120] aad = 436f756e742d313230 -ct = f6b7aaadedcdc89ef9147b3817494a3f43107e756990c415d4a2270312b0e257b756c0f1ba929ec722850fd762 +ct = 5562be7291f09cf9b3c9e7622af65846baefa84b38a69353084656c9681bc3c33b7c3ec6d1c3c0111de711b8b0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[121] aad = 436f756e742d313231 -ct = d4ea7ff429ccd38d86a3a35f1a86de748cd1c3fee83e7c85dc5e52bc5134dba53d4c85368733037a3845b1f8de +ct = 710caf513593d917cebb4a3d12a49f47b4316540f8c8446db7abc82da4710d43323d1f9fac121c36e39544c34c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[122] aad = 436f756e742d313232 -ct = 86771ccb6999dc2085ed073c6f0216cfd8a84347456e7e411753a70b20389ca84f25968d4bcf3687b8250d2048 +ct = d8c8ef69c4ee6a0f820d6a8e45403fab4549192aaaf48ecb56cb3f2becb39657c89ddd45d1dec4972551c5cb19 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[123] aad = 436f756e742d313233 -ct = 76196c59dd912a7fdf3da785b02edb0669830f23a40b23364d9a8417c25a44747eebf5f02173bf254bb6535451 +ct = d77337383dae131898513e758d30af2f0800a418668a6d159670d26d2550e92703565d84babc97014e517d32ea pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[124] aad = 436f756e742d313234 -ct = 6e5b768c7965f3292010ca206f966c30f1dd1c1faff520df04114442072c3890ae5bf14295eaf7cf8aa57330d7 +ct = 8904b0c8f8dd8186e9434f24b62e28f9109caa6f74ba9a1881e5eaf76fd52904b969bb6dbeae9fadd82a4ee832 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[125] aad = 436f756e742d313235 -ct = 7547da149fc7eb27d904143355133e920beb405a8c245e5ca8e418297f09cb96aae615d24661f834e7dffcb018 +ct = 983be08bed47991c01a1475d5dae7c24b20cf54ba0d7efccfcd5fd03567bccf7d2efb4668fda9b3e0f4641ed60 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[126] aad = 436f756e742d313236 -ct = ebe8030330f423a2324eb863310d1c13c62ff7894c1495a0d31709ec1fe567e62954fdccac05064c412ac00409 +ct = 0e639053bc508f725b7049bdbea8e4e14439d0b91208ec0a5ec3a2af4b9bcfdcd82a1cab379280af9401f4c87c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[127] aad = 436f756e742d313237 -ct = 99f8286c7921b46fc90023361caa5b4b2e0c3d3b71b65de596876eb70a2211d89b4a90acc225b24954224919b1 +ct = 59836a335a151ef278be252723abee0953fe521b7187f523b03690526060e27097e0387fcf4d54347a5a037595 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[128] aad = 436f756e742d313238 -ct = b9b31bc2dafa1c31154322fe4d23b5f130cdc8f6c92da9ccc937503f4173d5cbc6df18d7847b77aeaa11be32da +ct = 9d69bdc61e64e2bbb59ab52d51a5d6b126e9e7b2106198fe700381c8dc35064c9f3de37bb360da618be14c20de pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[129] aad = 436f756e742d313239 -ct = cfa6ab15f19877c4c030522077c18d442d1cf220c1b021e4a5fa45d14e66044ef18d894360237281b55745d10b +ct = c55c37cad984284d634ee73db6eb5a76a4d683a86deb2f53be6cadf460f84a1a60b5035f3a0ca45b321bec43a4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[130] aad = 436f756e742d313330 -ct = 46dda78d75d4beb46b6e79c68abf242895d072602ff0984d22ba95281652a55a26d5a3209177bd0b78f80b6565 +ct = 755a83c6d6a702070665eceb72f71d1e9a5ba1223445a251f8be5e3e218103b61f1926be9e0a86efc1212fba07 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[131] aad = 436f756e742d313331 -ct = ac8ddded913db97734636b351b65a3a7ec32de7c95f9c2f7ea2ce186a9cf39fdc6734d9d33631ff7b679047da7 +ct = 6b7907669ff3987ee9c3ea832b7b19abe12623b141c6c1c4c6d6a49000026b3d90232da644fbaee197ab67df64 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[132] aad = 436f756e742d313332 -ct = 5a63fd958d7da5229b2ff04155cf5eaad8af24292de1b6f23dbc1a6c8b717c373171ff46e9aa6ccc87cc38739b +ct = 1b32957f79a49363d4d667c051f76d8ba143207e4a91e870dd0106cb506336d261329002c92ef9f121094bbadb pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[133] aad = 436f756e742d313333 -ct = c3de57f22a0ef3147b395ad8dd1b920e6e331fe19ffc4a4436cb0587ee1f9fdff890ff1a02fb9ab220594b7f9d +ct = fb489163a7e7ac0b9c2d731919b0e484eb2d31fc9a5cec166b2dba01d6f18589e8da0c892d3b45dcb2a8ee91fa pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[134] aad = 436f756e742d313334 -ct = ec42e72f0a8f228508141998a0007f59bf281a9a3648812ac0f53af320375a0abe4ccaa73712ab9de8b2cf8327 +ct = 2e5e5092c57963424f18ac82cd2813f727f8a26a155f71e32f4e09d6887bb8d21695da3215acbcdc13c3514cce pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[135] aad = 436f756e742d313335 -ct = a8ef6cd778dcbb82e48217e77e132aaaf3434370527978fc6d68df1aadb1f6b1f534b9aa58e993044871cb7d71 +ct = 86a7d68707aeb690f327bace44b39f091635626446353652dde9bac18e9a2c4c477557052ba3bcf801b976b608 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[136] aad = 436f756e742d313336 -ct = 59b52a68e18b64aaeec537a113586ca56f94190b4c8fc0074febe8238606534228854d2fd45f734ae726fe0b3a +ct = c1bb44d1ce3a6796ebc9cf92d252de0e711336b645fb1f63459df7a3bed93d2fd8a76bf80ea3004041ad075a16 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[137] aad = 436f756e742d313337 -ct = 595214d9c7033b1790e9ae70b739332711baa4e199f5457bc72c033661b559c0f1c3802bc96c63953b9e2eb5e9 +ct = b49e9cb962459433d55d940628e5f4ca0147cdfdbd63a8dbd6fadcde9f567be0d84f766bc0c309e1af83171155 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[138] aad = 436f756e742d313338 -ct = f7970241897e25ef6c4fcb0224e5bcfb2cda3715c9baee3b3267c7b199c82459a2a95ac9c767d90d91962bde9f +ct = 3c7581c6b7cd65668f29f99ea81ec939bf926e80ce6a585fcde3d6515d2a94ef5ce6e625acad1d6d0a10d10f5e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[139] aad = 436f756e742d313339 -ct = 7569b68ca4ff6436c0a9e68b289ecb0d9eda9a1a60a3934ce13a92f57004a4b41e69a75c3d2a29cd2c929f5ff9 +ct = 1008b16c05c29ba352d69570147f63d7588115d43c2f4272d6d208985d3302538b44786f27e6179d1c8ba87d46 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[140] aad = 436f756e742d313430 -ct = 1ed5e8fb578f67d31a061ce5853710851c98b8b61765f76299711d2e763af33ddb9eddfd537bb4b967e47d9260 +ct = 6d10b989a058a5a9f08146519fc37dd98a54821a90a3340b93e3013a2ca87fae8a30c0d6dd633116516df9c1ef pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[141] aad = 436f756e742d313431 -ct = 92ce89e443024b7a80b61d1f58d638cec095d7d4664e8549e51aba582d219fc1dc5083cc1021b441560f58bc03 +ct = 7ae87645153c2b643430bfb2f34ddb268381ec60e1b895a533cf4e5bf91166258f078f67f5b14922090a3f27fd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[142] aad = 436f756e742d313432 -ct = 17103f6d8cb385452457040307ce7bc8f18705c9333ab51867f6cf62e51f76cf703b69b32e209c64e8777b05de +ct = 6e52e215f4abd43ab4b1bea110953e5da9e9a6af452373f1eefe86ae1657f0f63560c394519f2c16294cd55825 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[143] aad = 436f756e742d313433 -ct = 6441c689667add0ed50eeedc0dd5c487aed506f2f360e768b7937f3d06b0b43c2c3f9d9c883d105e7c97d050e2 +ct = 7346f609ab37a2819baa8dd5151bc0b60405dbe83b84730794f1efe0cf2cb40777a110095f23aee9adbb8e0e36 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[144] aad = 436f756e742d313434 -ct = 1848f52015c0b917d755528d3d0ff70574ebbec2271d4c5c672a93caf37dc87695848b79b9f3caaf8937585296 +ct = 90b135d13e01f5b2bd1a2fe275e771e960b1ddbbb7f8f297495a79cf0bbc221ffb6949561aa8e52934e654e653 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[145] aad = 436f756e742d313435 -ct = 71795a914c78062acef28a7e6326c106dae40f564c73fb63d9f52a0522954caf5f3d8b59406c1e4c4efb4e78c6 +ct = 9949b6ec08af333d9edbec6f24d1492b4c86ddfad845ffedbdb976095a653f050aae63d2a9118c27d9cdf3e47e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[146] aad = 436f756e742d313436 -ct = 18b51007114b30a1ddf14efd7297ecc0a8ad9626408ed9c6bdd22676d9aa0c11aa3f0cdc525180d47b1fc2803e +ct = 40edc2b843da05fa20c84b7e1051f623afd235270fcca29552cdff69c2f727277a287dc3d7d4906b5f0bcef44a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[147] aad = 436f756e742d313437 -ct = 1cf6954862fe38be7871d362a3836ced64dcbf2ff114ccddcb6f248a24446505f73cef228f1217647d3e70d7d0 +ct = 0365c963b4ea7da34bba7484e803fd7b825f858ec3352610361b41d0c589de508e7b71296c08573018a78e2f59 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[148] aad = 436f756e742d313438 -ct = 41cbb2064d9db9f43e9fb550a057b07bf90925ff28df85dcc01e11e2160749e3a4003df7693baf73315d3052e0 +ct = ed3d116c4af961f795d735338bac2b14170dcb5c3e6e2696804e55e3bb65eaebc23ae875268b520e48be029b94 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[149] aad = 436f756e742d313439 -ct = 099e43c3d5305e2294566ac688e4a4c716f3b81373e941b6d28320c4f48acf9c8bf4f3bc32e59ee4931fadae79 +ct = 89752e534d425a179b43616db8fe503c4ee3fc6dfac8e85ef984565044982abcc7d46212c607ed81041ca9b85c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[150] aad = 436f756e742d313530 -ct = 4f27075c65c4768779f33847f720f635de15d5074d3593391936e4f0db79abf016e548781313176bb83afd544e +ct = a988260aec1a06011b2c740bfc4cae0482eabfd191810cd2fb95e342104a14d0d95176081d9be161bb597b6f00 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[151] aad = 436f756e742d313531 -ct = b49d1947610dc84a71bec3407420f4351d74a6f97dc59cdbaa4063de82998480ac8d8576100f8fc1dec8fd0415 +ct = 7363c1bc299398934f4fad4185c93573bc80b367c93f7605ee2ab97a3b18179dc4761177c0e2b0c3d87dbd7bf1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[152] aad = 436f756e742d313532 -ct = 0452a34aad9eb57de1748b18570ee94d88d2b123cbde141525e53fad8da5e95fadc36d533d9ff158eaadddaedf +ct = 83cd7966ea988b9fdb064c1282d30d41dc9c4f37de5ec390ca0a1d55c508bd0d3af1b481f64541830cfb9b0e5d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[153] aad = 436f756e742d313533 -ct = 4034b6231f8e1809c54bf4d394cc05104fd223357e95a60597c7df32d2d1b69e0b78adebc088b4364970c9088b +ct = c5a20c2cf5336d791e45a4e97a1df88779a79cc259ebd9ad3b7406c2f42f655ba5a235e4f3e6687b21d21c129e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[154] aad = 436f756e742d313534 -ct = f2cb80c67d9226f131dbd64963e27ca64e428e8f64c2c193c3798e2af548a4bf5d0b64d0e9a5105bea4340e40f +ct = b84401ad73b092c5be750404eb74ad48c5f2193835495fcb2a6ac8f0bf9433d92d8d3c17f0722e3cfaff428c39 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[155] aad = 436f756e742d313535 -ct = e4be8d8aeb13fad3db0e7d266e89ee5ab7e3c861bdff61776d6356e786787e14e6d1328bcea2001cc48a013425 +ct = 233c14c55330a706f1269f1a81c7381779c14ef2cafd12054eaf740bc9ce13f7849a0143ae9ad5924c9c31121b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[156] aad = 436f756e742d313536 -ct = c1084bd11719f15b3194ae5f84d278efe6a962c0b5f16123cbde523ff7ed2eb88d91293c22e3ad9683f5dfaf69 +ct = 4888309bc44a04ba1708d59d30495247c0eb1e55e68d3d814d8eb8d2d9df704babd92e5d2a3b61cf0fa0599570 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[157] aad = 436f756e742d313537 -ct = 91e9c1582a12184b4fbf796a81ae583f865a2170bb09f2ca46121824f19dfc7944044d533c046ad093f7eb820e +ct = b8be632847c77c4c9bd4d6e448942a698a23a630d7bca02e4eed4e79b146032d60400aa41d5bc1d82799044b3a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[158] aad = 436f756e742d313538 -ct = 8e4fecf7a15fc3b258900b55adad4aeb1386c6486193e4d3fda60fcb255635266791eca1cd76fc20b411955210 +ct = 53497421c5eda1f339ddafb9d21842d5ba7e1e93909308512ca76044b5f18c5eeabeae194c434a3ca9b6573c22 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[159] aad = 436f756e742d313539 -ct = 671e011d0e3c57f73508f885c64dab5124a4283a9430168033f11ec0f1aaeafb7da3224a62264d2013baf4cf72 +ct = 2bc98ea9344da4e9beb2b19100397809f75d5c4fe960c7616380111b5831096de6155c9fe8a16ccba73feae3b1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[160] aad = 436f756e742d313630 -ct = 8d27e076edbcba9f6a9e58b62914463dfa5bfba6f419807d6664659230a947e069756098429285b590acc89927 +ct = 61205ce18b656b2861cb38fa0ea5d91de1e27df60fd23c476a641ffbfa7eb0c50ea000962e2d1f1796bf99aa8c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[161] aad = 436f756e742d313631 -ct = 7ed3247399afa43f2e3db2697f9e37e94f71d4d210e2ba4f3896eb62bed1308df32e5a63a16c7915538ce7463a +ct = a6c01951f5e2a019ee77b4028ba33c2e204d21563795b2c1ea78271280255f98f1b903ab05d3afd089439ae6a2 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[162] aad = 436f756e742d313632 -ct = 535bc957326207f14417a5c79dfa28103f488169039d81986319c0d54ec72ee23b8154b26bfa9e1e6941bab038 +ct = 5c1dca44abdbcb6c895800e2d0a0e4112bc1b2a81e1953d80268c99ad235da2888ced02fa53ab60f2ce737fb9c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[163] aad = 436f756e742d313633 -ct = b7a029e3486549bdb19fb063eae5ac28c646929b1f195f6f1bbdf9f99a65214e923d9bb03cf19f17765c62befe +ct = bdc83d3cf8044b9b91ba3c4c4c5470c7bfffb1cf44762b977de0c79635253d71b8a9ba32d82ad5625e23ba3046 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[164] aad = 436f756e742d313634 -ct = 11c717389193120fa6b61d9fdbfc74ec17309d744c1fd6e0d49393a5c32665c0b70a0a64916ae4a02d020762d2 +ct = ea6acf6fe36fc0e728874232c30390a5e2fba7e8ee95e9f2ca719f980bc6203deaa5d704ab3f8ef47ba3cdd789 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[165] aad = 436f756e742d313635 -ct = 45a5fc34bb9062b93a34063f009778d4bcc3af74a69152087db014bd88eed080c06cadcf1efd41b31a9bd9a65f +ct = 3b7823bb868dfccb41d9460742d3e845187ad100fcb1b4c0fce18c58bfb5e48d39f02a630cf2454dbf50d1ba85 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[166] aad = 436f756e742d313636 -ct = 2ed43cae3a8299d0ee9caf4297b330ff643066d71af8465cc19a834bbb953343a7e165f646eee638ab0485b903 +ct = 6fb22b75d0a26ae07bf894e54fb066976b45a386c4f616b13c48923613ad5b87a13dece0cfa6e35c4837ba73c1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[167] aad = 436f756e742d313637 -ct = b42058802b285612ffc4c9660931a282125eaf820c116659672ea4cf4e901f9aa9c496ed515d6fed6cd72930bb +ct = 0bf18ee332538b314d98a0f850469e2c54827923565102712558bb07af9a6fb0297510dd46d0975ba2869a4170 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[168] aad = 436f756e742d313638 -ct = a5cda906160fc86a45c80cb2b51c07a0a1308626426bda2cb6b2e15aa5d650b6f59a97b503ef046c88f643e0cf +ct = 6d823e5a8fd645b8f53dedafd7a592975d8e8f0f124c0229d7c8b6db80b043cb2365f39bd8d63d468c70cba26b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[169] aad = 436f756e742d313639 -ct = 3c0656ff6ad0c678d1ab7f1c49118191a475882c66b9a771a9570e1b19a7bafe0e2e2b55f0d17a4d054d175516 +ct = 14e7e71ed3a662f1fc9d4f9eb9432ac788a125ef1d0d15941d98d0db8026eb3de49758d4001945046bc8d0fa7b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[170] aad = 436f756e742d313730 -ct = 75c7b335e15e94bda0851db69e35f108fc233a545da4b928ad14461e269694d8820956fafb4e44720ce8381507 +ct = 1c4ede11879727fd70080e8d33106f1319a5aace4e35831d143c046f2acd1640321b9df29d606ceb29b479f95e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[171] aad = 436f756e742d313731 -ct = d3d4208c7bca3519228b580237ddf552c0f479fd621b5751d797cd1d973f62702e1ddc2d743ddea6a14810981a +ct = 778ef01e05e75d9ddbaa5e2732797973d0a0d40e53310f829b2c7fd31f96a50fdcd13229db146795cbfd6254f3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[172] aad = 436f756e742d313732 -ct = bd8072b89e773e49b1ea161dc308c1f47e0ba2900eeb8969feae8c69ede105660b348d2a6ab5251e192812a704 +ct = 25807db1f5a3a6481a240dab4a8173601600e577cad5703db9973ae5a3cecdbaa454a57064ecd7fde4f0ca5aee pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[173] aad = 436f756e742d313733 -ct = 802ba6104adc7ec67dc96bad11d1540c37c7d09a1d8e588e9d037a559aeb8bcccf00199e002dd1b51e38346d01 +ct = 64cc1acc033bb52a4ece52d51500052e41c4f716a6b93f92351557184ebd3ac2f1c8dca0bde406a36f8e6cb03c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[174] aad = 436f756e742d313734 -ct = 170693138046e54de3f940047bc9c083905bd0d5f66ce4a21b447e8671662ebc13ee7cad4d0710fc453fd18c44 +ct = 1414cb7aa19771b187ab8847f9bfb3d8fbea142ac7e458779751eb357ea12fe5789aabfcd027576fcbf60a0baf pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[175] aad = 436f756e742d313735 -ct = fe66bc839bcc84b49b7b2f74bc79f6b6d66d081b431a9f875738ec99278da15f562636f26a3305c06ff0ac1dd7 +ct = aab3afdf79e28db0ad509fa8d64d35cda533a1da3e6a76a14b2ac1952ac2b573adb22e5c7ccd4824783f35e5db pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[176] aad = 436f756e742d313736 -ct = 68387b231332367d7c8b6d57bd2053c79158bd8b364001f0ad10c2687266df9c2339179d7278db2c9b6a0a378c +ct = 381cfc887f4a33bad777c29c9d706ca8349a887f72bece0826e49d87e964a5307e86d24f09c104cdc30f18fa4c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[177] aad = 436f756e742d313737 -ct = 5c15441304b8c28780c052b3354b85f05985dc83ffb718e4b680bd0fb1c052aa5741370ae14ced0dfb94d80fe8 +ct = 0f98fc2a6d41379342df0dfeafd13a679dc166193bb40316383aee3397ae7606798be7414f941fcaf8c7136679 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[178] aad = 436f756e742d313738 -ct = a5b93d9b53f0134eb135abac39506ebde71368021255ad77964ba92095b370ca6bc1887266746f2f24a1ac68cd +ct = f50864b8e23d0d56476113d7195a9878abcc16b1f1538970dfceea4ce3fb738ffb9af5ace7204fff3d62e2ad46 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[179] aad = 436f756e742d313739 -ct = bc646bd2d4af6cb3eeefec80d906ef332716d228ebc473fd543c51fd4c626ebd9a9ca3c5379fc935748b302fe3 +ct = 123ad7cb5df5d0f172f1767513dc77543851ad63c15b90192a00f80c417079a02ac7838bf13640ad79171e58ab pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[180] aad = 436f756e742d313830 -ct = baa95961ad3798f5ea49f68c7bd46a47f1e1b1f4c4410aaa23ffd29b539257dc6a519bfbdc12f48c2dd44f41b8 +ct = 00ff6ee0d24c38b8ba9073824b547375381fe08cd921c4ae3ce9dd6dc51d595a64b2ab61b268e4883f12322e09 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[181] aad = 436f756e742d313831 -ct = 63350bfe96ec394c5df26cfec536c1e13c36f11366dada5c7fbc87c7a77824d3aef9f68420edcc90dba8840e8f +ct = c06f35ff7ed289407ccce5100e43833c86248e35be2eb60c365c87e2e189326b345c831ff639219bee69aa9148 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[182] aad = 436f756e742d313832 -ct = 2aa46f85e84cd57b484eaafb542af4fc5be63a3cf0517924311c5014754cd28ed4aa3a7c6ace995369a121d919 +ct = 4adc642f976ec1de0e1177f0ea29f0da33f20e99f5f957b1bd219da9a2a90d6f38e8194ea7812b7b7dd6a2ed7f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[183] aad = 436f756e742d313833 -ct = 7125de9a7ab93363e12742330ab38a0afc493cacd21fac7dfd8d6650b58088e5441b4612957290bd81bd9b51a5 +ct = f08f65f247619c09c77f0c36b873d423800cbbb68b6012e39182be10f03fd05cb0df4a9063b8fea215ec613014 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[184] aad = 436f756e742d313834 -ct = 99e607edbe8020e3d501f2d861864c65c0f3c7017f73a5ffe4a13f55bf5576848f3c74982cc59b599b10f5d16a +ct = 795a1860ccd2777ec87e7691c8c7b87fa60905c973d5b4cb63fb4c1ac2d64bc2ebf5f3baf43b5388ecce3e3c81 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[185] aad = 436f756e742d313835 -ct = 327928bae37c3ec8e3013157520df8a40fc82e554b8ab673f0785aa30ad582b3d5c16214668a9c02b8a3305996 +ct = 4eb24b8ef9de11652206ffd21185b00cb5738d4d3836422f64ba3da86e0b512141434cd91b189b3ad178975817 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[186] aad = 436f756e742d313836 -ct = 970a798ffbc3d26f2d8d937ddfe93944b9b0a8ef5b5090cc2050c9e1cfa24ae8c9e383b5443b6b06498bfb4576 +ct = bdc4f22e46b5e4bec8c7013d3e2419fd36b47d8b3d4323c508374c97c2673083a550a5a8e425b3b3f2952449f6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[187] aad = 436f756e742d313837 -ct = f9888faf2641b1cf17a32a2f1be9ebed7461bf164bef4d66f925d97aaa29890011dc5d32b1662a46e56422ad4b +ct = 0d2faa408d419e3fd7c39175b5052df2c9243843494f27e29721533446ff551ebfead78f2a19b8243a33915c3d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[188] aad = 436f756e742d313838 -ct = c4b3edf0d1f37509c2571d4b5862f59b2ebe75c53553fec09fd4331db9e968beb517f1c48a2e1025a13d0849de +ct = 08a2211770ded14e210dc9a5a711b011aec7283624be62d67754b7c0e37bf88e947180b7ba035ccccc754e7139 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[189] aad = 436f756e742d313839 -ct = 128a7f7e9f4840e993df22c6a27fe71ce85ea48e30e09cba1d61ed2a4ace07cbc6d498e10909b581a548facb53 +ct = 706b1f001fa04d7639aa1838e6b94c710231a25f10d30426f098965961f13be8ecc9b9031b120e4af5652b1e27 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[190] aad = 436f756e742d313930 -ct = 640183b2b366539114dd437cc52c7e11ace537522dc32513d28a72306a0859bfbb57e88f0ed282c328b2811575 +ct = 3550a384167bb99f123c4ab49ecd62e2a7c21b151ecd6dd0252465b45d532402aaf767f139708abfa31857037f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[191] aad = 436f756e742d313931 -ct = 737920941a5416463d091bb39cc88fb9a8777946b3d491d74f873149c121a680f61bac1644fbbbf4e4e084615d +ct = d07ab8c75beec6f9b3bfa5b580aeba179c93f607828f43bb1acddcd698b12509db5a08f110d1d46fe124953e01 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[192] aad = 436f756e742d313932 -ct = ee533361a9075cbd1ae3448b865d16d540869e232beb3e7b7fcf0982baea5d4a7634b9ea2bf3a768da75d7bf62 +ct = fe1c8f5e53563225b7192250e3f07bc47ae46fa77c441a2479fe28241d2b83ac3f8ab24a8b16ea628f8f7dc138 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[193] aad = 436f756e742d313933 -ct = 94be547dd7acb0e06fcf9699e4e0417b08da4248b09d2344ec5a3f3740cb6df8a2e73cb7d1f586e2bf81fbe01a +ct = ca0001a376ec98bc5195d861f61d699fc08ab8e8933becb9a1d4dbb46092439e5bde711f817258a91ce864a972 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[194] aad = 436f756e742d313934 -ct = 595ad5462e873d7289b871482889242cc322d57e840a826164fea4b240c18a951464d27444a5672cf0339cdecd +ct = f5ec0401b4bb76ad6664bc88e104c84ab9e23aa3df077d4019d6e81efb838f95bc6e4cc0950db56dc7e4415969 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[195] aad = 436f756e742d313935 -ct = 88fddd9846559b1e0165e961bf90d9320b8846406353174667f03d667e90da202b5dce27a32cfd2c4288e80cdf +ct = 3287b895c5ab198fd61e498118d4c91ba8559c5a5feb2e1e1bdaa14691c8fa3b868a3c6962aa6905f8421bc141 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[196] aad = 436f756e742d313936 -ct = d0b40335e694ecf36a1c628c215f8d1e59fdea2ec54d1997a7784c519440c58bf1cb2cef6f1787b84f75182726 +ct = 887a2c0746336d67fa4edfa866313be32b3950013c0aa3eb2bd666a6d277060f0f5913d8c0cfcc95b2e70c29ee pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[197] aad = 436f756e742d313937 -ct = 3e7e536627f6b2bff437b7c3147e19b40a779ef2f9d46d0be7aa086dc462301398e912b268cfe8ac174535ddeb +ct = 9e246a263d6662f70f8d5a05487cfcc99965489ae233c209262bd0ec65b4994e1d7dfcfddef63a956f3cc91193 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[198] aad = 436f756e742d313938 -ct = 61919626cf4fdcb05b3994b2b4f1cff36cde151621afbccbacf5cd30371328023548debe410f5fd510de7b3f8d +ct = 5fe3f5242df92c284ea2806c0492e5c47837921cbfd8c49d5769ec8a54206ca34156358756681664090a8ec2b3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[199] aad = 436f756e742d313939 -ct = 5cda7630909f65f1639d17ee1bf9af32a154e07a09d5ec0cd6d980b2246420ac3a713f64b747325ff98ffbccff +ct = 726f0392cbd3f225064c5408c90c7486dc6028deb9fb3e60ebb84ddc0b339ad872dbac9aeae61985a3cd03a5ea pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[200] aad = 436f756e742d323030 -ct = 93a81809a5c145a51792f16fff011cda42b7955c15f8005eaac4b5a2c69edd7c6a30e4007a9d7a28eb4c916f91 +ct = 82e3074ee6f828726fd8da9cb54ff24181e01a379e01bbc1d00b4ec69937ac24dc7e055aa5e9924531f907fbcc pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[201] aad = 436f756e742d323031 -ct = a3be48ca8ad70c6dd6b2763088cdd9ec7fce54535369fa711895e938ef40b634d765976e74997bd6ce3334d691 +ct = 8383e31c4dfc253cb64eedb29bb50e3f03fb7d88216146cfd8bc46a6e24b259831df8aeefa9484a2b1c50b713c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[202] aad = 436f756e742d323032 -ct = 3f060c4ebcf65552febaa5301832a124ac261aab14cb4987abe467712948466ef42a819442e857a7ed2d406a04 +ct = d1064f889c0a1c74c9e812980ddeb4db85ccae0b770d0d9797f79edc8924c3af354c92519566b1856e7d4da7e1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[203] aad = 436f756e742d323033 -ct = ec45590afff57643dc270647f6932475fdedd8c94c13c7834c44d0f80b48f409fc311063140819518fee6274a3 +ct = 5cc0e2246dc23cbcdedc6be5ff8563ea527ab0b7976016eb23d029f359816c998d980f4c30668c662260b17869 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[204] aad = 436f756e742d323034 -ct = 157c4157c5f1afaa789e304c096b751c3ac0174264696238dc614c0872ce6259261613938c14757173966fa5f4 +ct = 4989fcb35d8c5d52e61f4a1dbd7de520fe36dce0bacde2832689f76b26ddd4ca326576562a939474b6813c0711 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[205] aad = 436f756e742d323035 -ct = df36b86290c7ba0b99f6b9ac4489d570af4941296ffb352cf0a2caec11e9edadcb61391e381763a3f89055f1b1 +ct = cb2cf08cf6eaae26dc2824aed8b93627c570956427732c9e18e8f77b9c255d0c01cf546d9f80d7edd594c5978f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[206] aad = 436f756e742d323036 -ct = 4ab902188cd8040ba6c4d325cbde2161e672e996f2431af34a94bc89be127ea99278e896082847c11029c94cd1 +ct = 7559eddc8eac912b20fd672610acd68d92f8e0d608182e3689542d69d8015facdf09ccd6e62ae902d4a7a31005 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[207] aad = 436f756e742d323037 -ct = ecdbd21be32fae547cfa7fb4d665f3038b5ef47383b349700f53fa37808f9f971c4e6f2c686dbead494695037e +ct = ebe4067990f4439d84f7684139de6fa2f0abdcb9002738821e4e6c2392124f17ab77ddfec293ad790044b06a94 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[208] aad = 436f756e742d323038 -ct = e4721d14e172cd2db536535a8452a247a60642a7645f56b30b2c920433f082a111e798d644e764eae231b9e36d +ct = b2442c7c263cf07bc84857281860c2b5e3e12865bfce9ed32b0f86af630d718f5b14da335658e256de2243445e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[209] aad = 436f756e742d323039 -ct = beb673981c54566d15239a625e70beb02dbe9ad49782a9589c6dda7db3409ec9b0fd5485b2b9ca89f51ad2ba92 +ct = 2ef92ede552eb2a291d9dd81034f2b47ce79f6b9e88f87cc84b0c460fb66535197f5d3936c1b99b5ba66c0de33 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[210] aad = 436f756e742d323130 -ct = e2b02be0b2a8b327c7a83d4c276e7fd9f8ebdee2e951113bf0622f2d1b52566d0b5fcd582b8f11f2891206e439 +ct = 183220a6989012152186d775d6f15bbf56cae846e3a6c534a863b4287ab778851315d24621defe982a4c735759 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[211] aad = 436f756e742d323131 -ct = 33ae0f52a3cef337a7286ae47e4f2939c18435135f3f93794507db9fb4d779a4af607683a3f837d6f175570ea4 +ct = ec0704f1a68006acc6142b6294936199228144706a5cf730be95078585686c1501f57a97d2e7a1ce561dadaa5f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[212] aad = 436f756e742d323132 -ct = 7bbfc9c9e8a4b2781f1dfcc48c3a6d9e66ec91e39348a458736681d7cee6fef84102da9bab48aa3fbd295b129f +ct = 4f182c1f81ab60e667c48fc78fedf17d3f4be43479956c06871b9935a28db8ef1fb91ca7a05cf06c6c16bdd3b0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[213] aad = 436f756e742d323133 -ct = 951bc3e3f3a302eff4cfb7989a6508ffd2bd69223d9b962a4c68cf04d209e37b056f92c4ff96e41b60e411fdda +ct = 26da513d75efa918a650d24c738473713383f129ce85ad996513db0284dedfba7b04def48d985e3f77b24f31a7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[214] aad = 436f756e742d323134 -ct = 031ffc754d54a488cb7bf4577e840b9257d81ea3605e2b1fed1c4d83ddc76ad7ec76d3cc2587636287bdd15423 +ct = 57966eb046bcd25b0f530cc8f844ba2999a0faf954e7106f40ce041d97f99e69d71e0bb20034a5ee46790753ea pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[215] aad = 436f756e742d323135 -ct = 7a88f024350986aed407259173cc4f1672ac1b0e4d29584c3bf4c717ca48e9d835ba99cafcc0ba9428368df5cc +ct = 554122776faeec90d03157835252732eb116d796603cc16c075a89a01b943f80f334bc2b584590de10a082ac2a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[216] aad = 436f756e742d323136 -ct = ca06ec3e337014731f122f8db788f765083be95cb6abe2e9827d521f63a71932a304fc8f452611c02bdc8ae83f +ct = 4a93387559a484b91fbd298b3bb2609270c48feb7a31c1168c2c229bf345aeee4bec0e4b71271413bf9c211c94 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[217] aad = 436f756e742d323137 -ct = 44571995fbbcc50754e9858f45f81f9fda89f862de946f55f6def93c0703486a59675a28df6616057aa2962bb2 +ct = 725a88ae41bcab900b27b92450c3cc081de9fcccffa58afd0f23533189443d04659d8c6eda37f10fdf0a1573f3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[218] aad = 436f756e742d323138 -ct = 2eb20f3269a93720f615d25f908c9678dd1249646211eab665b4e15ab84661fd737f32d4c319d2bca171bc33c3 +ct = e37ed1b71ab95aa52fc9ac19f0a0b0449797cbaf5cc73f0da89025d52e11481801dc3de65b34845e193391775d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[219] aad = 436f756e742d323139 -ct = 9db897191dba0aeace4709846d28d905933e576d8d19f64cb26cff759608eaa308752db430c41e6c1c13b51878 +ct = 3539ee61e9a5d7b83e44c16e7a814da6fb440a55f6548b4df7b9797309bce67f63959a8a237c59723cdac3ee77 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[220] aad = 436f756e742d323230 -ct = 132911b40ea785d6becddf35b68c8edb4ce3bf81eb982bbe6e93bbd500c7804a62d66ed3e17ba1677e5f19693c +ct = a192300578ca40a4d88bc195814c80725b01d479c1c4e7140c61963c5aeb0939e2fc9100dc0893da4a4ec0fa62 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[221] aad = 436f756e742d323231 -ct = c0c3cb5727eae2624429233d3864007cffed7e839777a25d15dc3d46ac06dbd89004059e01a346feb05c1c81c7 +ct = aa9cc7b2224b57e280a0e56bd4a8dcacd4981d7516a4a7e526e925bd97260b6b3c75427da747e006bc2ddf3ae6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[222] aad = 436f756e742d323232 -ct = f5d86b3e4a39ab7317273283244422d0a764f897b6b91ae8faebe925fd1ba2a15bd980e066dbebef574c894a92 +ct = eebe5ba2f3a25eb3602188a6fa7d7600f83b31e447e0bd950ab5064e6ce714df761b4599ba7818c2cc80365b20 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[223] aad = 436f756e742d323233 -ct = 681295d554e5f657c02531e84309c96abdce3ff58fabc8f969234e5f5e4c6726c51be58218063cf086abcf5983 +ct = ae81d85a6a29eb394bd83ac3843eb61cd5e8f322d639c3a5b8ce3222c85ef0b058d1c34695fb783eca8aaf3658 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[224] aad = 436f756e742d323234 -ct = c61b1a3724c8d67195ce45c0bd59886fd9b12c43f76379fb9c99d528bb8165ad41017f1dac1e26937e84c8adb9 +ct = a3265e946f45a0dfc2d20dafaf4d65cd4595c9c9c9dbd3bf7745bdef26f35d1588906e122de8143b3e316dd43c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[225] aad = 436f756e742d323235 -ct = 5aab74d6eea92c635d2c751530d2f0361a8684a515a475277bfaaf5fbef1a2171a33c34a90302807c701d56790 +ct = b68e78ed1ea01475d0775a6e20be845084de3c7d68c58611fb8c9dda3b83ad980fbc4bf99e3ee9980ebef862ff pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[226] aad = 436f756e742d323236 -ct = 7b998eed5008fa6295b94dac34ce9ec60faa1c4608d013cfa014aa3a96ea6687a106dde3657825e63440dac506 +ct = 1a065a204fff91b71d0a8d92858b77cd4d9ab9f7293dbfad8ae4173d6752be925bf7f996d40ceca5099f424484 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[227] aad = 436f756e742d323237 -ct = 956ad989000458007af0b41eb2fb5a716db1b095594821fc305ee35ea27b41b2476880db3b4c86bc60c4394d05 +ct = ae8ac359da42f98628985f27bc96aa25acc9a9e1354491a8325cbc4a5e17d30f8f77a0275761ec1d7e1c0b1dc0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[228] aad = 436f756e742d323238 -ct = 21de030f4aa7fcb8650847deea5ab6a2934f2e0c1c5d592320a3933bd6054d6ab8498aaa4afd84592577f5982c +ct = fd831d62c9cce5a711697891110acede3b5885dba0d1c1333c009a6715402e6dd5ce8d629f1056eb2eb990c798 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[229] aad = 436f756e742d323239 -ct = 09ebbc42714876507032d57cd75862b36e37c258a60381c2eacd54df57b63866bb6638ba70b819c5154a8449aa +ct = 2ab45b2a78a28a874bca7625da63ced2e83c11d9640c428a5a16e311053152a04b9d8db7e1bb58ab60da47df0f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[230] aad = 436f756e742d323330 -ct = e00f7b42761478774b545ad968ba8065df957f3ebc9f08bd7c87883635ca3150d68a0762e366346610627d89af +ct = d9221ea8c84f6dffb37fca1211eef538d24e2a180a5e24dc535291faf32c7ccbe03747a1d790d8e00bb1f1f61c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[231] aad = 436f756e742d323331 -ct = d943ccb5bec78bb5c5456ce7e0c2bbc2710451f67f9398f81b1365dda8ceeada480e270c6bd39cd40fead78ec0 +ct = d2cf65a555de09dc505b894dbcef2f72b4ed6fe15e685b41a15182ef1105542c462689bc16ed29c3e3badd0b50 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[232] aad = 436f756e742d323332 -ct = 97e618976ba5b39d98d79dbb6e94f853cf2f231d32e6240929e4674d91789d7a3dd7199051d49acb92ff1e3064 +ct = 6dcc61746a8aa5c549fccec383e9a387039cc4ab617ac1c6b0014de3e02a104217e1c7f404724b8beb3f684803 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[233] aad = 436f756e742d323333 -ct = 3a089d31db7927069a7956793308cf8f59e3570fbf8f561888699aaf5ba4681a427d68748705754d6a7344ca24 +ct = 8fedb6438e1d014c4eed849b7497c681bb91fe6491752ee3abb61b6329544aab8896ea1a2b80b6f1291d99cc43 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[234] aad = 436f756e742d323334 -ct = a4e7bfa5b0a0b537c1832206561f764c88d722429340101906b380aff934fbb98f5bdfca0e77024805338e4e61 +ct = 1746236a4775e8841dbd4e1a3e95a1b15fee50a9e3b137bc094545989eada59ef1d4a35cbcd90eafa149126de6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[235] aad = 436f756e742d323335 -ct = 2396cc5b30ab05634f7fc6f6067eadd043e6263f1e68c6ba556fa99dd075a7f1b42b5cf195a469ef2443896fa8 +ct = 075f3e87792e9ec9f1c7b7f5af2e80d3e6b3db51a319cedf79d06161abffa9ea35d8b56caf2eaf5a6e06e225cd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[236] aad = 436f756e742d323336 -ct = 8e419af52a43da88133fd3bccec458a44c82cc24dffc7475f62fcd69d9118c85505c0080811504b6b28d94c7d4 +ct = 7c71f10dc7f02913ae8692e93a886119f6b5940a9c4bdc24850502dc163939c5e74364780d414774a0b0b6e757 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[237] aad = 436f756e742d323337 -ct = fa41df9a9badbb1eaad232e4bf7c431b17418b429cf8345e45b1b9aed9e8669ea2e19893f22dcf4dcdfd370f39 +ct = a7660bd0d3420f847c09a034d34e086049c70baf1d183fe58af2e4d8f581eab7fb043ffe2b75b54f24b51ff8c9 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[238] aad = 436f756e742d323338 -ct = 03ddaf89dd237786f561dc04711aeb5976a61f5a32f789f92867b39024ba0f5f09bca97ce2456b4d4c8ea1e692 +ct = 173ea65a00440de994e2a6751b3d553641c57b4bf2cd9f41b10e4bb16c6b2d6c5ab715dd970114b6486d1f6a6a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[239] aad = 436f756e742d323339 -ct = 185eab1d7ae0d33b774abf1d730abe7cdbc7e238ed7c986de2f41e650f0915f33e816fa9b0e08143cc76c76e6c +ct = daf7fa1a6a83741e82f13262e7730447ee1c1f29cc60810b4f0f10001ae0c37858db6a3aace4a03f3e70d4ec5b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[240] aad = 436f756e742d323430 -ct = 559b45bb28a558ebbaf55adf12130d45e18adf68249514e564437bf61d4c49fe9f252c006914429d96ee719173 +ct = 6a581b9771b748adbaa26d20085da812933d5ecf2ab2d11dee1ad560a2333f9182d31f017f02ed6b47b2fdc50d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[241] aad = 436f756e742d323431 -ct = 6457329e5fb4296beb868c175f84f16ae889a3edeb37edc19b38bad597064287aca727b420b5ed8b1a0b677786 +ct = abd6668670bdeaba122f577eb635e56bab0f9f861b3223e8e17facf19ad716a9457029a09174791322810ff81b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[242] aad = 436f756e742d323432 -ct = 38f7ba2c57febe4b4d832c29299060d93f8fed98b6cbc95d0d6e95dd385d1fee063783ea774a770111ff9aa31f +ct = 7a2f1b4b5cab79ef46c15d764461ccaa4124cb98f019782013904877ee830de5632c551ddb8119cdd2e38de5d7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[243] aad = 436f756e742d323433 -ct = c45408567b0ad94fed4067cd1d250db315561c9322db62e2d4604bd36aeaf1fcea7db541ab88197266e5d9d7f2 +ct = e97b38dc3a965a1b2c7eac9071a4ac388145a9fc3d975c857859d3cc73574c65bf111ec3c8155ebec8a5d5452d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[244] aad = 436f756e742d323434 -ct = 15211da2711b3ffd8f4fd59500a7fa1e5e4bc96e1ecb874671e455ae30cd8d993ae61f7f2c741337dae98d3514 +ct = 6301deb287ffc74bf231704ad1a59aa60cb470953fa6bb7d0c03cf69fbc8c4fb89acd0162dff353756a73d6415 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[245] aad = 436f756e742d323435 -ct = ce742653b0a38f7c93e901f97379f074f875eec71299361ebf5cada487b9992d1e7cbb975ba8d5d44aab2d5854 +ct = 1921a34039e2579c8e86fbdc731449bcec690214d157f3f9c528102f19d228ca36e8eee061f733e0eb64bbdf50 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[246] aad = 436f756e742d323436 -ct = 83165d93c0178f0b4f73a46952457183421a3284b17d9d5a056c897b7021ce1cfe5295a44a6daec6da9a02e1e5 +ct = 4943f4dc007e9d1366cb4efbb5e71cb19e70ab4bd917f07770db6bb956c7bc00fef39fb5e7f1f5f0d116552147 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[247] aad = 436f756e742d323437 -ct = 816bcd488508d071fecb91b9a0c792b93461a1b6eea76728fc29cc1791f47b9043adde84e0af3e99acf72f7c95 +ct = d45b763713b7aa7d36da691a52a1a6edf128ba72397fd20d2ca59afaf6df53751f04c5879e9a4118298944110a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[248] aad = 436f756e742d323438 -ct = de13015f54f2d415dab8f63a47d8bd5799b169f1982b67b79890fccc187be7a1ebe08670e4ba6e61e98e4a353a +ct = abb4bfa463b825b00ce013d965cb8c232593819411ed494ee6087932d4c088f3c64b0e75585726dde1b28cf37d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[249] +aad = 436f756e742d323439 +ct = 17ca4cf2e6fe5ac0ffa1409a272e29766acbb73c3454be25eea8e3ceb5d3c00a37d9ff3b7400daa2039cee9d43 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[250] +aad = 436f756e742d323530 +ct = 8d73d3eac79d6462dfd82bc0f7a0a2532e2903a88259b3891a5622be390ccb882384557704ae7866fc623dfbcc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[251] +aad = 436f756e742d323531 +ct = 24262541ad0b43fb8f007debefe2d0493863fe5ed9c51080c6a08e5cf747a0ff2c203b2c8b22e4647a3de753d9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[252] +aad = 436f756e742d323532 +ct = 624fc58b855bda904dedecce0391e91b8cb2ff6e45f04f56311512b19de81337a6efa8685a33c36b5642fb7d65 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[253] +aad = 436f756e742d323533 +ct = 769ac35e2820405b0bf9b41d1390a57665230606cfd3e61aa4b3780fda6244b2c3671fac7e67cc2a727d671f3a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[254] +aad = 436f756e742d323534 +ct = 31aa9fc2c5276ddf3e045df4a3c471146e834a7e827988654843999f0d0c1507c77c57069dabcef90a286df87a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[255] +aad = 436f756e742d323535 +ct = 55d53d85fe4d9e1e97903101eab0b4865ef20cef28765a47f840ff99625b7d69dee927df1defa66a036fc58ff2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[256] +aad = 436f756e742d323536 +ct = 42fa248a0e67ccca688f2b1d13ba4ba84755acf764bd797c8f7ba3b9b1dc3330326f8d172fef6003c79ec72319 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# exports[0] +exporter_context = +L = 32 +exported_value = 28c70088017d70c896a8420f04702c5a321d9cbf0279fba899b59e51bac72c85 +# exports[1] +exporter_context = 00 +L = 32 +exported_value = 25dfc004b0892be1888c3914977aa9c9bbaf2c7471708a49e1195af48a6f29ce +# exports[2] +exporter_context = 54657374436f6e74657874 +L = 32 +exported_value = 5a0131813abc9a522cad678eb6bafaabc43389934adb8097d23c5ff68059eb64 + +mode = 0 +kdf_id = 1 +aead_id = 2 +info = 4f6465206f6e2061204772656369616e2055726e +skRm = 497b4502664cfea5d5af0b39934dac72242a74f8480451e1aee7d6a53320333d +skEm = 179d4b53b6365c45b600c4163b61d95cbc2f4d9e36f1695558dce265ab8bab11 +pkRm = 430f4b9859665145a6b1ba274024487bd66f03a2dd577d7753c68d7d7d00c00c +pkEm = 6c93e09869df3402d7bf231bf540fadd35cd56be14f97178f0954db94b7fc256 +# encryptions[0] +aad = 436f756e742d30 +ct = e5d84cd531cfb583096e7cfa9641bd3079cf3a91cda813c52deb5f512be9931980a41de125a925cdad859d5b7a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[1] +aad = 436f756e742d31 +ct = 2c43aff25343fdbff864506f0818b9d87df84ea01b1a2144d23b4d40c26bf655fdf197fe40297a8aebeed5cc2d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[2] +aad = 436f756e742d32 +ct = e0a8f2cf92ff61215edbb8c55dc31fe9e2eb42a5685867bb6854211542099f9e940c4b41c192bc390835b1a5f7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[3] +aad = 436f756e742d33 +ct = a8ea1deafbe4935d0d484a026301a339d4668c43c37f5e289bf758c7aeb3e2812d0321c12b71978855883420c0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[4] +aad = 436f756e742d34 +ct = 448a8892f261cbb6bf5b7b64a4fae8a2c86492494b069c10525895d871c27c2f12cd17e0588fedaba9f7b0cd4c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[5] +aad = 436f756e742d35 +ct = 97c746402aa3728594f8c4f217d1e4059dae56c5fb401025ff601a61da903f2706355685954b2fdd518b81ef79 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[6] +aad = 436f756e742d36 +ct = 91fe133508fe3fa6905ce19e6c8aba53994c168664088a2cd4300238236dcc90b5d2510d4315dfa8dc34bca821 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[7] +aad = 436f756e742d37 +ct = 641346e222a57bd4cf1f0e6a6039c77c1684e6d01c8983b568552d338f080f1bf22d022a5ae863e12191aebc7f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[8] +aad = 436f756e742d38 +ct = fc8446f5867c639c4c3f64079b2bee8987180b88e789a64297b91107886d739ec8f492e252bcdfb008cd6e061a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[9] +aad = 436f756e742d39 +ct = c21ce89d9947297e1de30d9a59c0815ff1508a8930f63a91d29ed89bf2a20029830728045cd54d8a00b06f3520 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[10] +aad = 436f756e742d3130 +ct = 8c26159d7fb4c50cf29b0fd2d005d9a04dd42402f8e4e1dc9e2dd7cd0cf807f5b5a230554127c85510f95d945f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[11] +aad = 436f756e742d3131 +ct = 75af5386f4a2d4a27dd20a490d1feb261dae8206a3201c02ab48ede53d2a92523a6105ab80bda1dbc1fe8e8deb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[12] +aad = 436f756e742d3132 +ct = 1c8873e7af703e1e8f8085ee385e694173c9fe2d66cbdec2bdce1b3ace52c13d0ff321b41d8ce95bdce73c38ba +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[13] +aad = 436f756e742d3133 +ct = 10ce2c23ffa22de0f547b33afa2f34552200ae764c65d2acf6a5366e4d2c6dbd6614d964574b97687963b93400 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[14] +aad = 436f756e742d3134 +ct = fb0e6d7705e829ab6509668862e65136cd0fd2cbe83a158c832ba630a2eceac6042019ec726aaee793961c663e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[15] +aad = 436f756e742d3135 +ct = 4bd36bb99b6035a3ccd5f41998b6d49d5562c72225ddbdc82e38d5be180e6b0e69abe68d12be85239a664ac672 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[16] +aad = 436f756e742d3136 +ct = 1a1916713004d3a90c8651e9781a759e63eb70bf1d74db5d3871e01f4664ea5241035f9a09c50c7c64b877a2ce +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[17] +aad = 436f756e742d3137 +ct = 510ffbb00d709b3ce27bea8b8202f2fad82632d6429992b4c0f71728bb3291f20f696c4d2abd942dc9a8960b39 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[18] +aad = 436f756e742d3138 +ct = 25695fc573d452c33f7bb8f61a30d1719c75637cef9bd9c11e4b48583d926fed3a31ecacf54bcdaf42d7927f98 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[19] +aad = 436f756e742d3139 +ct = 913948ede40a023565bfd70f5f47c37ba2506e09b22d4784374659c90da556d3ecdef17e89b8f749e266f11b46 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[20] +aad = 436f756e742d3230 +ct = 3fd6c17dba8dbb2a4a0a5cd99aa0f1288f0f5bb02b720243d6b7c1cc92621c1efd0dae437ca54a67e2b3127f76 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[21] +aad = 436f756e742d3231 +ct = a42358de18cb5495cff2729069fe0eb7996dbaf2138ec00f570107eca2a7c6950b9670b4ec66795de04685c2a7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[22] +aad = 436f756e742d3232 +ct = 18b1f565922a8e9d58959adcf3cb25a3a907d2adb69d71e19c09268f173157f569b1d4279c93f840d08b746b4a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[23] +aad = 436f756e742d3233 +ct = 34355c72a3581d4eacb5269e76f920a77242cf7525c8d734afe8921c87deaa0780ecf5998af6e5f84ecd689048 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[24] +aad = 436f756e742d3234 +ct = ca6ded0b04e98db9bf3e62a3cd5604678e805c3ea8a8c5c390b29977662a344791b443d0aba785bd8b9fec65dd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[25] +aad = 436f756e742d3235 +ct = d9065c203b0782caeb631af2ad08d685fe121033ba52b94608557bcfc8007adf68e2c77a4b6a475ce1171b70d5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[26] +aad = 436f756e742d3236 +ct = 27d600688c31400608c332d1af2bfadc89d22739e3cc06d6f0f1b356a61e214f5b0ddbf7caf47b71d2be8cefb1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[27] +aad = 436f756e742d3237 +ct = 9ed3e280b8605d721509cedbce556ee4429aeb48c0fcd400e30d21074ed902ce77589ac1f5d282ff1bddfa8cfc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[28] +aad = 436f756e742d3238 +ct = 3eb0855fa879f7dc8335b5d426a440f19acdc0fc721532304de51323464707643b40d54812599670936eed2208 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[29] +aad = 436f756e742d3239 +ct = fffd265116539bf8b564f012fe3ec3a9dfccd9a5b9dc4ad9e2964e794c764ed63a759dcdef61ad043f7588a11b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[30] +aad = 436f756e742d3330 +ct = 9e7fd0052e15aa19e46050a2661febaf6c5f326caa52dc439eef425662661388fb9a9be58ed989760a7494d3b1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[31] +aad = 436f756e742d3331 +ct = 3693b73981435ddc8b081186f7a7f06fb4a20eb7c39c147f6db5cddb47e2f29f60f909c4504b2b789ddfb8e40b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[32] +aad = 436f756e742d3332 +ct = 78fb4fbcb3de5bf9230fd0e41aab0b2899f331a4d806423d2a7cf91110b06ed76146a9b815fc0f5b1941d24de6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[33] +aad = 436f756e742d3333 +ct = 8030cb70867979059a6e5848feb3c25f7504458da998c831594371141c868715578f3a62ed71dff8aff1afa2c9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[34] +aad = 436f756e742d3334 +ct = 89488d044633eebb4a41f649bf3a5f1d17affd9d5d9baf5132c71f8ad057aea36fd31ff72fc78d6880444696f1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[35] +aad = 436f756e742d3335 +ct = 4ef51de05e1e02e6a15e30d313a8905ec12e35adb3fdc6ce79ae56dc348e1a636531fabf5e2c78962d492bc0f6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[36] +aad = 436f756e742d3336 +ct = 2242a8228e57ca15267e01abfe430f1d6e4aabada7e38f17f20df015657d81aa898d2291c631773628f8833e9d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[37] +aad = 436f756e742d3337 +ct = 8d71a286ec6f330462aebcfe15a2e3b3382eee9fd2e57123565bb1aeb319112e9e53418a2bd48d16f68a59ca5c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[38] +aad = 436f756e742d3338 +ct = 87e2b695e365860db3f4653bc16bbe0389dcf225838cfb1c480442899d38a204c474565039e3e120848257c1a3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[39] +aad = 436f756e742d3339 +ct = 86adae7eee8d06e9a8855672e7cb80276deba65f0b5d17e5e8ef0cf80189e69c62187605ec2329330264127063 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[40] +aad = 436f756e742d3430 +ct = ce603ee533d23f2f902aa82adf76c98a30d0c5865079840acc8ff62e7c774db66b3cb758137efd3134d790ec13 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[41] +aad = 436f756e742d3431 +ct = 904d3c71ad0a4f8d6a0f087fcd93059cc19da7c9983b59da32f83a614ffdd9cf65f0eb8bc2fe3ee64a4f5c4981 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[42] +aad = 436f756e742d3432 +ct = 71dfd30756f262628af5e5293a624eb219d2ef6d323d37096a2a94db6308e752f9659cba28d9072b71946d7868 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[43] +aad = 436f756e742d3433 +ct = 4f0d84759f83d02f49152f5852121e863ff3732bff98915799be5c8d5cfebfa2048ed83c0380888028f7dc081b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[44] +aad = 436f756e742d3434 +ct = dbb775112c824b1ff0689cb13ee056d84615d7c0604de71a825bf6998c41623d66124e7b871c7fc2ad4887ecda +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[45] +aad = 436f756e742d3435 +ct = db01d24f44d167d78a9bff68828aa4340f99ff89e045476c4e918438801a02bfae77ad4161c298d958702535e9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[46] +aad = 436f756e742d3436 +ct = 59ae01cfcc784d69f25c005e9dec4b7f74bc05f284166ed5a056918eae0d9e1a83fd028a52f9e6dc6ded369941 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[47] +aad = 436f756e742d3437 +ct = 8a5e074f9f14ffcaead4aaf599a97a8dd791c44833bd6676a09b7b87e29f1237ee926550d80a44378f025f650f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[48] +aad = 436f756e742d3438 +ct = c86b3b47535fd4c11610a1830a2847c6f7c7338d96656f8d04453edd1f5842af3397c6f762bbb39d4730f043fa +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[49] +aad = 436f756e742d3439 +ct = 053e3ec87d82425c627ed4c2d84ada5cc0b5253d6ae1cfbacff5c78f377f3c09ac89257d551772f6d2e053b344 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[50] +aad = 436f756e742d3530 +ct = 73a145c830aee75e0fea9e3c7bfa24c9a5b1c0602683a5502fc83dc4a087e0a9c9b142dccdbd3205fa22cad268 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[51] +aad = 436f756e742d3531 +ct = 98d8fb2a4bf5f772880010e4cdfdd992360189f45fe418f3736255423e60657a2a01c3e60b54d3efa932d090c5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[52] +aad = 436f756e742d3532 +ct = b8abe4d887990e1e527a8b7c2ffd661dd4b65c618d7afe742281bddcb39c8be07c143b061bc607b4a8f41a3fd5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[53] +aad = 436f756e742d3533 +ct = 1090be42c502b75570c25a9b74777a4f3c981992156a9dae81c1f3a637c388ad55a42782f3785eda7fc00ed9bb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[54] +aad = 436f756e742d3534 +ct = 2ed5cd3dd937bcc54bc8193cd81420350e5a94f233bf52428dade8033de59a4bd0d461c7680fee19d3eaa49790 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[55] +aad = 436f756e742d3535 +ct = da16bc9c2b04ac234af1d2bbd11bb4bbfe6b32864e7381ac73604b2a870e7b8aaf10b128d8ca39b4e3f0ece26b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[56] +aad = 436f756e742d3536 +ct = f0d9acf36f857f86e02b06348e94d0fed7fb010d4e6365177ceba970c1a17e7f472240dbc585ee0cb137cd3b70 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[57] +aad = 436f756e742d3537 +ct = 32199e20199904c07595fc6e9307022a0548f8f56ccf664497b840ca50176a05c72469c3231e4220544114054a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[58] +aad = 436f756e742d3538 +ct = 257884a96d90d927de623709a39cb34a5981007676ba96b2e1e4e3ff7dfc499acb265dbb4e1812428d5ae31514 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[59] +aad = 436f756e742d3539 +ct = 6e37fd96cc41de256d9363d9eb27868304ed5d979da469fcac98b4509719b10a8ed0c205abb05c7d2c9afb34bb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[60] +aad = 436f756e742d3630 +ct = 7bfb5b966d1a92d893c0bc4ac5526a8a104ad929053d09481538b731c3e164ec46b4a6e6849ff1b6f732f3109f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[61] +aad = 436f756e742d3631 +ct = 8a70b13706ba38fb0b279449984a4df5203c05d242bd7e6af70c9e96cb556abd9088f8e9b28121d050ed74908d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[62] +aad = 436f756e742d3632 +ct = 44dd0d86d69344f086f4bbc3b75f04b1a5eade98e4d22ff130a28b4f0c60f7db23fe2c30c3e2f8269719b57dc1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[63] +aad = 436f756e742d3633 +ct = 946181d28098f47928bef7199f777dd0d2653f08c326bfd10090b47bcd294735dca636428bad26d0c186ff56dc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[64] +aad = 436f756e742d3634 +ct = e080406e00c83bed2e94537263727d65ce99534cad2279dbf119eeb614cc5ba0b9103b7497fddd7b149579bad1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[65] +aad = 436f756e742d3635 +ct = a86551ee5f2b9cced52e1fe1cca9a8f7e63065515787ea7f4f9f4ff51bbd7698a79bfb853913c96fd714694b8e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[66] +aad = 436f756e742d3636 +ct = f450c832f51334c08e08461d087ea1d3b475ea1964e3075e41b227a57b6f8cf2b9ea8838d54784d0c533d5b5c8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[67] +aad = 436f756e742d3637 +ct = c25e6034c2c2283f5b8e6b7f659ee33eeaf3401ef43a81dc3d8ffbb9e7a32370311ceeba97c6a6287d3786321e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[68] +aad = 436f756e742d3638 +ct = 5c30e2053f7f1501eb430edccca9cbc90f01b03200ece329b232fe0a4a9baf418adf846d402c2443fbd72aa360 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[69] +aad = 436f756e742d3639 +ct = 9df08200e50ce71aaa016d6f18768803a8bfd20ad405345f4cbe60cb28164eb897e5ad2675c90595d0df83b662 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[70] +aad = 436f756e742d3730 +ct = 56fb1c4a86f4642fe820f60b440e59be913ab632de2027defee6161e627ebd78fd30a606f119070460cba0aacd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[71] +aad = 436f756e742d3731 +ct = a8163438d8ea48dfdaa8ee0286efb83747796263c11e97cf910f8b56adef3f6bcc12c2aa885323d641985116ee +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[72] +aad = 436f756e742d3732 +ct = 10a66fd85dee2f3179efe704174f2fa4fdf0dc3839c6ba06a39f947dcd9422a32fb5b7df5d6a467bb0c5035d32 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[73] +aad = 436f756e742d3733 +ct = 50384f9efe0ae3adb9c834114862e989995ce080f353f0727c4ab2d41911755d154b4eb0a693b0e72124c465b4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[74] +aad = 436f756e742d3734 +ct = f74ad7b18fee3ca88f91c653102e6b877e1f8ceb73a3a5bd44323ba5194ac722e87e0656121001c39653bf2822 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[75] +aad = 436f756e742d3735 +ct = 3d0b638910c26c035444b494342b5059eaa485d51d49a7526bf5a76cf18ce92be1e88922f1ba27db8f29a3bc17 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[76] +aad = 436f756e742d3736 +ct = 4d17c2da2c4688c5ae15be76b2fedab1d677065ea79a452f3cd01c12926ef4991cbe8be7e7e5e69cf2666121d6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[77] +aad = 436f756e742d3737 +ct = 7aa7ebe84cf4c35dccf15682fdca996164f1ec056455ace8b9544b9c1b1571b8bcfc104fc5e91f5d68d7738707 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[78] +aad = 436f756e742d3738 +ct = c8300629a6cac3b1a7b408bb50e503191cbb79f102256d0bf3f25e33af30ae12e430af1bc9e44753a0e25a824e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[79] +aad = 436f756e742d3739 +ct = 37c428339a389e8ce35daa03a99f5c07fbeebdcfc3e695434f2eaff8f90cae8902fef683e2ad238f2ba037b5a5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[80] +aad = 436f756e742d3830 +ct = 39e65faf2c41d0bfeeceb28699042b62e976fbc3836e6a8a41ce5a5a85f9c428887792f725baf7ac68db824c9b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[81] +aad = 436f756e742d3831 +ct = 0a478a818d4fc9da07c90487cef008949818fcaeeb5c1cc83f45d487321fd491ad58aa1863c4a5bb75e9db1b66 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[82] +aad = 436f756e742d3832 +ct = 32cf849851e83b92db5eccef5ad9464af0133d588fb0ecdc4a43ef0c03b1dad9889d673900e95c7e0051035426 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[83] +aad = 436f756e742d3833 +ct = ba1e5814a83a84dada756914f38e7069718ce13e97442003ee37bcdfcb54032f8cc3e50bec78c2b8c2e6402d65 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[84] +aad = 436f756e742d3834 +ct = 3b91fac4f67af1a93f5ee312fe5c39bfa915a2317c2268b594e363d368d9df09022468a5719a3cc91d07f3c36f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[85] +aad = 436f756e742d3835 +ct = 5888dab7e84869c9ad8d5a80db2e89da750780da4e3fd59f317c4440ab2ade53aa855254f534e8abf7b030e1ba +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[86] +aad = 436f756e742d3836 +ct = 9f8d979e4c9965a2e135e0e85849e8e51cb9edf27c5a48713c0342f78c6eb42f89c246884f42b925d508ac1118 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[87] +aad = 436f756e742d3837 +ct = 1a3fe6ad4387133e6dde596102384e034984b26ea9c2518690e43bfcbba241b8991b1fc22f5301f50a6c067b18 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[88] +aad = 436f756e742d3838 +ct = 35ec707cfbebcd8d29a94b2a53279f06d6dad1d67a85d26515b33805cbe9c8054de90590d90ecfa2e75b319426 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[89] +aad = 436f756e742d3839 +ct = 98b90ba87c954ef7a61833679d2d9634cf6c9e0e2bd346b9240cfee3cae141f3bb886ebc195019bf61ea174fd2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[90] +aad = 436f756e742d3930 +ct = 29d4773ca7566d5e9e32701d6c46c70111d615f150663e76c62c8afbf3cde30395b424530e71fdcd91abad8235 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[91] +aad = 436f756e742d3931 +ct = a3ddd151493934a6d056bfb33c3cdfb872204b2e40494b2c12c298aa2443563eba9baa7a984b4627a1aef12b35 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[92] +aad = 436f756e742d3932 +ct = 97fee29b1aecb67490fa440db94e8edb9d44da3db59466700235cd0613bd7f385621ef78bbd1a61207f61d58d7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[93] +aad = 436f756e742d3933 +ct = bcf3f399b75f170a59b61b5a8e381f1254d4599bfaf906ec035aaa89b862616163b32c0078ee65f57e372921c9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[94] +aad = 436f756e742d3934 +ct = b4fb4b40243ff48b3af21b81f86742faf71e9a2006c0dada26824262d3fddc428575c2b3fdebf84f777e6ea7b8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[95] +aad = 436f756e742d3935 +ct = 3e4774d43410c80bdd17e94276dc4c9e593dfe1be6e7e512fb0ec7e8321f0825ae52cec95ec88e0a73cee34632 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[96] +aad = 436f756e742d3936 +ct = 149628f5c0a0c7a83a255124b93bae9acb5566caf56e2a44d425a045f5de8d8b99fdb859853195048e9a2c6838 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[97] +aad = 436f756e742d3937 +ct = 23353f67794a1ab146b07737c42dcbaf16fe80f5fe275808900ba8b64f7c277710f99887617c315749db003750 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[98] +aad = 436f756e742d3938 +ct = 7f682e36cd661cd0604d0d161b6747c9116fb2155698a880390b170c95a1a4ac56281296c3f92b643a43bd7bbb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[99] +aad = 436f756e742d3939 +ct = 5060bd31673101670052d60db668ba50e577282f2d04ac7f55a968df8f1e656f3e54c042bc376dff57881449f2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[100] +aad = 436f756e742d313030 +ct = a1a9e8eba75c2d5492de5ac21b96067d86db723ca40446043d6b518ed99e546adc70e872b389c8b252f968ecca +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[101] +aad = 436f756e742d313031 +ct = 265c2fd6d576240fedc1e9d2e54ea85d4c6f948ccae75dbdf5131ab9e34e6b7c546fcd2799fd70bbbd80f4a403 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[102] +aad = 436f756e742d313032 +ct = e5cd249047639b55351adec7054b4bad49ba504dfd012c24e6664b174aa7a96a8f43e3e74c24c72a2084a30f54 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[103] +aad = 436f756e742d313033 +ct = 718f45fba90a6d7fe762a963a3afddd422bcfb69b4d67f68a07f0963542d11a9f93fa7becbe1467a6d4ba2bd59 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[104] +aad = 436f756e742d313034 +ct = 83317a03f6e6f5c8a70c2ab5a13e594f71de479e37041bb665f2f7a1222cf3f989dba32842bcbc2e9d104eeb6b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[105] +aad = 436f756e742d313035 +ct = abb06a322a83405b85f2921f0faa10d142e7957cf39c0f61efe8d4ef7aa408dee8af86032f3c16a2e103753a75 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[106] +aad = 436f756e742d313036 +ct = 1846787cb992d807a28985c645ab2752cec1059250224f49da67cec65ff51d9ea1edaf496c1e35d74a39746296 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[107] +aad = 436f756e742d313037 +ct = 5c272f93edda401fb918c03179478563bf812a7012faf8662002e4e8d0c45b4faf1f8f1345b3cf93efbf0c3590 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[108] +aad = 436f756e742d313038 +ct = b93b55d7382c44f03f7d5c376fb325f009ffa705b785922525f83d81226259cbf27d5cd1d5657eb18ab49c8f57 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[109] +aad = 436f756e742d313039 +ct = 78f36217e54bba52f594bb8f0ea26e189abb484421b838e983d5432151f5ee702310a7da43b3f3477b6446e42a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[110] +aad = 436f756e742d313130 +ct = 98b9e8dd6a2e8dc8e2011ce879b160554365afb06bc62db992131c2ca3ccc83d83aac8157816921da8cd54933e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[111] +aad = 436f756e742d313131 +ct = 4cf48574b0986e1b19c19af1254c62403ba242ca7e379407095bffa6e65baae539bb9fcbcab8a915d3c633013c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[112] +aad = 436f756e742d313132 +ct = 94da1edb651a79419cb2c0ea1a89c14fa3a725335e3b3b10b71e97eca026526c9d61669ddef6fd5f71f15fb930 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[113] +aad = 436f756e742d313133 +ct = aba2968f77b8170707f3b7affa945289ea56986a10070956efcbb48b6512e22f960f7a07e05c77d5debd69daef +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[114] +aad = 436f756e742d313134 +ct = 258e1acdaa6c7ba5e31bc1098ca42d844531b0039c399e05fac4c0c22a75fd4e308b288a24127334fdb1900b0c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[115] +aad = 436f756e742d313135 +ct = 6a6d65cf15054487bc8f4840b86d3de127c1a90080051cb0242f4b730d4a526659a7c059fafb0a83d937d62e48 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[116] +aad = 436f756e742d313136 +ct = b8bf351fbdabc9a5c4843b6ababef5ca9faf95868cec99c04d1d555e615005dffc6ad3e4eb84cf7379242575ec +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[117] +aad = 436f756e742d313137 +ct = 5a042d64ab6da7841bfe83766b66d10c272ee4dd3b9cf9bad9d8980f8b1d191e495ecedd6b28444bb6431c0457 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[118] +aad = 436f756e742d313138 +ct = 7198f5b0e7d9a041570522a57cfa5db3d488504339762fdba72e1593e164a7df5316c674a592c064cddc9a6c05 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[119] +aad = 436f756e742d313139 +ct = fed6055b80361e2493dbcc48b658a35afaf6247ac4532063fa5812f10b7e4f259d557bac0f049b1b88577dd67e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[120] +aad = 436f756e742d313230 +ct = f6b7aaadedcdc89ef9147b3817494a3f43107e756990c415d4a2270312b0e257b756c0f1ba929ec722850fd762 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[121] +aad = 436f756e742d313231 +ct = d4ea7ff429ccd38d86a3a35f1a86de748cd1c3fee83e7c85dc5e52bc5134dba53d4c85368733037a3845b1f8de +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[122] +aad = 436f756e742d313232 +ct = 86771ccb6999dc2085ed073c6f0216cfd8a84347456e7e411753a70b20389ca84f25968d4bcf3687b8250d2048 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[123] +aad = 436f756e742d313233 +ct = 76196c59dd912a7fdf3da785b02edb0669830f23a40b23364d9a8417c25a44747eebf5f02173bf254bb6535451 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[124] +aad = 436f756e742d313234 +ct = 6e5b768c7965f3292010ca206f966c30f1dd1c1faff520df04114442072c3890ae5bf14295eaf7cf8aa57330d7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[125] +aad = 436f756e742d313235 +ct = 7547da149fc7eb27d904143355133e920beb405a8c245e5ca8e418297f09cb96aae615d24661f834e7dffcb018 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[126] +aad = 436f756e742d313236 +ct = ebe8030330f423a2324eb863310d1c13c62ff7894c1495a0d31709ec1fe567e62954fdccac05064c412ac00409 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[127] +aad = 436f756e742d313237 +ct = 99f8286c7921b46fc90023361caa5b4b2e0c3d3b71b65de596876eb70a2211d89b4a90acc225b24954224919b1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[128] +aad = 436f756e742d313238 +ct = b9b31bc2dafa1c31154322fe4d23b5f130cdc8f6c92da9ccc937503f4173d5cbc6df18d7847b77aeaa11be32da +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[129] +aad = 436f756e742d313239 +ct = cfa6ab15f19877c4c030522077c18d442d1cf220c1b021e4a5fa45d14e66044ef18d894360237281b55745d10b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[130] +aad = 436f756e742d313330 +ct = 46dda78d75d4beb46b6e79c68abf242895d072602ff0984d22ba95281652a55a26d5a3209177bd0b78f80b6565 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[131] +aad = 436f756e742d313331 +ct = ac8ddded913db97734636b351b65a3a7ec32de7c95f9c2f7ea2ce186a9cf39fdc6734d9d33631ff7b679047da7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[132] +aad = 436f756e742d313332 +ct = 5a63fd958d7da5229b2ff04155cf5eaad8af24292de1b6f23dbc1a6c8b717c373171ff46e9aa6ccc87cc38739b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[133] +aad = 436f756e742d313333 +ct = c3de57f22a0ef3147b395ad8dd1b920e6e331fe19ffc4a4436cb0587ee1f9fdff890ff1a02fb9ab220594b7f9d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[134] +aad = 436f756e742d313334 +ct = ec42e72f0a8f228508141998a0007f59bf281a9a3648812ac0f53af320375a0abe4ccaa73712ab9de8b2cf8327 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[135] +aad = 436f756e742d313335 +ct = a8ef6cd778dcbb82e48217e77e132aaaf3434370527978fc6d68df1aadb1f6b1f534b9aa58e993044871cb7d71 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[136] +aad = 436f756e742d313336 +ct = 59b52a68e18b64aaeec537a113586ca56f94190b4c8fc0074febe8238606534228854d2fd45f734ae726fe0b3a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[137] +aad = 436f756e742d313337 +ct = 595214d9c7033b1790e9ae70b739332711baa4e199f5457bc72c033661b559c0f1c3802bc96c63953b9e2eb5e9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[138] +aad = 436f756e742d313338 +ct = f7970241897e25ef6c4fcb0224e5bcfb2cda3715c9baee3b3267c7b199c82459a2a95ac9c767d90d91962bde9f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[139] +aad = 436f756e742d313339 +ct = 7569b68ca4ff6436c0a9e68b289ecb0d9eda9a1a60a3934ce13a92f57004a4b41e69a75c3d2a29cd2c929f5ff9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[140] +aad = 436f756e742d313430 +ct = 1ed5e8fb578f67d31a061ce5853710851c98b8b61765f76299711d2e763af33ddb9eddfd537bb4b967e47d9260 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[141] +aad = 436f756e742d313431 +ct = 92ce89e443024b7a80b61d1f58d638cec095d7d4664e8549e51aba582d219fc1dc5083cc1021b441560f58bc03 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[142] +aad = 436f756e742d313432 +ct = 17103f6d8cb385452457040307ce7bc8f18705c9333ab51867f6cf62e51f76cf703b69b32e209c64e8777b05de +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[143] +aad = 436f756e742d313433 +ct = 6441c689667add0ed50eeedc0dd5c487aed506f2f360e768b7937f3d06b0b43c2c3f9d9c883d105e7c97d050e2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[144] +aad = 436f756e742d313434 +ct = 1848f52015c0b917d755528d3d0ff70574ebbec2271d4c5c672a93caf37dc87695848b79b9f3caaf8937585296 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[145] +aad = 436f756e742d313435 +ct = 71795a914c78062acef28a7e6326c106dae40f564c73fb63d9f52a0522954caf5f3d8b59406c1e4c4efb4e78c6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[146] +aad = 436f756e742d313436 +ct = 18b51007114b30a1ddf14efd7297ecc0a8ad9626408ed9c6bdd22676d9aa0c11aa3f0cdc525180d47b1fc2803e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[147] +aad = 436f756e742d313437 +ct = 1cf6954862fe38be7871d362a3836ced64dcbf2ff114ccddcb6f248a24446505f73cef228f1217647d3e70d7d0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[148] +aad = 436f756e742d313438 +ct = 41cbb2064d9db9f43e9fb550a057b07bf90925ff28df85dcc01e11e2160749e3a4003df7693baf73315d3052e0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[149] +aad = 436f756e742d313439 +ct = 099e43c3d5305e2294566ac688e4a4c716f3b81373e941b6d28320c4f48acf9c8bf4f3bc32e59ee4931fadae79 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[150] +aad = 436f756e742d313530 +ct = 4f27075c65c4768779f33847f720f635de15d5074d3593391936e4f0db79abf016e548781313176bb83afd544e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[151] +aad = 436f756e742d313531 +ct = b49d1947610dc84a71bec3407420f4351d74a6f97dc59cdbaa4063de82998480ac8d8576100f8fc1dec8fd0415 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[152] +aad = 436f756e742d313532 +ct = 0452a34aad9eb57de1748b18570ee94d88d2b123cbde141525e53fad8da5e95fadc36d533d9ff158eaadddaedf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[153] +aad = 436f756e742d313533 +ct = 4034b6231f8e1809c54bf4d394cc05104fd223357e95a60597c7df32d2d1b69e0b78adebc088b4364970c9088b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[154] +aad = 436f756e742d313534 +ct = f2cb80c67d9226f131dbd64963e27ca64e428e8f64c2c193c3798e2af548a4bf5d0b64d0e9a5105bea4340e40f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[155] +aad = 436f756e742d313535 +ct = e4be8d8aeb13fad3db0e7d266e89ee5ab7e3c861bdff61776d6356e786787e14e6d1328bcea2001cc48a013425 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[156] +aad = 436f756e742d313536 +ct = c1084bd11719f15b3194ae5f84d278efe6a962c0b5f16123cbde523ff7ed2eb88d91293c22e3ad9683f5dfaf69 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[157] +aad = 436f756e742d313537 +ct = 91e9c1582a12184b4fbf796a81ae583f865a2170bb09f2ca46121824f19dfc7944044d533c046ad093f7eb820e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[158] +aad = 436f756e742d313538 +ct = 8e4fecf7a15fc3b258900b55adad4aeb1386c6486193e4d3fda60fcb255635266791eca1cd76fc20b411955210 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[159] +aad = 436f756e742d313539 +ct = 671e011d0e3c57f73508f885c64dab5124a4283a9430168033f11ec0f1aaeafb7da3224a62264d2013baf4cf72 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[160] +aad = 436f756e742d313630 +ct = 8d27e076edbcba9f6a9e58b62914463dfa5bfba6f419807d6664659230a947e069756098429285b590acc89927 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[161] +aad = 436f756e742d313631 +ct = 7ed3247399afa43f2e3db2697f9e37e94f71d4d210e2ba4f3896eb62bed1308df32e5a63a16c7915538ce7463a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[162] +aad = 436f756e742d313632 +ct = 535bc957326207f14417a5c79dfa28103f488169039d81986319c0d54ec72ee23b8154b26bfa9e1e6941bab038 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[163] +aad = 436f756e742d313633 +ct = b7a029e3486549bdb19fb063eae5ac28c646929b1f195f6f1bbdf9f99a65214e923d9bb03cf19f17765c62befe +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[164] +aad = 436f756e742d313634 +ct = 11c717389193120fa6b61d9fdbfc74ec17309d744c1fd6e0d49393a5c32665c0b70a0a64916ae4a02d020762d2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[165] +aad = 436f756e742d313635 +ct = 45a5fc34bb9062b93a34063f009778d4bcc3af74a69152087db014bd88eed080c06cadcf1efd41b31a9bd9a65f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[166] +aad = 436f756e742d313636 +ct = 2ed43cae3a8299d0ee9caf4297b330ff643066d71af8465cc19a834bbb953343a7e165f646eee638ab0485b903 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[167] +aad = 436f756e742d313637 +ct = b42058802b285612ffc4c9660931a282125eaf820c116659672ea4cf4e901f9aa9c496ed515d6fed6cd72930bb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[168] +aad = 436f756e742d313638 +ct = a5cda906160fc86a45c80cb2b51c07a0a1308626426bda2cb6b2e15aa5d650b6f59a97b503ef046c88f643e0cf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[169] +aad = 436f756e742d313639 +ct = 3c0656ff6ad0c678d1ab7f1c49118191a475882c66b9a771a9570e1b19a7bafe0e2e2b55f0d17a4d054d175516 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[170] +aad = 436f756e742d313730 +ct = 75c7b335e15e94bda0851db69e35f108fc233a545da4b928ad14461e269694d8820956fafb4e44720ce8381507 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[171] +aad = 436f756e742d313731 +ct = d3d4208c7bca3519228b580237ddf552c0f479fd621b5751d797cd1d973f62702e1ddc2d743ddea6a14810981a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[172] +aad = 436f756e742d313732 +ct = bd8072b89e773e49b1ea161dc308c1f47e0ba2900eeb8969feae8c69ede105660b348d2a6ab5251e192812a704 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[173] +aad = 436f756e742d313733 +ct = 802ba6104adc7ec67dc96bad11d1540c37c7d09a1d8e588e9d037a559aeb8bcccf00199e002dd1b51e38346d01 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[174] +aad = 436f756e742d313734 +ct = 170693138046e54de3f940047bc9c083905bd0d5f66ce4a21b447e8671662ebc13ee7cad4d0710fc453fd18c44 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[175] +aad = 436f756e742d313735 +ct = fe66bc839bcc84b49b7b2f74bc79f6b6d66d081b431a9f875738ec99278da15f562636f26a3305c06ff0ac1dd7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[176] +aad = 436f756e742d313736 +ct = 68387b231332367d7c8b6d57bd2053c79158bd8b364001f0ad10c2687266df9c2339179d7278db2c9b6a0a378c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[177] +aad = 436f756e742d313737 +ct = 5c15441304b8c28780c052b3354b85f05985dc83ffb718e4b680bd0fb1c052aa5741370ae14ced0dfb94d80fe8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[178] +aad = 436f756e742d313738 +ct = a5b93d9b53f0134eb135abac39506ebde71368021255ad77964ba92095b370ca6bc1887266746f2f24a1ac68cd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[179] +aad = 436f756e742d313739 +ct = bc646bd2d4af6cb3eeefec80d906ef332716d228ebc473fd543c51fd4c626ebd9a9ca3c5379fc935748b302fe3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[180] +aad = 436f756e742d313830 +ct = baa95961ad3798f5ea49f68c7bd46a47f1e1b1f4c4410aaa23ffd29b539257dc6a519bfbdc12f48c2dd44f41b8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[181] +aad = 436f756e742d313831 +ct = 63350bfe96ec394c5df26cfec536c1e13c36f11366dada5c7fbc87c7a77824d3aef9f68420edcc90dba8840e8f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[182] +aad = 436f756e742d313832 +ct = 2aa46f85e84cd57b484eaafb542af4fc5be63a3cf0517924311c5014754cd28ed4aa3a7c6ace995369a121d919 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[183] +aad = 436f756e742d313833 +ct = 7125de9a7ab93363e12742330ab38a0afc493cacd21fac7dfd8d6650b58088e5441b4612957290bd81bd9b51a5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[184] +aad = 436f756e742d313834 +ct = 99e607edbe8020e3d501f2d861864c65c0f3c7017f73a5ffe4a13f55bf5576848f3c74982cc59b599b10f5d16a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[185] +aad = 436f756e742d313835 +ct = 327928bae37c3ec8e3013157520df8a40fc82e554b8ab673f0785aa30ad582b3d5c16214668a9c02b8a3305996 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[186] +aad = 436f756e742d313836 +ct = 970a798ffbc3d26f2d8d937ddfe93944b9b0a8ef5b5090cc2050c9e1cfa24ae8c9e383b5443b6b06498bfb4576 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[187] +aad = 436f756e742d313837 +ct = f9888faf2641b1cf17a32a2f1be9ebed7461bf164bef4d66f925d97aaa29890011dc5d32b1662a46e56422ad4b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[188] +aad = 436f756e742d313838 +ct = c4b3edf0d1f37509c2571d4b5862f59b2ebe75c53553fec09fd4331db9e968beb517f1c48a2e1025a13d0849de +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[189] +aad = 436f756e742d313839 +ct = 128a7f7e9f4840e993df22c6a27fe71ce85ea48e30e09cba1d61ed2a4ace07cbc6d498e10909b581a548facb53 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[190] +aad = 436f756e742d313930 +ct = 640183b2b366539114dd437cc52c7e11ace537522dc32513d28a72306a0859bfbb57e88f0ed282c328b2811575 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[191] +aad = 436f756e742d313931 +ct = 737920941a5416463d091bb39cc88fb9a8777946b3d491d74f873149c121a680f61bac1644fbbbf4e4e084615d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[192] +aad = 436f756e742d313932 +ct = ee533361a9075cbd1ae3448b865d16d540869e232beb3e7b7fcf0982baea5d4a7634b9ea2bf3a768da75d7bf62 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[193] +aad = 436f756e742d313933 +ct = 94be547dd7acb0e06fcf9699e4e0417b08da4248b09d2344ec5a3f3740cb6df8a2e73cb7d1f586e2bf81fbe01a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[194] +aad = 436f756e742d313934 +ct = 595ad5462e873d7289b871482889242cc322d57e840a826164fea4b240c18a951464d27444a5672cf0339cdecd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[195] +aad = 436f756e742d313935 +ct = 88fddd9846559b1e0165e961bf90d9320b8846406353174667f03d667e90da202b5dce27a32cfd2c4288e80cdf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[196] +aad = 436f756e742d313936 +ct = d0b40335e694ecf36a1c628c215f8d1e59fdea2ec54d1997a7784c519440c58bf1cb2cef6f1787b84f75182726 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[197] +aad = 436f756e742d313937 +ct = 3e7e536627f6b2bff437b7c3147e19b40a779ef2f9d46d0be7aa086dc462301398e912b268cfe8ac174535ddeb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[198] +aad = 436f756e742d313938 +ct = 61919626cf4fdcb05b3994b2b4f1cff36cde151621afbccbacf5cd30371328023548debe410f5fd510de7b3f8d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[199] +aad = 436f756e742d313939 +ct = 5cda7630909f65f1639d17ee1bf9af32a154e07a09d5ec0cd6d980b2246420ac3a713f64b747325ff98ffbccff +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[200] +aad = 436f756e742d323030 +ct = 93a81809a5c145a51792f16fff011cda42b7955c15f8005eaac4b5a2c69edd7c6a30e4007a9d7a28eb4c916f91 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[201] +aad = 436f756e742d323031 +ct = a3be48ca8ad70c6dd6b2763088cdd9ec7fce54535369fa711895e938ef40b634d765976e74997bd6ce3334d691 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[202] +aad = 436f756e742d323032 +ct = 3f060c4ebcf65552febaa5301832a124ac261aab14cb4987abe467712948466ef42a819442e857a7ed2d406a04 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[203] +aad = 436f756e742d323033 +ct = ec45590afff57643dc270647f6932475fdedd8c94c13c7834c44d0f80b48f409fc311063140819518fee6274a3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[204] +aad = 436f756e742d323034 +ct = 157c4157c5f1afaa789e304c096b751c3ac0174264696238dc614c0872ce6259261613938c14757173966fa5f4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[205] +aad = 436f756e742d323035 +ct = df36b86290c7ba0b99f6b9ac4489d570af4941296ffb352cf0a2caec11e9edadcb61391e381763a3f89055f1b1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[206] +aad = 436f756e742d323036 +ct = 4ab902188cd8040ba6c4d325cbde2161e672e996f2431af34a94bc89be127ea99278e896082847c11029c94cd1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[207] +aad = 436f756e742d323037 +ct = ecdbd21be32fae547cfa7fb4d665f3038b5ef47383b349700f53fa37808f9f971c4e6f2c686dbead494695037e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[208] +aad = 436f756e742d323038 +ct = e4721d14e172cd2db536535a8452a247a60642a7645f56b30b2c920433f082a111e798d644e764eae231b9e36d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[209] +aad = 436f756e742d323039 +ct = beb673981c54566d15239a625e70beb02dbe9ad49782a9589c6dda7db3409ec9b0fd5485b2b9ca89f51ad2ba92 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[210] +aad = 436f756e742d323130 +ct = e2b02be0b2a8b327c7a83d4c276e7fd9f8ebdee2e951113bf0622f2d1b52566d0b5fcd582b8f11f2891206e439 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[211] +aad = 436f756e742d323131 +ct = 33ae0f52a3cef337a7286ae47e4f2939c18435135f3f93794507db9fb4d779a4af607683a3f837d6f175570ea4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[212] +aad = 436f756e742d323132 +ct = 7bbfc9c9e8a4b2781f1dfcc48c3a6d9e66ec91e39348a458736681d7cee6fef84102da9bab48aa3fbd295b129f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[213] +aad = 436f756e742d323133 +ct = 951bc3e3f3a302eff4cfb7989a6508ffd2bd69223d9b962a4c68cf04d209e37b056f92c4ff96e41b60e411fdda +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[214] +aad = 436f756e742d323134 +ct = 031ffc754d54a488cb7bf4577e840b9257d81ea3605e2b1fed1c4d83ddc76ad7ec76d3cc2587636287bdd15423 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[215] +aad = 436f756e742d323135 +ct = 7a88f024350986aed407259173cc4f1672ac1b0e4d29584c3bf4c717ca48e9d835ba99cafcc0ba9428368df5cc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[216] +aad = 436f756e742d323136 +ct = ca06ec3e337014731f122f8db788f765083be95cb6abe2e9827d521f63a71932a304fc8f452611c02bdc8ae83f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[217] +aad = 436f756e742d323137 +ct = 44571995fbbcc50754e9858f45f81f9fda89f862de946f55f6def93c0703486a59675a28df6616057aa2962bb2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[218] +aad = 436f756e742d323138 +ct = 2eb20f3269a93720f615d25f908c9678dd1249646211eab665b4e15ab84661fd737f32d4c319d2bca171bc33c3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[219] +aad = 436f756e742d323139 +ct = 9db897191dba0aeace4709846d28d905933e576d8d19f64cb26cff759608eaa308752db430c41e6c1c13b51878 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[220] +aad = 436f756e742d323230 +ct = 132911b40ea785d6becddf35b68c8edb4ce3bf81eb982bbe6e93bbd500c7804a62d66ed3e17ba1677e5f19693c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[221] +aad = 436f756e742d323231 +ct = c0c3cb5727eae2624429233d3864007cffed7e839777a25d15dc3d46ac06dbd89004059e01a346feb05c1c81c7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[222] +aad = 436f756e742d323232 +ct = f5d86b3e4a39ab7317273283244422d0a764f897b6b91ae8faebe925fd1ba2a15bd980e066dbebef574c894a92 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[223] +aad = 436f756e742d323233 +ct = 681295d554e5f657c02531e84309c96abdce3ff58fabc8f969234e5f5e4c6726c51be58218063cf086abcf5983 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[224] +aad = 436f756e742d323234 +ct = c61b1a3724c8d67195ce45c0bd59886fd9b12c43f76379fb9c99d528bb8165ad41017f1dac1e26937e84c8adb9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[225] +aad = 436f756e742d323235 +ct = 5aab74d6eea92c635d2c751530d2f0361a8684a515a475277bfaaf5fbef1a2171a33c34a90302807c701d56790 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[226] +aad = 436f756e742d323236 +ct = 7b998eed5008fa6295b94dac34ce9ec60faa1c4608d013cfa014aa3a96ea6687a106dde3657825e63440dac506 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[227] +aad = 436f756e742d323237 +ct = 956ad989000458007af0b41eb2fb5a716db1b095594821fc305ee35ea27b41b2476880db3b4c86bc60c4394d05 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[228] +aad = 436f756e742d323238 +ct = 21de030f4aa7fcb8650847deea5ab6a2934f2e0c1c5d592320a3933bd6054d6ab8498aaa4afd84592577f5982c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[229] +aad = 436f756e742d323239 +ct = 09ebbc42714876507032d57cd75862b36e37c258a60381c2eacd54df57b63866bb6638ba70b819c5154a8449aa +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[230] +aad = 436f756e742d323330 +ct = e00f7b42761478774b545ad968ba8065df957f3ebc9f08bd7c87883635ca3150d68a0762e366346610627d89af +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[231] +aad = 436f756e742d323331 +ct = d943ccb5bec78bb5c5456ce7e0c2bbc2710451f67f9398f81b1365dda8ceeada480e270c6bd39cd40fead78ec0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[232] +aad = 436f756e742d323332 +ct = 97e618976ba5b39d98d79dbb6e94f853cf2f231d32e6240929e4674d91789d7a3dd7199051d49acb92ff1e3064 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[233] +aad = 436f756e742d323333 +ct = 3a089d31db7927069a7956793308cf8f59e3570fbf8f561888699aaf5ba4681a427d68748705754d6a7344ca24 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[234] +aad = 436f756e742d323334 +ct = a4e7bfa5b0a0b537c1832206561f764c88d722429340101906b380aff934fbb98f5bdfca0e77024805338e4e61 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[235] +aad = 436f756e742d323335 +ct = 2396cc5b30ab05634f7fc6f6067eadd043e6263f1e68c6ba556fa99dd075a7f1b42b5cf195a469ef2443896fa8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[236] +aad = 436f756e742d323336 +ct = 8e419af52a43da88133fd3bccec458a44c82cc24dffc7475f62fcd69d9118c85505c0080811504b6b28d94c7d4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[237] +aad = 436f756e742d323337 +ct = fa41df9a9badbb1eaad232e4bf7c431b17418b429cf8345e45b1b9aed9e8669ea2e19893f22dcf4dcdfd370f39 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[238] +aad = 436f756e742d323338 +ct = 03ddaf89dd237786f561dc04711aeb5976a61f5a32f789f92867b39024ba0f5f09bca97ce2456b4d4c8ea1e692 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[239] +aad = 436f756e742d323339 +ct = 185eab1d7ae0d33b774abf1d730abe7cdbc7e238ed7c986de2f41e650f0915f33e816fa9b0e08143cc76c76e6c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[240] +aad = 436f756e742d323430 +ct = 559b45bb28a558ebbaf55adf12130d45e18adf68249514e564437bf61d4c49fe9f252c006914429d96ee719173 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[241] +aad = 436f756e742d323431 +ct = 6457329e5fb4296beb868c175f84f16ae889a3edeb37edc19b38bad597064287aca727b420b5ed8b1a0b677786 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[242] +aad = 436f756e742d323432 +ct = 38f7ba2c57febe4b4d832c29299060d93f8fed98b6cbc95d0d6e95dd385d1fee063783ea774a770111ff9aa31f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[243] +aad = 436f756e742d323433 +ct = c45408567b0ad94fed4067cd1d250db315561c9322db62e2d4604bd36aeaf1fcea7db541ab88197266e5d9d7f2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[244] +aad = 436f756e742d323434 +ct = 15211da2711b3ffd8f4fd59500a7fa1e5e4bc96e1ecb874671e455ae30cd8d993ae61f7f2c741337dae98d3514 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[245] +aad = 436f756e742d323435 +ct = ce742653b0a38f7c93e901f97379f074f875eec71299361ebf5cada487b9992d1e7cbb975ba8d5d44aab2d5854 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[246] +aad = 436f756e742d323436 +ct = 83165d93c0178f0b4f73a46952457183421a3284b17d9d5a056c897b7021ce1cfe5295a44a6daec6da9a02e1e5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[247] +aad = 436f756e742d323437 +ct = 816bcd488508d071fecb91b9a0c792b93461a1b6eea76728fc29cc1791f47b9043adde84e0af3e99acf72f7c95 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[248] +aad = 436f756e742d323438 +ct = de13015f54f2d415dab8f63a47d8bd5799b169f1982b67b79890fccc187be7a1ebe08670e4ba6e61e98e4a353a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[249] aad = 436f756e742d323439 @@ -2057,1090 +3108,3192 @@ ct = 6f533ed89dbc3d56641e7c6baaea85455a24d7c81bba4c2c415e146d78c15b05acc144c64a3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[250] aad = 436f756e742d323530 -ct = 43220fbb436a9269a2b8dba1734e8a9f77f443f32fd89dc78b6205a10817c38e8d26859b2c3aa62d4012dfd8c9 +ct = 43220fbb436a9269a2b8dba1734e8a9f77f443f32fd89dc78b6205a10817c38e8d26859b2c3aa62d4012dfd8c9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[251] +aad = 436f756e742d323531 +ct = 1a9acc8588317d8be40f50afdd9ff12464dced0401e6f8043e387a1b4d82c75e63cb0752a06d3d6aab8eb41cc6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[252] +aad = 436f756e742d323532 +ct = 1b6652abf366cb5106ee5e6676510d44de609794badb2672f9d5537fe32134955d8159da22d98c58780980de3e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[253] +aad = 436f756e742d323533 +ct = f4048c4d1b9210430abe699016e1d696b9f67102a68d216d84bb99eb03f6d57d7968075942d4f6e56d462d25a3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[254] +aad = 436f756e742d323534 +ct = f3e1101622e9c97c64fc58e58d71bd92acedbea1a5dbd90d09fca60470aa2c708ece6e8e845444860b37a9b420 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[255] +aad = 436f756e742d323535 +ct = f6ad1823eb0b932d04b6e23010eea64f1fe5edd0583dae5ba27ca6363f4ea104bd217331460ef4208040423641 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[256] +aad = 436f756e742d323536 +ct = 53624f4f9f173453b14e633b45390ff54cacaa4428d44baee1bff8133fab1ab3afe60f88e4634b525c54e92eda +pt = 4265617574792069732074727574682c20747275746820626561757479 +# exports[0] +exporter_context = +L = 32 +exported_value = ded6cffafaea6b812cbf3e241e88332adbc077aca81512914213810ee291770a +# exports[1] +exporter_context = 00 +L = 32 +exported_value = 04d3cb6cc116b28ffd22ad5bc276c60d31fec71ceb87ae24db811c64b7507339 +# exports[2] +exporter_context = 54657374436f6e74657874 +L = 32 +exported_value = 7c5ded445732c14fe09727d29b4251c0fd38455fe8440571e687f0886aac94d2 + +mode = 2 +kdf_id = 1 +aead_id = 2 +info = 4f6465206f6e2061204772656369616e2055726e +skRm = 47f1eee3670dfaaf27c30a83d06ee9f257af174727c17b35328ef730dfc1cd81 +skEm = 805b278cabd22c9dbd461bf25771703eda4950ed3ef35b369163097899555356 +pkRm = 3668d659cec6f338f4f8dc6da6733118d2a633f186a3c1415c895111a8eb7c7d +pkEm = 9e59f4b1fa5c876f684765290c34e51145894cc4f244342b9fb1a4bdfd8bb426 +pkSm = 4a91c3d0893433f5e31a79fc520f885527a1bc60bf2b0c72693dd7f0b2e41a5a +skSm = 98fdf9b9773578a79d4ba82fbe483c74cc2e3b8d9525d148a18969fd79a74876 +# encryptions[0] +aad = 436f756e742d30 +ct = 10b964283ac2cc0bdc4c85ab617291b446bf3832e9359b2c3a0facc50ea75a3c1afd08aeaacd6041d02eb560ec +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[1] +aad = 436f756e742d31 +ct = 83b24287a5ac672289ccebf5ec303d3c0a85bc60bb7a748014d85179b51c7552ca93a70817ee3140442f92e23b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[2] +aad = 436f756e742d32 +ct = f42d890891825c1a57dea5a66baf2c940126704682826bc7c5caee60ca71578d767db256b0c2a4051bef1236f7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[3] +aad = 436f756e742d33 +ct = fab3f66ea4273bcc0e40858c346f4e12067b685dc8ad6d57f3d398bb3035c4144b578991c99df545c214a53373 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[4] +aad = 436f756e742d34 +ct = 470a09a528036f80a2f1e23bced44551e5da71dff490bd7de6e01e2eb412cfe69be650b201f10e55a9c289e712 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[5] +aad = 436f756e742d35 +ct = 96838a987715414de7048ce44f8bd0cf7634638d4d4ea25748baf44c65bed08692a8442f060bd87def25098d2a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[6] +aad = 436f756e742d36 +ct = 2c088d57556144930fe7f52d49d8a451cea3aa6e307d794a034fd5fc91e69f56c8c31464dcfa26ff1b5782c80f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[7] +aad = 436f756e742d37 +ct = ef8b777272642c61eedb8bf809e92e2ea35f92a53f09b131e7f7a6004cbf0b7e6c528d27567638cb54f86fd89b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[8] +aad = 436f756e742d38 +ct = 953a2067e752c7355f30364979ae55efc9f36346e6fc2c51c5fca956a6367080b045381612cd85aea2b41f8291 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[9] +aad = 436f756e742d39 +ct = be96bd02bc6cfada4561a2655b4214d541bd812b0ecb45b4446d93785287a68dda16dcda9790603327996004e9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[10] +aad = 436f756e742d3130 +ct = 4b553762b63d15769e5b0594f87971776044b2e0ed4b58aa6379769a56334f87361dd5ac710b0a4afdb61e42b2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[11] +aad = 436f756e742d3131 +ct = 1b92f016ae4ba14d4662d6f65f2cf3d1df4b99bf98b1c8b7a7f9c7d722085e5a2cd7f242c4680dd896c08fb9fe +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[12] +aad = 436f756e742d3132 +ct = 93cef4666cbb4c191fe7791b0dd46cfd09c7a9bccd3dd120e31e1592379c5112268661c738c27fd583d1a69aed +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[13] +aad = 436f756e742d3133 +ct = ec195f886d5ee74f79eae5cbd1b46e143a92a598b1c0b585c709d704d97ff256cfba127afb2a9f1a23f26ad6ed +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[14] +aad = 436f756e742d3134 +ct = b7a4f0af656ad0afeb7c3718971940a31f4822125943171520981b17473a5ee7b7f1192478534db62ebb79e546 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[15] +aad = 436f756e742d3135 +ct = fc8b1d895f7d85c4a07e756ceecf6add2141056a80e86eabbe62feff6cf69db47d6c3e9735d8c5befa973196b3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[16] +aad = 436f756e742d3136 +ct = 328ed2e5b69f06a3ee88aac0851952c7723f9bb28370db85a300b01b5a2d41c7355bc2286784cd0fcebc433ff6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[17] +aad = 436f756e742d3137 +ct = 19cd1196f10eb2df0b1fdad07c36ae1ef483d66c0a474cf82447d2a8906093880b1d8360c507ce0ea06fa16532 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[18] +aad = 436f756e742d3138 +ct = e281b6d64b0f97ceee63df5923192a42eed46a87551d476b5e6a01e0a6ddae36415394c3bcb2c2c51b9ccbe80e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[19] +aad = 436f756e742d3139 +ct = d764613d9a6359243a9f37dc8d1b2fb384c9d036beba29aaa99e966f5624300da396952413ef482a5034c66300 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[20] +aad = 436f756e742d3230 +ct = f0d056ca8484082c5e08980dcce8e5bac8503d914bb6662c196dee3778f0ba795d108361e3b82c01883d6b4880 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[21] +aad = 436f756e742d3231 +ct = 47d384a5108791541732373492c339e4001760802862ee2307ed01d8692f81efa8750d940a0f8ecc1d509053f5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[22] +aad = 436f756e742d3232 +ct = c0bbebe48e5980326bafb7840ca6d408a4ab796acf26634991b21c34170c40817199cc71345c2e467acf5cab30 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[23] +aad = 436f756e742d3233 +ct = 0ea456e2deb27ade97571f5c51835dda401585260eec29f29896bb7a6947667cddec9d52fbdd0155d33c0cb318 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[24] +aad = 436f756e742d3234 +ct = b525498a5ffde5bdd0c0c50b0c1d8c8e64ed47124d3ba52b0c5fcdb11b773f568906e5643b390f73abf178860e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[25] +aad = 436f756e742d3235 +ct = 019b344de40001e1d18fae03002be1be4d2e020c32a514ff4d84b15d066cbcdf045490ebfe9e4fe536cc001b6b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[26] +aad = 436f756e742d3236 +ct = 6542b6f3e9abae49d31af2a8871f5260648cb9d3c5ade0d7d3c43ece10186f6b1ab465d71c5503a703aee2d889 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[27] +aad = 436f756e742d3237 +ct = 8079a278f77b5dc928f17125af7f62f0ce040ca8d90afef0de758da1694b056be1efde71258636c8a39a300428 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[28] +aad = 436f756e742d3238 +ct = 2f4cbdbfc8e9e1498dfe1f20addcd16e00fba26f06fe8bf510ce726f4e6e38141a027eb9b930512300ba50d772 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[29] +aad = 436f756e742d3239 +ct = ef6390e3d57f95aeb00e6a8cdb3b545bbffee6755c8215d3b431a7327da4981bc3dc35b5b913b18de0abdbe721 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[30] +aad = 436f756e742d3330 +ct = 0aa56230de06dee53bd6e405bac54899367a1f6d4dc4791f99a86f6eeced0b50acfc68eb49393482325dceb15d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[31] +aad = 436f756e742d3331 +ct = bc0812f89e395491f19b70d43b4ce1be7d0d274352817134ef9baf7d9c5d7b93a272a79350b8bc541997097023 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[32] +aad = 436f756e742d3332 +ct = 86980d73a1f515952156be21c6b42ecfdb40ba67ddc9c8af12dc4afab2e659622f341e84adf06ec71f2c4fb19a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[33] +aad = 436f756e742d3333 +ct = 97205bd532ca8dca11de6245d21fdfac06d6b48fdcbd399cdfc3cd18415a78bbc62bb9aae0ec326fdba7c1c846 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[34] +aad = 436f756e742d3334 +ct = 625be4d9e0e0caa56cf6e7c24ceb7cb336ce4265b0177b93783d6225bf347b84b3c872de9992666d8d7255b3b1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[35] +aad = 436f756e742d3335 +ct = e1957331f9fcab02fa9697924b1a22b7ca36ac728a4bd2c4db20b839987aebc6db741669ed96f63bc52d949f64 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[36] +aad = 436f756e742d3336 +ct = 5d83fd726dd22802afb242f25923de6d55e1a481c1d5041c2dd05986b5be5f72d611efbaf8071fe2bc0d416438 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[37] +aad = 436f756e742d3337 +ct = ec453efb75c777cb1fe3322f3504da40c2fbb613bb4735a02b33280c1383748377bd33c35eae2f48930a6aeaa7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[38] +aad = 436f756e742d3338 +ct = 3a050cf76b072e1897fb498d090dc4591dd06200f8c74e8f7a6b43e455680b32fc831fd7891450c626a847aa4c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[39] +aad = 436f756e742d3339 +ct = cd6a04939353bf21e3c68fb190cc2e450bee3403938db4fe9eb1d826cc15ee1f0b7b32af11a32310c2e4b49e30 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[40] +aad = 436f756e742d3430 +ct = 2242c9f6d2b04a400892c3d7d7f4086f7851489e4bc86ac090ea5723585dbf61bace21248c2643e062329c32c1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[41] +aad = 436f756e742d3431 +ct = 6bcdf8d421bd9623a6872b1aea124a4b978312e29d24a3b0f019c1434e55d2de4775b256aa91096533fe51d292 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[42] +aad = 436f756e742d3432 +ct = 4e02b9b212688ca51278baed8e57f3c948d70d096afb6842920b8fe504992b7920ebbd4e3e655ae6cc598244e0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[43] +aad = 436f756e742d3433 +ct = c2acfa09b1f580da4d924247b5c98c3122c09a37b72b5aac9826e579bdf194d7a3d179e15a7085c9fa8c53de19 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[44] +aad = 436f756e742d3434 +ct = c7f6c9d6360f14a124bbee3624e2f03e34b73248576f2c83127eeba3fd9da799a456f27bfffd9211c5a40a414a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[45] +aad = 436f756e742d3435 +ct = fb885e9fb8012b9d801ac0c1cab978b753ec391ececcae9582b360f0c28e6b58f7e432d3f0e020dfe0831231c1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[46] +aad = 436f756e742d3436 +ct = b10033bc7cf55378cf7d919a0773bcc79b6878117071674df4028cf59ff3554963dc3f6a5edda250170fc55d85 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[47] +aad = 436f756e742d3437 +ct = 3e62ec8300d4c6d0195a7403ba2d8c70c347a920a9f1051a9825fb5620bfad8aa139940b5f3a91e5409a00849e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[48] +aad = 436f756e742d3438 +ct = a7d0016602e0501f39ebb6f4173005a5732fad028dee2a3dc3e087ac7b43afbe0f486c6267a883f223081dd89f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[49] +aad = 436f756e742d3439 +ct = 93c01585a1d1775f3fd3b1925c26bb6e810842a24bb69a9c2521db72f6d66a2e005bb875a480cccf2eca122d8f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[50] +aad = 436f756e742d3530 +ct = ed18775671121dc68a6413f544a45a3a197faf39c43cc244b32c606ebb61cd1333f830414624530e43c5328216 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[51] +aad = 436f756e742d3531 +ct = 4cdc7b5fbb3c8f392e84b238ab3cdc7b490cfe1476259d0db4eefe53f718f1f6a7a32bbbeef1574ddc41358b83 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[52] +aad = 436f756e742d3532 +ct = b47aee63fdb669daf990181bb75bc094bb9919b2df809615b3aed0ddfdef0235f79cbb95082bcb44f76513876e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[53] +aad = 436f756e742d3533 +ct = 55b76bcd5f44cab153ffb90b809f5cb504bd02f705b6649dcff9917bbc9df878e2265d96591d6d0bd856afd1d1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[54] +aad = 436f756e742d3534 +ct = 67eab42d7d1bd9a03221c283669ec7ade98f5b3a970f7903b9dc160501f643eb614625f35fa89c834d582282fe +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[55] +aad = 436f756e742d3535 +ct = 95d31adf6ca4f047c5097816a6e6cd02e2c952f3d63710cc05df53da29bb37abb8caa037bfa2c50b59948ab656 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[56] +aad = 436f756e742d3536 +ct = a48d3ef0c3f065e7cc4b6ddebedcda1b27a8dc0664f4049521a3c446834a9cfdb76dd83a506c1f6f25178287cf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[57] +aad = 436f756e742d3537 +ct = 57d1902ba96fa509d930d5ed2c7cbd57fa43232b14c7c6fa3f33168fd543f4d96777902707cb02a1282f83856e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[58] +aad = 436f756e742d3538 +ct = bee02243ee8196cdd8470528e5f2a0a366a0c48fe71827c07783192a762506d283c6903419e84404738f27a31b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[59] +aad = 436f756e742d3539 +ct = da1e009146d60483a43a1518c2bd545f21392f98f5d2761b6b54d455d6903ed8f8a7e5794946b1d2c8b46ebdeb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[60] +aad = 436f756e742d3630 +ct = 99bd8213cf3e48db8b0cae6cca6088b3c3f25d8d8a4e1d38b1cecfaa777ca0975b579f2858ad29f5d292b59295 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[61] +aad = 436f756e742d3631 +ct = c49043927a47694c3e0c6095fc3fd7ef19b947b1c15d455504a72286238be0aca23bbb8c78e9c5c066d7d2d965 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[62] +aad = 436f756e742d3632 +ct = d056c8521b101402202aebbd5ebdff1085a1e0f32e177f44787c2f25b47c3ad598ed05a2441002637cb15b7257 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[63] +aad = 436f756e742d3633 +ct = 3790260dba51810aa30b24f7e841c0c485b40f234ae1e0cc66bf895c6fc00e5515b3b4b383844eab29c706c336 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[64] +aad = 436f756e742d3634 +ct = 6fa82757e4a3cd33d8480a35c303250ca6bfbc7584296ce67af456be72b58a9ff310c7ec6a50f86b20a92994f0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[65] +aad = 436f756e742d3635 +ct = 44dfa1d42f6f7e2acab917cff4536463a3e73c4f5dc0c2ddb189e28dd7c3e6b84540b98dc0c51e1f5d00f9805c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[66] +aad = 436f756e742d3636 +ct = 26a22d894060884040677def8afd4502c79873f13c1b4c5e0b093ce0e21e6c07c07106bdab1b1e57e365433a34 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[67] +aad = 436f756e742d3637 +ct = db85091e34637ca4b5d709285d61e13cbd5db120cadef028caf4d7975dd8f2eabf8cc33d0ad6bdd9f4b3d270b2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[68] +aad = 436f756e742d3638 +ct = 294b49e84bfaa136422bde1ec4d15a75cb8a8c0c7b9063d08d798e641c6aa7fde89ebcfbdcf7bce1823a9ff3cf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[69] +aad = 436f756e742d3639 +ct = 93ded3b6c98642921cdd0663bc2f3bd844b6aab133cadce857a06a9b125a34ab62fd21699f834c6c961c567ad3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[70] +aad = 436f756e742d3730 +ct = 41c05ee1b1d21d9779f39d8331945636f0e6214e0293da5c13457cc6e2ac700fe39086ab35fb700225671cf680 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[71] +aad = 436f756e742d3731 +ct = a26d2e109a3dcf33fb46f2283d3427b92275afaa1e8f0f8cc0129e6900e9c3278f614525851e1939a97b1acb02 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[72] +aad = 436f756e742d3732 +ct = 4160b4d94a4c4f08cebf3360d64188de51b2a062463d6af30d8e60844f915528acbf675f86b6517c7b605979d3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[73] +aad = 436f756e742d3733 +ct = e2396d75603d928144c116457245275f48e681f627fda6a888fb02b00bc61648e010d4b82a993c9d882fc9c209 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[74] +aad = 436f756e742d3734 +ct = cf469851b3a16878978082d773079252e7646e3d1c15ce10e11533ea5b89389baf5677679b792337b107d4cf8d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[75] +aad = 436f756e742d3735 +ct = e5913c4c0403b0cf15e20443cd18a91365022f141e8e480e271d335c4fab1fc5c9e4af70107daa43f2869e1978 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[76] +aad = 436f756e742d3736 +ct = 7a6a29c5e897b0df0f986bad7d073e3680f6447b820d36cdcc24c7a6d5881bfb8d42a812ee74dc3a945c3aa23b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[77] +aad = 436f756e742d3737 +ct = e88641d6c70b5eaa39e00ab2a7d55188066e9520cf517aab36724dcf00de2e9614b10f389aa79044c21574236d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[78] +aad = 436f756e742d3738 +ct = 0f97f67f90f69d087390b081c7d026f4f37df0086c3dce2e9a02a930a39e68c894ddf92bbd7111e0451fe6cf7f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[79] +aad = 436f756e742d3739 +ct = 06b7381cb3efda92c617ba646a92e2e7afb22671c71f913eebfd6d3f9595beaeb90011d7e18ca545d3fc2a29d9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[80] +aad = 436f756e742d3830 +ct = 4d6f4638c2f8b3b8282c87b7d5881ee4572d0a8878842119d21b89d519fb4c7d063e0d553b4eb0da11df6d33b0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[81] +aad = 436f756e742d3831 +ct = 294110587b38ce5ae4b34f037a8ddef605754c6951b5f6c0f1288e17f6d0045acbd4a0f41e98b2178d9acf4b6a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[82] +aad = 436f756e742d3832 +ct = 5918e4d0b1dd3ebb1812b715a46a9674bee2207a1bbe77f810a3a481b0ed0b84f60e5adc2228915b4fc4da58cc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[83] +aad = 436f756e742d3833 +ct = ea7c2a8fe7d6cc0237fef4002226d2b0b1dd9e9c37e0a7d083c57ea7f3118368f8337b972f7642d52152e16a37 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[84] +aad = 436f756e742d3834 +ct = e6ab7aecfd81e4808eaf4d160f726275c006761f4ead2e9c9637b81cdd8759a35469342b9066f65ecb8f6336a6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[85] +aad = 436f756e742d3835 +ct = 72d49670b3dff4551c1c6ea2a5cb7d74e9655a2bdb94048ac9173b5a5918d551a818bae8c78070aa580fadb7ab +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[86] +aad = 436f756e742d3836 +ct = d8615ddb96a5ee3a29e17f00fc1bfd64199bb4587f54a41b60b516a9ac590dc4ff2ce7ccef1baf56ba08d25a32 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[87] +aad = 436f756e742d3837 +ct = bdb6cb3fd276d11f8b3839f1daa23c25407b85e50d990becbc7548406664060b3e5ea7b8744cd6d01f7d6246dc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[88] +aad = 436f756e742d3838 +ct = f11c35cd0da9d7986d34525226edbe665c332af3f265ec9ac3252349d13e2079d90e733e67d3a05153876f8b1e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[89] +aad = 436f756e742d3839 +ct = 21207c730b60ed9139203c845156fa9ed93166eaeaf33d91501f2a183e98d6f9941eb270df1d0fa455f028a9c2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[90] +aad = 436f756e742d3930 +ct = febca60a4ef7ee6a73993ba1ed1d39427d96597d04e1ae338ff3418fc4323227143a6f5ab874cefd098bdb3b8c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[91] +aad = 436f756e742d3931 +ct = 08ec4f99873f2548a2bc8ae0de56543e927944c305a31543fd56d5f1bee086acf96387d918e7af898598fe427c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[92] +aad = 436f756e742d3932 +ct = 99b47953bab7e516974cf195a7f14d09ed9ea6f74fe612e6cdf58a9ef0710b2ea7582fdfd98c90a343c6110d85 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[93] +aad = 436f756e742d3933 +ct = b70561bf36b2acad3eb13d7c551af56e0e2fd6d81ba181489c857f66c88817fdb8b76b8d7d594585427b032c7a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[94] +aad = 436f756e742d3934 +ct = 2180d3d0a7d925c0af160101f6b334f0f94bbb32142fc1e6efca3e82e9099e382caffdd909b0fa7f4e5407a0d3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[95] +aad = 436f756e742d3935 +ct = 03d6a815ea1f2f88f0028ee0670e07bf4a0db028a5dfcacb9c281daffcd9226565fa56f92da3ce5eb36e095d8f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[96] +aad = 436f756e742d3936 +ct = d5e0da3bde65864905f8f8c8f9b6082f22a18f035fb9c04a2973f71bda24eade1772c27faa8c3e2552f817996c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[97] +aad = 436f756e742d3937 +ct = f13df7ecf2282a7aff702530d169134c0bad279a94e4de7a0604c4b57a2e394189bbf6c0237e6872e0614599ed +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[98] +aad = 436f756e742d3938 +ct = f9c348a57f3249fdce7612d3329293519f6a675d2a030ef812ebe8c7fe1c69408608152e5f489eb41671c36891 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[99] +aad = 436f756e742d3939 +ct = 18335b721b8f80ea3c5b0eb16d6fd9eed45f96f7b11140d3692f2dba9ade5cc48a16b4b316ddc704b70e299138 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[100] +aad = 436f756e742d313030 +ct = 3801b54b9a1d15b10a84eb78a8a84e2f70b4e57e0f6b7638a3d75a40720c101fdd92cfbca87ad22ff7dd20d317 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[101] +aad = 436f756e742d313031 +ct = 7d1b5a06d94e07e677cb647b44f378114ddcb55798dcb8c98fc263f61f4b34d4bcd375cab0c1ef2224c9540961 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[102] +aad = 436f756e742d313032 +ct = 08891c005d9ebc0f9f8d07ab3dd15a88c3d9c60402b9516e3c6727bd0b26ad70f78e8d1a1bf269077a35fc745a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[103] +aad = 436f756e742d313033 +ct = ddabdfb862b8e4d6f03e2858e2a05976286fedcec6447355c2ea0f0540f0d3abe3d9dc17f7aec0f4684ac8a11d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[104] +aad = 436f756e742d313034 +ct = 533056df19cd99b22c522903837e9b04b38f072e869fcf98e63ab4e138116fb1a327090612b2cd01ce60a92c04 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[105] +aad = 436f756e742d313035 +ct = 84a75eae557806a60d8dec4e0a030b31e2150299ebaafba2118e1d9f8a4332dd383c3cd1bf01bff70f235e7ca3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[106] +aad = 436f756e742d313036 +ct = 5288205e740e6eb70b52dcf29f44ade64979a07023888f5a098d6b386b926e5b2b3dbf1aac04a6f80920d27f2e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[107] +aad = 436f756e742d313037 +ct = 24f72645798f856137576f8044502e55f03c53cb3fbdbe9b13a3caeac07631ecdf5b30c11757f6d66697244aaf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[108] +aad = 436f756e742d313038 +ct = 178de8bef65b6abca9a55a1819a9573a248e0612832f255f4d307df38a8f29554fd664639a6a6277b5e33201b3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[109] +aad = 436f756e742d313039 +ct = 34613e05962717b7a5c60c9c3a2cc0c2039e584948c9a028da05bf31317efbfdb0fd86252e6061712e3b03a53d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[110] +aad = 436f756e742d313130 +ct = bce0ba4438567b1570821759d9f6d84a6c600701b8632e9fc82a5e68f3568f05a00080bbc4c69d1043fe09a2e2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[111] +aad = 436f756e742d313131 +ct = c848e35cec53b724b632a27d3b90abcf1044b93ab5db0a5e63c93f15b8e3e599f737826db5258ff8078d4cc379 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[112] +aad = 436f756e742d313132 +ct = 2026cfc3ee0f725ebf11c9474bdda1560dd4046eda764d9656cb46c949cf0cdec3fa8a21cd0ed4eff3a7b64ee8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[113] +aad = 436f756e742d313133 +ct = aaa53f387b1651d71fbe2b11f541f6f8b6d70a92ed1668a797d89be0862e2867a35b43f746482271bc8337eb79 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[114] +aad = 436f756e742d313134 +ct = 426bd3f51bb64eaadcc1444282dc0d25edb2b4e777c2437910d355cf3e6cd09ca989a76a34ea8c415e9b9af767 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[115] +aad = 436f756e742d313135 +ct = 1e8c313e38d847030c366926fc26029045fa4cf5523d86e883e386d348b9d2cb3ea727a0ebc586191f45017320 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[116] +aad = 436f756e742d313136 +ct = e44024793dd020b4a059346e2e4d325a301c643fccae7994b620972ad3c5d249cc08bc4c30d3434a62a93825a3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[117] +aad = 436f756e742d313137 +ct = b608878acfd7c879b587555c43f5713f5b8c0f6abe2f1c781e72cbadb32dbec4697f23d8af80eabf32ab969417 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[118] +aad = 436f756e742d313138 +ct = 0563bb0cfbb03d236e68090252082c866c2d05dc48c530fa5920b32eccf2d4913a190c12aa8d55f6a834458684 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[119] +aad = 436f756e742d313139 +ct = c0191c7b91f01ab891336ce5d77d97261632ffff8fcaaf25a0da0f563604a5cdcfda6d7d0d6a492d4bc8f8eb64 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[120] +aad = 436f756e742d313230 +ct = 2e71a5a07fa44ac159d7eb2e483d46d59d4552895973fd7fe32f4919310b814c45699dcace887744d4bac9eb36 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[121] +aad = 436f756e742d313231 +ct = 6c769767ccc92a2e3c6ef2f94df67d72b9c02b6d1993281d2ffdea0b40b5af09f25b3898f05ccdcebe4bd6f31c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[122] +aad = 436f756e742d313232 +ct = 5dcc6147c104f9f5586d88a7cd715830d70d88820a6b2157a574b96b7e9c37f834aa6adb957cd8e0aace79bf47 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[123] +aad = 436f756e742d313233 +ct = 5839720b5f44874828ba95443c2685d53d079f83d3246895906decd87ee41a3cd7969e66c7fd5e88330b6f354f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[124] +aad = 436f756e742d313234 +ct = b01ece5e6481555fa1db96bdead1d578508b9d601a6aab00a1d433e2f94ad75b843809b4d85aaa4f0ba88f0d11 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[125] +aad = 436f756e742d313235 +ct = bfef11050cca99cbcefd59be7f27a793de11dd74793ed2bbfeb600fb1ffb0e2d1e559a68e14ca6369dd48036ae +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[126] +aad = 436f756e742d313236 +ct = bedb06bef935d7035b316b485408a8c4bb745af2ca5214bfd87560f33fb2841618b431988373018adb03e58cc0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[127] +aad = 436f756e742d313237 +ct = 72d0e6266e19f5bbec3f4a5ced9dcfcce96c3d98ec677cb1e91953f0d3774a9c17d766ea497a25397bab478964 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[128] +aad = 436f756e742d313238 +ct = cab945a20e896773bc7408ac7e90e39e7530b2f6408c09693c241835a76d7a9f0894f9f7275a8c9ab78df0bea8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[129] +aad = 436f756e742d313239 +ct = a8c02c46ac55f9b655b547d29bd5b00be116094f1208edbc83b8b27aa1edfa4e3b7d7eed3199cd64ee4f451c1c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[130] +aad = 436f756e742d313330 +ct = 878713ff6c3375f2ac8a2b38c7c0d8b49a7ec57811118b9990b0952c08f097d7f1f41bd86974e0b419246379a5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[131] +aad = 436f756e742d313331 +ct = 36bc1b88559208bc331263d2ed1a16ffd8ddf3770290531f8a6198701d9b668d2819744befffa6d2d0ac01b1af +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[132] +aad = 436f756e742d313332 +ct = 94e5ac2d046cf385ab849a7327278e6d3c51cad5b5d38adc071a113ff3273b1ad5fb5289a01e4da180c77e8ab2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[133] +aad = 436f756e742d313333 +ct = 7db0c79103f304fb6cbe56ffd5876aae98322e285fb705fe724f31e283bef9ed1ae4946c7e7dd8de2ea6073cfd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[134] +aad = 436f756e742d313334 +ct = 516d927bc91d3e6c822fd7612af2b129a5ded8bf590faedeb8495b7493d12e8ccf52f34d630280800a126ba478 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[135] +aad = 436f756e742d313335 +ct = eed3aeedab617f72af68573c059ef7e786c233a2420b58426f01689e65a5c89d48ad08713102536c7beaa37d16 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[136] +aad = 436f756e742d313336 +ct = 8fe4c52fadc9175a6468a45fc8b96be427e570531dd5ee573d70e5dd0b9b1a67cb3873ce2a7148a066b26c8c3a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[137] +aad = 436f756e742d313337 +ct = d506cd6d849069d44977b1fcd4233ea51f812ae84bfc912b7ad80fbc4b7eb330755ee73c037e04ea4d54cc06ce +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[138] +aad = 436f756e742d313338 +ct = cbe30ec8e0fa8aa643cd53fd08c036f27ff2b56d46f2fb071bc9730c3bba256dd0317f14cd658b7d347e0eeccc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[139] +aad = 436f756e742d313339 +ct = f3029bda331c4e1c90960d60c2536bd0dc758e23d59ad17da680318fa9253f952e4fb019642920307f9dd59e94 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[140] +aad = 436f756e742d313430 +ct = 8d1b5e14384b86b38dfa1b837573247c3bb58ca07bd6d8a0261306e6a04fec85ce2e0999eb994efe91cef0d8a6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[141] +aad = 436f756e742d313431 +ct = de39ba2be428a69e47b70eee0315663e5d169da6ef2218bfe7f0ac59957022e5eda5c0b3e804f65138bfb09b8b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[142] +aad = 436f756e742d313432 +ct = d26d5406228c57ea78ed35a5d5725411b86b82a7f155d845b2e024aa86e2eeac11d33be3c986fa065fdc92ad68 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[143] +aad = 436f756e742d313433 +ct = 8a8dff67b3d101c00e48d1c6f77d2e6e123417064f5798e0efc7e994cd31a5e34c913e2262c609991e56000b4e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[144] +aad = 436f756e742d313434 +ct = 90443aa2655619390b627e09daf3949f79e77b903cf2343b84ce5c109eb02238e442bbb9bd2a158c445c7e57fd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[145] +aad = 436f756e742d313435 +ct = a3df261a314fb20a519cb4b116832fcfca255372e9582c51bca30df529df7f8bea576390abdc25a8c09c030dfc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[146] +aad = 436f756e742d313436 +ct = 764b6ef88a4ef4e00495eae59c83eb4d4da8512ad24982c04c332cdc0c39944bd322d74c89b78977c649e344f2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[147] +aad = 436f756e742d313437 +ct = c1149b45a6f6dacca8342741b452c3c0fe8ffe65f12ba4dcc731f38a0e29cfd551984ebf4d2850c05b05e4638e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[148] +aad = 436f756e742d313438 +ct = f5c2222655ded319eb73adcb75cfdab103855d43bc8e2098cadabcb6f02c75d5017fa95854d4dc16514cb85bc6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[149] +aad = 436f756e742d313439 +ct = 67de8b5afc35709924eb1598c90d1f8db559e5d1f224e7549205cba6ba70dc4bb67b1f7f3f9a15d56692d3e88f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[150] +aad = 436f756e742d313530 +ct = e6add3f1f1dbad46769e62b770e0e79f795d43c64b76e46d578447bfc7c01e48a7bef0607791fa51b9f8f73db6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[151] +aad = 436f756e742d313531 +ct = d974c073ea225646215fef776186673b1c3b10c8fd130dd6c46216c90cdb05e5d899c55be32dafb2f52777be56 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[152] +aad = 436f756e742d313532 +ct = dbb16370248672972c240fbe7558669713aa40221a8138789a4b1fd95edfbe5dabc361b95e1adbcb804fe38188 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[153] +aad = 436f756e742d313533 +ct = 0021cb3186fd692c8ab715950564165ee8f89a17ea7e308ce48c6337103a1a505ab2aac137e5a110b7c92260b9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[154] +aad = 436f756e742d313534 +ct = fffc59f2ff1d3a761d8e5005c25e12044f10875aad3ebd5e9346534aae5e4896eaecdf05f7fdc8c60952a0056c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[155] +aad = 436f756e742d313535 +ct = 84d2ab92172e21b7251bf2825f3c083f474d891ca0b8cb7f5661ce37956446cbce80046c82bcec29eba26b4289 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[156] +aad = 436f756e742d313536 +ct = e80ba09d1d2d7de13067e460755f3609840f017e8a6e4561b7b4078817696936ad19ff6b5c5cdac2b25ce809c5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[157] +aad = 436f756e742d313537 +ct = 445d8be1d404aa0e508f7021b22e48dd6a349141c182e601520420ae4610791a8db67f4584ecbeafd3b4169e50 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[158] +aad = 436f756e742d313538 +ct = aee6debdac56b80f9b55435fdf649d174fcb801a93866fdd8f6bde22ff85a3baba12409fe7f41b1c9b248711f2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[159] +aad = 436f756e742d313539 +ct = fe39078d272abc9c7999630c5eebfd1e1628a4a694430c105f119d20e524e99face043b5da613d3b11ecc897d4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[160] +aad = 436f756e742d313630 +ct = ae4193c43e06948b19d2c912613f772c6be49b16a4f7dca4991c06417530681b54821b94ad8ad6c0d388884ff5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[161] +aad = 436f756e742d313631 +ct = 114fccd21850ebd4069127be28198c5c2e9f270b598baa7be337975510299aa20c054f8498f51898eac61567ac +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[162] +aad = 436f756e742d313632 +ct = f11d3b4bc526d850043c454f9936f85bca7df5fc1957c55677d3dbc18a55de8a02efcfbd407cd8a4d0a30d366d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[163] +aad = 436f756e742d313633 +ct = e59152496079561fe9f114ac73ed3356720542d395921f7a4c5c50da7f6afa3f492848361cd3a1a13f4b7a2fbb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[164] +aad = 436f756e742d313634 +ct = c62cfe00dfced3a0d9f35f6f9bbbab100bf6d609f3d78230e1bdbc7a2b3f1c4713975b62133bec7cdb8cdd91fa +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[165] +aad = 436f756e742d313635 +ct = f7e0185224ec145225b3cf0451dfb014dd44137775617ee72d9da4f7b41ec248904c107d6c6db25f3f8e2aecf9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[166] +aad = 436f756e742d313636 +ct = 93c68f805eca253c23dc452302ef9ae791b4ffab97853c01f5967b6891cf2c5bde002ccd85a365fe348a57d6ca +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[167] +aad = 436f756e742d313637 +ct = eaeda86b4f90c1f66e5929454220ef8ae0cefec40a6c03911212810abe11d5d961f625fd973855c7d6d8bd6426 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[168] +aad = 436f756e742d313638 +ct = 72ab591663e0fd2edbce4d5ee04997d259b834bfb7bc10d36fc14e04e2808ae38cf601af89ef33d28224301424 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[169] +aad = 436f756e742d313639 +ct = 5da0811d6bb5b9d00402c1f803062e6e6db4da219d695ff502ed4e74f011cefc3c74bfe86f142a6d5ebcef873e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[170] +aad = 436f756e742d313730 +ct = fe429d92e1cdbc0c738fa1b057762a61b6d0b3bf3d6c4a480504f3d8c07363d3d9adb50c5c44fc9ad2f80afbb4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[171] +aad = 436f756e742d313731 +ct = 73d7980299de66489e24e2b042d8cb62bf02a50ea4f6edfb3a265fdb54028a2284c5090fbd5bf7401d8f7d8c55 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[172] +aad = 436f756e742d313732 +ct = 9b81f97ffded87a9697145b6d0b0210cc20afdd117311238a5354d1ac0a5d0b834becda5de16280c7ea3728e26 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[173] +aad = 436f756e742d313733 +ct = eb9a1e55a34f825c13d2b7b014cbb7db6249c4c511111af9ae9bf441a9b9b1a701f778f2bfdac6383a9fa79ad2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[174] +aad = 436f756e742d313734 +ct = a0603640d761fba6ace56a20de14ccbc45baf0997755175d7f3e3742edb274368ce0a776eda420c0eff6a4785a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[175] +aad = 436f756e742d313735 +ct = 0abb86f71c0d2e456c4322bf4a26cc5dd898952a98b6fc815b5ddcdfba4308e6ec2c6260d7540bd0bc2a399141 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[176] +aad = 436f756e742d313736 +ct = 2d076ed5858dd9f5441b6cdc386bc30eed7471a8f819de6eb6173f0704365f8043fb6e8fc4a7d7f9549457a3fa +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[177] +aad = 436f756e742d313737 +ct = c51e01a9dc463c20728a6d15fd59525709a8c51d9f46f15cf093773aa7a968d40232c9ef26d20257762ee49f56 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[178] +aad = 436f756e742d313738 +ct = 6be4673041b4f9281b6f5f5b3a4a611062254f82d7d298e93ac3395b0f93ee4277f3d60d1116c5f559ee498c1b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[179] +aad = 436f756e742d313739 +ct = 56fb203d31045da80ade5e18a2a2e16b361fe1ed4edf4ed654d75edbe82d0326ce9dc51f75454fb7651d5d25b7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[180] +aad = 436f756e742d313830 +ct = 046305f4ac30a91936afe73f55363480558b476ffee4ba19a4a99a6edab9bdb712f8dd2abf16e37839382f1c07 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[181] +aad = 436f756e742d313831 +ct = cb90b1ea72f58b73984e41ef7297338ca0db1b4bf51d1bde41372e4e4bb9ca00f6da1a54e55fd20f1c21ee996e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[182] +aad = 436f756e742d313832 +ct = 33fc92d18d7aff541c2d8d3d0d590fbf94c7fac0f5403ef4abab82ee855e42a0753ecef6154dde04926799b2f6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[183] +aad = 436f756e742d313833 +ct = 1fcdce642c0628dbd694cf14df7182c5f5bc300ded6c2c9354866a52f4ebbcdb3a07f16cd66a1f6e25f1aa5c36 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[184] +aad = 436f756e742d313834 +ct = fb4ee64e15307f7209e60aaaf58ffa1e3348c3e6aff46cf95c3a15e96b65762cf72749898649aa4f2554ec973c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[185] +aad = 436f756e742d313835 +ct = a64ad7dc7d7f2c272293f2c0fd957c4748f3911e6bc7242a3bad175a20b4508b0cb065a7ec848677ed9d349e5f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[186] +aad = 436f756e742d313836 +ct = 95eec59259b5fb711157229920349524e7e85756419492df26298ec7b16668a892a5fa41ef7728bc8929a1f942 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[187] +aad = 436f756e742d313837 +ct = 8cc240907d8cab9b1a0168abfd01aed8cdeeda252e298de2f3f89190e1e03719e40845b9b5d93df184702bfd7c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[188] +aad = 436f756e742d313838 +ct = 5cece69c96911efcf1406c5faff0de7e7965ce0b6b661df3290ee4b86b4ced5db98d2782cf8ca5c7ec81191ee3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[189] +aad = 436f756e742d313839 +ct = 9a37d67894742202ac23904b65d72e40b7afe31f7aef8083e3f41185e402481f1f6466bd441a27dcf5a135f6c3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[190] +aad = 436f756e742d313930 +ct = db536753e52ccee922ca4578dbfc8b24069dc526202b9e95d865ef7f76b9406ba6afbb665f4a2d048f0c8afb9e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[191] +aad = 436f756e742d313931 +ct = 015649389a63f9410008083f30a4ae626ac78d8cf4b35f701845a56ca07c58aea12908020c43890db3f91745b3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[192] +aad = 436f756e742d313932 +ct = bf7df6bf223d74a821afeff194aa402a5f71eda3a2a78ae319b4f996aa7b0da67c221c87ff2a778b7a20030a2f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[193] +aad = 436f756e742d313933 +ct = 9003c98d71b1aa4f531c51537cf538302b5b6036e7af1cb4aadae99921baa5fc30aa86abc8ac525495d92f8b69 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[194] +aad = 436f756e742d313934 +ct = 6b7980f6b429998a899dcd87ba98a96cbf03b9a0878d3afe10acc0742114a7ee003047deb911ca38ef760fc903 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[195] +aad = 436f756e742d313935 +ct = 4681f2b8075420e813ad70b9dd169187ee65779371d3f1abc6e62a99c8ee1cfe9be5088cdb20ebc11373d8af38 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[196] +aad = 436f756e742d313936 +ct = 66361f11cf2515e44be30d93a4a8d9497945f5cc8e7f06df6e4f3f58cb47951841d00ab8b4a52011303bc58be1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[197] +aad = 436f756e742d313937 +ct = 09cbadadec104db37f240fcfcbcabecc92a03ec3157b789cc12c25e01c376a2f59189ff77fd8488b43bb81e8fd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[198] +aad = 436f756e742d313938 +ct = d490d9602e9e59f96b8aeda570e2e58428ce7c06a4e4dd3b8a3b61307d6fd4c6cb89d07776c30417484ad2f249 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[199] +aad = 436f756e742d313939 +ct = fc5ae84ab4afbc898cb4b5712e1fbe7f75465bb6e834a50f039a0d2b7095cb732db60b053ded3c0e3df0626864 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[200] +aad = 436f756e742d323030 +ct = 8f1af0ac6b21371f2a347a007b9de28f54cdc3ee1db93552bd340732e61d1bbaf3194e24cb3707b018d97f5010 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[201] +aad = 436f756e742d323031 +ct = 45eb8bc519b8ffb448af0dddcf31b378029d916aef6c91dff98dc01a10d1a2a4c0e43445da2d2cc6da4037193b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[202] +aad = 436f756e742d323032 +ct = 65cd2f48815dc6ecadc4d751cb8f9aab5e678d87abad28d4499670eb5b61c4d1c3c808d62cc946771a5673afdc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[203] +aad = 436f756e742d323033 +ct = fb0111868c29bc462791ef235b845450873cbce9d64a7d8851b993de034e13f40e9998046e9d29caebd1625be1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[204] +aad = 436f756e742d323034 +ct = 6f6b24fe3698cb0c0a8b8b4f6c999aac265a81a25e85db60dd0847b8be655480e462cf8d3bf6f9beb21de26feb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[205] +aad = 436f756e742d323035 +ct = c93a9ae61a56dc361674f9e6c2570b464840afb49842807989c6d9f700552245151e85e06e37d7a30c09780cf4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[206] +aad = 436f756e742d323036 +ct = 145048e595c7c405afbea4c8013fe3dff529a2cee5117c61d70150a3c0b97200809c03cb7d317ae9aa3c06628a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[207] +aad = 436f756e742d323037 +ct = 29f01ab2a7ffa29fbd4c63a590ad7ecf87ae93a2c0eb1b5936b3a6d649e7803fc950a94810dedf18b930536170 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[208] +aad = 436f756e742d323038 +ct = 633d7ef1a17ff121485a82bf4bcbc9051d9768343e547ee9531f3b3c1cdcbc11dc45705553b1e16a1182488b1a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[209] +aad = 436f756e742d323039 +ct = 37bc7fc586ccb2579fdb41d13865c8d9659bd8d383910e2474fad0dce89dd418404a458f02eb8172a1f56d8453 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[210] +aad = 436f756e742d323130 +ct = 92c1f5393dfe1325ffa85d86c1acdb492476ec7a5564820771a761a2df780ac6be823900edc2fb0b61a1ed5aa3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[211] +aad = 436f756e742d323131 +ct = 7da1a3fb27f68587bfb66e54aa2b98b1217c1b274802dda873c2143aa69b0dc999537f07d473fe2f0b9dc6a8d5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[212] +aad = 436f756e742d323132 +ct = aad51528d9d7518519e3e610e9048077062eb164e64388c9bb8f63e0eab617be0ace7878cb261fa426fb051d12 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[213] +aad = 436f756e742d323133 +ct = a646e6617fbe4e18d4908a1f0cf46500fe3b82cc306e249b76586865cbfcc39d7b5c73b3f372a18a135aee8523 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[214] +aad = 436f756e742d323134 +ct = ba2a96778c42d5be2c036ff75cab34898896b62b1b2d0adee7dfa194e3da00a2c36967a74107c25030d1b23bd4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[215] +aad = 436f756e742d323135 +ct = b7c0b4fc91764f3935da56c764311e6ac6d3c8af44fd5b5f53901842e9bbbc6ce886dd615d6f6c4b6c285dc9c1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[216] +aad = 436f756e742d323136 +ct = 3420f14b4463e393dfaaaf07d48b383d6f082e5d58708b2f2ae51e432c435fc9e2fc17f5db6b1575343e91482e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[217] +aad = 436f756e742d323137 +ct = 0f37542535f680177a32128a9f79ebe52d34821fd818298d6dbba4a51c484d1426d904b5afe80f60e180dbff91 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[218] +aad = 436f756e742d323138 +ct = 67325db96b9572e0b1082446950019b05da85c062e9a5978c3065aa5bb938b03cddcb50575b8b3b5b689bb59e6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[219] +aad = 436f756e742d323139 +ct = c5211f82cc9a8261a0a5d93b005a241eb23404497b77689975437b19a2e42b6b7bb38a16ac51d813a413997e4c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[220] +aad = 436f756e742d323230 +ct = 4d9571193ceffe27a4944d1c78fa0ffe3aa6cfbca6c970b0f93e32aa7a96333fd16abfe81de9114ddc45fec762 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[221] +aad = 436f756e742d323231 +ct = aa0133057136602263f523658181fa9bb1e66262a9c79b97b1579bb0b5b1bf4bc0a0fd64b607b01cccf52d8e9a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[222] +aad = 436f756e742d323232 +ct = 825b7894b5a6c4ade04f5f70cd98d975c5ae7707c5f8c1ea197e1faeb280562c77a3e5130d0037d64eb1c86cce +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[223] +aad = 436f756e742d323233 +ct = 46f11fa25fe412843fedade29098bdf448fcc6473ff0ee7503d1345667d75e74746905166924db804399ec2b8c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[224] +aad = 436f756e742d323234 +ct = f7fd8d51d9b9d2d5e24b9d4de9f61c9d604cab2bb65712f80de2d94e8daa307de22283c4bb8614504f71b4a819 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[225] +aad = 436f756e742d323235 +ct = 6f54ae130c8cd9b75627495187d6aacf564778a7bc9f6fbe7001b5a284592dd0c3e7ba3f14d955fe42eec72e31 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[226] +aad = 436f756e742d323236 +ct = b0ead5ca3c514d405e22f57459bf3e4b3b10480bc5c5ed6cdc907eec7d7c55791c3ea020640cdef28995163a6e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[227] +aad = 436f756e742d323237 +ct = a0fcdb684a93d7a27ddbdf6c2dcfb191d9a9bfa0a7ec64ce88b408cf8a8deb19b966cb641d944895b85f0b954d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[228] +aad = 436f756e742d323238 +ct = 616bc44dfe78f7f3ef9d56dd2312e8ac0d08de8f4852dae7794a7e7a415094f59665645ed09387507d00303def +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[229] +aad = 436f756e742d323239 +ct = 8929024200819b1fd946627756e9bee6efe49fc6a80c6e720fe00c2ec5689f330eaff95e77398a09ac8d3b9aed +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[230] +aad = 436f756e742d323330 +ct = 54e672bb9e4ecdecfa3526f5bcf1a6745f2007658f794712c8f68e2544c6dcc9946f4a81288c3e76475c1c929c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[231] +aad = 436f756e742d323331 +ct = 9846eab40523dd43878ff150ee10a54c5fe54248fbbed57cfc64ca52aa5817caf0465eb934b4dd99b96e5464f4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[232] +aad = 436f756e742d323332 +ct = aa6e8697ae32fc0908b8f6fc79639f65f59282329f74f65d82bd23d5cffb83ad289b7400f25a87825658c551a3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[233] +aad = 436f756e742d323333 +ct = 8412449390ae9f7a8811282c45109e2074213a282edee6014f0f9b51ad5a573de7c98d02c19fe9f29336d4e4e4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[234] +aad = 436f756e742d323334 +ct = ec413d776c28591efa625f57ac7b1efc0137654044c3763a103b86e94082b92c2ba158eabf8ddc80e232f184a0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[235] +aad = 436f756e742d323335 +ct = 179626ccb1dda5d800312a158da372a184fd6f1803bdb472da045467f2d8e4676114881aa10cd1c3979be9cfaa +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[236] +aad = 436f756e742d323336 +ct = 6de796ba74b37a78fac00a329ec3e7c936425aceb4e36a623671cb39b04a571408fa1992bc592a44ac56f2a96d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[237] +aad = 436f756e742d323337 +ct = 48b947a68b838f5393acc967cbb6f52dbd161328817438df5dfb9533cb1ec2f7f77aac3c8d1a487691ff3f917e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[238] +aad = 436f756e742d323338 +ct = bce1baf335f9a2a0677cac2bc6b5d3d2618e772f3af688bc82fa63d839c5e7fcd51535fcd9ccbea75936d90b51 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[239] +aad = 436f756e742d323339 +ct = 952e38288246111e5cc6a6f0fc5901577dfafd4e28bc544ef5e468e71bbac87ab338773f859ca87f3474fa629f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[240] +aad = 436f756e742d323430 +ct = 660c6a8f448d5b0680cc1dc929628405e2a6c02da409cd3c6fe3cf7141811abb751b223ad789fd14b9e1602afb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[241] +aad = 436f756e742d323431 +ct = e5747a16c008e797c3be09d597b2884945db07314faed0f8f778d4b6b9cfc59620d53be6ed8b4aab2e4d9f59be +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[242] +aad = 436f756e742d323432 +ct = 07ae27bbcee503b65523d33d061e97316f061f7c355e633d3c4ab131fbf33f4c6792e947072774bdf8adfae78e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[243] +aad = 436f756e742d323433 +ct = 3d9f2b4d7c14170cdfd535f6190d35e7a1abb2021b30b40ee8f3bbe3d54c02cf69f2b9da331a916e739d74f959 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[244] +aad = 436f756e742d323434 +ct = e2c42282ea2f99db6d93c31bd90e7bbff5e3376d32303a99e358bd5083918986469f01263bcf60c38b7c822230 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[245] +aad = 436f756e742d323435 +ct = db37f6664496ccd0cc0422c0151cbd0a5ae14cc5355504e76b52d7cdc0625eae945ff1c39f37a78de712d9d30f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[246] +aad = 436f756e742d323436 +ct = 98c02dac817d309004e910ff1aad1ee768d641f717e68a951762dee0384f8a5fd09b47a5ce35aac62a1093db4c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[247] +aad = 436f756e742d323437 +ct = ffb8ec458cb1d80e79871777e3d6340e41acfee88b8a777d08f83a95e9e8c0806f23a5ae627b85c1bf67031d3d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[248] +aad = 436f756e742d323438 +ct = 9666674453d6e55e481ac351253fd806f1dff6833c755f16737acb4e01a52a15eb51549892f08c039710ff17f7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[249] +aad = 436f756e742d323439 +ct = 87faac25c2e84bbf72abc74bb8f86ae409bc36c1d7f4ee3583c6246a2cc4f72bd4503c92209f0bdcf2bf9b97c8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[250] +aad = 436f756e742d323530 +ct = 9b779902d73179cc203b8551e595b2525005f1b963768fa742471bb8e399ed016806052cffe16ec1113bb92761 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[251] +aad = 436f756e742d323531 +ct = 9cdc91cd4dcf786f3d64b9e60f60aa39185aa9124d67474e8d5ccf252a486b8f99475f2391acb83cfc97572329 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[252] +aad = 436f756e742d323532 +ct = 5a8ac0f7e52b423a242ddf4a109c81d67d340f6c73115e327fa34768cd57e2b2f03b97b59040757a0ce78c8d41 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[253] +aad = 436f756e742d323533 +ct = 77796249ac3cb85b11d8a912f4e3ab18e941875e4fbfff3ed13b0e1e8b6f70199fb1aaf82c90e0106abd697fdf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[254] +aad = 436f756e742d323534 +ct = c62723610b47a9702d7226f58e4b309a3165e81425a0e0fac70dd6c3c2dad7230da418743a3f196a51c7cd06db +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[255] +aad = 436f756e742d323535 +ct = f2783a56b5f0cac017424bbe7d29dc9cc45ea7a6050ef83c3284f5ad7bc889aab2cb46e6916a683b17b903b63e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[256] +aad = 436f756e742d323536 +ct = 16bc024eb0af9037260c822d45fa786e3c259aab1b7a4a196a72c3e794e78446440ba42b531da44d3d36d0a042 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# exports[0] +exporter_context = +L = 32 +exported_value = 8890c5615e5d6b0e1b212e26d80a7e8c0d03e796377f09e9377aa0497ccf89c9 +# exports[1] +exporter_context = 00 +L = 32 +exported_value = 51f60f1d4505688a1aca99c9b789e44f38a5bfa177a6b4660ff57114bf50c6be +# exports[2] +exporter_context = 54657374436f6e74657874 +L = 32 +exported_value = 25f7c731201fe73978b5c66405f17de3e59b7f1c4bbe21e9ff57541d152841ac + +mode = 0 +kdf_id = 1 +aead_id = 3 +info = 4f6465206f6e2061204772656369616e2055726e +skRm = 8057991eef8f1f1af18f4a9491d16a1ce333f695d4db8e38da75975c4478e0fb +skEm = f4ec9b33b792c372c1d2c2063507b684ef925b8c75a42dbcbf57d63ccd381600 +pkRm = 4310ee97d88cc1f088a5576c77ab0cf5c3ac797f3d95139c6c84b5429c59662a +pkEm = 1afa08d3dec047a643885163f1180476fa7ddb54c6a8029ea33f95796bf2ac4a +# encryptions[0] +aad = 436f756e742d30 +ct = 1c5250d8034ec2b784ba2cfd69dbdb8af406cfe3ff938e131f0def8c8b60b4db21993c62ce81883d2dd1b51a28 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[1] +aad = 436f756e742d31 +ct = 6b53c051e4199c518de79594e1c4ab18b96f081549d45ce015be002090bb119e85285337cc95ba5f59992dc98c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[2] +aad = 436f756e742d32 +ct = 71146bd6795ccc9c49ce25dda112a48f202ad220559502cef1f34271e0cb4b02b4f10ecac6f48c32f878fae86b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[3] +aad = 436f756e742d33 +ct = 5b23a1bb4a46eb6534d7929b88055d6a73fe36fa2209b7c851391a8b73aba3f8034e2cc588317ad35804fa4f0c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[4] +aad = 436f756e742d34 +ct = 63357a2aa291f5a4e5f27db6baa2af8cf77427c7c1a909e0b37214dd47db122bb153495ff0b02e9e54a50dbe16 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[5] +aad = 436f756e742d35 +ct = 13e916caf926e56e911b1f114f4d3b91da26a5761bc475bb874e91fc625e2f15d6789a8bcb69907d03d618406b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[6] +aad = 436f756e742d36 +ct = 1ae4fc091fddf17c3c18c8b7bb60063668e6eb7fdcd0abef5aaa8922eb73b4317cbe38301689a9bd876487e86d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[7] +aad = 436f756e742d37 +ct = 3034f34153aa2227884561ea011af79eaf74fc9f4540c7ef71bb49e80c0a38834ecd2a2582c0c6c7412b76fbdb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[8] +aad = 436f756e742d38 +ct = d9f753851465e7153c1c0ec83c5d9804f52b2a984e6d8bbeafd92865a736ce1dffec4cb28f3adbde0d16acac77 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[9] +aad = 436f756e742d39 +ct = f3af37da4888aa0b0f1ded625e06a277429df8e8d89782b6d10e58e94bf50136abdb2b5daee5101213b0f49f5f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[10] +aad = 436f756e742d3130 +ct = cb8bc2f5c08dd4ad61b85ea2e0ad5d0ae244a663172d1b7b2cf0477f7c1f16d35b3c5145fd6c310db97fa56f6e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[11] +aad = 436f756e742d3131 +ct = 7b21af3ffba9165013c692cab1287d60a93c82ffaf3f9329ee5fa9d8eb6f11d2432314f45d02b2dd5a3f73438c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[12] +aad = 436f756e742d3132 +ct = 039fd4450d4c35b2ec404479975c3a83a526bea12c1d41653e758a8f84f41b7ad2c1ec84f6fe0e21dd664f36b2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[13] +aad = 436f756e742d3133 +ct = 2f65411d6ba8e3113b67c7710502f7772bfc9718d37f21f2cc4d0f61f2717d0fdc2c2a380f8b84d006e8af33e4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[14] +aad = 436f756e742d3134 +ct = 494dbc5558dd047c8e6f3c547cf5ae3010496f99d2ccbcbf8e3660d435d40ed41c441abe4a71f7cdc298a47512 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[15] +aad = 436f756e742d3135 +ct = 155dc29cdc2e5718756c572197731172cb5463692619d10c0f49142c858e7fe4c84a801ad74ee11277a899b17b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[16] +aad = 436f756e742d3136 +ct = 554c22933d7d58c6689ce050d8e1eda0af1a1e6b0c9621ee5c3cecb24170be59b59794f78851bee7c75c9bc9b2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[17] +aad = 436f756e742d3137 +ct = f14f868aeec918d8917b5e1c5a3acba3eac72500e2e1c5859e940b836bb5fc690c9fa666040e0f24235ef89461 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[18] +aad = 436f756e742d3138 +ct = 09aa8c97325c57173175ff935f1545dfef19a3c23df9d650e6e504b0f38476f9c328e9f8545dc03eeecd397efa +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[19] +aad = 436f756e742d3139 +ct = aab8d8659b899dda7ed988788c1f753f65182fa46aaec3790c752c5e6d4edc66d1a29cb7775a06d611cc3ba9da +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[20] +aad = 436f756e742d3230 +ct = b53cb489b5afe8d32b8b7f06a85ea21eba5d95637f1b60f5bd065ca400176588edbacff42a2fd0b9b2319c6b54 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[21] +aad = 436f756e742d3231 +ct = 2de0dc0045de431a43e2d46b8309c01755777174ed464e3076d1af20b0ea679e40c426df862d3d9e24885e815c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[22] +aad = 436f756e742d3232 +ct = 4e92189ed1d24e7816771cca561591384a644a7ace00cde6a3680d83032c3d74194dd478019cd89544fe802db9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[23] +aad = 436f756e742d3233 +ct = 3992ca5ddc6cb82d81f1b317c3a1105ae1d0b5b7bc38649c7c350a4dc257753097bba175deee96426f96aee308 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[24] +aad = 436f756e742d3234 +ct = e6f475061e9cf348298d4de1b3ed8e84d05b1a22210222d317092554b4b1b591b89c91f890da65e815294eb71b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[25] +aad = 436f756e742d3235 +ct = 7081949d6353a8a4849adca6ab69c21873368cd5381f317cdfaf64d5e47b21499996a890b24df18e96a50ec4c3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[26] +aad = 436f756e742d3236 +ct = 154c97813292de73d50275d18fba298c207e7c8f27f74f2d7566db9334348166b0be420c0cef431e085fd44324 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[27] +aad = 436f756e742d3237 +ct = 9e453e6146c12681cf1ad8c033c5a18cc28824c847a391413fc2bf51c0657499fcf3cb659cde1c0d00dd092d24 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[28] +aad = 436f756e742d3238 +ct = 53e99d1fe817118adf77c5eaab64ddea7f8880e5296c5261194e666931924c92d031cedb844f23f2284270e4b4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[29] +aad = 436f756e742d3239 +ct = f4337b127f13c333d1c979803fb31fe57673d4e68dcc907dccbe67cfa2de78ac154c63cc43510a821f7dba17c5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[30] +aad = 436f756e742d3330 +ct = f6ee59922b6f249f7d55f64d52692b06f6deeafae40f91d56ccf8d574d61f93a37cebe5744f40bf5b1451ef983 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[31] +aad = 436f756e742d3331 +ct = 39975125abc4f4647b5e8dd5141a375f9ba66bbff0c4f89fa26eac66abbb71f90044be9197283ed9b60516d866 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[32] +aad = 436f756e742d3332 +ct = 545ed2b3050db6cbbae44b8f59fd3e80635390d22b2a93114bd928fffffb126481b32ee539120ff99dc3138dc1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[33] +aad = 436f756e742d3333 +ct = 2dccce6855d90951971ad92eb2fed5961823e402af0d4f21f910465c3072622ef18e37f91e6e456a854256159a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[34] +aad = 436f756e742d3334 +ct = 1c614a68a70a26f0824a92d25121791d985e8f99a54f0b72475ae04656f8517f5124fe0c8d55d243e47f296f5a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[35] +aad = 436f756e742d3335 +ct = 9425385e046c183e19515b5776407f7cb6b8b71a0352598e57f8bd8808652e1267506432084d98b8397ae18df9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[36] +aad = 436f756e742d3336 +ct = e5de6144eab00d48ecf33a175be12bd845fbd640ed9cef6c6a31340ab536c9a0f07291762f77f1638e248946f4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[37] +aad = 436f756e742d3337 +ct = e402b0a9c028a1b292820d8e438506d157ce717b5c8bbd4eaaac9e6520363df7e108900f0f94eecbfa314c3c43 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[38] +aad = 436f756e742d3338 +ct = 47a319e1ad50f8d95f55e2075f1d54f9af446636571d81b39ae95cd50a55543c74d65f811aea42de7ed79ce756 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[39] +aad = 436f756e742d3339 +ct = c35d9f43b38e549c6c12a3aa433af0d6f3fb383259ba8292604c82f6bb2761a474a165c37f6f27ab816388af3f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[40] +aad = 436f756e742d3430 +ct = 918222466085e53705e47e6162d3e715cc1ca21bfcfba857dcb1a4dd1fe45c0fe95f4eb2dcb7f27b100dd165c3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[41] +aad = 436f756e742d3431 +ct = bb2136e56748f6d78f7c4aa8093cbe651d0081d7046e66873ab849e7b155e83402fcabb30af22b607a3758e5e7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[42] +aad = 436f756e742d3432 +ct = 7671268965a6bff9b8ffda26e5292eb37e1257d3952dcf37a65a6077d93651744d5e5c44643b1b0b53c20d2039 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[43] +aad = 436f756e742d3433 +ct = 17784b52a709bde67d6fcc6b6de937cbf80f9cea7405708f42bf1cded9da2f6c240a6d2063692bf2c896c6df86 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[44] +aad = 436f756e742d3434 +ct = ddeeeb8ee50963740d7283ee5404581b0eb97619acba905588f66b5e79052ab61da7af7e3c9b54c201899565ce +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[45] +aad = 436f756e742d3435 +ct = b4a4871ef73db1b66c310341e67187c30cc526ec5fa203e57848449f029d20906f8968a6599ba5b9b5a519d1b7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[46] +aad = 436f756e742d3436 +ct = 5de1796b6b89f1cf0b93c88c41e7778cfb482a81f3bab287f636b10d0c10612cb884aec9b2514b0c1b7af59fbc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[47] +aad = 436f756e742d3437 +ct = 041b12ea31a73f9fb5b80ffd373c13a938a1f7888923355e17bb47c62221383d614d485bd25d090c68f45dfa93 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[48] +aad = 436f756e742d3438 +ct = 96506b77c1a44ced490059dbda1578226c3514977d4ebb39fc334c92b71af1220463f46af1d9effdaf099d23e7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[49] +aad = 436f756e742d3439 +ct = fc3dc86ddf279c9bf386c0161dea4a060f5e109484a4c0371bf551a5aeab963e0c38fd3d1562531572fcf041db +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[50] +aad = 436f756e742d3530 +ct = 762086d44613f1c0a15ce6c5dbf89d314e3af3728c0063a8eee91cda202de81b678230eabed359421493113578 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[51] +aad = 436f756e742d3531 +ct = 33f3cbd6ec16c70b1e639d455090c939732cecc87c7eed10bf57cd395b31c3b48f9a5a1655b48d3c471f57e969 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[52] +aad = 436f756e742d3532 +ct = 515dd43217bd14c705e96f8032e58fb486ffd167c89215111ddcd88087ae0df6741180eea245e2f834aa3216d0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[53] +aad = 436f756e742d3533 +ct = b93c95015ef99d815be1381fb27a6c5b2ba1667c859db56b2eccc2df9ec697aeed944f0cbd93fd8f952432015d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[54] +aad = 436f756e742d3534 +ct = 543a160b7a3025f401958732ca4892608bb3bdd362f6f48c3052e0b5599ddfda1b9ac57dc82d436bb2fd890728 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[55] +aad = 436f756e742d3535 +ct = ebe8436ae2822e2f6c3ba59b8a79752d10201da5551caffde4e8421e35ff23918e82ef57c154882edf949412b6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[56] +aad = 436f756e742d3536 +ct = 2e3babd04dbec3db0c25943f765409f83efe07287272d53fda796edce01604a24a409791b1dc6c9491ef951ead +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[57] +aad = 436f756e742d3537 +ct = 23d8e8aea875a89cd44d1a0f2f652f389a2ee8899c06f1b186f2d35b98ce2ca55586bc8304f2ad8f11ec6d4a45 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[58] +aad = 436f756e742d3538 +ct = 7fbd9f0b4ab1ebadd868ae523bedc740f19f619e3147cfd44626ac9e0148facf092c1b7a1439f12b66fab1ee91 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[59] +aad = 436f756e742d3539 +ct = 79901c340c134f34a87943df878ab284769a7fb6ab6b63c03107150a7c0bf02532c203b847f6b2e82b9dde4daf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[60] +aad = 436f756e742d3630 +ct = afea3edb11f087496f4e969455d323c65936376a11db5818717b3fc4729567140aa786e25a6420be379d9d7356 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[61] +aad = 436f756e742d3631 +ct = f7ea8ba2c5aa0317e7364d13429d7db23aa3184afd9698fd368287043ab04b9b0da3477973aae8df7c95055467 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[62] +aad = 436f756e742d3632 +ct = bb875e89ad36fc0be4ff873d25548e73c572f22af59cfb75db6a5842528720d0e9251a8d0d69d85fe4a44c23ca +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[63] +aad = 436f756e742d3633 +ct = 93d5bb5d990e893325555ef94928cff7e722dc1ea4be036e7803dc959c33cdc052a3da5af36ec904247128ef71 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[64] +aad = 436f756e742d3634 +ct = 1c77e504b276395a277babdcb14e96c02d44966bc1722e813e2ddabadfbe0893be0d5dfeff38abac3b4fe8c6c0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[65] +aad = 436f756e742d3635 +ct = e54391814005400e0a3712f651ac1cc3a4d8987a75c03b111d71f80cb9b1491efeee7a2894e794e83ab3e65333 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[66] +aad = 436f756e742d3636 +ct = 84e80b892d7f4b4fe505047d67f61d8a62de98429d4f34d5fae2508e7a38037ad8c67e85b9def05b628a0b85db +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[67] +aad = 436f756e742d3637 +ct = 3feff021bc5491d7329b2f0521397af99ee65a301488697b3c96ae6e8216d92b43478e7f45a8950c16888e94bf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[68] +aad = 436f756e742d3638 +ct = 328bfd026fe81f27992e84d4daac65d37661c5f16c41b4901163eb0e4ec4a9da77d46b7f35fa5eb41ed19bd054 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[69] +aad = 436f756e742d3639 +ct = 3f975f0ecf397b0e57e007c588bb93a4bd123506089a7c907f733cdf21c5359f861e6ecf36d137f3b8e3b951da +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[70] +aad = 436f756e742d3730 +ct = afbeb6001680eada34d532ed5fcb64f888eda521bf62ec048405c40433d6cac6cd1317f8309529354d581767ac +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[71] +aad = 436f756e742d3731 +ct = bf217e3b30a4210e59173df68e359f806e9a1636e2c683d12cd1ec9443fbc1c7c2b14f54ffadbf4d0d8f32c300 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[72] +aad = 436f756e742d3732 +ct = 4dbdfc3cbd4dc0efdb3c8f9e660d07bc8f1d022679c0d0ce7108fd679992dbdbf4ea0e05caa1439fddc705b5e6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[73] +aad = 436f756e742d3733 +ct = 2894e03bca52f3d6ccfa334a5e6832fa73ca18c75d21ed01321d7cfffd87cf56ac3b141ebb5dea1d611adbdc61 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[74] +aad = 436f756e742d3734 +ct = ea1c4c156fbf85ca5e6dd5cadd8bcb6c9e19b3b833012560d5da193abe33752794f92e67525446502c0b684aed +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[75] +aad = 436f756e742d3735 +ct = f7f162240ba707111097a7fa5030fa6e96033f3fc67551398fe06bb26779e33bc2e8130081ae237607e7a8146f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[76] +aad = 436f756e742d3736 +ct = c3343330c59be643478135ed7604e9f5a8e65cd6c38b13d51b0e3ee59bde00c2108116f9d585f0c5941c32860c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[77] +aad = 436f756e742d3737 +ct = 252d5d39d319eb01e8723da3adec3197c6c012a058e7ededc5fea6ace3cdc643c45e17cca3ec4e8f22ee4cc373 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[78] +aad = 436f756e742d3738 +ct = 77cd702a74023299629f0f3ee73d1f1f9515939d4b82c0e4bc1cb608b3281dceaefed6dd604b51c28fffb772ac +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[79] +aad = 436f756e742d3739 +ct = 2d5636db4e74f6259a4a63927cccbc2393ccd024bb9880a475776432ba27e1c1045c73fbb74948a8d3d2c0f811 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[80] +aad = 436f756e742d3830 +ct = 8ecfa6ca7db677ad757d74ff454d1c8f076166bcde9cf71bc22a6724cb6e5ce6e963aac83650f45f36c069df85 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[81] +aad = 436f756e742d3831 +ct = 3951a980d02ee0d047402352895ec3092c96687f3a4a81af987f808ce7a7df88cc8a2b04ad4dd7e1b93a3cde00 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[82] +aad = 436f756e742d3832 +ct = 5fd41e209137f2bd71793de55445a4f4df44f732488d657404b335d0a5e21d737d3ced858be28d5f396dce8810 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[83] +aad = 436f756e742d3833 +ct = 1516e99633edc73806a84334bf6a4b5ae77461de405fe6827da12c820a5eaa78f6aea9d41b22cb0c6c11ac3bde +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[84] +aad = 436f756e742d3834 +ct = b2ff502eff6663def30ffac7e432f1e580ea814b8513b1004af12d268de932e7cde5a55d99b6cf8517f34c4567 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[85] +aad = 436f756e742d3835 +ct = 34aa152d2822ccb3c2efde62f6a7923d9bfa510376c8622c0148fda24c62a9da754f979c44c65e93020baccc3b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[86] +aad = 436f756e742d3836 +ct = cf271c985cd39fddacd870f2be45eeefa6b1f7dd7d85d4865708847f3916656b4d05ddf593a0bbcbef0ed984c2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[87] +aad = 436f756e742d3837 +ct = 5199c1fddf6fa7c089b20665662284fed97ac3c925973bee516767b4fe1e0005fe476fce94bd3deea4d0c9fcfe +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[88] +aad = 436f756e742d3838 +ct = ef3a374f39725309cc9752d6e661c79cd8db58bdedbbd7d6b08fe1554644e5a601433bb035240dcf7a3d9a38f6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[89] +aad = 436f756e742d3839 +ct = c3e155aa10237e1043e28a7a8f681b91792e13bf78c897db601fec3d8c284b247638467a5a57dda646b90543c7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[90] +aad = 436f756e742d3930 +ct = 0e72f2d5e27c37094638f2d0e3c1b1d8d7c745ca85546348acb4ab8fe1a3d379191509189cbdfc4245090487c4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[91] +aad = 436f756e742d3931 +ct = 27ac400f3b4beb50ada443e43d74c46730e1b71eb72e97c636d0ff977d79cf91bbe87c6913d4f9601bc90ccb4e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[92] +aad = 436f756e742d3932 +ct = e8b2e055c163061a6234245f3e6ab72c9c7e897c2c2d00e298d3774f65c0f538e6172cb12ccb36a98278f2e3cd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[93] +aad = 436f756e742d3933 +ct = f61f2943d8a4648282206473fa3702cc74fb1d6931ef2a52ccc88fc4e4b6ce23667103f6d452f691e591e6afd2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[94] +aad = 436f756e742d3934 +ct = 0cc73e09604e6bed58aecf1b365285c56f5a94ab35c3f4177fda4b52757a1f003c46b9ff528863ba9a2644dbd7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[95] +aad = 436f756e742d3935 +ct = 2e5ad52049529415c2b24dc5949a128cb9045304e1645d428e9602dbdccc9f4d8ee5b7337caf69049d7091267b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[96] +aad = 436f756e742d3936 +ct = 6146ffeeb44cf294c63962c4bb48cb233a5157eef4c1688a99b259cae5b0125b2cee8a4969a7c8736c3b959d3d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[97] +aad = 436f756e742d3937 +ct = b0c71e3417967f477658a019ad720307e21287096fdf9cba517c81bdaad0dddd39a8ea1ba5e9b03d0adea8b4f8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[98] +aad = 436f756e742d3938 +ct = ddc7ea7991cf45bbabed2c1fc38ca55b475a226bacdd1778ec8f90f38fb10ddd9e14ebcf57a8a472f89005fcdc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[99] +aad = 436f756e742d3939 +ct = 43b4c369a15522e7fd8ffc94ea8fc0ac4bfe6423f2140d741948b99d7f37a7d19b8c711cd1cab239eeb8b6a1c7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[100] +aad = 436f756e742d313030 +ct = ebd8870f51fe43cfc1ff67bae967befad397f316d183382f72dbc8feac3aad0c06808a0f914d871be6ab3cf2c9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[101] +aad = 436f756e742d313031 +ct = a5abd9ac1c787a9548b37346a4a6337e694fd42fd180623fbb860e9df75b0948e9558791d5729f064c11cf11d3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[102] +aad = 436f756e742d313032 +ct = 11b1858f8cd4668aba2d2c6b5f7a9b34fa4c2e5afa16ff42a3c05d58fbb2a994a387ad4deca4ad6f569d9a9f39 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[103] +aad = 436f756e742d313033 +ct = fcb7d46fa9102974cedfb8e83aafd1dc2392042b8dc52dccbc0a6717440597fd710bd9c1ea3af0e3d7a362f122 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[104] +aad = 436f756e742d313034 +ct = 780f8f46e0c247ec2793933ad66e2926d6461426923e2f4821d021facdcf0271fa252fde7f640d3c2780932bb7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[105] +aad = 436f756e742d313035 +ct = 0e0cf8a78acd8b57ccb6271c134fee2ee7c2ccaae1fd7869e91b07c9252a81f27abfcc14e7d5f79a28ee444676 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[106] +aad = 436f756e742d313036 +ct = d6290633b09e5511d1c4e019a1dc35902c3ef1b3c6f25050a88328f615e737e0a5a118a2ad6ebab15ddf982c0e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[107] +aad = 436f756e742d313037 +ct = e1d7d3ed74c0ae1a55c25990813f19257aff7d518c9cea74e958c7e9da405fb0faf1b0890e5ebde57958eab161 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[108] +aad = 436f756e742d313038 +ct = 337be5b4890c40a215ec994a22c052271d190bb16c21a617396623ceab9c92c24659f365a825fb3d2f83a2a51b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[109] +aad = 436f756e742d313039 +ct = faf4e4ca80ab7165a7c438dd3408d639d81be2fd41acf359c7bf2aa36a3ae2b85048415582089ca077572c8127 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[110] +aad = 436f756e742d313130 +ct = 117a8924f12695b93ad2a524fffcdfea837ec279e587e23bb91baecf5db4ea35c54658dd57c3c4bcd4e7c8b19f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[111] +aad = 436f756e742d313131 +ct = fbf09a8165127a844b9d879a39addf98f08474e244a8db6dbe50d51944233086aef4ddb0cddb61fa9e9cec113d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[112] +aad = 436f756e742d313132 +ct = f2b6bc73bb81a7db754d4210c3e29addb2bb31668321a79d1673c258acc6aa35c62282f9ae89c4fe3caf816ea0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[113] +aad = 436f756e742d313133 +ct = 1dbe114873ed874af58808fe65631fd1ef2e29a4142e7f15c3e9c12abaa11f26e4a945f662a99fabc0def49caf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[114] +aad = 436f756e742d313134 +ct = 424df6475b58070d56590f81e287798ec199aeac5a96f8d39f29a78fbe4b0b0a9c2991413e815edb0266f48bdb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[115] +aad = 436f756e742d313135 +ct = 672f979899572fee01ee11addd53923252cfea452f9933149d53cac450ef7215a98407c997096f16a87bf316a9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[116] +aad = 436f756e742d313136 +ct = c4158a774b811d3ba2bf11e00ea2b4887abfa329219370612935a8b22f4399718689be9bc54871f6a362c55f11 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[117] +aad = 436f756e742d313137 +ct = 9a153e98698656d114ce7b45b6c24341d50d66fe45a170bc570c185eec7f0424eaf20db7118d5ddaecd911f692 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[118] +aad = 436f756e742d313138 +ct = 641c90874675f1ad9131a995b632648e557edef53779e6572cd9ea80e684ed62b7c3cf25380634a0f34d3a2d13 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[119] +aad = 436f756e742d313139 +ct = cdbb52dcd782784096133a696ba4d20d755f0f150f4e1c7245cb17e30a5a599e53850c53ee980492a0ae0a86ea +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[120] +aad = 436f756e742d313230 +ct = d2d7bd0462eaf3320587507249643315a77da7cdb61d9e00b59b7d882142daa8d64ff910b637ee892b97c9542f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[121] +aad = 436f756e742d313231 +ct = 31d62424dad797797679163e601da04bfb30b1b214ee56fc514f728d3ec1928175ef03b04cc0ec8ec449145a9f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[122] +aad = 436f756e742d313232 +ct = 72890066793d4ce5851795f2bb11a702503d0b02091d8520e1236ca9429f6915e8b07ee41c560e9301a341b1bf +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[123] +aad = 436f756e742d313233 +ct = cd427af93e5a6e662da9d023a4731972348a186fda02f2524f197708edfc7770e2395f0ba24c0e3a73827628db +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[124] +aad = 436f756e742d313234 +ct = 0f54466a39ee0e3cff12f715fff595576d925f76afeb50193173d744bde8679fae3dcb65be7e307b23ade40504 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[125] +aad = 436f756e742d313235 +ct = a30fb4f1fa85c078468ddb6ded139106b6b4f19f4e0c9f51f32801a3f67af90fafd3cbf46c9692ab54bacfec17 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[126] +aad = 436f756e742d313236 +ct = f5205006e1605b0f5b9943d5bea5c452c00261fe468902d948cb4e77a88c9cfbd9c4f765de197d67a0a2e7097c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[127] +aad = 436f756e742d313237 +ct = 5a1ae229d393354ef6188759e73ceaef47c5c5038a4764774f996035000d34e9f8235f7a7ce94c1a6a29d982e3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[128] +aad = 436f756e742d313238 +ct = edec2520d385d5a75d4281d927865302c61dc3d99311ce987fe9ee87c2035fb93a5ebc2e5ec9396a9ecee6b973 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[129] +aad = 436f756e742d313239 +ct = c410d16f9eec0b1f2e6ab1a65fab63885f1555e3499d1883012cc94ee87490fab8e82d40b749a317b15b26494b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[130] +aad = 436f756e742d313330 +ct = 14f1d6f624b582aec247062f9f9d6c32d89c80d7876d41441440b324f9c769e4e071320fe8ecd30a8041da7acb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[131] +aad = 436f756e742d313331 +ct = 7f89975b443e215589978e9f61e6207cede48a6e5b19ad4df15688babc33eda041ae74f5476b6fc37f10798dcc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[132] +aad = 436f756e742d313332 +ct = 91dd02deb3f61e67ff45cd8a2c61aa6c39df18b4d5676f7b6c57c0c274b4a65c9d22a8b412ec9eb2e2fe5de3e4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[133] +aad = 436f756e742d313333 +ct = b3c6fe76011eb105e4b1d5a511be0e863b5b3f3832ffe8afc84966b36ed4829c734b1191e7fc83ea94db64b024 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[134] +aad = 436f756e742d313334 +ct = baffbdac2c8c9a24909bbd467ee896625d9dd72eaaa11b7ee1520cdf64412c20a07fc60620ff17e9c19f5cb519 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[135] +aad = 436f756e742d313335 +ct = 8a7bbc189f3b80d0777d94cf7e47270b0d120de46e76de9a896311d4b8e4bb1e946475641d987c15e1abbd39b9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[136] +aad = 436f756e742d313336 +ct = e24362464d437c2d00bb59f020282c6a72c43bdff5c660c6d7184272157248edd7362e20550545cd9b7e2c54f1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[137] +aad = 436f756e742d313337 +ct = 9808dcdd8dd239d2405dfa278479dad5366feca0c6e15cbf0750c68e092c08fe02ebdb029f0719022265299453 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[138] +aad = 436f756e742d313338 +ct = 6096422f4c0a38d68b4faf4364e22fc98534d594b7791cba71ca1e1a381b318158e34eaf30e4b030206792a859 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[139] +aad = 436f756e742d313339 +ct = 21f71e717075903e15db104f6865b6f7047fbc3dbf65f9f648d15fde45c1755072c8a211c1c0bcf5d5b42e4137 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[140] +aad = 436f756e742d313430 +ct = 636e85e1b727f382bd1d83910e0908bb3f47a204b0e04a77722c76f168919489727df626e346600f28d0aedd32 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[141] +aad = 436f756e742d313431 +ct = 4f6c63ce156ed1168d83778579215ce35312166bbc98d02abc4ee03c60d02326ad07c51d08777544f0705cb7ee +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[142] +aad = 436f756e742d313432 +ct = 8f8359af17b3a5c18343ccae2b5d553b9994dc6f7ea613fca8479529f842decbb118ee9e74ede49e7003b49f3d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[143] +aad = 436f756e742d313433 +ct = 221270c0f2ac46fee06b8b779eab41baa74d0ddcffef47b9ca30a33f76cdde4b22d5a57bd91953736d98b1cb60 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[144] +aad = 436f756e742d313434 +ct = 23a8555e5165ef29e3d30d087f471c2b28eec5e94eb818d8d4fa422757019a3e1784271627ff2b526333b740e5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[145] +aad = 436f756e742d313435 +ct = d375e5d6ba2387ab0f19fbf63a55af82b4ea6ceed080be285c6efcec7f1d9eaa7717d8bea52783beea0a8b06d8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[146] +aad = 436f756e742d313436 +ct = d4747347e4f5b93863cb1079951819e9148ef5f5b830c45799efa13ac446987052d47b20b678621f8a223debe8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[147] +aad = 436f756e742d313437 +ct = 9d759d117fbdef4ebb9b70fabba081c3d2c6e083faad82999f9b2fc9ecbf738351594eee9d949df083d9c954e4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[148] +aad = 436f756e742d313438 +ct = dc539696ac9a42698551ae070eba7dc1b540ab553dbbd43e1113e0f1079d3e6b092e90e9fe9b5a27d2b86dfa50 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[149] +aad = 436f756e742d313439 +ct = 6f508b76afab6ec152f4a9f19013f37363c5f348ac098e172efe775f25c8726190eb17256fd91f21d6aadb18d7 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[150] +aad = 436f756e742d313530 +ct = 0ea02391896c4b37451a3863344f606dfbd654afd7d58aeb29b09d19768dbafeae09e858f6726e6e708130db19 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[151] +aad = 436f756e742d313531 +ct = 52b181eeab88887689810a72ab9ca29eac16910f635e5eb2716a47790017b3782c9f8dba0a1bce3bda527fced2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[152] +aad = 436f756e742d313532 +ct = cd8c5f53ef7a6a19493d3fb4d88a491c3663c0a6d8380f53dfed5f727e583ca6de725645c128a6e739c4f928f5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[153] +aad = 436f756e742d313533 +ct = 5876a1c9b5971b0433f9dd08780fb47b4bccf298bcb9363c83a376ddae778d9ccdc9bf13f6f81a818828e48dbd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[154] +aad = 436f756e742d313534 +ct = f68cd40a6d61712410ab2c2d3fdf3d5fdfdfebdc2e533c6e9150615469189e5854cf4424022aca568bbdebf527 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[155] +aad = 436f756e742d313535 +ct = 3b982a6feb4b033b7b742c895c16d0c273cfe4a3e43453677626fc8eaf5867b26622ab8d49cafb444894ac1e17 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[156] +aad = 436f756e742d313536 +ct = 3f283b4367614462aeea93abb6f5e565a9138e4b3fa3453b719bce40170210869025725ed494f9db4416b06411 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[157] +aad = 436f756e742d313537 +ct = 549ed49d0ed44536dc6f9a73fcb6cb6420f0441b87a269c390974602259aa376f20e16c42da372d5c1b397da28 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[158] +aad = 436f756e742d313538 +ct = 9f3229384c4dabb5e647618f501b66989311fb5258b19b4ad20c72874f273fb8a434dfdafc8803346be8d5e801 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[159] +aad = 436f756e742d313539 +ct = 239c4c8a6dee032f79cffea36724709c2ecdde052ce0c9ae6c15f7757eadc11ddb0fbb949ec4720040d039a3c0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[160] +aad = 436f756e742d313630 +ct = 027b6cca81e30aa3f37c68f619badbbf4aa9d26c5eb279ecb57b6f5fddd4020e6143e49920301c8ce1dd0d60c6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[161] +aad = 436f756e742d313631 +ct = b14f60943b33a79a398b225a517a0f9bf03709afa714375d4398371551e91834ffa11baa6e27c878593113596f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[162] +aad = 436f756e742d313632 +ct = c8b145b8217f0b86a8c69ef1d835bfe6c2185f22d87b938cc2a4d838c830a75dadcc7b5b7b63823d3aba11c14b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[163] +aad = 436f756e742d313633 +ct = 53026edabb6dddcd3b63512641c2134801130bbbab6b1b21cda7d5e4a48af68fd56287552834f1120be8980424 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[164] +aad = 436f756e742d313634 +ct = cd52eff6227d1e8a9201acb50faeeeb476515857f0e127a0db69176d41e70ccc9c01a9d426120389f1d08eb5dd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[165] +aad = 436f756e742d313635 +ct = 4e9c7956a5fdda91bd84fd006df5b298edbc6055fbf8553c733eb55658fbb8a4d3b80d969838bf3eb2153c47e5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[166] +aad = 436f756e742d313636 +ct = 46bba4391f8c75515b7a2b2825071d09b44a73450185375540902cf86c47917fe9f19156db6555d6a8d9e4ec00 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[167] +aad = 436f756e742d313637 +ct = 69aceffa957a4fb972a42bbbd1daa8a98d1dedadf925e827bd41b8e8e4adb33de639f2c8f92e69ce7669a63cb8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[168] +aad = 436f756e742d313638 +ct = 4b44cfa8a50a1eeb357b08f1659ed01fa0527d3c4ab59d72f0bf06301620cd2d25be3dbb3444c3884c5366dbca +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[169] +aad = 436f756e742d313639 +ct = 5442eafe977df2fef456f9658e6e4a74b7c90180bf8a33d2d5adce2958bd343741fe1579ef2f78a52f5a0842e1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[170] +aad = 436f756e742d313730 +ct = 30b747860a4f39eeb11e3758a15cd554142490fe12c9aabe5d3c71fdce34e69a6c1d4c799d485f4d4b51a5c721 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[171] +aad = 436f756e742d313731 +ct = 608dacb5aa99f31f8c957b3c4630aed121774138ace30d373dd98f29c17a6892e1a842d727671721145d93e5d5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[172] +aad = 436f756e742d313732 +ct = 6fd543b032740e762f04f6d90d83e75183a997214883246bc24d4236d6e26656124289b4b4b6accee4176f1dec +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[173] +aad = 436f756e742d313733 +ct = 6e3cdf915393c8a4265055c1d2671b97776e074115156e10e7f81e69adf97871bb0ae58f15fbd7b1e31a395292 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[174] +aad = 436f756e742d313734 +ct = 4bd80d3f79c99c40b5fa3913fc83f5a7d9486fca22f5589f2b4aa50c2b9d86e3c0f1a49aed3ccc1c9e6164e7bd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[175] +aad = 436f756e742d313735 +ct = 31ba0bc96f3a6db0ac4bd73b17d5a0f21ddef1668db1bfc5a3f3498f88a23033cce86933abc8831f62529df2dd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[176] +aad = 436f756e742d313736 +ct = c3cc98fa65baa464cb950b3c539c5988ea36f73bd3ab13f85be6dd0df1f9d79a9fdbc369d9c286253f78126e93 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[177] +aad = 436f756e742d313737 +ct = f337704ea92c55ef28b1cf904f066c7b62187a313051ce165584b40a2aba61ffc04dfd01be8493e15967234c73 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[178] +aad = 436f756e742d313738 +ct = 3050885e6e284811a759bd67884ab62f1d0bce7d790729d6cb224811c83b73cd3d708d85b826e204c5978f47b9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[179] +aad = 436f756e742d313739 +ct = 461dd9b8e3c50875b0f07519cdb9aef7d13f34df61dd97a093637b6ae09cd1e24741e40a2c309d0cd6b11394e5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[180] +aad = 436f756e742d313830 +ct = 9f795bed00dc2ba48760fd5c9cdc2006ac435ae471a69c8926019f7d71919829dfb6359bd54b4d87c04b3398b8 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[181] +aad = 436f756e742d313831 +ct = b557d7f6cdfc4707e99c047bc831a0558f19bd9b15ed607f143aaa85bcf73ecf2468752881c6e02b3e83d4543a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[182] +aad = 436f756e742d313832 +ct = ac251b361aea0a771c028cc9ff768994d008389f126970d9c89d1b8713575833e3757fa3f9efa076b5e77ec318 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[183] +aad = 436f756e742d313833 +ct = b69c7bf9d7ef08541f4bb4d96030a83fe3fdd77005cb16c865c7923ba30b3236955db8b28e7beb3c0535b08f5b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[184] +aad = 436f756e742d313834 +ct = 615b848aa99f4fb56bf436f6673145784906fca3172125375eeeafc57d895d3f6cfb2a6305d8e09f4e077278d9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[185] +aad = 436f756e742d313835 +ct = 1d4006772989c69d4d8b41b189ba68d1216d003812524a1db206da42f111ab38da9de9c39b06d0b5a0f4f7931f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[186] +aad = 436f756e742d313836 +ct = b9cd2de5a742eff0f508eeb3a43644060a88a73f5476e804e7be8d426b39b3f23324c89bc653e320b651cb843a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[187] +aad = 436f756e742d313837 +ct = 33d5a57af1cfa7fbc086b39770180dda5bd9ac8b7fcfd5ec8f3608a8e239ab39c6486b6733b4978c0cc011adc5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[188] +aad = 436f756e742d313838 +ct = 3f9665a5e33e089fcb79413f53e79c40ee93ad5b2a6de97a35843ded62fa277d4c258ea260a5c7e06f95a8d449 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[189] +aad = 436f756e742d313839 +ct = 242b8fee457d1c21311ce60c7774b6262852fb64e1d4f61de6d11f002535ee6bd9d65cd7f87573e1d8cce8383f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[190] +aad = 436f756e742d313930 +ct = 0b6e167302c1351ed4b8543c0d2879a7a8fd58e42f906e57279e4b52d8b9773e9f6a10334a5dbc07eec5577708 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[191] +aad = 436f756e742d313931 +ct = f34086725af61863c42947ed52aadd66b4e48b475f13266384e48e2b536c3dfd2ec6fb984f3bdfbdafa84b213c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[192] +aad = 436f756e742d313932 +ct = a53074ed3b88343c5b44799aa2cb6b323ef5b0615f948de2784c00af2709f7afa25f987ae24eb061b69c6ca2a3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[193] +aad = 436f756e742d313933 +ct = d293b46b823f01385c458a9bb3125ac70cd021de4cdf5624810a9899d3a3ab4394a3b8407f6a49ade6ed95cbb0 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[194] +aad = 436f756e742d313934 +ct = b1c77b724b044ba27240fce5f840c4de73d13b00ce73ba7582930d725a9766347cd6e210362c6ad01eae100141 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[195] +aad = 436f756e742d313935 +ct = 12afbe5e92bf061c3ac2cf48919616fc21f268cee9dcea2c9f61e02d9c37d0e2a27f55383b11ff4a8da4026a2b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[196] +aad = 436f756e742d313936 +ct = 7397c4a17f59b44a4530f2b1c2b766412244d31f340ceb6abeee44fda4a7e08bd390cc458b19ae003cd833143d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[197] +aad = 436f756e742d313937 +ct = 6181055e55e9f226013faba7694ad4f2655fb7c4ac9776b98fa9cfac6d4373a60199c6501a14461eff0ebd9eab +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[198] +aad = 436f756e742d313938 +ct = 51a0413101207b176f54ff80be07e219d3c526633cc83a4d4dcb504e2f394ca8be6c927c1698cca387eff89f8e +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[199] +aad = 436f756e742d313939 +ct = 4dda2afa170011d4a85928780d19d0874e6fd993c1994d23e3ab6abe2ea48e8b6cf72e3935ecb9f5db85978500 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[200] +aad = 436f756e742d323030 +ct = b37a22b46572fc97e5ae45043834d8a19bfdcae1b98111cd82135ae2f059d85e686d464e8ecd5ea42c73f20362 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[201] +aad = 436f756e742d323031 +ct = f8261dcdc908d46e6aa03bc25565cca2f2e6b86436ed94bd0ca94fdf28001b8b541a2dbae111b28f1a56a2e86a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[202] +aad = 436f756e742d323032 +ct = 64628718d4472b3f592cd09d3e1180ddcd7d2618129c0665085d3b377b3065c03b13c3e3f5cc57cfec3038c6b6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[203] +aad = 436f756e742d323033 +ct = 3f2ac05adeaaa8d70088302c09bcf3c2e29b11ddfdbaee8a2aee04608241ce8e663fffc4421a92abc69a1c9f80 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[204] +aad = 436f756e742d323034 +ct = 44f72dfe1d6de08f95407f63ec7fbcd97cee0e778b74268d7a50c994653cd3443efd4fb50adb13a6d6c79ca9ce +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[205] +aad = 436f756e742d323035 +ct = 8860128148e7fa751e2176bdd0989f81699f4a6f8db8b9bb9a740878bb98c1da926b34e7f10326527ba27dfbb3 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[206] +aad = 436f756e742d323036 +ct = d79816873a6e24b3738576e66ee2a3cd2faca1a8e6300e0bdd7932f7bbc2908f02af2bce13ebdd6cc108f4c9aa +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[207] +aad = 436f756e742d323037 +ct = 6925df0f28576eff6d3a575e8917bd1b94d3f656299e6d7f10b6cef87d0a228051c21e8c4adb6202396cc4502c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[208] +aad = 436f756e742d323038 +ct = 45465e087d0b390d3a13351a12ddc2c20b3055d2868be79465bec9a5eeb114a034dc04964928d973313b3a9f61 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[209] +aad = 436f756e742d323039 +ct = 92d94f52220fb8908a226599d67f101d8803a6b38a59ca1cd439cd42fb3e9dc3cbcb4449e36449e5f9823476fd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[210] +aad = 436f756e742d323130 +ct = e95cf8938a01158d09ff66c37a5436d6118db2aedc449951126ebf4184da493803a7cb6a71dc0e09cc46d42a22 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[211] +aad = 436f756e742d323131 +ct = 95ea0e88e2cb4b88c1669d9567de88a8f403849af9a74254e906ef595586b2e168eb0cfa2d6d258dc7b75e1ee2 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[212] +aad = 436f756e742d323132 +ct = e5c938d2605a5eb68fd5dc37a3ee20a83633ed5e5dfad218bcb2d8962eec2346ed040b4eab2a95b44fd98220fd +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[213] +aad = 436f756e742d323133 +ct = 9f75c8ad1becb7a32fcb307c5b29a91c53c7e6a745ae7664071d4aa3bd23c8e99859f1c4731473948a01655e57 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[214] +aad = 436f756e742d323134 +ct = 5b1e23823276f8ad3a202ae5403efd60eec67238703767f85e2f7d2191670491db06e109a0a23c47cea7ea7f0a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[215] +aad = 436f756e742d323135 +ct = a954766abb4da6228599061eff24e6e488dd28e645044cd2ff194114dcf8676da441f5d3d6f6a95156edc01d58 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[216] +aad = 436f756e742d323136 +ct = 08388a64ac543cf748ec47e7e6080a38ca18d40eb3ddf1efdbebcd57d3f357aaf7ce57f7433601175bbc2a97e9 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[217] +aad = 436f756e742d323137 +ct = 41d792afa8a74fd0d9bf4d9cefb406d9208b3364dd9a4059234ec9c3d5ecc08d5dda0e8df119467663f8b770c5 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[218] +aad = 436f756e742d323138 +ct = a765697054b7d1bcf82d5a3869f01ad632fa412e23f8b517ac4745e2f34954c422f108256d36b7c12ac942a9d1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[219] +aad = 436f756e742d323139 +ct = 164e696bd9a10e227fe9a3582e40574fe59d225661c5cf09a7c75423f8ddc370337292bada80e48b9f7d88628a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[220] +aad = 436f756e742d323230 +ct = fb6d6c347a61f7279767a92897ebfff446e929562315ab50adf47cea14d7f03b0d86939c0b0dacb245fe4314f1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[221] +aad = 436f756e742d323231 +ct = 61625bab2d94464510430ff6f74793cfb64bd87a5ca4193c5b80401058d082e351a36cac8881aa083018f9443d +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[222] +aad = 436f756e742d323232 +ct = 6c04a3f61cc9bfc10a6e67e2adcb7818a61a0709bd49285c5bd069808799a4b888292a4a802c15dd38d75925bc +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[223] +aad = 436f756e742d323233 +ct = f4f8b3ba316bc1109069dceadb7809b2864c7857f8d9ed3f8523fee84e4033ea681bd941868e1190d40ae96b18 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[224] +aad = 436f756e742d323234 +ct = 1ecd688ce744a684f660547887d910f0445b5b7167ea29ad646f2668bb064d83160205b5e977e7487bb4d06523 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[225] +aad = 436f756e742d323235 +ct = 38e766640dce7ce1edf30aa96c4324763036633bb4d881fcf26225e3c021e333ca8aed8288c565fa74e9238333 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[226] +aad = 436f756e742d323236 +ct = 8bb09de244855723d0b697b02a967bc98d064bd529819046640c1bb009f27c9bc85f68aebc1da97791701e4e53 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[227] +aad = 436f756e742d323237 +ct = 5364e964cca737d51bd327276a0bb9340c4efaf3630b6086b4b0e20205a418d4fdc8855962da8b682eccfd53c6 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[228] +aad = 436f756e742d323238 +ct = fb7a049058fade2c1653b3dccbae8c4ce3c5d50cafdefc618695c8a8955a8b8d48cd792c97b9c7599ecaa08456 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[229] +aad = 436f756e742d323239 +ct = 72ee72219b3239f96a902837a653fbea4a652f76e765ea4009e97f647fd0441f23abc6e6fd4af79c91bd206307 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[230] +aad = 436f756e742d323330 +ct = 54215a6653acd4e6976d5230607127f898aaae52addddebe170515d8cd6551eafc0e653d3f91e714dcc2cd0504 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[231] +aad = 436f756e742d323331 +ct = 1375489e8fa717c36d15cd26c9519c7c798af560b41e354fa86fc242760cbc448fe81de05044f1e8671e3a29d4 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[232] +aad = 436f756e742d323332 +ct = 025b901c822275bbe1d6f72358f9919d76ae4062f9cb29f0e8c4c034e2c8791f198ed837c5a78c01ace2a74e89 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[233] +aad = 436f756e742d323333 +ct = 7a7d9406e7bf753493cdc3167253e53b21ab34b5fb906c13255fc63001566aee76f1f2ba9dbe2de613e4178195 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[234] +aad = 436f756e742d323334 +ct = b192c5443cd1b4434c3d5f031f56fba802c965eab7803371c9702dd15927d1f842981c633b28e93f3bb9254df1 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[235] +aad = 436f756e742d323335 +ct = 1ba5f39d42dc02590901b8b2b755e528ca59085feda6c37318baeebdf6604cafd79a26369a5d55e58c45d90645 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[236] +aad = 436f756e742d323336 +ct = 699225fa0b0a7cd2350d4e6100ceaf21945bde25084b031bf2c83bdcaac73ae9563b5e3f60366d4f152ebb156b +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[237] +aad = 436f756e742d323337 +ct = 03a5d97ce6e8ddf07a3c2c33dd4d401eedbd09fc85ce68a5e52b1a2d63de672f9ed62e5e4e3a843560b4363937 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[238] +aad = 436f756e742d323338 +ct = 177a9525be60073909a731825a3622cc60dbdd7540e7fa6b706a45beff03f8d3c65220d439832a42660caf3beb +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[239] +aad = 436f756e742d323339 +ct = dc3ca9a852da948fcb4659fdd6e3b8fa307ba56e8face0f3d723582fc06c090a7d817a82df0cecf86335b82e31 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[240] +aad = 436f756e742d323430 +ct = 6ca9b591de5234579a0aa90bea2f016d60cf50e77bc2a06d729579cb8b7b4c68e5dc6d483d337c5151d2989180 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[241] +aad = 436f756e742d323431 +ct = 02e644e2e21b35f8868e786ab534c31a485b6e69097d10df2a25f24993c4d4d407f067796af1ca127de2f325fa +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[242] +aad = 436f756e742d323432 +ct = cc9ea8088634939f2e757726833e70ca2b00d7e617b1e525bc147fbfa9c6b3d29621d38a73e954944ff4e9ce5a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[243] +aad = 436f756e742d323433 +ct = 180bec2fc3e686d2f37f2b18a3b0a195a2277c28ffb49d85bcdecbba92f7cfd3d1832a310baaf01ca9396c3d8a +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[244] +aad = 436f756e742d323434 +ct = b067fc48293520ce29f528b1bad11c0d38dbbe942f0c27c0ca953469dcc88bb1fe4a6b156134ec7803a8f6d367 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[245] +aad = 436f756e742d323435 +ct = 42bb52ae652c21e3a16821c1a7dddb127e42b56c1985cf3800090a9accd8eb8080861e00f69f22bd09af42e19f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[246] +aad = 436f756e742d323436 +ct = 6bb1ca4dceb6137e525632def5bb056f7ce6f5dd452edb7a69449e43e947706e970978d47554fc50707c30567f +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[247] +aad = 436f756e742d323437 +ct = a37b7d0abd040300937b12ec5b6c3c43e594295f2b1d0f3292fdb0c38205d6ba925d0a11d3d1274b10a45c1d29 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[248] +aad = 436f756e742d323438 +ct = 729c0bae1bb680320852f4ab084062a0b143d535eff67da55999088f9f751fa7fcee704f524a9f6b8a94aa280c +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[249] +aad = 436f756e742d323439 +ct = dcbe1ab062cafc3bd1c189007316e09bba8df92eb0dd9ece681a62e1d5bb9ab9ce4e5055257c96d70b43b62092 +pt = 4265617574792069732074727574682c20747275746820626561757479 +# encryptions[250] +aad = 436f756e742d323530 +ct = b08f5a570d41d21d0aa528c9da0b68bc2006e2579a956616f40f46caa5c24f5bf2e6bd8bd5ebf4bce2b79fa282 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[251] aad = 436f756e742d323531 -ct = 1a9acc8588317d8be40f50afdd9ff12464dced0401e6f8043e387a1b4d82c75e63cb0752a06d3d6aab8eb41cc6 +ct = 985991414c213e093e8ca144c4ac5c6d90e2f136810c934831e8623a64349dfe77ca188acd973551b5241754b6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[252] aad = 436f756e742d323532 -ct = 1b6652abf366cb5106ee5e6676510d44de609794badb2672f9d5537fe32134955d8159da22d98c58780980de3e +ct = 67c3d85876339d04e89d76bde220151c85f88b83718d50973ed5712373545ede91492b1f22b3c2da20d6e6d7f7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[253] aad = 436f756e742d323533 -ct = f4048c4d1b9210430abe699016e1d696b9f67102a68d216d84bb99eb03f6d57d7968075942d4f6e56d462d25a3 +ct = 7552addfff71040acd9740a8deda98cf23dbe410a9af5fefffb7d0a21d60cff55d0ef91eb295fc2e0ef51516e6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[254] aad = 436f756e742d323534 -ct = f3e1101622e9c97c64fc58e58d71bd92acedbea1a5dbd90d09fca60470aa2c708ece6e8e845444860b37a9b420 +ct = 8f531f2137e6b9d7b8f07af2f3fbd425c5ed60cdcd642c035f4354432d6f5d41870cf1d6bc18bb192489982866 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[255] aad = 436f756e742d323535 -ct = f6ad1823eb0b932d04b6e23010eea64f1fe5edd0583dae5ba27ca6363f4ea104bd217331460ef4208040423641 +ct = 18ab939d63ddec9f6ac2b60d61d36a7375d2070c9b683861110757062c52b8880a5f6b3936da9cd6c23ef2a95c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[256] aad = 436f756e742d323536 -ct = 53624f4f9f173453b14e633b45390ff54cacaa4428d44baee1bff8133fab1ab3afe60f88e4634b525c54e92eda +ct = 7a4a13e9ef23978e2c520fd4d2e757514ae160cd0cd05e556ef692370ca53076214c0c40d4c728d6ed9e727a5b pt = 4265617574792069732074727574682c20747275746820626561757479 # exports[0] exporter_context = L = 32 -exported_value = ded6cffafaea6b812cbf3e241e88332adbc077aca81512914213810ee291770a +exported_value = 4bbd6243b8bb54cec311fac9df81841b6fd61f56538a775e7c80a9f40160606e # exports[1] exporter_context = 00 L = 32 -exported_value = 04d3cb6cc116b28ffd22ad5bc276c60d31fec71ceb87ae24db811c64b7507339 +exported_value = 8c1df14732580e5501b00f82b10a1647b40713191b7c1240ac80e2b68808ba69 # exports[2] exporter_context = 54657374436f6e74657874 L = 32 -exported_value = 7c5ded445732c14fe09727d29b4251c0fd38455fe8440571e687f0886aac94d2 +exported_value = 5acb09211139c43b3090489a9da433e8a30ee7188ba8b0a9a1ccf0c229283e53 -mode = 0 +mode = 2 kdf_id = 1 aead_id = 3 info = 4f6465206f6e2061204772656369616e2055726e -skRm = 8057991eef8f1f1af18f4a9491d16a1ce333f695d4db8e38da75975c4478e0fb -skEm = f4ec9b33b792c372c1d2c2063507b684ef925b8c75a42dbcbf57d63ccd381600 -pkRm = 4310ee97d88cc1f088a5576c77ab0cf5c3ac797f3d95139c6c84b5429c59662a -pkEm = 1afa08d3dec047a643885163f1180476fa7ddb54c6a8029ea33f95796bf2ac4a +skRm = 3ca22a6d1cda1bb9480949ec5329d3bf0b080ca4c45879c95eddb55c70b80b82 +skEm = c94619e1af28971c8fa7957192b7e62a71ca2dcdde0a7cc4a8a9e741d600ab13 +pkRm = 1a478716d63cb2e16786ee93004486dc151e988b34b475043d3e0175bdb01c44 +pkEm = f7674cc8cd7baa5872d1f33dbaffe3314239f6197ddf5ded1746760bfc847e0e +pkSm = f0f4f9e96c54aeed3f323de8534fffd7e0577e4ce269896716bcb95643c8712b +skSm = 2def0cb58ffcf83d1062dd085c8aceca7f4c0c3fd05912d847b61f3e54121f05 # encryptions[0] aad = 436f756e742d30 -ct = 1c5250d8034ec2b784ba2cfd69dbdb8af406cfe3ff938e131f0def8c8b60b4db21993c62ce81883d2dd1b51a28 +ct = ab1a13c9d4f01a87ec3440dbd756e2677bd2ecf9df0ce7ed73869b98e00c09be111cb9fdf077347aeb88e61bdf pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[1] aad = 436f756e742d31 -ct = 6b53c051e4199c518de79594e1c4ab18b96f081549d45ce015be002090bb119e85285337cc95ba5f59992dc98c +ct = 3265c7807ffff7fdace21659a2c6ccffee52a26d270c76468ed74202a65478bfaedfff9c2b7634e24f10b71016 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[2] aad = 436f756e742d32 -ct = 71146bd6795ccc9c49ce25dda112a48f202ad220559502cef1f34271e0cb4b02b4f10ecac6f48c32f878fae86b +ct = 3aadee86ad2a05081ea860033a9d09dbccb4acac2ded0891da40f51d4df19925f7a767b076a5cbc9355c8fd35e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[3] aad = 436f756e742d33 -ct = 5b23a1bb4a46eb6534d7929b88055d6a73fe36fa2209b7c851391a8b73aba3f8034e2cc588317ad35804fa4f0c +ct = b7de2d672ecddcc77718bb6736d3982fcaa5362198e63690f0452b0137f55480f5d5d3ad7c3265f7aa3f72f140 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[4] aad = 436f756e742d34 -ct = 63357a2aa291f5a4e5f27db6baa2af8cf77427c7c1a909e0b37214dd47db122bb153495ff0b02e9e54a50dbe16 +ct = 502ecccd5c2be3506a081809cc58b43b94f77cbe37b8b31712d9e21c9e61aa6946a8e922f54eae630f88eb8033 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[5] aad = 436f756e742d35 -ct = 13e916caf926e56e911b1f114f4d3b91da26a5761bc475bb874e91fc625e2f15d6789a8bcb69907d03d618406b +ct = 0ca5f85ce4569e0ff208fc23c691c2fc85da677a270cae116fd5357f9c4548f5e08a3ded8e137649b86cb5cc97 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[6] aad = 436f756e742d36 -ct = 1ae4fc091fddf17c3c18c8b7bb60063668e6eb7fdcd0abef5aaa8922eb73b4317cbe38301689a9bd876487e86d +ct = 9a953b1823973147329f2fb802f2944e5b01a889b21700374b3dbc2cf41ddacd04266796a47364cefae16db6b7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[7] aad = 436f756e742d37 -ct = 3034f34153aa2227884561ea011af79eaf74fc9f4540c7ef71bb49e80c0a38834ecd2a2582c0c6c7412b76fbdb +ct = 472bbda3a67603e6a242ef8fb037d033560cb9e8f95132e9a52f16d0d4fdce88bee88c00f682fea1798976b3da pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[8] aad = 436f756e742d38 -ct = d9f753851465e7153c1c0ec83c5d9804f52b2a984e6d8bbeafd92865a736ce1dffec4cb28f3adbde0d16acac77 +ct = 2f1a2b7fa25d10af90c993c87a533da919c3d274e25bd74b4e5a299afb283138a8f1e6d85a08d6af19a384ed22 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[9] aad = 436f756e742d39 -ct = f3af37da4888aa0b0f1ded625e06a277429df8e8d89782b6d10e58e94bf50136abdb2b5daee5101213b0f49f5f +ct = 8afc7a43e9e8d575f8e09c71dbaf2259fab97b5f48d90a284a1b9e0d52c2974e22518e9c22076e7aab14c7dc7a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[10] aad = 436f756e742d3130 -ct = cb8bc2f5c08dd4ad61b85ea2e0ad5d0ae244a663172d1b7b2cf0477f7c1f16d35b3c5145fd6c310db97fa56f6e +ct = 10d3c4181248ac1e01aa263439ad123ad9458e46da3d513c8eea06b4218a442ced2b27c68f2bb27b29b0f9fba5 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[11] aad = 436f756e742d3131 -ct = 7b21af3ffba9165013c692cab1287d60a93c82ffaf3f9329ee5fa9d8eb6f11d2432314f45d02b2dd5a3f73438c +ct = 14d77d5349d17d3f3cd787356180d424ef93835485e82593ce8b0403eca1e1924a7aedab78a2f3be37994bfec3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[12] aad = 436f756e742d3132 -ct = 039fd4450d4c35b2ec404479975c3a83a526bea12c1d41653e758a8f84f41b7ad2c1ec84f6fe0e21dd664f36b2 +ct = 1665cc5b2829613ac24feedf9847207bee8ec2ad536aa0a3b1de5cf614e5eb419b00aaabcc7d9b85d03626a053 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[13] aad = 436f756e742d3133 -ct = 2f65411d6ba8e3113b67c7710502f7772bfc9718d37f21f2cc4d0f61f2717d0fdc2c2a380f8b84d006e8af33e4 +ct = 4beb712b2dc79cb2923affcc5ee55df481a807922b74894741f1a8ea1ca4145b3872ae617dc23c1b940320dc5f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[14] aad = 436f756e742d3134 -ct = 494dbc5558dd047c8e6f3c547cf5ae3010496f99d2ccbcbf8e3660d435d40ed41c441abe4a71f7cdc298a47512 +ct = d24b966c9ee0dad75457b0bfbbc0f204540cbb01e0875fbbf6e434111b0934b4a4d1cff94ad918135233021ced pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[15] aad = 436f756e742d3135 -ct = 155dc29cdc2e5718756c572197731172cb5463692619d10c0f49142c858e7fe4c84a801ad74ee11277a899b17b +ct = 64fcf95695b71766b8447d96ce5af5c8629268d6738e46032a5a14d7f69d280ce004876eee8dc3009987e5a774 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[16] aad = 436f756e742d3136 -ct = 554c22933d7d58c6689ce050d8e1eda0af1a1e6b0c9621ee5c3cecb24170be59b59794f78851bee7c75c9bc9b2 +ct = 0ab4da8253b8eb87f8c934527484e9b1371ea99bd48c47ec9060cc43803a8640ffb0c904f41d5821c3312a5d7a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[17] aad = 436f756e742d3137 -ct = f14f868aeec918d8917b5e1c5a3acba3eac72500e2e1c5859e940b836bb5fc690c9fa666040e0f24235ef89461 +ct = e813a7fab6db458b5b819788c35671485d53b2647c8989e865cd0adbf9fdf21e98c69b9e49976b6d29611768ba pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[18] aad = 436f756e742d3138 -ct = 09aa8c97325c57173175ff935f1545dfef19a3c23df9d650e6e504b0f38476f9c328e9f8545dc03eeecd397efa +ct = ef43d472e241bada94631ea7f713b553fb01df4abb004f56a4f0b0b35c2879259d94c48b087b9eb84393d5029d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[19] aad = 436f756e742d3139 -ct = aab8d8659b899dda7ed988788c1f753f65182fa46aaec3790c752c5e6d4edc66d1a29cb7775a06d611cc3ba9da +ct = 87573897dcb5e2ded008addde56b4652b44b286662689a651bed7949dad1034c8751462d9e7d7c7dabb976d4ff pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[20] aad = 436f756e742d3230 -ct = b53cb489b5afe8d32b8b7f06a85ea21eba5d95637f1b60f5bd065ca400176588edbacff42a2fd0b9b2319c6b54 +ct = 99e8c16b09b11d63912d23b29b9514c5a8a13c7f6d26352088b648c6cf1ba6fd71cb15c16a911d2538023fe4b6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[21] aad = 436f756e742d3231 -ct = 2de0dc0045de431a43e2d46b8309c01755777174ed464e3076d1af20b0ea679e40c426df862d3d9e24885e815c +ct = e82e1588353a993dc57e713d9f1dffd711152edb7667370044424291877f93143751643a3d2b646de364d40060 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[22] aad = 436f756e742d3232 -ct = 4e92189ed1d24e7816771cca561591384a644a7ace00cde6a3680d83032c3d74194dd478019cd89544fe802db9 +ct = c07ab9089b2406c2f8f8871e555042ad683c6e9182b3e5198032062b81c59850342b653085bef4525def9078da pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[23] aad = 436f756e742d3233 -ct = 3992ca5ddc6cb82d81f1b317c3a1105ae1d0b5b7bc38649c7c350a4dc257753097bba175deee96426f96aee308 +ct = 882f8fde7e025247d9684126e08f44dbe6e8158804b9c42b652a471ba904ce19f8f3d3a9162230d717ae083815 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[24] aad = 436f756e742d3234 -ct = e6f475061e9cf348298d4de1b3ed8e84d05b1a22210222d317092554b4b1b591b89c91f890da65e815294eb71b +ct = e14ef552b77de117f9fa7384c93bce3dfc471e78853b6c35d2c5b18b57ba7940650805e61c3b915e1640aed9e6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[25] aad = 436f756e742d3235 -ct = 7081949d6353a8a4849adca6ab69c21873368cd5381f317cdfaf64d5e47b21499996a890b24df18e96a50ec4c3 +ct = d258655d099fb86e3e2740c0c1e11621ef7dc61c9e770ceb07fa9249a3dc42790b0e0eaa63f22bfeee9181ba03 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[26] aad = 436f756e742d3236 -ct = 154c97813292de73d50275d18fba298c207e7c8f27f74f2d7566db9334348166b0be420c0cef431e085fd44324 +ct = dd836e8c628a4d794cd731a26cfd591985445be24cb5ce9eadafb86dc93e03b1b53dae2808d5a8a56ad4ce76b7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[27] aad = 436f756e742d3237 -ct = 9e453e6146c12681cf1ad8c033c5a18cc28824c847a391413fc2bf51c0657499fcf3cb659cde1c0d00dd092d24 +ct = 95dd4f0d739fa6d3a5c823af5be5cbff4f67681ff4e91da4dd60862e0aac191a01a2a786e3bc4ab17968c921fb pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[28] aad = 436f756e742d3238 -ct = 53e99d1fe817118adf77c5eaab64ddea7f8880e5296c5261194e666931924c92d031cedb844f23f2284270e4b4 +ct = 4826674734200324d6111c86c76cd574b2e6838b61fcdec1ff9166140791919ee848122aceb4fa39a4b00d487c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[29] aad = 436f756e742d3239 -ct = f4337b127f13c333d1c979803fb31fe57673d4e68dcc907dccbe67cfa2de78ac154c63cc43510a821f7dba17c5 +ct = c23f7e91ffccfab228848435d09a8d5b540b3263ee03381dccbf268244e109b3ef00f46c7328e5bc5904a8e4f8 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[30] aad = 436f756e742d3330 -ct = f6ee59922b6f249f7d55f64d52692b06f6deeafae40f91d56ccf8d574d61f93a37cebe5744f40bf5b1451ef983 +ct = a1951f639b495355fde23c6097dbd93a2291c84e2e5d047e07f0db291b2a23a162106328bb257ea78c87ce1499 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[31] aad = 436f756e742d3331 -ct = 39975125abc4f4647b5e8dd5141a375f9ba66bbff0c4f89fa26eac66abbb71f90044be9197283ed9b60516d866 +ct = 2efee285dce215c4d318a7e7cb3c79a5f4ed206810badfd13db42f4af0aad43675e2c3c7f2818018ababfc0bee pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[32] aad = 436f756e742d3332 -ct = 545ed2b3050db6cbbae44b8f59fd3e80635390d22b2a93114bd928fffffb126481b32ee539120ff99dc3138dc1 +ct = 19fa32f8a868463888d6468a9177c2c09ef5eb09502646a6f2f24055d670e3714f5bee6c15a6fd3cfb8caf6a7c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[33] aad = 436f756e742d3333 -ct = 2dccce6855d90951971ad92eb2fed5961823e402af0d4f21f910465c3072622ef18e37f91e6e456a854256159a +ct = ec8cf86893c64175c3247ab71f71669de7152cdf2735ee855b272535445d707a58c9188c386c9d62cefde9ad4e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[34] aad = 436f756e742d3334 -ct = 1c614a68a70a26f0824a92d25121791d985e8f99a54f0b72475ae04656f8517f5124fe0c8d55d243e47f296f5a +ct = 2bcb2e07356124e3bf185777306701d48c3f007df73ad77ed95e87e18d503fedf881f9b428edefff6dcbf35457 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[35] aad = 436f756e742d3335 -ct = 9425385e046c183e19515b5776407f7cb6b8b71a0352598e57f8bd8808652e1267506432084d98b8397ae18df9 +ct = d112973726df1719a6756479b75ccb218d5cd493f0a641344ceced3c1e7e48a62dfaf2eb27f943b321ffd11eb0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[36] aad = 436f756e742d3336 -ct = e5de6144eab00d48ecf33a175be12bd845fbd640ed9cef6c6a31340ab536c9a0f07291762f77f1638e248946f4 +ct = f7e38aa4187cb6f9f2b46990dc690a340b1244b0e96ff3b4599ede765b1982cdefdd3738be0b2e98f929e04cf9 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[37] aad = 436f756e742d3337 -ct = e402b0a9c028a1b292820d8e438506d157ce717b5c8bbd4eaaac9e6520363df7e108900f0f94eecbfa314c3c43 +ct = 43011ed36c336f6c499a33fa35ef185e08434ca63f9fa5478a533133af82c3bf38a31729af87a7ad1a0db6e886 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[38] aad = 436f756e742d3338 -ct = 47a319e1ad50f8d95f55e2075f1d54f9af446636571d81b39ae95cd50a55543c74d65f811aea42de7ed79ce756 +ct = 3241fa612f4feb1f2dba73beef8a35da4b3650af9edcf0fb6d364b2028b335933e3dd04bcf013ddc5df174a8c1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[39] aad = 436f756e742d3339 -ct = c35d9f43b38e549c6c12a3aa433af0d6f3fb383259ba8292604c82f6bb2761a474a165c37f6f27ab816388af3f +ct = 195052ebbd8afd125f4462e935ded4c6cc999f41d11aaacf6d645fab1f6e64ab0ea600a480ec7c21921c6a49a2 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[40] aad = 436f756e742d3430 -ct = 918222466085e53705e47e6162d3e715cc1ca21bfcfba857dcb1a4dd1fe45c0fe95f4eb2dcb7f27b100dd165c3 +ct = d659b5beb44258ab7f5045a91e4ae127d1bec460fe58af259cd3ba8eba696efb4d8344e0438ff64a952955f16a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[41] aad = 436f756e742d3431 -ct = bb2136e56748f6d78f7c4aa8093cbe651d0081d7046e66873ab849e7b155e83402fcabb30af22b607a3758e5e7 +ct = 1e5d05cf7eace9542eada2db4f7579452febe6ed7f4b3b53b5971238ec182e0c2a898204f47338dc469b1a2298 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[42] aad = 436f756e742d3432 -ct = 7671268965a6bff9b8ffda26e5292eb37e1257d3952dcf37a65a6077d93651744d5e5c44643b1b0b53c20d2039 +ct = 1cbe40802bc5a0c96414ae9330eff0adf7bc160944863bb354f6602d49989076010cb8381892ea8f30384226ae pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[43] aad = 436f756e742d3433 -ct = 17784b52a709bde67d6fcc6b6de937cbf80f9cea7405708f42bf1cded9da2f6c240a6d2063692bf2c896c6df86 +ct = 02d88f0941c79663d90b8f8603c1a78101242cce044fe72ec585b48bd71bb79636f04b04084b4007cb24bf1ddc pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[44] aad = 436f756e742d3434 -ct = ddeeeb8ee50963740d7283ee5404581b0eb97619acba905588f66b5e79052ab61da7af7e3c9b54c201899565ce +ct = 5910202f4266d349ca3b1e40f051fe16be784545bc8031f533d30e82b900b9edf5096f448d5e2de8fdaea4b72e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[45] aad = 436f756e742d3435 -ct = b4a4871ef73db1b66c310341e67187c30cc526ec5fa203e57848449f029d20906f8968a6599ba5b9b5a519d1b7 +ct = 1f8e71b30e4a199f7ffd05a7feea60a09bfe3d052047def72c8f8bbc94ebfcdb9b6bbea97eb15a30ad80f67ea8 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[46] aad = 436f756e742d3436 -ct = 5de1796b6b89f1cf0b93c88c41e7778cfb482a81f3bab287f636b10d0c10612cb884aec9b2514b0c1b7af59fbc +ct = 4feea6befa30b7318fbd769cdd44e4b30374993edcdc3bba868056b30f1f1fbb32b7ba9f17807feec73e646cbc pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[47] aad = 436f756e742d3437 -ct = 041b12ea31a73f9fb5b80ffd373c13a938a1f7888923355e17bb47c62221383d614d485bd25d090c68f45dfa93 +ct = e62536d436e2bbbfcb8f01aa84671ca601ccf537b3288491b20ad62046602d8f3d1b2fef5e0af542b29eb7cb07 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[48] aad = 436f756e742d3438 -ct = 96506b77c1a44ced490059dbda1578226c3514977d4ebb39fc334c92b71af1220463f46af1d9effdaf099d23e7 +ct = 57e90938ec88919ad5c7de2e2ed9b410e8e8ab46e1983f71ba3a1a85bd8726e7a84777a97532165b0a1d00636d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[49] aad = 436f756e742d3439 -ct = fc3dc86ddf279c9bf386c0161dea4a060f5e109484a4c0371bf551a5aeab963e0c38fd3d1562531572fcf041db +ct = 056625bc0f5da4d70678d51a0b9e79278042a18d81e4c12362dcffbe91d53b8c5f357a9e0afde2b841fdd65cbe pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[50] aad = 436f756e742d3530 -ct = 762086d44613f1c0a15ce6c5dbf89d314e3af3728c0063a8eee91cda202de81b678230eabed359421493113578 +ct = 2e4ae62382e4ae36dea0d243bb69e02195188eeb91009c6a02dc4295543452233e97caf6fdb1909b7c4c9782ca pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[51] aad = 436f756e742d3531 -ct = 33f3cbd6ec16c70b1e639d455090c939732cecc87c7eed10bf57cd395b31c3b48f9a5a1655b48d3c471f57e969 +ct = 6a5101ea9f65bc392d82cb52aa6e5d5e09262639ac5a7fa4684c3724c2c9883d20873b4a03816d0d62ce550820 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[52] aad = 436f756e742d3532 -ct = 515dd43217bd14c705e96f8032e58fb486ffd167c89215111ddcd88087ae0df6741180eea245e2f834aa3216d0 +ct = 8c3ee8a0bff374943428dcfd6d6fd0ff06103c776a26a04ea4c25c606e1442e4be786fd71c412ae9916f45f8ae pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[53] aad = 436f756e742d3533 -ct = b93c95015ef99d815be1381fb27a6c5b2ba1667c859db56b2eccc2df9ec697aeed944f0cbd93fd8f952432015d +ct = b382567d688e25f95da3b8d7dd290115b5012acf4783bb70336e192ec4c52a9769b29c20325d9a4caaa72e9ece pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[54] aad = 436f756e742d3534 -ct = 543a160b7a3025f401958732ca4892608bb3bdd362f6f48c3052e0b5599ddfda1b9ac57dc82d436bb2fd890728 +ct = e048715bb0bfbd3c5cf4df882d03d5464ce682400dc4c349a2f1d1827473100e7d4dd88735e21cc3d9017c097f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[55] aad = 436f756e742d3535 -ct = ebe8436ae2822e2f6c3ba59b8a79752d10201da5551caffde4e8421e35ff23918e82ef57c154882edf949412b6 +ct = 17863a9136085e486347c5bb9e13b13d311c7453881a6632eb9711e6bb0aa8e4eed65a3f77025eec5b18b4b180 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[56] aad = 436f756e742d3536 -ct = 2e3babd04dbec3db0c25943f765409f83efe07287272d53fda796edce01604a24a409791b1dc6c9491ef951ead +ct = 5eae326e0d64c3d2eb3ca030b86574aec87ef9aaa3e8f73e10a55f15d54cbcdffb1599a30fe765cbb4b01b1620 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[57] aad = 436f756e742d3537 -ct = 23d8e8aea875a89cd44d1a0f2f652f389a2ee8899c06f1b186f2d35b98ce2ca55586bc8304f2ad8f11ec6d4a45 +ct = d8f57a7357b566b35bb59f12d7cececc675ff42a849cc0204b59fa8dd8f32e28367e194d5f0e6686b5a304d5fa pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[58] aad = 436f756e742d3538 -ct = 7fbd9f0b4ab1ebadd868ae523bedc740f19f619e3147cfd44626ac9e0148facf092c1b7a1439f12b66fab1ee91 +ct = 5291cd0c0007d0f903ea34a44c8416604cd581e135cd53388fccb2760e64c497148f510a74bc0bf8c5d9300dc2 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[59] aad = 436f756e742d3539 -ct = 79901c340c134f34a87943df878ab284769a7fb6ab6b63c03107150a7c0bf02532c203b847f6b2e82b9dde4daf +ct = 8e686ad247050455bc96e7fd09bbd75b811479f19c74a4b9efb42358138c0665154508b40d066cf01786e5b14f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[60] aad = 436f756e742d3630 -ct = afea3edb11f087496f4e969455d323c65936376a11db5818717b3fc4729567140aa786e25a6420be379d9d7356 +ct = 16b50d9f5803b951a5cf311bc2f974db9dab83290a29c892173400864af47909d89bdce645f43b18a40ad224c7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[61] aad = 436f756e742d3631 -ct = f7ea8ba2c5aa0317e7364d13429d7db23aa3184afd9698fd368287043ab04b9b0da3477973aae8df7c95055467 +ct = 069c4eeb76b1fab4025818cd505109062398b57d996e16487ad944f97fba4225299801806753ed2008a930d792 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[62] aad = 436f756e742d3632 -ct = bb875e89ad36fc0be4ff873d25548e73c572f22af59cfb75db6a5842528720d0e9251a8d0d69d85fe4a44c23ca +ct = 0daf3b2ddf8acdf78228d418742f97a43bc4175c4490d627ae4b689a1b58187cd95eb8919031ef450b43b5a3af pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[63] aad = 436f756e742d3633 -ct = 93d5bb5d990e893325555ef94928cff7e722dc1ea4be036e7803dc959c33cdc052a3da5af36ec904247128ef71 +ct = 0e87df1bb6c8e6c39bfc581703caa8c8c89283578766bf180bc1c47d297d42ce90e87172f7f7d75de175379e93 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[64] aad = 436f756e742d3634 -ct = 1c77e504b276395a277babdcb14e96c02d44966bc1722e813e2ddabadfbe0893be0d5dfeff38abac3b4fe8c6c0 +ct = ca21ba4e95aea092d5514267e6fda85ecc1aae1b52bb03c598655e64e839aa54aadcedbb65c1d1d5d7c19971c0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[65] aad = 436f756e742d3635 -ct = e54391814005400e0a3712f651ac1cc3a4d8987a75c03b111d71f80cb9b1491efeee7a2894e794e83ab3e65333 +ct = b38a51ef7d68dcda26f36ba9430c841310fbcef1dc2b0656747faf4987c6da76e81cc098b6da02883c47e9cb80 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[66] aad = 436f756e742d3636 -ct = 84e80b892d7f4b4fe505047d67f61d8a62de98429d4f34d5fae2508e7a38037ad8c67e85b9def05b628a0b85db +ct = 1a8c0cbc4967c3da7ccc5e14748fca5b1ae0ce7b07b99c60ae133f493ad94fba50c2e0f44edb68a1a6d6ded1d1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[67] aad = 436f756e742d3637 -ct = 3feff021bc5491d7329b2f0521397af99ee65a301488697b3c96ae6e8216d92b43478e7f45a8950c16888e94bf +ct = 4b232c97fa9cef6fea482bd90002a6637629e59e6839aa4b51a9698b0db79ec010bb06aba00c1b05f282115181 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[68] aad = 436f756e742d3638 -ct = 328bfd026fe81f27992e84d4daac65d37661c5f16c41b4901163eb0e4ec4a9da77d46b7f35fa5eb41ed19bd054 +ct = 277542b55e05f4f5b6f1149a45e981973c860e140b0be9be700605be226b5482bdc94873971d7a03b03b180b1a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[69] aad = 436f756e742d3639 -ct = 3f975f0ecf397b0e57e007c588bb93a4bd123506089a7c907f733cdf21c5359f861e6ecf36d137f3b8e3b951da +ct = d1bd44f2aaac3cec6dad09ec5939c8bcfeaa45a020b104af54db92805c150ceec660c14be21114e691c17100b6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[70] aad = 436f756e742d3730 -ct = afbeb6001680eada34d532ed5fcb64f888eda521bf62ec048405c40433d6cac6cd1317f8309529354d581767ac +ct = fe86fe64f4424a3cc43ae90ca90c4c829555be0d346195fc6f98c027326c5907f652e9ed292e88c262c8d1333d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[71] aad = 436f756e742d3731 -ct = bf217e3b30a4210e59173df68e359f806e9a1636e2c683d12cd1ec9443fbc1c7c2b14f54ffadbf4d0d8f32c300 +ct = 4b1a3c565eb99b18edf4240a06cb30acf037dc1a932937f649c24c3bc313368f9c13aa814886886cb8250e33f8 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[72] aad = 436f756e742d3732 -ct = 4dbdfc3cbd4dc0efdb3c8f9e660d07bc8f1d022679c0d0ce7108fd679992dbdbf4ea0e05caa1439fddc705b5e6 +ct = 82b190bd232d86589e0e1e7f37c0185ad0ddcf2b082c76429e1995b0d1f62acd588bba85b94f226da892db271f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[73] aad = 436f756e742d3733 -ct = 2894e03bca52f3d6ccfa334a5e6832fa73ca18c75d21ed01321d7cfffd87cf56ac3b141ebb5dea1d611adbdc61 +ct = 51f98f99fa19184916e1b08c76345b5998ca5fa7fb5242aaa521f7b07b47cd53ac3dc9637e13b436ca617a0b92 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[74] aad = 436f756e742d3734 -ct = ea1c4c156fbf85ca5e6dd5cadd8bcb6c9e19b3b833012560d5da193abe33752794f92e67525446502c0b684aed +ct = 323a32f6c87217db499ac6bda975371333f1189a618fbad68e0d8887d1c71b0520fc301f259598de1e48b1044a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[75] aad = 436f756e742d3735 -ct = f7f162240ba707111097a7fa5030fa6e96033f3fc67551398fe06bb26779e33bc2e8130081ae237607e7a8146f +ct = 43227f6091853dd20734cbb1f0aa1ca58d8fcada7a6b8366a1ad0f777b34ebd040abcaed06be5dc6f4c05df706 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[76] aad = 436f756e742d3736 -ct = c3343330c59be643478135ed7604e9f5a8e65cd6c38b13d51b0e3ee59bde00c2108116f9d585f0c5941c32860c +ct = 209ac341492e0d028320704c2af7c2a3ea84b86e6542b9b3f2a9a3b7da467d3faa471fe2dae932dccff31f30aa pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[77] aad = 436f756e742d3737 -ct = 252d5d39d319eb01e8723da3adec3197c6c012a058e7ededc5fea6ace3cdc643c45e17cca3ec4e8f22ee4cc373 +ct = a68f24e02ad3f221d11e3ccd7f6a749f7e3c1b2f37bf20108ab4996db6c599d62ce4425bdb4f596b84eef05e12 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[78] aad = 436f756e742d3738 -ct = 77cd702a74023299629f0f3ee73d1f1f9515939d4b82c0e4bc1cb608b3281dceaefed6dd604b51c28fffb772ac +ct = 04309d4b824c4c2d7aa0586b90b18f3b96b8139e27ddc64b9a2e16850025b4e837b9c4e2965d46d69d5580a2b7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[79] aad = 436f756e742d3739 -ct = 2d5636db4e74f6259a4a63927cccbc2393ccd024bb9880a475776432ba27e1c1045c73fbb74948a8d3d2c0f811 +ct = 015dfc58fa0be8ad7b4fa8fdd2705a07c9d70a615abe09ea744535667f0a444616b888f16a744ba50bee990ca6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[80] aad = 436f756e742d3830 -ct = 8ecfa6ca7db677ad757d74ff454d1c8f076166bcde9cf71bc22a6724cb6e5ce6e963aac83650f45f36c069df85 +ct = 583194570397fd8c5f366627b695df81b281f70c97acb4f9e957739e7741e64aded30ed2bb892a082cff249d5b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[81] aad = 436f756e742d3831 -ct = 3951a980d02ee0d047402352895ec3092c96687f3a4a81af987f808ce7a7df88cc8a2b04ad4dd7e1b93a3cde00 +ct = 2e8468cb395a1b361f4ae24d1fa7b080451edf50ebcc5a605cc0c64926a0a36adcbeebba318189e3a3f10ec1bd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[82] aad = 436f756e742d3832 -ct = 5fd41e209137f2bd71793de55445a4f4df44f732488d657404b335d0a5e21d737d3ced858be28d5f396dce8810 +ct = db3a33983fec5d55e1152118386a3942313dd11a52b43ea2453e555619bdd8f2272c4ae6b6b2e45afa0708e62e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[83] aad = 436f756e742d3833 -ct = 1516e99633edc73806a84334bf6a4b5ae77461de405fe6827da12c820a5eaa78f6aea9d41b22cb0c6c11ac3bde +ct = a55d4f5c9e4b54d5c430984040d9e3250a4ef60b51c6913ad9f0ffd24485c5220dce9368047b2bb275aded5d1f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[84] aad = 436f756e742d3834 -ct = b2ff502eff6663def30ffac7e432f1e580ea814b8513b1004af12d268de932e7cde5a55d99b6cf8517f34c4567 +ct = 7546ced9a69893f81e8a1fe01ee428f1fa989d81a91b67b37335d4e3d74f4c568e37673c8357aea9585f1bf8e7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[85] aad = 436f756e742d3835 -ct = 34aa152d2822ccb3c2efde62f6a7923d9bfa510376c8622c0148fda24c62a9da754f979c44c65e93020baccc3b +ct = da9ad2308781a5e98f26623db55632458b1213d6255d9f93eec34dc122d92882a573f4489dfe8819a33712a56f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[86] aad = 436f756e742d3836 -ct = cf271c985cd39fddacd870f2be45eeefa6b1f7dd7d85d4865708847f3916656b4d05ddf593a0bbcbef0ed984c2 +ct = 8807ebf2c3017769a8fcdf49724b6e87ce6b78946f157fa7b596909ded7f3fc5a74c96e6a30bc94c693a10484a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[87] aad = 436f756e742d3837 -ct = 5199c1fddf6fa7c089b20665662284fed97ac3c925973bee516767b4fe1e0005fe476fce94bd3deea4d0c9fcfe +ct = 617fbe2f615fe2d78e7ebd09d7119ab6aff2f6948f5b11b0fdbb38f0097fe9728d87478699ba2c4418833e3111 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[88] aad = 436f756e742d3838 -ct = ef3a374f39725309cc9752d6e661c79cd8db58bdedbbd7d6b08fe1554644e5a601433bb035240dcf7a3d9a38f6 +ct = 50a2a02f5394690595cb345db18c4da427fc31bd1e7aa225780a9f707296429f3ba7ea55dbfb4e9071ad46c33c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[89] aad = 436f756e742d3839 -ct = c3e155aa10237e1043e28a7a8f681b91792e13bf78c897db601fec3d8c284b247638467a5a57dda646b90543c7 +ct = 7ad5ce81fc409119042466e46b8b5f69a9ba6ef9ab8f774d6931971854ae54dd26534ac8ff8006c6c5b6bfc080 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[90] aad = 436f756e742d3930 -ct = 0e72f2d5e27c37094638f2d0e3c1b1d8d7c745ca85546348acb4ab8fe1a3d379191509189cbdfc4245090487c4 +ct = 9ae0d06ce9213dbea68533a6f45db7819a38ba452251aca8c648fd4ce55fa98ea1016e9b607bc2a1c86b9dbd5b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[91] aad = 436f756e742d3931 -ct = 27ac400f3b4beb50ada443e43d74c46730e1b71eb72e97c636d0ff977d79cf91bbe87c6913d4f9601bc90ccb4e +ct = 7411c84f11d4b995887faebd4068eb91f4cc6a4210e78db48a5b95349c55797280ee86efbf50aa4979c4291658 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[92] aad = 436f756e742d3932 -ct = e8b2e055c163061a6234245f3e6ab72c9c7e897c2c2d00e298d3774f65c0f538e6172cb12ccb36a98278f2e3cd +ct = 00c70bb93351ff8c53993390f9739ba7c6ea01b7340d98eca81a48c833af3694586d80d9eb84a28609ae505e66 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[93] aad = 436f756e742d3933 -ct = f61f2943d8a4648282206473fa3702cc74fb1d6931ef2a52ccc88fc4e4b6ce23667103f6d452f691e591e6afd2 +ct = c1292deef48fbd48a60e5ceea9d2de9aa74d6a6c2f4ad7af550502d48e85340031608f7c6be408909723e96619 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[94] aad = 436f756e742d3934 -ct = 0cc73e09604e6bed58aecf1b365285c56f5a94ab35c3f4177fda4b52757a1f003c46b9ff528863ba9a2644dbd7 +ct = dcf02c0f52dad173ab81af5ba6a71c6aeab76a2f6bedb95a9686a11073ceaa555aad04cca16d61c3000d8f2707 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[95] aad = 436f756e742d3935 -ct = 2e5ad52049529415c2b24dc5949a128cb9045304e1645d428e9602dbdccc9f4d8ee5b7337caf69049d7091267b +ct = 99c731a1024760cfabed4c9e6e06ba16362bf9cf8af0984e3e524a35c57e1b70132b401e879ac25b5a19e52608 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[96] aad = 436f756e742d3936 -ct = 6146ffeeb44cf294c63962c4bb48cb233a5157eef4c1688a99b259cae5b0125b2cee8a4969a7c8736c3b959d3d +ct = 380da1568940ae8141c20d77a0c3ca063a0f742aad509a244cc4218a0894f2d4f70d442f2bc3f45e898e8709dc pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[97] aad = 436f756e742d3937 -ct = b0c71e3417967f477658a019ad720307e21287096fdf9cba517c81bdaad0dddd39a8ea1ba5e9b03d0adea8b4f8 +ct = 577edaf7ba9b06c19d8b3afad647f1fbe2cfe0a1e56532a9942d4d3288dbcf2d65720c5cc5bee93b4524924e0d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[98] aad = 436f756e742d3938 -ct = ddc7ea7991cf45bbabed2c1fc38ca55b475a226bacdd1778ec8f90f38fb10ddd9e14ebcf57a8a472f89005fcdc +ct = b8819cad3a864fabdbf303f761b2622ef5f12599684c59a81618b3e8055aae2b62030fa487e672339abb772624 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[99] aad = 436f756e742d3939 -ct = 43b4c369a15522e7fd8ffc94ea8fc0ac4bfe6423f2140d741948b99d7f37a7d19b8c711cd1cab239eeb8b6a1c7 +ct = 8d0ccbebe563ba37f5973677e0b3cfc333032d0c6fed82158702b1c39a3378b02e8a474079ee03e7be10c3f8b9 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[100] aad = 436f756e742d313030 -ct = ebd8870f51fe43cfc1ff67bae967befad397f316d183382f72dbc8feac3aad0c06808a0f914d871be6ab3cf2c9 +ct = f7b0d944940dcb42172ff7f050ced108a040c92cd111f62f64c7c52bfaf0768eb2c22fc50371c6c73a22abd7d1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[101] aad = 436f756e742d313031 -ct = a5abd9ac1c787a9548b37346a4a6337e694fd42fd180623fbb860e9df75b0948e9558791d5729f064c11cf11d3 +ct = 8a2759704dd2c7712e7fc09674b5c786a0c08fe6abffecb93eae0667adfc68f5b69a8dd1527fe7ef9260b665a1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[102] aad = 436f756e742d313032 -ct = 11b1858f8cd4668aba2d2c6b5f7a9b34fa4c2e5afa16ff42a3c05d58fbb2a994a387ad4deca4ad6f569d9a9f39 +ct = be595d327a37a484b706780f14a48626426b35a61ca0c897304a8d3cdfa4e0f769bf7c489f207240a548494d1a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[103] aad = 436f756e742d313033 -ct = fcb7d46fa9102974cedfb8e83aafd1dc2392042b8dc52dccbc0a6717440597fd710bd9c1ea3af0e3d7a362f122 +ct = 58081bd5e9bb449b50338e606a5c9ddb06323e0b30606ec2e7ba914e9783be9455c5864e5cd591cecda45d3818 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[104] aad = 436f756e742d313034 -ct = 780f8f46e0c247ec2793933ad66e2926d6461426923e2f4821d021facdcf0271fa252fde7f640d3c2780932bb7 +ct = 5b841f947cb3000c81e0dceb2a647d87fce6fdb8ffc1b168b483ce2a7575f03a02a4a7ec748b21a18d75d94f69 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[105] aad = 436f756e742d313035 -ct = 0e0cf8a78acd8b57ccb6271c134fee2ee7c2ccaae1fd7869e91b07c9252a81f27abfcc14e7d5f79a28ee444676 +ct = 7db27590c2b9d81f0c51505db4aff4aba0114977c04ab386078368f4a6efa239d94efb93c2291a031dae851324 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[106] aad = 436f756e742d313036 -ct = d6290633b09e5511d1c4e019a1dc35902c3ef1b3c6f25050a88328f615e737e0a5a118a2ad6ebab15ddf982c0e +ct = 3d3d4b63bf33ffe734df92cdb7ff38133c3661f985770e814d5961c8bf8934b7151f722fc0d801afa031cd9a5c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[107] aad = 436f756e742d313037 -ct = e1d7d3ed74c0ae1a55c25990813f19257aff7d518c9cea74e958c7e9da405fb0faf1b0890e5ebde57958eab161 +ct = a123bb67617a8d49db372b9158d3b741b55c6052bc23ac936dc1c86371594fce34e40f7a85041642f2941442b3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[108] aad = 436f756e742d313038 -ct = 337be5b4890c40a215ec994a22c052271d190bb16c21a617396623ceab9c92c24659f365a825fb3d2f83a2a51b +ct = e593774a7353ef7730ee7fedf79199fd47df3f4a0f35aad4a584112283d137bb7d1fdbcf9d8980ed4244b6eaec pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[109] aad = 436f756e742d313039 -ct = faf4e4ca80ab7165a7c438dd3408d639d81be2fd41acf359c7bf2aa36a3ae2b85048415582089ca077572c8127 +ct = a083192b5973ed1a6adb237cec62aad1a304ca0044e272fc023f3a906f696bd60f545f1dbc0ec7ff551619e0a4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[110] aad = 436f756e742d313130 -ct = 117a8924f12695b93ad2a524fffcdfea837ec279e587e23bb91baecf5db4ea35c54658dd57c3c4bcd4e7c8b19f +ct = 7bfcbaebb82a899a39ea6c34bd76be9358f53e7397d40f76b46c7262510f264d547c56fed89a688c4d9a2b2e4b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[111] aad = 436f756e742d313131 -ct = fbf09a8165127a844b9d879a39addf98f08474e244a8db6dbe50d51944233086aef4ddb0cddb61fa9e9cec113d +ct = fbfc7bc29317c97a62de2ec25cdef1729d169986b334f9272a50110e1b37a71b6cb1e12b762022d4f49685979d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[112] aad = 436f756e742d313132 -ct = f2b6bc73bb81a7db754d4210c3e29addb2bb31668321a79d1673c258acc6aa35c62282f9ae89c4fe3caf816ea0 +ct = 21fa26c371405a806346f540f8c82bd562d517a1a9bc531f089819b7bcd66cd6adf4e93afaf2aa1b7ba2f06baf pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[113] aad = 436f756e742d313133 -ct = 1dbe114873ed874af58808fe65631fd1ef2e29a4142e7f15c3e9c12abaa11f26e4a945f662a99fabc0def49caf +ct = 6c254fb53652021322d5ef73a16b6562e57432f51ac20b364aeedaae603cd4f391b06f305d9a2fb266a2d3e55b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[114] aad = 436f756e742d313134 -ct = 424df6475b58070d56590f81e287798ec199aeac5a96f8d39f29a78fbe4b0b0a9c2991413e815edb0266f48bdb +ct = 9d0e3c870e95145533491b24626dedfa8c2b54508ea88310c285e60d4064f3e033aa9ed7b0d06e759e9bb8cc1d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[115] aad = 436f756e742d313135 -ct = 672f979899572fee01ee11addd53923252cfea452f9933149d53cac450ef7215a98407c997096f16a87bf316a9 +ct = e18e654b8bfb3ebaa9a42de68fc117f1df0b50d1f690101d7ea5905441733f776a1bb789f6490dcd902b232924 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[116] aad = 436f756e742d313136 -ct = c4158a774b811d3ba2bf11e00ea2b4887abfa329219370612935a8b22f4399718689be9bc54871f6a362c55f11 +ct = 44c2bc8b27fbcc94f7861e6d115203940d437c0bc10f6abfe3f7f54a1dbbf7e16d83a624de58d6d984db4629aa pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[117] aad = 436f756e742d313137 -ct = 9a153e98698656d114ce7b45b6c24341d50d66fe45a170bc570c185eec7f0424eaf20db7118d5ddaecd911f692 +ct = 40c149be04bf41e6edc15e40f44276ab6b76f9e2da3a6060680075467b696310320d3bb21ba23de62070cd2d56 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[118] aad = 436f756e742d313138 -ct = 641c90874675f1ad9131a995b632648e557edef53779e6572cd9ea80e684ed62b7c3cf25380634a0f34d3a2d13 +ct = 582a5f80a54af024cdde0bf597d332f94b58094ad4930e470e9122a00da2823761733ed6efd7ebb208e5dc11c6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[119] aad = 436f756e742d313139 -ct = cdbb52dcd782784096133a696ba4d20d755f0f150f4e1c7245cb17e30a5a599e53850c53ee980492a0ae0a86ea +ct = 6fedb508a62f8119866fa2f77680511461d6acffd5fe5c9cbdf755d0d696416245e94efe70c440d02968f4682e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[120] aad = 436f756e742d313230 -ct = d2d7bd0462eaf3320587507249643315a77da7cdb61d9e00b59b7d882142daa8d64ff910b637ee892b97c9542f +ct = 7b0baf62119a4aa6f261f840ff529913c0d430042581939fd5c4c706eca535d4bb8b27f4b85b063d6c4b672194 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[121] aad = 436f756e742d313231 -ct = 31d62424dad797797679163e601da04bfb30b1b214ee56fc514f728d3ec1928175ef03b04cc0ec8ec449145a9f +ct = 788717ddb583b85e508ed3adde0a02dd665d887ef538261718f5e08a1d25ccd6d3f669bed5ce34cb12fe94512a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[122] aad = 436f756e742d313232 -ct = 72890066793d4ce5851795f2bb11a702503d0b02091d8520e1236ca9429f6915e8b07ee41c560e9301a341b1bf +ct = 2d306491874eb01fcbfeeb9ca73bb6ae048077b87f524e597cc87e560ae8faf08a38fcac3b1608431715b232a0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[123] aad = 436f756e742d313233 -ct = cd427af93e5a6e662da9d023a4731972348a186fda02f2524f197708edfc7770e2395f0ba24c0e3a73827628db +ct = e5b3e678e0e0df8de042871dbc3d2bc3acbfbda12646825ae162340636177e73aebc28265cb0430553940e5cd5 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[124] aad = 436f756e742d313234 -ct = 0f54466a39ee0e3cff12f715fff595576d925f76afeb50193173d744bde8679fae3dcb65be7e307b23ade40504 +ct = 6efccc349b12e2f49b660d577783681b571aa00faba56cc51e71c041eea5e2c855090a0183b395bdc5c1e649c3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[125] aad = 436f756e742d313235 -ct = a30fb4f1fa85c078468ddb6ded139106b6b4f19f4e0c9f51f32801a3f67af90fafd3cbf46c9692ab54bacfec17 +ct = 5a43b00495f38c68f39eed4151935cbb44104f3aae74307c474e824f8f5e2cc4bc967c4b9fe8ed41a6e00c1704 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[126] aad = 436f756e742d313236 -ct = f5205006e1605b0f5b9943d5bea5c452c00261fe468902d948cb4e77a88c9cfbd9c4f765de197d67a0a2e7097c +ct = 884e27f01a7fc3b3c01204a8d4d21128c597a06aca13081e82305ab6b3369d0ea39c401088129d9484d511dbac pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[127] aad = 436f756e742d313237 -ct = 5a1ae229d393354ef6188759e73ceaef47c5c5038a4764774f996035000d34e9f8235f7a7ce94c1a6a29d982e3 +ct = 6708a8ab40099f4fcc5ce3a1f4c1eaad0959f40d52d7efde9805a1e309cda3da9a229e3388f7fdc5798ddcf8ef pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[128] aad = 436f756e742d313238 -ct = edec2520d385d5a75d4281d927865302c61dc3d99311ce987fe9ee87c2035fb93a5ebc2e5ec9396a9ecee6b973 +ct = 2b59c9116a3cf4a2b1ff7b862f05d0a9f4fa5b21beb071a417f9ddd229fbdd3160fcf1f5588f85fe1583d910d3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[129] aad = 436f756e742d313239 -ct = c410d16f9eec0b1f2e6ab1a65fab63885f1555e3499d1883012cc94ee87490fab8e82d40b749a317b15b26494b +ct = 05e5f0ef2c208da0fce32169d86aadcd206ca2b1a64f06b602cefbf791960f99c6763708362b0d321e8b917bd9 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[130] aad = 436f756e742d313330 -ct = 14f1d6f624b582aec247062f9f9d6c32d89c80d7876d41441440b324f9c769e4e071320fe8ecd30a8041da7acb +ct = 55fbb90f11eb01007b31682815a474280ab8718957856ad32b4dc0d86f71fd49ee1000957b76ba3f56ba5749bf pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[131] aad = 436f756e742d313331 -ct = 7f89975b443e215589978e9f61e6207cede48a6e5b19ad4df15688babc33eda041ae74f5476b6fc37f10798dcc +ct = cfffd60cbd241199eeaf529be3cbef77a67d9c5b62fd65861c84056037c73149988be4d6031d036b9d5ead6494 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[132] aad = 436f756e742d313332 -ct = 91dd02deb3f61e67ff45cd8a2c61aa6c39df18b4d5676f7b6c57c0c274b4a65c9d22a8b412ec9eb2e2fe5de3e4 +ct = e065c3fa01c9b0d1d2c20132b5fb21d85c50715ca55d85fbf29e29c95b4119dc054a02a7061e9373ee6ed49736 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[133] aad = 436f756e742d313333 -ct = b3c6fe76011eb105e4b1d5a511be0e863b5b3f3832ffe8afc84966b36ed4829c734b1191e7fc83ea94db64b024 +ct = 2ceeb7fe75ad7845efa4867ad23de6816467b5305f5bec964c5d4726e6cedc42e18654c2000cddbdd18e013382 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[134] aad = 436f756e742d313334 -ct = baffbdac2c8c9a24909bbd467ee896625d9dd72eaaa11b7ee1520cdf64412c20a07fc60620ff17e9c19f5cb519 +ct = b0a31296ead350554678e5460b31ce11c7f5928433ee2f948f441702112d838718170e81f4b3038139316a154c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[135] aad = 436f756e742d313335 -ct = 8a7bbc189f3b80d0777d94cf7e47270b0d120de46e76de9a896311d4b8e4bb1e946475641d987c15e1abbd39b9 +ct = d8e3e2a3c1452588477be454dea80c7ec1d84f63430fdc46143bbabd77348c37ac4eb24fa23ae7b4fc0e5bf04e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[136] aad = 436f756e742d313336 -ct = e24362464d437c2d00bb59f020282c6a72c43bdff5c660c6d7184272157248edd7362e20550545cd9b7e2c54f1 +ct = db487ed57bb04f39a39e6ae8e82e86ff0efb765c47bc49333671b6394b2b50f0e56907adb2a40bedb7fe70c460 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[137] aad = 436f756e742d313337 -ct = 9808dcdd8dd239d2405dfa278479dad5366feca0c6e15cbf0750c68e092c08fe02ebdb029f0719022265299453 +ct = 7f7277bd1a14fb3843c88306b5f7480c2621b98d76a42e5cb6f3ca139443a2f3a07fdea341dff01e29d68a5afd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[138] aad = 436f756e742d313338 -ct = 6096422f4c0a38d68b4faf4364e22fc98534d594b7791cba71ca1e1a381b318158e34eaf30e4b030206792a859 +ct = 3fc4dc2569ecf94fc28f7a61109351c4ddb7648d7c42285cf33d732075e3852d528cb7e0858313b5be0f00c6dd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[139] aad = 436f756e742d313339 -ct = 21f71e717075903e15db104f6865b6f7047fbc3dbf65f9f648d15fde45c1755072c8a211c1c0bcf5d5b42e4137 +ct = 825c39e7cfe13ce352225b76abcc4f434d3fbf8e1209f852326ae195c669ce411b150149e14d4634b6eedf0b05 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[140] aad = 436f756e742d313430 -ct = 636e85e1b727f382bd1d83910e0908bb3f47a204b0e04a77722c76f168919489727df626e346600f28d0aedd32 +ct = 9de9581a72f883c91a4e160c2a9ebb75e41538a9612a930b86d5c86cef16c4c88c86c6cb9c4b4aeb91b9ca988e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[141] aad = 436f756e742d313431 -ct = 4f6c63ce156ed1168d83778579215ce35312166bbc98d02abc4ee03c60d02326ad07c51d08777544f0705cb7ee +ct = e04a92935f4ac59e99aab8d602b4816bf7c1dec5d5d47e5d76f75bdddf80ac7f6ed46e6a0986c5d50a980a61d3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[142] aad = 436f756e742d313432 -ct = 8f8359af17b3a5c18343ccae2b5d553b9994dc6f7ea613fca8479529f842decbb118ee9e74ede49e7003b49f3d +ct = da4285f3b19a5a63611948f89a9141b060987ac46739c68e65d85e1265043efdb0aa5d390b9e216660c29c9185 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[143] aad = 436f756e742d313433 -ct = 221270c0f2ac46fee06b8b779eab41baa74d0ddcffef47b9ca30a33f76cdde4b22d5a57bd91953736d98b1cb60 +ct = 72c1383d0adf2021832cf8e7be8565f68f2693fbb79d1b181331fb84c189d8543cba13e6b7a6dea80208bb6f39 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[144] aad = 436f756e742d313434 -ct = 23a8555e5165ef29e3d30d087f471c2b28eec5e94eb818d8d4fa422757019a3e1784271627ff2b526333b740e5 +ct = 7ffaef3ded32191024d313221da9a3652cfd1ec17cf65aff57b1b67224e5ff7a931e32c72ebf8b226911bddeee pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[145] aad = 436f756e742d313435 -ct = d375e5d6ba2387ab0f19fbf63a55af82b4ea6ceed080be285c6efcec7f1d9eaa7717d8bea52783beea0a8b06d8 +ct = 8eaf068482dec200d6e13a15f23fcb59f30cb2948ac226aecd002cea99c89686daf77848f956933cc25fd26f48 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[146] aad = 436f756e742d313436 -ct = d4747347e4f5b93863cb1079951819e9148ef5f5b830c45799efa13ac446987052d47b20b678621f8a223debe8 +ct = 264cc5d6a0b7a0b10f6b1b3248b5a3324e3d6f478145618d09c47fa28978493bf1aff64ed4fabd094d5ddabcc6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[147] aad = 436f756e742d313437 -ct = 9d759d117fbdef4ebb9b70fabba081c3d2c6e083faad82999f9b2fc9ecbf738351594eee9d949df083d9c954e4 +ct = c148c4bcadd21fdcdd7e068507fa3ca526b14443164eaff48a81db46148cd2ae333bfb325a335296bd19efbbc0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[148] aad = 436f756e742d313438 -ct = dc539696ac9a42698551ae070eba7dc1b540ab553dbbd43e1113e0f1079d3e6b092e90e9fe9b5a27d2b86dfa50 +ct = 098d1dc0cb7cd977948f0b44542af26e09aa4d6ea63b17b5e72a78723ca9efe1eb002c98a08bdaa8b3fda0b7b3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[149] aad = 436f756e742d313439 -ct = 6f508b76afab6ec152f4a9f19013f37363c5f348ac098e172efe775f25c8726190eb17256fd91f21d6aadb18d7 +ct = 13fc200eb7d9ac3ec5672a9dab0e813903576fd05bf8fb7ee5635fcc8741419b869a7b8d9f863b12e88e2c5930 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[150] aad = 436f756e742d313530 -ct = 0ea02391896c4b37451a3863344f606dfbd654afd7d58aeb29b09d19768dbafeae09e858f6726e6e708130db19 +ct = 81a5873565aca0a8bf27d7e0a40b5190406a8be971a79e71a249fbba371cd6e95297140bf30a9a247db65b5573 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[151] aad = 436f756e742d313531 -ct = 52b181eeab88887689810a72ab9ca29eac16910f635e5eb2716a47790017b3782c9f8dba0a1bce3bda527fced2 +ct = dbc759f3edd826642105b502435edfb28a66c7c9053f77f701d019e8054a854c50ddd9951c8d329afdfc5afaa7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[152] aad = 436f756e742d313532 -ct = cd8c5f53ef7a6a19493d3fb4d88a491c3663c0a6d8380f53dfed5f727e583ca6de725645c128a6e739c4f928f5 +ct = ddf2376a8e02ff6aae395fc4455a4c776c0c9783453a2e42b28b3ea3cd1dece1d6a87924307611ccab815bbc4c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[153] aad = 436f756e742d313533 -ct = 5876a1c9b5971b0433f9dd08780fb47b4bccf298bcb9363c83a376ddae778d9ccdc9bf13f6f81a818828e48dbd +ct = 87757e2c0821f95564bcc568723acb7171f293e955173726017985e9cb3383b33ed8066fa6f48ceaa6cac6df0c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[154] aad = 436f756e742d313534 -ct = f68cd40a6d61712410ab2c2d3fdf3d5fdfdfebdc2e533c6e9150615469189e5854cf4424022aca568bbdebf527 +ct = 036d4fd7e9e72929cfd2e1fcecdc572aea5bd5ef16a92e5b711cdd9646eb3a1008a2e7d39ce74e67df6b73f468 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[155] aad = 436f756e742d313535 -ct = 3b982a6feb4b033b7b742c895c16d0c273cfe4a3e43453677626fc8eaf5867b26622ab8d49cafb444894ac1e17 +ct = 5cad074af3887ff07a8d3ce2e8a20e67feba06ba4893e26f14123894d7819392f827f646bb28cd29bfbf7be7f7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[156] aad = 436f756e742d313536 -ct = 3f283b4367614462aeea93abb6f5e565a9138e4b3fa3453b719bce40170210869025725ed494f9db4416b06411 +ct = e52d575fdb08e3d2084927dc3da9c7084bcdccdc88d997de6e06109d203b2c030ba2cb79a50ae8e0e738fc0736 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[157] aad = 436f756e742d313537 -ct = 549ed49d0ed44536dc6f9a73fcb6cb6420f0441b87a269c390974602259aa376f20e16c42da372d5c1b397da28 +ct = 4c98fe2ce4b77757ee09bfef308f9973c2aa28939ab24ef5fe619124b1c94e3aaf67d7739b22af2f3e158a04c8 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[158] aad = 436f756e742d313538 -ct = 9f3229384c4dabb5e647618f501b66989311fb5258b19b4ad20c72874f273fb8a434dfdafc8803346be8d5e801 +ct = f74e7f2532e417fbcd01f4683bd5ea14e94dd4a42f0834819d283c39f27fed8c3dc8dd3e74dcd5fb525d099044 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[159] aad = 436f756e742d313539 -ct = 239c4c8a6dee032f79cffea36724709c2ecdde052ce0c9ae6c15f7757eadc11ddb0fbb949ec4720040d039a3c0 +ct = 48aa523a358b5777f7dbe60c24eaa1240bd2fc186d91b7d9fd340a62cdee8a79a84785873efb9ff65bfec68f6f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[160] aad = 436f756e742d313630 -ct = 027b6cca81e30aa3f37c68f619badbbf4aa9d26c5eb279ecb57b6f5fddd4020e6143e49920301c8ce1dd0d60c6 +ct = ce4db0c062b8195e46f62aa014b1cd99c00697e6c04cb0adeea45f076ae31200cc03f32e224c585208e580fc87 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[161] aad = 436f756e742d313631 -ct = b14f60943b33a79a398b225a517a0f9bf03709afa714375d4398371551e91834ffa11baa6e27c878593113596f +ct = a53b8dc05218c1f4dfcc2af880df86233ec8fdcf3697c4ffee694c0c042fd545e01a652fb30ce0c46c00f1c7cd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[162] aad = 436f756e742d313632 -ct = c8b145b8217f0b86a8c69ef1d835bfe6c2185f22d87b938cc2a4d838c830a75dadcc7b5b7b63823d3aba11c14b +ct = 18459e8a46abe63533022ab99edc9417f41f0e43704e3146bf7b3638d9ee9715e89d2593f47296d6e287fc25b1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[163] aad = 436f756e742d313633 -ct = 53026edabb6dddcd3b63512641c2134801130bbbab6b1b21cda7d5e4a48af68fd56287552834f1120be8980424 +ct = d3d522979eeb9e6be40d83ad69cff87fc3b1c7b664629454f97087a61de9743586c129ba27849449edc3e218dd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[164] aad = 436f756e742d313634 -ct = cd52eff6227d1e8a9201acb50faeeeb476515857f0e127a0db69176d41e70ccc9c01a9d426120389f1d08eb5dd +ct = 8ecc61ed64cea2091b3e5b13ebc92f91f3daff14b029c0741b7b7541b5e4c4db44e6cb3ead3f379ab6f7ba2134 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[165] aad = 436f756e742d313635 -ct = 4e9c7956a5fdda91bd84fd006df5b298edbc6055fbf8553c733eb55658fbb8a4d3b80d969838bf3eb2153c47e5 +ct = 2344551199f0e4ffd040d05ebd33ed4e72b8798bb9e0a48c3cad3c3b6953dc51eeb28ed9bdf7dda5c96faf453b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[166] aad = 436f756e742d313636 -ct = 46bba4391f8c75515b7a2b2825071d09b44a73450185375540902cf86c47917fe9f19156db6555d6a8d9e4ec00 +ct = 45247cc2629c2dceda0e9260ae8cd347d82ffe9986407b1d4279216ef9599dbdb6427d5a8b1ca999b6a86626fa pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[167] aad = 436f756e742d313637 -ct = 69aceffa957a4fb972a42bbbd1daa8a98d1dedadf925e827bd41b8e8e4adb33de639f2c8f92e69ce7669a63cb8 +ct = 451db2902d2b4391c47be9a54d5d53b476b5d5d71ba02832fa5b28f35c5a0604d161f4b2baebb09013ea8d5d1b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[168] aad = 436f756e742d313638 -ct = 4b44cfa8a50a1eeb357b08f1659ed01fa0527d3c4ab59d72f0bf06301620cd2d25be3dbb3444c3884c5366dbca +ct = 97fd72b9c01b4974522d4bd494563f05404725034db95a4b4bd6dd147d6258cfe473e5425c39273302f654f09c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[169] aad = 436f756e742d313639 -ct = 5442eafe977df2fef456f9658e6e4a74b7c90180bf8a33d2d5adce2958bd343741fe1579ef2f78a52f5a0842e1 +ct = 77ef019177e690acfe0eceeaa26094135271e14125c3c9d84d539bf86150cf2f4d5e1871fcea5ab3a881e98f10 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[170] aad = 436f756e742d313730 -ct = 30b747860a4f39eeb11e3758a15cd554142490fe12c9aabe5d3c71fdce34e69a6c1d4c799d485f4d4b51a5c721 +ct = 89819d7bbe96c3cd71d90279ae98765d701b3b21c07dc287b6b5af0fab9e4569dbf57701e4e20a9a68840c04e7 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[171] aad = 436f756e742d313731 -ct = 608dacb5aa99f31f8c957b3c4630aed121774138ace30d373dd98f29c17a6892e1a842d727671721145d93e5d5 +ct = bf4206d7896f079093d3e6fd309ce43999554b8d961f51e2070bd23850cba7071065369af22a56122318a34d9a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[172] aad = 436f756e742d313732 -ct = 6fd543b032740e762f04f6d90d83e75183a997214883246bc24d4236d6e26656124289b4b4b6accee4176f1dec +ct = f10322e7dc93246fc9528b238fda0e8bdc779b908ac5dddf1411b2aaff19dddef9a5ea8eb464ac38939c5147f5 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[173] aad = 436f756e742d313733 -ct = 6e3cdf915393c8a4265055c1d2671b97776e074115156e10e7f81e69adf97871bb0ae58f15fbd7b1e31a395292 +ct = e2a426d1a686b4d994cc9a919c50a207f5c86c5d4f019592fd0c3255dea61a5230be629c77d69bcaebad454196 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[174] aad = 436f756e742d313734 -ct = 4bd80d3f79c99c40b5fa3913fc83f5a7d9486fca22f5589f2b4aa50c2b9d86e3c0f1a49aed3ccc1c9e6164e7bd +ct = 8b0ac7f5154a3adffe0463b0a7c86e7397bcd7ad1eb9db45721c6a472f55a30546de99cffd4042fdd7ac071b27 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[175] aad = 436f756e742d313735 -ct = 31ba0bc96f3a6db0ac4bd73b17d5a0f21ddef1668db1bfc5a3f3498f88a23033cce86933abc8831f62529df2dd +ct = 712953e4994fe54d6a5e02d1ab33df9b5f028726af60795aa8571ab53a1cf3c44024cd40d2bfccd79afaabd13d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[176] aad = 436f756e742d313736 -ct = c3cc98fa65baa464cb950b3c539c5988ea36f73bd3ab13f85be6dd0df1f9d79a9fdbc369d9c286253f78126e93 +ct = 929f4f028c846ed34b643f5bf111e7c2b2cc38676c37918be2cf1cf1432528194f8210eebb330415ffec3ee601 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[177] aad = 436f756e742d313737 -ct = f337704ea92c55ef28b1cf904f066c7b62187a313051ce165584b40a2aba61ffc04dfd01be8493e15967234c73 +ct = b5622dd7e3eec8cbb474ce5ec72505100f85c98725c2ab0ec69747b6a8ba6740417c1b90ba2d285f2e7e8aed23 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[178] aad = 436f756e742d313738 -ct = 3050885e6e284811a759bd67884ab62f1d0bce7d790729d6cb224811c83b73cd3d708d85b826e204c5978f47b9 +ct = b94bfdec74e4da59e23a0abdf35e78230df609e6e939e1590483ccd7168cc0d730afa2aae1bf5c04c10b5d146f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[179] aad = 436f756e742d313739 -ct = 461dd9b8e3c50875b0f07519cdb9aef7d13f34df61dd97a093637b6ae09cd1e24741e40a2c309d0cd6b11394e5 +ct = 825fd8362d28d8c9ee2cfeefb8baa0ad579acd6380cadd617eb4241a45571fe75407f1c3c288476a1951f13799 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[180] aad = 436f756e742d313830 -ct = 9f795bed00dc2ba48760fd5c9cdc2006ac435ae471a69c8926019f7d71919829dfb6359bd54b4d87c04b3398b8 +ct = e91fd4c291642964a2e3206668e41e7a833b3eaf3c73d8ae18224479d5e603ad0d266dba04d07e187dcc7e8817 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[181] aad = 436f756e742d313831 -ct = b557d7f6cdfc4707e99c047bc831a0558f19bd9b15ed607f143aaa85bcf73ecf2468752881c6e02b3e83d4543a +ct = e9cb31df1943fa60763a5883b2dd803f1a1e114b945ea746fe1169ee04206339a109b33d6dd4963a46c95b9d60 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[182] aad = 436f756e742d313832 -ct = ac251b361aea0a771c028cc9ff768994d008389f126970d9c89d1b8713575833e3757fa3f9efa076b5e77ec318 +ct = e907d69102325aaa155644e2fbf83402752bd7c769abc9d587eaaddf75fa196de4c100c9dde8ab273328f8895d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[183] aad = 436f756e742d313833 -ct = b69c7bf9d7ef08541f4bb4d96030a83fe3fdd77005cb16c865c7923ba30b3236955db8b28e7beb3c0535b08f5b +ct = 7ec7579899f8c4000fce0f7b6c5ebfaf4b65cf973181dbb4f8cae39256ab61843605f58dd2f40e5a375136011b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[184] aad = 436f756e742d313834 -ct = 615b848aa99f4fb56bf436f6673145784906fca3172125375eeeafc57d895d3f6cfb2a6305d8e09f4e077278d9 +ct = 6470ca4f7442d31ac907fcf167ad10b185ea0673a48f0fb52e08df541707ddfce14df56e1f1ec136eceda5dde8 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[185] aad = 436f756e742d313835 -ct = 1d4006772989c69d4d8b41b189ba68d1216d003812524a1db206da42f111ab38da9de9c39b06d0b5a0f4f7931f +ct = 712c2484fee14b3eaeaf6e68f22016121302a6c4071e3bb4dcb41315bc056c7de29504bd30461dc61e2a62290a pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[186] aad = 436f756e742d313836 -ct = b9cd2de5a742eff0f508eeb3a43644060a88a73f5476e804e7be8d426b39b3f23324c89bc653e320b651cb843a +ct = 1089d0ad01eb981b0e75d04ac8ff62a2a8b611b932bb524cde1a33f1103765022b056f0d082aa41d162e9643be pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[187] aad = 436f756e742d313837 -ct = 33d5a57af1cfa7fbc086b39770180dda5bd9ac8b7fcfd5ec8f3608a8e239ab39c6486b6733b4978c0cc011adc5 +ct = 7055173920dab9eccfbbeefe136fc57ef767e1e8e6db8eae6783235755ae9b0cccdbca572fad83b28bcc7b4248 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[188] aad = 436f756e742d313838 -ct = 3f9665a5e33e089fcb79413f53e79c40ee93ad5b2a6de97a35843ded62fa277d4c258ea260a5c7e06f95a8d449 +ct = 62a7f47491f3d31a422fc9e908823a8f2d7254f36131d363c32df985ed6dda80871e3829375f25a96d90b45235 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[189] aad = 436f756e742d313839 -ct = 242b8fee457d1c21311ce60c7774b6262852fb64e1d4f61de6d11f002535ee6bd9d65cd7f87573e1d8cce8383f +ct = 192f865b9b0f87c8f3b35b2ce1900e3687554a48736e6188aba905ef472c7377db213d32d56b903f7be0acee06 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[190] aad = 436f756e742d313930 -ct = 0b6e167302c1351ed4b8543c0d2879a7a8fd58e42f906e57279e4b52d8b9773e9f6a10334a5dbc07eec5577708 +ct = d0f7f686a5225d8183394c33b1f10c707e7f085660f858d3491198b3a9b4e42f6a9eb365c409993c59093228aa pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[191] aad = 436f756e742d313931 -ct = f34086725af61863c42947ed52aadd66b4e48b475f13266384e48e2b536c3dfd2ec6fb984f3bdfbdafa84b213c +ct = cf3f64e8b054cf660298d2e7ec7d644a2337429476a7108f14f491345c42e1164a6d96a83b0c56ebee45cce38c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[192] aad = 436f756e742d313932 -ct = a53074ed3b88343c5b44799aa2cb6b323ef5b0615f948de2784c00af2709f7afa25f987ae24eb061b69c6ca2a3 +ct = 9893da31204738a3f8f4c107c533f64cf8c01b81060308576cb94bfef56c7c204421503eda93d05f5f9ff3f7c9 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[193] aad = 436f756e742d313933 -ct = d293b46b823f01385c458a9bb3125ac70cd021de4cdf5624810a9899d3a3ab4394a3b8407f6a49ade6ed95cbb0 +ct = e407a8a84fc18a3df9833de5ce4e227f338cbe0549bb70d1b30abd5c8ad89f0a0de24bc8dcdb8455c80f507cb3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[194] aad = 436f756e742d313934 -ct = b1c77b724b044ba27240fce5f840c4de73d13b00ce73ba7582930d725a9766347cd6e210362c6ad01eae100141 +ct = c400c9a6494c2c62cfc420c7348f03b5598648842115975d204d7b039b3e6bec4f5a24b879d688b590ea0ad3fc pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[195] aad = 436f756e742d313935 -ct = 12afbe5e92bf061c3ac2cf48919616fc21f268cee9dcea2c9f61e02d9c37d0e2a27f55383b11ff4a8da4026a2b +ct = 49ab830a7a7be18d1fce87538b02c4514ce2e33fe7dd0041bf206923270ce1eae49fa7afdcc23c2e7095ccd371 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[196] aad = 436f756e742d313936 -ct = 7397c4a17f59b44a4530f2b1c2b766412244d31f340ceb6abeee44fda4a7e08bd390cc458b19ae003cd833143d +ct = d5beef3acedf662be1ac545ff22e0968ded5e7f835082563cbf32f2f97e2ec57ac0a24ef9b69b311c08b2d0705 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[197] aad = 436f756e742d313937 -ct = 6181055e55e9f226013faba7694ad4f2655fb7c4ac9776b98fa9cfac6d4373a60199c6501a14461eff0ebd9eab +ct = 3200011bd93203e202108feb721f33cff9adf984d7b765c152c42c71a08f6a4b914f59aaea2373dede1d84f49c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[198] aad = 436f756e742d313938 -ct = 51a0413101207b176f54ff80be07e219d3c526633cc83a4d4dcb504e2f394ca8be6c927c1698cca387eff89f8e +ct = 0d546040e599350adfce92d598fc83b2f17b8210648ff39c91d7382f1ddf9316fd55762a863bd39ac183d71cfc pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[199] aad = 436f756e742d313939 -ct = 4dda2afa170011d4a85928780d19d0874e6fd993c1994d23e3ab6abe2ea48e8b6cf72e3935ecb9f5db85978500 +ct = 56d782dcc5ae009b8b10f486678fc31d04d3e2c2fd14557bc160540eb5b40eb2f4d76a2a54f6ca7debbc8f6091 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[200] aad = 436f756e742d323030 -ct = b37a22b46572fc97e5ae45043834d8a19bfdcae1b98111cd82135ae2f059d85e686d464e8ecd5ea42c73f20362 +ct = 57584651099749aa985fa971b34618aa8d30aa9c1fcbc8cd15d887ee5ab0fa3d515d8dbba66eb3b1bd53d5849e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[201] aad = 436f756e742d323031 -ct = f8261dcdc908d46e6aa03bc25565cca2f2e6b86436ed94bd0ca94fdf28001b8b541a2dbae111b28f1a56a2e86a +ct = d18e9ec60dfb849deb7f665a032f5819b9d047516a4be94a48e8bd2066662d183f7853b3baadfe8971e34a88dd pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[202] aad = 436f756e742d323032 -ct = 64628718d4472b3f592cd09d3e1180ddcd7d2618129c0665085d3b377b3065c03b13c3e3f5cc57cfec3038c6b6 +ct = b05faf558aeadfc164859a477e9cbcab1d27edf19bbcb35a813aa49282b42f8a20bf5fcf943ebaa6d94f93eb32 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[203] aad = 436f756e742d323033 -ct = 3f2ac05adeaaa8d70088302c09bcf3c2e29b11ddfdbaee8a2aee04608241ce8e663fffc4421a92abc69a1c9f80 +ct = c069204693e8b828a9ac4d6001f8b0c49a9e7f606a45a8829dcfbc7ef0c23618f7c5ac44a76b00d6b06bd32e5f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[204] aad = 436f756e742d323034 -ct = 44f72dfe1d6de08f95407f63ec7fbcd97cee0e778b74268d7a50c994653cd3443efd4fb50adb13a6d6c79ca9ce +ct = 957d7c12afc411e4c87d7cc1bfac25e4f3391aa9d71bfd0b8606ccd7565a78c39b02c7c9d763a2d3529600f7f1 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[205] aad = 436f756e742d323035 -ct = 8860128148e7fa751e2176bdd0989f81699f4a6f8db8b9bb9a740878bb98c1da926b34e7f10326527ba27dfbb3 +ct = 648a024a31fd41c542eb6bc1ae2bc234ad3cb899fa65b1d22e947f061c5804f86df390f8ae79642630c26ab5e9 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[206] aad = 436f756e742d323036 -ct = d79816873a6e24b3738576e66ee2a3cd2faca1a8e6300e0bdd7932f7bbc2908f02af2bce13ebdd6cc108f4c9aa +ct = a54a551ae735941e911b84b09c3a33b97c8324f745220f78a0514ad814502654b0377fb45e8628575a7fb14018 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[207] aad = 436f756e742d323037 -ct = 6925df0f28576eff6d3a575e8917bd1b94d3f656299e6d7f10b6cef87d0a228051c21e8c4adb6202396cc4502c +ct = 35dd21130084fcf97491b42348efcb8271dc611c94cc57d9f1d7700efdcb207d9b725aab10b33868cacb53b5b4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[208] aad = 436f756e742d323038 -ct = 45465e087d0b390d3a13351a12ddc2c20b3055d2868be79465bec9a5eeb114a034dc04964928d973313b3a9f61 +ct = 2d7946eaf65d501637c5a51139ffe27bd5c0189c986731e9519ae256f17cc2b363adc654e28622236e9517007b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[209] aad = 436f756e742d323039 -ct = 92d94f52220fb8908a226599d67f101d8803a6b38a59ca1cd439cd42fb3e9dc3cbcb4449e36449e5f9823476fd +ct = 2182643ecb216095a07ec8e341bbc3bbd9700b98cf6108caf2c6e6a99c567ae9650e18e7137784ea60c0037bed pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[210] aad = 436f756e742d323130 -ct = e95cf8938a01158d09ff66c37a5436d6118db2aedc449951126ebf4184da493803a7cb6a71dc0e09cc46d42a22 +ct = 5cb48c09ae88281008141e22f274be6aeab55d061bd0592388330518bd4e9877f14edcebcdaed09b17839526eb pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[211] aad = 436f756e742d323131 -ct = 95ea0e88e2cb4b88c1669d9567de88a8f403849af9a74254e906ef595586b2e168eb0cfa2d6d258dc7b75e1ee2 +ct = ddb662da553a5f64f9e70dec7a00b5fe2492c5a8e7fac8b11a24225fec99b72b46a259f58d30ea1e565c3621d4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[212] aad = 436f756e742d323132 -ct = e5c938d2605a5eb68fd5dc37a3ee20a83633ed5e5dfad218bcb2d8962eec2346ed040b4eab2a95b44fd98220fd +ct = a812ef927ca2d5a7e6f6c25dba203a28b3749e94ceda1d2ae2f1e4a9607304521eb2b87a74ea8d22cbddee107e pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[213] aad = 436f756e742d323133 -ct = 9f75c8ad1becb7a32fcb307c5b29a91c53c7e6a745ae7664071d4aa3bd23c8e99859f1c4731473948a01655e57 +ct = 94f9430c6563ac09a8fa019177cb0bf6be3e222e3299211cb771a2e3c39dc490ed2962621d18988f6a8494dcf3 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[214] aad = 436f756e742d323134 -ct = 5b1e23823276f8ad3a202ae5403efd60eec67238703767f85e2f7d2191670491db06e109a0a23c47cea7ea7f0a +ct = 88277b8afc800e1bb7f26f46223b8ec3175d1397c6f132f1930429397b40bead4dfbd194f030b5f9eefeb88c39 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[215] aad = 436f756e742d323135 -ct = a954766abb4da6228599061eff24e6e488dd28e645044cd2ff194114dcf8676da441f5d3d6f6a95156edc01d58 +ct = 409e3d1897304b141d13abe0f59a4b10d0af57618577b340ed6d5480e4e83457b7186a3ea05a18f80a9a6cd637 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[216] aad = 436f756e742d323136 -ct = 08388a64ac543cf748ec47e7e6080a38ca18d40eb3ddf1efdbebcd57d3f357aaf7ce57f7433601175bbc2a97e9 +ct = 7ec49da8a4de583b3edebc5b67357cc3ffc51362866c02523ababe69f6a5ee3049d737e25610eb0c3a61899f0f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[217] aad = 436f756e742d323137 -ct = 41d792afa8a74fd0d9bf4d9cefb406d9208b3364dd9a4059234ec9c3d5ecc08d5dda0e8df119467663f8b770c5 +ct = 4246008ed7b0791df31f88250292a3a1e26dd47b14035e9ee4279aaa5d51bf2dfb594d68761ef239da62d38d67 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[218] aad = 436f756e742d323138 -ct = a765697054b7d1bcf82d5a3869f01ad632fa412e23f8b517ac4745e2f34954c422f108256d36b7c12ac942a9d1 +ct = c5d310202308ed77fb3bef60298eac77608ae541bc5ab2d9fb3e43c1b3e2f20cb266927ca85af01353dbaa0166 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[219] aad = 436f756e742d323139 -ct = 164e696bd9a10e227fe9a3582e40574fe59d225661c5cf09a7c75423f8ddc370337292bada80e48b9f7d88628a +ct = 812334975ad365ad977fe1df9fb18bfba5af83ee39455f877a9f496c1e883f64571917ce52499479270c7db7cc pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[220] aad = 436f756e742d323230 -ct = fb6d6c347a61f7279767a92897ebfff446e929562315ab50adf47cea14d7f03b0d86939c0b0dacb245fe4314f1 +ct = 7455ec4dafadc6a32c4a1482e78e7c80d34ade86bcf44860230055fedae26b642f2577dd5ec3742e06fc72b285 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[221] aad = 436f756e742d323231 -ct = 61625bab2d94464510430ff6f74793cfb64bd87a5ca4193c5b80401058d082e351a36cac8881aa083018f9443d +ct = d99776edf6dfa1683b926c03a35a08f5fa6e5ed4307a6bffec785ebe2ad4663e824aea40958ef2fdfcca851a3d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[222] aad = 436f756e742d323232 -ct = 6c04a3f61cc9bfc10a6e67e2adcb7818a61a0709bd49285c5bd069808799a4b888292a4a802c15dd38d75925bc +ct = e1773f8fd60b35fe8459a194b3ed05ba72f4d0f16f64169577e2ee4f0d1e9dd1fc5bc5d10da552ae5fbebb0605 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[223] aad = 436f756e742d323233 -ct = f4f8b3ba316bc1109069dceadb7809b2864c7857f8d9ed3f8523fee84e4033ea681bd941868e1190d40ae96b18 +ct = b0977a21fb86e2f53605146703243dd713979041ad41b7f4e2eb07a81823a741dfd6296f7a021d0863cdf407a6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[224] aad = 436f756e742d323234 -ct = 1ecd688ce744a684f660547887d910f0445b5b7167ea29ad646f2668bb064d83160205b5e977e7487bb4d06523 +ct = dcc76d9c0b453f3bfa0e93e4b21665157670d6363a0444bcc2cbbe3a82017712420fa62e5976f1eb459627350d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[225] aad = 436f756e742d323235 -ct = 38e766640dce7ce1edf30aa96c4324763036633bb4d881fcf26225e3c021e333ca8aed8288c565fa74e9238333 +ct = 4630e92285a0940af56c00a34b93ef07e755000d4b1faafd93eb01a076798dc5304c9119ca4b458ba39742a4ea pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[226] aad = 436f756e742d323236 -ct = 8bb09de244855723d0b697b02a967bc98d064bd529819046640c1bb009f27c9bc85f68aebc1da97791701e4e53 +ct = f980e55d2dd9dfbd6f0d7f26e681cb6a99b01536ed287570db15819ebadea6c383970e5935faa97f3f7567d419 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[227] aad = 436f756e742d323237 -ct = 5364e964cca737d51bd327276a0bb9340c4efaf3630b6086b4b0e20205a418d4fdc8855962da8b682eccfd53c6 +ct = 8b1b4be8257e2d2383b2b5236ac58a4bbc0619129a6af82201034f27bf762f14c9e113d36b94066a52b81edb63 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[228] aad = 436f756e742d323238 -ct = fb7a049058fade2c1653b3dccbae8c4ce3c5d50cafdefc618695c8a8955a8b8d48cd792c97b9c7599ecaa08456 +ct = 79368883a496b5f8962d2dd3c54116730aed4a6652fd2c222490470b66a91fbf2d8abf8d1336cf596a0c89b488 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[229] aad = 436f756e742d323239 -ct = 72ee72219b3239f96a902837a653fbea4a652f76e765ea4009e97f647fd0441f23abc6e6fd4af79c91bd206307 +ct = 6e0315642bc29b8a0f6eae9f0f3772c4af2d9451b6756847cefce570299cc8a09bcb14bd3c8e4e348dc60a80cf pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[230] aad = 436f756e742d323330 -ct = 54215a6653acd4e6976d5230607127f898aaae52addddebe170515d8cd6551eafc0e653d3f91e714dcc2cd0504 +ct = d74717cc168f8cc3340346e442a7b789776ba2f5f3f50b18cb61608f1a638d57d5f6f819713bf617936f7193da pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[231] aad = 436f756e742d323331 -ct = 1375489e8fa717c36d15cd26c9519c7c798af560b41e354fa86fc242760cbc448fe81de05044f1e8671e3a29d4 +ct = 8885a9956a8864f070e8b83175dc2a76208c32c669fd64c84c7efbc9eae048e3a3bda1a6c5e9e014177985f345 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[232] aad = 436f756e742d323332 -ct = 025b901c822275bbe1d6f72358f9919d76ae4062f9cb29f0e8c4c034e2c8791f198ed837c5a78c01ace2a74e89 +ct = 8248c633eb511e4148c97a9d997288ffe3e9b130f7e1768900e07a3dbd0322bf5feaa3ef1069a69d2f63b8b5e4 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[233] aad = 436f756e742d323333 -ct = 7a7d9406e7bf753493cdc3167253e53b21ab34b5fb906c13255fc63001566aee76f1f2ba9dbe2de613e4178195 +ct = 661b8260a395a229aadb89a0b0afddd08f65597d5e2965763b4c8779bec4f5a91c6a73f395ee45aacdc03f244c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[234] aad = 436f756e742d323334 -ct = b192c5443cd1b4434c3d5f031f56fba802c965eab7803371c9702dd15927d1f842981c633b28e93f3bb9254df1 +ct = 9e270862f567f91b5fc378247693a6a598dca076802c15f311ad977c862cae39feaf9da66ea276e3f6826ecf3d pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[235] aad = 436f756e742d323335 -ct = 1ba5f39d42dc02590901b8b2b755e528ca59085feda6c37318baeebdf6604cafd79a26369a5d55e58c45d90645 +ct = 9e07269e710dea587007ea36f823e5a6c361a7d852e411d0f608468b61a1a4cda1e79cfa8ae3e0398a471970b6 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[236] aad = 436f756e742d323336 -ct = 699225fa0b0a7cd2350d4e6100ceaf21945bde25084b031bf2c83bdcaac73ae9563b5e3f60366d4f152ebb156b +ct = a2cd8eb604f9dab48b73b5e09a99be8b4fffb8eed1ae639866fa1626acba6469a4389f867c068601e1622a61a0 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[237] aad = 436f756e742d323337 -ct = 03a5d97ce6e8ddf07a3c2c33dd4d401eedbd09fc85ce68a5e52b1a2d63de672f9ed62e5e4e3a843560b4363937 +ct = fe968506c8c9a82cac93961e2470e048eee80c4a2898677f624d8a1051412475ea905a499cf6eabe8c2ec58348 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[238] aad = 436f756e742d323338 -ct = 177a9525be60073909a731825a3622cc60dbdd7540e7fa6b706a45beff03f8d3c65220d439832a42660caf3beb +ct = bb45acdb4652e760404402bf5d2a424e8fccc7c5dde8b26338ad64fe2b2cd5e53f32e9e3f69a896bfc3489408f pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[239] aad = 436f756e742d323339 -ct = dc3ca9a852da948fcb4659fdd6e3b8fa307ba56e8face0f3d723582fc06c090a7d817a82df0cecf86335b82e31 +ct = 828fc85f305e3e63442ea0b178d182b53055c4ad909be23ed57603d9572f8c146e17648a3a4787c120daa8feed pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[240] aad = 436f756e742d323430 -ct = 6ca9b591de5234579a0aa90bea2f016d60cf50e77bc2a06d729579cb8b7b4c68e5dc6d483d337c5151d2989180 +ct = b0bbbc30e91367092697057b87e49a0278d6783e7100e58052aae3d6e43d86acf15aa52826bc29b0e1a3b22790 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[241] aad = 436f756e742d323431 -ct = 02e644e2e21b35f8868e786ab534c31a485b6e69097d10df2a25f24993c4d4d407f067796af1ca127de2f325fa +ct = 2dd238f23bf4c01ec65d5a5852358a6179783673414daa0007ac448744072057ca090203229d79ad6fa7676219 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[242] aad = 436f756e742d323432 -ct = cc9ea8088634939f2e757726833e70ca2b00d7e617b1e525bc147fbfa9c6b3d29621d38a73e954944ff4e9ce5a +ct = 1f086bb895f86ebca24d03d530e085e64e99194e4c4b741d80a8ecfda0a93c791b84b9c5df8fb054573bb3cd55 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[243] aad = 436f756e742d323433 -ct = 180bec2fc3e686d2f37f2b18a3b0a195a2277c28ffb49d85bcdecbba92f7cfd3d1832a310baaf01ca9396c3d8a +ct = 530bca4e6045806f7cbc7f47ccbfbaab6fb78470f1d722f039f37f9ce03dd0f7c466f0288cdd70bd76e57298ee pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[244] aad = 436f756e742d323434 -ct = b067fc48293520ce29f528b1bad11c0d38dbbe942f0c27c0ca953469dcc88bb1fe4a6b156134ec7803a8f6d367 +ct = 32d031fe93733f5494d4bf4cdf2f331e477e993daa98fea19601255e768848fac11410026b796e10b106ae8e80 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[245] aad = 436f756e742d323435 -ct = 42bb52ae652c21e3a16821c1a7dddb127e42b56c1985cf3800090a9accd8eb8080861e00f69f22bd09af42e19f +ct = 0dfb7b313aea0e91dcd2ba7595ee587ec910e6c669f2518355538dd4be47e137873db3c9b34b2ac95ac3f7278b pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[246] aad = 436f756e742d323436 -ct = 6bb1ca4dceb6137e525632def5bb056f7ce6f5dd452edb7a69449e43e947706e970978d47554fc50707c30567f +ct = e602015ac66b00e8b34b1091368b4e1f3eb1d94277d6dcf11829a8cf3a71a554e6e2df953c916f278aafcc072c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[247] aad = 436f756e742d323437 -ct = a37b7d0abd040300937b12ec5b6c3c43e594295f2b1d0f3292fdb0c38205d6ba925d0a11d3d1274b10a45c1d29 +ct = 9dc47953aae535a27441e77b6eee0db9a884f69c6c3ba1e6ef046d04cad1b4028c34ae259900853f104e6d5edb pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[248] aad = 436f756e742d323438 -ct = 729c0bae1bb680320852f4ab084062a0b143d535eff67da55999088f9f751fa7fcee704f524a9f6b8a94aa280c +ct = 1b174d49afa1ed54c34a0d23921d4426b72133b094e5876c9f5089a20bd01ee740b9bf9623d35079b2a7f764ea pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[249] aad = 436f756e742d323439 -ct = dcbe1ab062cafc3bd1c189007316e09bba8df92eb0dd9ece681a62e1d5bb9ab9ce4e5055257c96d70b43b62092 +ct = e9a9a9a54a5909f74cbaa86707b6a3db088f2a4458d3075be9d50795284abf0912ac094a17e8228011fe8584e5 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[250] aad = 436f756e742d323530 -ct = b08f5a570d41d21d0aa528c9da0b68bc2006e2579a956616f40f46caa5c24f5bf2e6bd8bd5ebf4bce2b79fa282 +ct = 5c21e68187f15c7d68c30c1d515567a6bb812f79646c97122de81e2f4603487f2398622ad573ec22d6c8d07b9c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[251] aad = 436f756e742d323531 -ct = 985991414c213e093e8ca144c4ac5c6d90e2f136810c934831e8623a64349dfe77ca188acd973551b5241754b6 +ct = 5ebbb4ce70e2e65fd6efc03cf6fda8892321740fec30ea21fd742dbc1b53f531f58697dced5c6b1623bf659feb pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[252] aad = 436f756e742d323532 -ct = 67c3d85876339d04e89d76bde220151c85f88b83718d50973ed5712373545ede91492b1f22b3c2da20d6e6d7f7 +ct = 0d4a1a33581ef910547ec8bde264a46441bcde2e06050b780d887bebc13f7853ab8b264fe4633cee8c4caed106 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[253] aad = 436f756e742d323533 -ct = 7552addfff71040acd9740a8deda98cf23dbe410a9af5fefffb7d0a21d60cff55d0ef91eb295fc2e0ef51516e6 +ct = 4e89d3f7b4f86e71601eb768ac42df8afeb983c18397fd4f277e3d1caa631d66960f923798e4b0fcd78c1ccb3c pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[254] aad = 436f756e742d323534 -ct = 8f531f2137e6b9d7b8f07af2f3fbd425c5ed60cdcd642c035f4354432d6f5d41870cf1d6bc18bb192489982866 +ct = b640e286eef2d6078f8d5a3e801a2466042121f5f001f8ac8f3461cc261c9f772904b9c15cead99bf305063f29 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[255] aad = 436f756e742d323535 -ct = 18ab939d63ddec9f6ac2b60d61d36a7375d2070c9b683861110757062c52b8880a5f6b3936da9cd6c23ef2a95c +ct = 652e597ba20f3d9241cda61f33937298b1169e6adf72974bbe454297502eb4be132e1c5064702fc165c2ddbde8 pt = 4265617574792069732074727574682c20747275746820626561757479 # encryptions[256] aad = 436f756e742d323536 -ct = 7a4a13e9ef23978e2c520fd4d2e757514ae160cd0cd05e556ef692370ca53076214c0c40d4c728d6ed9e727a5b +ct = 3be14e8b3bbd1028cf2b7d0a691dbbeff71321e7dec92d3c2cfb30a0994ab246af76168480285a60037b4ba13a pt = 4265617574792069732074727574682c20747275746820626561757479 # exports[0] exporter_context = L = 32 -exported_value = 4bbd6243b8bb54cec311fac9df81841b6fd61f56538a775e7c80a9f40160606e +exported_value = 070cffafd89b67b7f0eeb800235303a223e6ff9d1e774dce8eac585c8688c872 # exports[1] exporter_context = 00 L = 32 -exported_value = 8c1df14732580e5501b00f82b10a1647b40713191b7c1240ac80e2b68808ba69 +exported_value = 2852e728568d40ddb0edde284d36a4359c56558bb2fb8837cd3d92e46a3a14a8 # exports[2] exporter_context = 54657374436f6e74657874 L = 32 -exported_value = 5acb09211139c43b3090489a9da433e8a30ee7188ba8b0a9a1ccf0c229283e53 +exported_value = 1df39dc5dd60edcbf5f9ae804e15ada66e885b28ed7929116f768369a3f950ee diff --git a/crypto/hpke/translate_test_vectors.py b/crypto/hpke/translate_test_vectors.py index a1fffcf0aa..6879e4214b 100755 --- a/crypto/hpke/translate_test_vectors.py +++ b/crypto/hpke/translate_test_vectors.py @@ -29,6 +29,7 @@ HPKE_MODE_BASE = 0 HPKE_MODE_PSK = 1 +HPKE_MODE_AUTH = 2 HPKE_DHKEM_X25519_SHA256 = 0x0020 HPKE_HKDF_SHA256 = 0x0001 HPKE_AEAD_EXPORT_ONLY = 0xffff @@ -49,7 +50,7 @@ def read_test_vectors_and_generate_code(json_file_in_path, test_file_out_path): lines = [] for test in test_vecs: # Filter out test cases that we don't use. - if (test["mode"] != HPKE_MODE_BASE or + if (test["mode"] not in (HPKE_MODE_BASE, HPKE_MODE_AUTH) or test["kem_id"] != HPKE_DHKEM_X25519_SHA256 or test["aead_id"] == HPKE_AEAD_EXPORT_ONLY or test["kdf_id"] != HPKE_HKDF_SHA256): @@ -57,9 +58,9 @@ def read_test_vectors_and_generate_code(json_file_in_path, test_file_out_path): keys = ["mode", "kdf_id", "aead_id", "info", "skRm", "skEm", "pkRm", "pkEm"] - if test["mode"] == HPKE_MODE_PSK: - keys.append("psk") - keys.append("psk_id") + if test["mode"] == HPKE_MODE_AUTH: + keys.append("pkSm") + keys.append("skSm") for key in keys: lines.append("{} = {}".format(key, str(test[key]))) diff --git a/include/openssl/hpke.h b/include/openssl/hpke.h index 3ce6946ff3..eaf5947f36 100644 --- a/include/openssl/hpke.h +++ b/include/openssl/hpke.h @@ -249,6 +249,34 @@ OPENSSL_EXPORT int EVP_HPKE_CTX_setup_recipient( const EVP_HPKE_AEAD *aead, const uint8_t *enc, size_t enc_len, const uint8_t *info, size_t info_len); +// EVP_HPKE_CTX_setup_auth_sender implements the SetupAuthS HPKE operation. It +// behaves like |EVP_HPKE_CTX_setup_sender| but authenticates the resulting +// context with |key|. +OPENSSL_EXPORT int EVP_HPKE_CTX_setup_auth_sender( + EVP_HPKE_CTX *ctx, uint8_t *out_enc, size_t *out_enc_len, size_t max_enc, + const EVP_HPKE_KEY *key, const EVP_HPKE_KDF *kdf, const EVP_HPKE_AEAD *aead, + const uint8_t *peer_public_key, size_t peer_public_key_len, + const uint8_t *info, size_t info_len); + +// EVP_HPKE_CTX_setup_auth_sender_with_seed_for_testing behaves like +// |EVP_HPKE_CTX_setup_auth_sender|, but takes a seed to behave +// deterministically. The seed's format depends on |kem|. For X25519, it is the +// sender's ephemeral private key. +OPENSSL_EXPORT int EVP_HPKE_CTX_setup_auth_sender_with_seed_for_testing( + EVP_HPKE_CTX *ctx, uint8_t *out_enc, size_t *out_enc_len, size_t max_enc, + const EVP_HPKE_KEY *key, const EVP_HPKE_KDF *kdf, const EVP_HPKE_AEAD *aead, + const uint8_t *peer_public_key, size_t peer_public_key_len, + const uint8_t *info, size_t info_len, const uint8_t *seed, size_t seed_len); + +// EVP_HPKE_CTX_setup_auth_recipient implements the SetupAuthR HPKE operation. +// It behaves like |EVP_HPKE_CTX_setup_recipient| but checks the resulting +// context was authenticated with |peer_public_key|. +OPENSSL_EXPORT int EVP_HPKE_CTX_setup_auth_recipient( + EVP_HPKE_CTX *ctx, const EVP_HPKE_KEY *key, const EVP_HPKE_KDF *kdf, + const EVP_HPKE_AEAD *aead, const uint8_t *enc, size_t enc_len, + const uint8_t *info, size_t info_len, const uint8_t *peer_public_key, + size_t peer_public_key_len); + // Using an HPKE context. // From af45ee28f2e5a04410c3d9975fcc37559a061848 Mon Sep 17 00:00:00 2001 From: Brian Smith Date: Thu, 28 Sep 2023 15:04:48 -0700 Subject: [PATCH 56/56] Add newly-added files to Cargo.toml to fix `package` job. --- Cargo.toml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 9e1791d813..e2835e252b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -137,8 +137,10 @@ include = [ "tests/rsa_test_public_modulus.bin", "third_party/fiat/curve25519_32.h", "third_party/fiat/curve25519_64.h", + "third_party/fiat/curve25519_64_msvc.h", "third_party/fiat/p256_32.h", "third_party/fiat/p256_64.h", + "third_party/fiat/p256_64_msvc.h", "third_party/fiat/LICENSE", "third_party/NIST/SHAVS/SHA1LongMsg.rsp", "third_party/NIST/SHAVS/SHA1Monte.rsp",