From: slontis Date: Thu, 7 Nov 2024 00:24:06 +0000 (+1100) Subject: Add SLH-DSA signing. X-Git-Tag: openssl-3.5.0-alpha1~196 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=e240d39c6c9e78302b5d49555dcd2d6308ff0b43;p=thirdparty%2Fopenssl.git Add SLH-DSA signing. Also updated function comments. Reviewed-by: Paul Dale Reviewed-by: Viktor Dukhovni Reviewed-by: Tim Hudson (Merged from https://github.com/openssl/openssl/pull/25882) --- diff --git a/crypto/slh_dsa/slh_dsa.c b/crypto/slh_dsa/slh_dsa.c index b3951bf2b6a..498586fb9d7 100644 --- a/crypto/slh_dsa/slh_dsa.c +++ b/crypto/slh_dsa/slh_dsa.c @@ -22,6 +22,106 @@ static void get_tree_ids(const uint8_t *digest, const SLH_DSA_PARAMS *params, uint64_t *tree_id, uint32_t *leaf_id); +/** + * @brief SLH-DSA Signature generation + * See FIPS 205 Section 9.2 Algorithm 19 + * + * A signature consists of + * r[n] random bytes + * [k]*[1+a][n] FORS signature bytes + * [h + d*len][n] Hyper tree signature bytes + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param priv The private SLH_DSA key to use for signing. + * @param msg The message to sign. This may be encoded beforehand. + * @param msg_len The size of |msg| + * @param sig The returned signature + * @param sig_len The size of the returned |sig| + * @param sig_size The maximum size of |sig| + * @param opt_rand An optional random value to use of size |n|. It can be NULL. + * @returns 1 if the signature generation succeeded or 0 otherwise. + */ +static int slh_sign_internal(SLH_DSA_CTX *ctx, const SLH_DSA_KEY *priv, + const uint8_t *msg, size_t msg_len, + uint8_t *sig, size_t *sig_len, size_t sig_size, + const uint8_t *opt_rand) +{ + const SLH_DSA_PARAMS *params = ctx->params; + uint32_t n = params->n; + size_t r_len = n; + size_t sig_fors_len = SLH_SIG_FORS_LEN(params->k, params->a, n); + size_t sig_ht_len = SLH_SIG_HT_LEN(params->h, params->d, n); + size_t sig_len_expected = r_len + sig_fors_len + sig_ht_len; + SLH_HASH_FUNC_DECLARE(ctx, hashf, hctx); + SLH_ADRS_FUNC_DECLARE(ctx, adrsf); + uint64_t tree_id; + uint32_t leaf_id; + uint8_t adrs[SLH_ADRS_SIZE_MAX]; + uint8_t pk_fors[SLH_MAX_N]; + uint8_t m_digest[SLH_MAX_M]; + uint8_t *r = sig; + uint8_t *sig_fors = r + r_len; + uint8_t *sig_ht = sig_fors + sig_fors_len; + const uint8_t *md, *pk_seed, *sk_seed; + + if (sig_size < sig_len_expected) + return 0; + if (sig_len != NULL) + *sig_len = sig_len_expected; + if (sig == NULL) + return 1; + /* Exit if private key is not set */ + if (priv->has_priv == 0) + return 0; + + pk_seed = SLH_DSA_PK_SEED(priv); + sk_seed = SLH_DSA_SK_SEED(priv); + + if (opt_rand == NULL) + opt_rand = pk_seed; + + adrsf->zero(adrs); + /* calculate Randomness value r, and output to the signature */ + hashf->PRF_MSG(hctx, SLH_DSA_SK_PRF(priv), opt_rand, msg, msg_len, r); + + /* generate a digest of size |params->m| bytes where m is (30..49) */ + hashf->H_MSG(hctx, r, pk_seed, SLH_DSA_PK_ROOT(priv), msg, msg_len, + m_digest); + /* Grab selected bytes from the digest to select tree and leaf id's */ + get_tree_ids(m_digest, params, &tree_id, &leaf_id); + + adrsf->set_tree_address(adrs, tree_id); + adrsf->set_type_and_clear(adrs, SLH_ADRS_TYPE_FORS_TREE); + adrsf->set_keypair_address(adrs, leaf_id); + + /* generate the FORS signature and append it to the signature */ + md = m_digest; + ossl_slh_fors_sign(ctx, md, sk_seed, pk_seed, adrs, sig_fors, sig_fors_len); + /* Calculate the FORS public key */ + ossl_slh_fors_pk_from_sig(ctx, sig_fors, md, pk_seed, adrs, pk_fors); + + ossl_slh_ht_sign(ctx, pk_fors, sk_seed, pk_seed, tree_id, leaf_id, + sig_ht, sig_ht_len); + return 1; +} + +/** + * @brief SLH-DSA Signature verification + * See FIPS 205 Section 9.3 Algorithm 20 + * + * A signature consists of + * r[n] random bytes + * [k]*[1+a][n] FORS signature bytes + * [h + d*len][n] Hyper tree signature bytes + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param pub The public SLH_DSA key to use for verification. + * @param msg The message to verify. This may be encoded beforehand. + * @param msg_len The size of |msg| + * @param sig A signature to verify + * @param sig_len The size of |sig| + * @returns 1 if the signature verification succeeded or 0 otherwise. + */ static int slh_verify_internal(SLH_DSA_CTX *ctx, const SLH_DSA_KEY *pub, const uint8_t *msg, size_t msg_len, const uint8_t *sig, size_t sig_len) @@ -66,9 +166,26 @@ static int slh_verify_internal(SLH_DSA_CTX *ctx, const SLH_DSA_KEY *pub, return ossl_slh_ht_verify(ctx, pk_fors, sig_ht, pk_seed, tree_id, leaf_id, pk_root); } -/* - * Pure signatures M' function - * ctx is the empty string by default. +/** + * @brief Encode a message + * See FIPS 205 Algorithm 22 Step 8 (and algorithm 24 Step 4). + * + * SLH_DSA pure signatures are encoded as M' = 00 || ctx_len || ctx || msg + * Where ctx is the empty string by default and ctx_len <= 255. + * + * @param msg A message to encode + * @param msg_len The size of |msg| + * @param ctx An optional context to add to the message encoding. + * @param ctx_len The size of |ctx|. It must be in the range 0..255 + * @param encode Use the Pure signature encoding if this is 1, and dont encode + * if this value is 0. + * @param tmp A small buffer that may be used if the message is small. + * @param tmp_len The size of |tmp| + * @param out_len The size of the returned encoded buffer. + * @returns A buffer containing the encoded message. If the passed in + * |tmp| buffer is big enough to hold the encoded message then it returns |tmp| + * otherwise it allocates memory which must be freed by the caller. If |encode| + * is 0 then it returns |msg|. NULL is returned if there is a failure. */ static uint8_t *msg_encode(const uint8_t *msg, size_t msg_len, const uint8_t *ctx, size_t ctx_len, int encode, @@ -83,7 +200,7 @@ static uint8_t *msg_encode(const uint8_t *msg, size_t msg_len, return (uint8_t *)msg; } if (ctx_len > SLH_DSA_MAX_CONTEXT_STRING_LEN) - return 0; + return NULL; /* Pure encoding */ encoded_len = 1 + 1 + ctx_len + msg_len; @@ -102,6 +219,34 @@ static uint8_t *msg_encode(const uint8_t *msg, size_t msg_len, return encoded; } +/** + * See FIPS 205 Section 10.2.1 Algorithm 22 + */ +int ossl_slh_dsa_sign(SLH_DSA_CTX *slh_ctx, const SLH_DSA_KEY *priv, + const uint8_t *msg, size_t msg_len, + const uint8_t *ctx, size_t ctx_len, + const uint8_t *add_rand, int encode, + unsigned char *sig, size_t *siglen, size_t sigsize) +{ + uint8_t *m; + size_t m_len; + uint8_t m_tmp[1024]; + int ret = 0; + + m = msg_encode(msg, msg_len, ctx, ctx_len, encode, m_tmp, sizeof(m_tmp), + &m_len); + if (m == NULL) + return 0; + + ret = slh_sign_internal(slh_ctx, priv, m, m_len, sig, siglen, sigsize, add_rand); + if (m != msg && m != m_tmp) + OPENSSL_free(m); + return ret; +} + +/** + * See FIPS 205 Section 10.3 Algorithm 24 + */ int ossl_slh_dsa_verify(SLH_DSA_CTX *slh_ctx, const SLH_DSA_KEY *pub, const uint8_t *msg, size_t msg_len, const uint8_t *ctx, size_t ctx_len, int encode, @@ -123,7 +268,7 @@ int ossl_slh_dsa_verify(SLH_DSA_CTX *slh_ctx, const SLH_DSA_KEY *pub, return ret; } -/* FIPS 205 Algorithm 2 toInt(X, n) */ +/* See FIPS 205 Algorithm 2 toInt(X, n) */ static uint64_t bytes_to_u64_be(const uint8_t *in, size_t in_len) { size_t i; diff --git a/crypto/slh_dsa/slh_dsa_ctx.c b/crypto/slh_dsa/slh_dsa_ctx.c index 385e57e8cd3..e886e4ac69b 100644 --- a/crypto/slh_dsa/slh_dsa_ctx.c +++ b/crypto/slh_dsa/slh_dsa_ctx.c @@ -10,8 +10,16 @@ #include #include "slh_dsa_local.h" -/* - * @param +/** + * @brief Create a SLH_DSA_CTX that contains parameters, functions, and + * pre-fetched HASH related objects for a SLH_DSA algorithm.This context is passed + * to most SLH-DSA functions. + * + * @param alg An SLH-DSA algorithm name such as "SLH-DSA-SHA2-128s" + * @param lib_ctx A library context used for fetching. Can be NULL + * @param propq A propqery query to use for algorithm fetching. Can be NULL. + * + * @returns The created SLH_DSA_CTX object or NULL on failure. */ SLH_DSA_CTX *ossl_slh_dsa_ctx_new(const char *alg, OSSL_LIB_CTX *lib_ctx, const char *propq) @@ -39,6 +47,11 @@ SLH_DSA_CTX *ossl_slh_dsa_ctx_new(const char *alg, return NULL; } +/** + * @brief Destroy a SLH_DSA_CTX + * + * @param ctx The SLH_DSA_CTX object to destroy. + */ void ossl_slh_dsa_ctx_free(SLH_DSA_CTX *ctx) { ossl_slh_hash_ctx_cleanup(&ctx->hash_ctx); diff --git a/crypto/slh_dsa/slh_dsa_key.c b/crypto/slh_dsa/slh_dsa_key.c index 11834e8db1a..8756010504f 100644 --- a/crypto/slh_dsa/slh_dsa_key.c +++ b/crypto/slh_dsa/slh_dsa_key.c @@ -124,6 +124,15 @@ int ossl_slh_dsa_key_has(const SLH_DSA_KEY *key, int selection) return 0; } +/** + * @brief Load a SLH_DSA key from raw data. + * + * @param key An SLH_DSA key to load into + * @param params An array of parameters containing key data. + * @param include_private Set to 1 to optionally include the private key data + * if it exists. + * @returns 1 on success, or 0 on failure. + */ int ossl_slh_dsa_key_fromdata(SLH_DSA_KEY *key, const OSSL_PARAM params[], int include_private) { @@ -198,9 +207,20 @@ int ossl_slh_dsa_key_fromdata(SLH_DSA_KEY *key, const OSSL_PARAM params[], err: key->key_len = 0; key->has_priv = 0; + ossl_slh_dsa_ctx_free(dsa_ctx); + OPENSSL_cleanse(key->priv, key_len); return 0; } +/** + * Generate the public key root from private key (seed and prf) and public key seed. + * See FIPS 205 Section 9.1 Algorithm 18 + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param out A SLH_DSA key containing the private key (seed and prf) and public key seed. + * The public root key is written to this key. + * @returns 1 if the root key is generated. + */ static int slh_dsa_compute_pk_root(SLH_DSA_CTX *ctx, SLH_DSA_KEY *out) { SLH_ADRS_FUNC_DECLARE(ctx, adrsf); @@ -217,7 +237,18 @@ static int slh_dsa_compute_pk_root(SLH_DSA_CTX *ctx, SLH_DSA_KEY *out) return 1; } -int ossl_slh_dsa_generate_key(SLH_DSA_CTX *ctx, OSSL_LIB_CTX *libctx, +/** + * @brief Generate a SLH_DSA keypair. The private key seed and prf as well as the + * public key seed are generated using an approved DRBG's. The public key root is + * calculated using these generated values. + * See FIPS 205 Section 10.1 Algorithm 21 + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param lib_ctx A library context for fetching RAND algorithms + * @param out An SLH_DSA key to write keypair data to. + * @returns 1 if the key is generated or 0 otherwise. + */ +int ossl_slh_dsa_generate_key(SLH_DSA_CTX *ctx, OSSL_LIB_CTX *lib_ctx, SLH_DSA_KEY *out) { size_t n = ctx->params->n; @@ -225,8 +256,8 @@ int ossl_slh_dsa_generate_key(SLH_DSA_CTX *ctx, OSSL_LIB_CTX *libctx, assert(ctx->params == out->params); - if (RAND_priv_bytes_ex(libctx, out->priv, key_len, 0) <= 0 - || RAND_bytes_ex(libctx, out->pub, n, 0) <= 0 + if (RAND_priv_bytes_ex(lib_ctx, out->priv, key_len, 0) <= 0 + || RAND_bytes_ex(lib_ctx, out->pub, n, 0) <= 0 || !slh_dsa_compute_pk_root(ctx, out)) goto err; out->key_len = key_len; @@ -239,11 +270,25 @@ err: return 0; } +/** + * @brief This is used when a SLH key is used for an operation. + * This checks that the algorithm is the same (i.e. uses the same parameters) + * + * @param ctx Contains SLH_DSA algorithm functions and constants to be used for + * an operation. + * @param key A SLH_DSA key to use for an operation. + * + * @returns 1 if the algorithm matches, or 0 otherwise. + */ int ossl_slh_dsa_key_type_matches(SLH_DSA_CTX *ctx, const SLH_DSA_KEY *key) { return (key->params == ctx->params); } +/* + * @returns 1 if the SLH_DSA key contains a private component, or 0 if the + * key is just a public key. + */ int ossl_slh_dsa_key_is_private(const SLH_DSA_KEY *key) { return key->has_priv; diff --git a/crypto/slh_dsa/slh_dsa_key.h b/crypto/slh_dsa/slh_dsa_key.h index e2c526fce63..520332965dc 100644 --- a/crypto/slh_dsa/slh_dsa_key.h +++ b/crypto/slh_dsa/slh_dsa_key.h @@ -17,12 +17,15 @@ #define SLH_DSA_PK_ROOT(key) (key->pub + key->params->n) struct slh_dsa_key_st { + /* The public key consists of a SEED and ROOT values each of size |n| */ uint8_t pub[SLH_DSA_MAX_KEYLEN]; + /* The private key consists of a SEED and PRF values of size |n| */ uint8_t priv[SLH_DSA_MAX_KEYLEN]; size_t key_len; /* This value is set to 2 * n if there is a public key */ CRYPTO_REF_COUNT references; OSSL_LIB_CTX *libctx; char *propq; + /* contains the algorithm name and constants such as |n| */ const SLH_DSA_PARAMS *params; - int has_priv; + int has_priv; /* Set to 1 if there is a private key component */ }; diff --git a/crypto/slh_dsa/slh_dsa_local.h b/crypto/slh_dsa/slh_dsa_local.h index 48dd49e7781..77bf6a410a2 100644 --- a/crypto/slh_dsa/slh_dsa_local.h +++ b/crypto/slh_dsa/slh_dsa_local.h @@ -49,7 +49,9 @@ struct slh_dsa_ctx_st { void ossl_slh_wots_pk_gen(SLH_DSA_CTX *ctx, const uint8_t *sk_seed, const uint8_t *pk_seed, SLH_ADRS adrs, uint8_t *pk_out); - +void ossl_slh_wots_sign(SLH_DSA_CTX *ctx, const uint8_t *msg, + const uint8_t *sk_seed, const uint8_t *pk_seed, + SLH_ADRS adrs, uint8_t *sig, size_t sig_len); void ossl_slh_wots_pk_from_sig(SLH_DSA_CTX *ctx, const uint8_t *sig, const uint8_t *msg, const uint8_t *pk_seed, uint8_t *adrs, @@ -58,15 +60,26 @@ void ossl_slh_wots_pk_from_sig(SLH_DSA_CTX *ctx, void ossl_slh_xmss_node(SLH_DSA_CTX *ctx, const uint8_t *sk_seed, uint32_t node_id, uint32_t height, const uint8_t *pk_seed, SLH_ADRS adrs, uint8_t *pk_out); +void ossl_slh_xmss_sign(SLH_DSA_CTX *ctx, const uint8_t *msg, + const uint8_t *sk_seed, uint32_t node_id, + const uint8_t *pk_seed, SLH_ADRS adrs, + uint8_t *sig, size_t sig_len); void ossl_slh_xmss_pk_from_sig(SLH_DSA_CTX *ctx, uint32_t node_id, const uint8_t *sig, const uint8_t *msg, const uint8_t *pk_seed, SLH_ADRS adrs, uint8_t *pk_out); +void ossl_slh_ht_sign(SLH_DSA_CTX *ctx, const uint8_t *msg, + const uint8_t *sk_seed, const uint8_t *pk_seed, + uint64_t tree_id, uint32_t leaf_id, + uint8_t *sig_out, size_t sig_out_len); int ossl_slh_ht_verify(SLH_DSA_CTX *ctx, const uint8_t *msg, const uint8_t *sig, const uint8_t *pk_seed, uint64_t tree_id, uint32_t leaf_id, const uint8_t *pk_root); +void ossl_slh_fors_sign(SLH_DSA_CTX *ctx, const uint8_t *md, + const uint8_t *sk_seed, const uint8_t *pk_seed, + SLH_ADRS adrs, uint8_t *sig, size_t sig_len); void ossl_slh_fors_pk_from_sig(SLH_DSA_CTX *ctx, const uint8_t *sig, const uint8_t *md, const uint8_t *pk_seed, SLH_ADRS adrs, uint8_t *pk_out); diff --git a/crypto/slh_dsa/slh_fors.c b/crypto/slh_dsa/slh_fors.c index ab591b41b71..baa7f905356 100644 --- a/crypto/slh_dsa/slh_fors.c +++ b/crypto/slh_dsa/slh_fors.c @@ -22,14 +22,144 @@ static void slh_base_2b(const uint8_t *in, uint32_t b, uint32_t *out, size_t out_len); /** - * @brief Compute a candidatr FORS public key from a message and signature. + * @brief Generate FORS secret values + * See FIPS 205 Section 8.1 Algorithm 14. + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param sk_seed A private key seed of size |n| + * @param pk_seed A public key seed of size |n| + * @param adrs An ADRS object containing the layer address of zero, with the + * tree address and key pair address set to the index of the WOTS+ + * key within the XMSS tree that signs the FORS key. + * @param id The index of the FORS secret value within the sets of FORS trees. + * (which must be < 2^(hm - height) + * @param pk_out The generated FORS secret value of size |n| + */ +static void slh_fors_sk_gen(SLH_DSA_CTX *ctx, const uint8_t *sk_seed, + const uint8_t *pk_seed, SLH_ADRS adrs, uint32_t id, + uint8_t *sk_out) +{ + SLH_ADRS_DECLARE(sk_adrs); + SLH_ADRS_FUNC_DECLARE(ctx, adrsf); + + adrsf->copy(sk_adrs, adrs); + adrsf->set_type_and_clear(sk_adrs, SLH_ADRS_TYPE_FORS_PRF); + adrsf->copy_keypair_address(sk_adrs, adrs); + adrsf->set_tree_index(sk_adrs, id); + ctx->hash_func->PRF(&ctx->hash_ctx, pk_seed, sk_seed, sk_adrs, sk_out); +} + +/** + * @brief Computes the nodes of a Merkle tree. + * See FIPS 205 Section 8.2 Algorithm 18 + * + * The leaf nodes are hashes of FORS secret values. + * Each parent node is a hash of its 2 children. + * Note this is a recursive function. + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param sk_seed A SLH_DSA private key seed of size |n| + * @param pk_seed A SLH_DSA public key seed of size |n| + * @param adrs The ADRS object must have a layer address of zero, and the + * tree address set to the XMSS tree that signs the FORS key, + * the type set to FORS_TREE, and the keypair address set to the + * index of the WOTS+ key that signs the FORS key. + * @param node_id The target node index + * @param height The target node height + * @param node The returned hash for a node of size|n| + */ +static void slh_fors_node(SLH_DSA_CTX *ctx, const uint8_t *sk_seed, + const uint8_t *pk_seed, SLH_ADRS adrs, uint32_t node_id, + uint32_t height, uint8_t *node) +{ + SLH_ADRS_FUNC_DECLARE(ctx, adrsf); + uint8_t sk[SLH_MAX_N], lnode[SLH_MAX_N], rnode[SLH_MAX_N]; + uint32_t n = ctx->params->n; + + if (height == 0) { + slh_fors_sk_gen(ctx, sk_seed, pk_seed, adrs, node_id, sk); + adrsf->set_tree_height(adrs, 0); + adrsf->set_tree_index(adrs, node_id); + ctx->hash_func->F(&ctx->hash_ctx, pk_seed, adrs, sk, n, node); + } else { + slh_fors_node(ctx, sk_seed, pk_seed, adrs, 2 * node_id, height - 1, + lnode); + slh_fors_node(ctx, sk_seed, pk_seed, adrs, 2 * node_id + 1, height - 1, + rnode); + adrsf->set_tree_height(adrs, height); + adrsf->set_tree_index(adrs, node_id); + ctx->hash_func->H(&ctx->hash_ctx, pk_seed, adrs, lnode, rnode, node); + } +} + +/** + * @brief Generate an FORS signature + * See FIPS 205 Section 8.3 Algorithm 16 + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param md A message digest of size |(k * a + 7) / 8| bytes to sign + * @param sk_seed A private key seed of size |n| + * @param pk_seed A public key seed of size |n| + * @param adrs The ADRS object must have a layer address of zero, and the + * tree address set to the XMSS tree that signs the FORS key, + * the type set to FORS_TREE, and the keypair address set to the + * index of the WOTS+ key that signs the FORS key. + * @param sig_out The generated XMSS signature which consists of a WOTS+ + * signature and authentication path + * @param sig_len The size of |sig| which is (2 * n + 3) * n + tree_height * n. + */ +void ossl_slh_fors_sign(SLH_DSA_CTX *ctx, const uint8_t *md, + const uint8_t *sk_seed, const uint8_t *pk_seed, + SLH_ADRS adrs, uint8_t *sig, size_t sig_len) +{ + uint32_t i, j, s; + uint32_t ids[SLH_MAX_K]; + const SLH_DSA_PARAMS *params = ctx->params; + uint32_t n = params->n; + uint32_t k = params->k; + uint32_t a = params->a; + uint32_t t = (1 << a); + uint32_t t_times_i = 0; + uint8_t *psig = sig; + + /* + * Split md into k a-bit values e.g with k = 14, a = 12 + * ids[0..13] = 12 bits each of md + */ + slh_base_2b(md, a, ids, k); + + for (i = 0; i < k; ++i) { + uint32_t id = ids[i]; /* |id| = |a| bits */ + + slh_fors_sk_gen(ctx, sk_seed, pk_seed, adrs, + id + t_times_i, psig); + psig += n; + + for (j = 0; j < a; ++j) { + s = id ^ 1; + slh_fors_node(ctx, sk_seed, pk_seed, adrs, s + i * (1 << (a - j)), + j, psig); + id >>= 1; + psig += n; + } + t_times_i += t; + } + assert((size_t)(psig - sig) == sig_len); +} + +/** + * @brief Compute a candidate FORS public key from a message and signature. * See FIPS 205 Section 8.4 Algorithm 17. * + * @param ctx Contains SLH_DSA algorithm functions and constants. * @param sig A FORS signature of size (k * (a + 1) * n) bytes * @param md A message digest of size (k * a / 8) bytes * @param pk_seed A public key seed of size |n| - * @param adrs An ADRS object containing - * @param pk_out The returned + * @param adrs The ADRS object must have a layer address of zero, and the + * tree address set to the XMSS tree that signs the FORS key, + * the type set to FORS_TREE, and the keypair address set to the + * index of the WOTS+ key that signs the FORS key. + * @param pk_out The returned candidate FORS public key of size |n| */ void ossl_slh_fors_pk_from_sig(SLH_DSA_CTX *ctx, const uint8_t *sig, const uint8_t *md, const uint8_t *pk_seed, @@ -92,17 +222,17 @@ void ossl_slh_fors_pk_from_sig(SLH_DSA_CTX *ctx, const uint8_t *sig, /** * @brief Convert a byte string into a base 2^b representation - * (See FIPS 205 Algorithm 4) + * See FIPS 205 Algorithm 4 * * @param in An input byte stream with a size >= |outlen * b / 8| * @param b The bit size to divide |in| into * This is one of 6, 8, 9, 12 or 14 for FORS. - * @param out The array of returned base-2^b integers that represents the first + * @param out The array of returned base 2^b integers that represents the first * |outlen|*|b| bits of |in| - * @param outlen The size of |out| - * + * @param out_len The size of |out| */ -static void slh_base_2b(const uint8_t *in, uint32_t b, uint32_t *out, size_t out_len) +static void slh_base_2b(const uint8_t *in, uint32_t b, + uint32_t *out, size_t out_len) { size_t consumed = 0; uint32_t bits = 0; diff --git a/crypto/slh_dsa/slh_hypertree.c b/crypto/slh_dsa/slh_hypertree.c index 6dfcd219126..a0be9d38c59 100644 --- a/crypto/slh_dsa/slh_hypertree.c +++ b/crypto/slh_dsa/slh_hypertree.c @@ -14,7 +14,56 @@ #define SLH_XMSS_SIG_LEN(n, hm) ((SLH_WOTS_LEN(n) + (hm)) * (n)) /** - * @brief + * @brief Generate a Hypertree Signature + * See FIPS 205 Section 7.1 Algorithm 12 + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param msg A message of size |n|. + * @param sk_seed The private key seed of size |n| + * @param pk_seed The public key seed of size |n| + * @param tree_id Index of the XMSS tree that will sign the message + * @param leaf_id Index of the WOTS+ key within the XMSS tree that will signed the message + * @param sig The returned Hypertree Signature (which is |d| XMSS signatures) + * @param sig_len The size of |sig| which is (|h| + |d| * |len|) * |n|) + */ +void ossl_slh_ht_sign(SLH_DSA_CTX *ctx, + const uint8_t *msg, const uint8_t *sk_seed, + const uint8_t *pk_seed, + uint64_t tree_id, uint32_t leaf_id, + uint8_t *sig, size_t sig_len) +{ + SLH_ADRS_FUNC_DECLARE(ctx, adrsf); + SLH_ADRS_DECLARE(adrs); + uint8_t root[SLH_MAX_N]; + uint32_t layer, mask; + uint32_t n = ctx->params->n; + uint32_t d = ctx->params->d; + uint32_t hm = ctx->params->hm; + uint8_t *psig = sig; + size_t xmss_sig_len = SLH_XMSS_SIG_LEN(n, hm); + + mask = (1 << hm) - 1; /* A mod 2^h = A & ((2^h - 1))) */ + + adrsf->zero(adrs); + memcpy(root, msg, n); + + for (layer = 0; layer < d; ++layer) { + adrsf->set_layer_address(adrs, layer); + adrsf->set_tree_address(adrs, tree_id); + ossl_slh_xmss_sign(ctx, root, sk_seed, leaf_id, pk_seed, adrs, + psig, xmss_sig_len); + if (layer < d - 1) + ossl_slh_xmss_pk_from_sig(ctx, leaf_id, psig, root, pk_seed, adrs, root); + psig += xmss_sig_len; + leaf_id = tree_id & mask; + tree_id >>= hm; + } + assert((size_t)(psig - sig) == sig_len); +} + +/** + * @brief Verify a Hypertree Signature + * See FIPS 205 Section 7.2 Algorithm 13 * * @param ctx Contains SLH_DSA algorithm functions and constants. * @param msg A message of size |n| bytes diff --git a/crypto/slh_dsa/slh_wots.c b/crypto/slh_dsa/slh_wots.c index a0b6e92e751..1c7c26b60b7 100644 --- a/crypto/slh_dsa/slh_wots.c +++ b/crypto/slh_dsa/slh_wots.c @@ -110,7 +110,8 @@ static void slh_wots_chain(SLH_DSA_CTX *ctx, const uint8_t *in, } /** - * @brief WOTS+ Public key generation. See FIPS 205 Section 5.1 + * @brief WOTS+ Public key generation. + * See FIPS 205 Section 5.1 Algorithm 6 * * @param ctx Contains SLH_DSA algorithm functions and constants. * @param sk_seed A private key seed of size |n| @@ -156,11 +157,68 @@ void ossl_slh_wots_pk_gen(SLH_DSA_CTX *ctx, } /** - * @brief Compute a candidate WOTS+ public key from a message and signature + * @brief WOTS+ Signature generation * See FIPS 205 Section 5.2 Algorithm 7 * * @param ctx Contains SLH_DSA algorithm functions and constants. - * @param sig A WOTS+signature of size len * |n| bytes. (where len = 2 * |n| + 3) + * @param msg An input message of size |n| bytes. + * The message is either an XMSS or FORS public key + * @param sk_seed The private key seed of size |n| bytes + * @param pk_seed The public key seed of size |n| bytes + * @param adrs An address containing the layer address, tree address and key + * pair address. The size is either 32 or 22 bytes. + * @param sig The returned signature. + * @param sig_len The size of |sig| which should be len * |n| bytes. + * (where len = 2 * |n| + 3) + */ +void ossl_slh_wots_sign(SLH_DSA_CTX *ctx, const uint8_t *msg, + const uint8_t *sk_seed, const uint8_t *pk_seed, + SLH_ADRS adrs, uint8_t *sig, size_t sig_len) +{ + SLH_HASH_FUNC_DECLARE(ctx, hashf, hctx); + SLH_ADRS_FUNC_DECLARE(ctx, adrsf); + SLH_HASH_FN_DECLARE(hashf, PRF); + SLH_ADRS_FN_DECLARE(adrsf, set_chain_address); + SLH_ADRS_DECLARE(sk_adrs); + uint8_t msg_and_csum_nibbles[SLH_WOTS_LEN_MAX]; /* size is >= 2 * n + 3 */ + uint8_t sk[SLH_MAX_N]; + size_t i, len1, len; + size_t n = ctx->params->n; + uint8_t *psig = sig; + + len1 = SLH_WOTS_LEN1(n); /* 2 * n is for the message length in nibbles */ + len = len1 + SLH_WOTS_LEN2; /* 2 * n + 3 (3 checksum nibbles) */ + + /* + * Convert n message bytes to 2*n base w=16 integers + * i.e. Convert message to an array of 2*n nibbles. + */ + slh_bytes_to_nibbles(msg, n, msg_and_csum_nibbles); + /* Compute a 12 bit checksum and add it to the end */ + compute_checksum_nibbles(msg_and_csum_nibbles, len1, msg_and_csum_nibbles + len1); + + adrsf->copy(sk_adrs, adrs); + adrsf->set_type_and_clear(sk_adrs, SLH_ADRS_TYPE_WOTS_PRF); + adrsf->copy_keypair_address(sk_adrs, adrs); + + for (i = 0; i < len; ++i) { + set_chain_address(sk_adrs, i); + /* compute chain i secret */ + PRF(hctx, pk_seed, sk_seed, sk_adrs, sk); + set_chain_address(adrs, i); + /* compute chain i signature */ + slh_wots_chain(ctx, sk, 0, msg_and_csum_nibbles[i], pk_seed, adrs, psig); + psig += n; + } + assert(sig_len == (size_t)(psig - sig)); +} + +/** + * @brief Compute a candidate WOTS+ public key from a message and signature + * See FIPS 205 Section 5.3 Algorithm 8 + * + * @param ctx Contains SLH_DSA algorithm functions and constants. + * @param sig A WOTS+ signature of size len * |n| bytes. (where len = 2 * |n| + 3) * @param msg A message of size |n| bytes. * @param pk_seed The public key seed of size |n|. * @param adrs An ADRS object containing the layer address, tree address and diff --git a/crypto/slh_dsa/slh_xmss.c b/crypto/slh_dsa/slh_xmss.c index b5969222211..682315791d5 100644 --- a/crypto/slh_dsa/slh_xmss.c +++ b/crypto/slh_dsa/slh_xmss.c @@ -21,7 +21,7 @@ * @param pk_seed A public key seed * @param n The size of |sk_seed|, |pk_seed| and |pk_out| * @param adrs An ADRS object containing the layer address and tree address set - * to the XMSS treewithing which the XMSS tree is being computed. + * to the XMSS tree within which the XMSS tree is being computed. * @param nodeid The index of the target node being computed * (which must be < 2^(hm - height) * @param height The height within the tree of the node being computed. @@ -59,8 +59,50 @@ void ossl_slh_xmss_node(SLH_DSA_CTX *ctx, } } +/** + * @brief Generate an XMSS signature using a message and key. + * See FIPS 205 Section 6.2 Algorithm 10 + * + * @param msg A message of size |n| bytes to sign + * @param sk_seed A private key seed + * @param pk_seed A public key seed + * @param n The size of |msg|, |sk_seed| and |pk_seed| + * @param adrs An ADRS object containing the layer address and tree address set + * to the XMSS key being used to sign the message. + * @param node_id The index of a WOTS+ key within the XMSS tree to use for signing. + * @param tree_height The height of the XMSS tree. + * @param sig_out The generated XMSS signature which consists of a WOTS+ + * signature of size [2 * n + 3][n] followed by an authentication + * path of size [tree_height[n]. + */ +void ossl_slh_xmss_sign(SLH_DSA_CTX *ctx, const uint8_t *msg, + const uint8_t *sk_seed, uint32_t node_id, + const uint8_t *pk_seed, SLH_ADRS adrs, + uint8_t *sig, size_t sig_len) +{ + SLH_ADRS_FUNC_DECLARE(ctx, adrsf); + uint32_t h, id = node_id; + size_t n = ctx->params->n; + uint32_t hm = ctx->params->hm; + size_t wots_sig_len = n * SLH_WOTS_LEN(n); + uint8_t *auth_path = sig + wots_sig_len; +/* + size_t auth_sig_len = n * hm; + assert(sig_len == (wots_sig_len + auth_sig_len)); +*/ + for (h = 0; h < hm; ++h) { + ossl_slh_xmss_node(ctx, sk_seed, id ^ 1, h, pk_seed, adrs, auth_path); + id >>= 1; + auth_path += n; + } + adrsf->set_type_and_clear(adrs, SLH_ADRS_TYPE_WOTS_HASH); + adrsf->set_keypair_address(adrs, node_id); + ossl_slh_wots_sign(ctx, msg, sk_seed, pk_seed, adrs, sig, wots_sig_len); +} + /** * @brief Compute a candidate XMSS public key from a message and XMSS signature + * See FIPS 205 Section 6.3 Algorithm 11 * * @param sig A XMSS signature which consists of a WOTS+ signature of * [2 * n + 3][n] bytes followed by an authentication path of diff --git a/include/crypto/slh_dsa.h b/include/crypto/slh_dsa.h index b3d0241ae60..e652196e291 100644 --- a/include/crypto/slh_dsa.h +++ b/include/crypto/slh_dsa.h @@ -36,13 +36,17 @@ const uint8_t *ossl_slh_dsa_key_get_pub(const SLH_DSA_KEY *key); const uint8_t *ossl_slh_dsa_key_get_priv(const SLH_DSA_KEY *key); size_t ossl_slh_dsa_key_get_len(const SLH_DSA_KEY *key); size_t ossl_slh_dsa_key_get_n(const SLH_DSA_KEY *key); - int ossl_slh_dsa_key_type_matches(SLH_DSA_CTX *ctx, const SLH_DSA_KEY *key); SLH_DSA_CTX *ossl_slh_dsa_ctx_new(const char *alg, OSSL_LIB_CTX *lib_ctx, const char *propq); void ossl_slh_dsa_ctx_free(SLH_DSA_CTX *ctx); +int ossl_slh_dsa_sign(SLH_DSA_CTX *slh_ctx, const SLH_DSA_KEY *priv, + const uint8_t *msg, size_t msg_len, + const uint8_t *ctx, size_t ctx_len, + const uint8_t *add_rand, int encode, + unsigned char *sig, size_t *siglen, size_t sigsize); int ossl_slh_dsa_verify(SLH_DSA_CTX *slh_ctx, const SLH_DSA_KEY *pub, const uint8_t *msg, size_t msg_len, const uint8_t *ctx, size_t ctx_len, int encode, diff --git a/providers/implementations/keymgmt/slh_dsa_kmgmt.c b/providers/implementations/keymgmt/slh_dsa_kmgmt.c index 31155e6b896..00ecfa254c7 100644 --- a/providers/implementations/keymgmt/slh_dsa_kmgmt.c +++ b/providers/implementations/keymgmt/slh_dsa_kmgmt.c @@ -219,6 +219,7 @@ static void slh_dsa_gen_cleanup(void *genctx) #define MAKE_KEYMGMT_FUNCTIONS(alg, fn) \ static OSSL_FUNC_keymgmt_new_fn slh_dsa_##fn##_new_key; \ +static OSSL_FUNC_keymgmt_gen_fn slh_dsa_##fn##_gen; \ static void *slh_dsa_##fn##_new_key(void *provctx) \ { \ return slh_dsa_new_key(provctx, alg); \ diff --git a/providers/implementations/signature/slh_dsa_sig.c b/providers/implementations/signature/slh_dsa_sig.c index 777108a8dd7..011dc5512b8 100644 --- a/providers/implementations/signature/slh_dsa_sig.c +++ b/providers/implementations/signature/slh_dsa_sig.c @@ -19,9 +19,13 @@ #include "prov/provider_ctx.h" #include "crypto/slh_dsa.h" +#define SLH_DSA_MAX_ADD_RANDOM_LEN 32 + #define SLH_DSA_MESSAGE_ENCODE_RAW 0 #define SLH_DSA_MESSAGE_ENCODE_PURE 1 +static OSSL_FUNC_signature_sign_init_fn slh_sign_init; +static OSSL_FUNC_signature_sign_fn slh_sign; static OSSL_FUNC_signature_verify_init_fn slh_verify_init; static OSSL_FUNC_signature_verify_fn slh_verify; static OSSL_FUNC_signature_freectx_fn slh_freectx; @@ -33,7 +37,10 @@ typedef struct { SLH_DSA_CTX *ctx; uint8_t context_string[SLH_DSA_MAX_CONTEXT_STRING_LEN]; size_t context_string_len; + uint8_t add_random[SLH_DSA_MAX_ADD_RANDOM_LEN]; + size_t add_random_len; int msg_encode; + int deterministic; OSSL_LIB_CTX *libctx; char *propq; } PROV_SLH_DSA_CTX; @@ -45,6 +52,7 @@ static void slh_freectx(void *vctx) OPENSSL_free(ctx->propq); ossl_slh_dsa_ctx_free(ctx->ctx); ossl_slh_dsa_key_free(ctx->key); + OPENSSL_cleanse(ctx->add_random, ctx->add_random_len); OPENSSL_free(ctx); } @@ -103,6 +111,39 @@ static int slh_signverify_init(void *vctx, void *vkey, return 1; } +static int slh_sign_init(void *vctx, void *vkey, const OSSL_PARAM params[]) +{ + return slh_signverify_init(vctx, vkey, params, + EVP_PKEY_OP_SIGN, "SLH_DSA Sign Init"); +} + +static int slh_sign(void *vctx, unsigned char *sig, size_t *siglen, + size_t sigsize, const unsigned char *msg, size_t msg_len) +{ + int ret = 0; + PROV_SLH_DSA_CTX *ctx = (PROV_SLH_DSA_CTX *)vctx; + uint8_t add_rand[SLH_DSA_MAX_ADD_RANDOM_LEN], *opt_rand = NULL; + size_t n = 0; + + if (!ossl_prov_is_running()) + return 0; + if (ctx->add_random_len != 0) { + opt_rand = ctx->add_random; + } else if (ctx->deterministic == 0) { + n = ossl_slh_dsa_key_get_n(ctx->key); + if (RAND_priv_bytes_ex(ctx->libctx, add_rand, n, 0) <= 0) + return 0; + opt_rand = add_rand; + } + ret = ossl_slh_dsa_sign(ctx->ctx, ctx->key, msg, msg_len, + ctx->context_string, ctx->context_string_len, + opt_rand, ctx->msg_encode, + sig, siglen, sigsize); + if (opt_rand != add_rand) + OPENSSL_cleanse(opt_rand, n); + return ret; +} + static int slh_verify_init(void *vctx, void *vkey, const OSSL_PARAM params[]) { @@ -145,6 +186,21 @@ static int slh_set_ctx_params(void *vctx, const OSSL_PARAM params[]) return 0; } } + p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_ADD_RANDOM); + if (p != NULL) { + void *vp = pctx->add_random; + size_t n = ossl_slh_dsa_key_get_n(pctx->key); + + assert(n <= sizeof(pctx->add_random)); + if (!OSSL_PARAM_get_octet_string(p, &vp, n, &(pctx->add_random_len)) + || pctx->add_random_len != n) { + pctx->add_random_len = 0; + return 0; + } + } + p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DETERMINISTIC); + if (p != NULL && !OSSL_PARAM_get_int(p, &pctx->deterministic)) + return 0; p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING); if (p != NULL && !OSSL_PARAM_get_int(p, &pctx->msg_encode)) @@ -157,6 +213,8 @@ static const OSSL_PARAM *slh_settable_ctx_params(void *vctx, { static const OSSL_PARAM settable_ctx_params[] = { OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING, NULL, 0), + OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ADD_RANDOM, NULL, 0), + OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, 0), OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, 0), OSSL_PARAM_END }; @@ -172,6 +230,8 @@ static void *slh_##fn##_newctx(void *provctx, const char *propq) \ } \ const OSSL_DISPATCH ossl_slh_dsa_##fn##_signature_functions[] = { \ { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))slh_##fn##_newctx }, \ + { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))slh_sign_init }, \ + { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))slh_sign }, \ { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))slh_verify_init }, \ { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))slh_verify }, \ { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))slh_freectx }, \ diff --git a/test/slh_dsa.inc b/test/slh_dsa.inc index f06915c757a..b6df105b0dd 100644 --- a/test/slh_dsa.inc +++ b/test/slh_dsa.inc @@ -7,6 +7,21 @@ * https://www.openssl.org/source/license.html */ +#define SLH_DSA_SIG_TEST_ITEM(name, alg) { \ + alg, \ + name##_pub, sizeof(name##_pub), \ + name##_priv, sizeof(name##_priv), \ + name##_msg, sizeof(name##_msg), \ + name##_sig_digest, sizeof(name##_sig_digest) \ +} + +#define SLH_DSA_KEYGEN_TEST_ITEM(name, alg) { \ + alg, \ + name##_keygen_priv, sizeof(name##_keygen_priv), \ + name##_keygen_pub_seed, sizeof(name##_keygen_pub_seed), \ + name##_keygen_pub_expected, sizeof(name##_keygen_pub_expected) \ +} + typedef struct slh_dsa_sig_test_data_st { const char *alg; const unsigned char *pub; @@ -15,8 +30,9 @@ typedef struct slh_dsa_sig_test_data_st { size_t priv_len; const unsigned char *msg; size_t msg_len; - const unsigned char *sig; - size_t sig_len; + /* This is the sha256 digest of the signature, to reduce its size */ + const unsigned char *sig_digest; + size_t sig_digest_len; } SLH_DSA_SIG_TEST_DATA; typedef struct slh_dsa_keygen_test_data_st { @@ -29,20 +45,6 @@ typedef struct slh_dsa_keygen_test_data_st { size_t pub_expected_len; } SLH_DSA_KEYGEN_TEST_DATA; -#define SLH_DSA_SIG_TEST_ITEM(name, alg) { \ - alg, \ - name##_pub, sizeof(name##_pub), \ - name##_priv, sizeof(name##_priv), \ - name##_msg, sizeof(name##_msg), \ - name##_sig, sizeof(name##_sig) } - -#define SLH_DSA_KEYGEN_TEST_ITEM(name, alg) { \ - alg, \ - name##_keygen_priv, sizeof(name##_keygen_priv), \ - name##_keygen_pub_seed, sizeof(name##_keygen_pub_seed), \ - name##_keygen_pub_expected, sizeof(name##_keygen_pub_expected) \ -} - /* * Test vectors from * usnistgov/ACVP-Server/refs/heads/master/gen-val/json-files/SLH-DSA-sigGen-FIPS205/internalProjection.json @@ -62,137 +64,15 @@ static const uint8_t slh_dsa_sha2_128s_0_pub[] = { static const uint8_t slh_dsa_sha2_128s_0_msg[] = { 0x9D, 0xDF }; -static const uint8_t slh_dsa_sha2_128s_0_sig[] = { - 0x34,0x59,0x17,0x61,0x41,0xf6,0x6f,0xb0,0xb2,0x13,0x73,0x0d,0x1a,0x4b,0x2c,0x21,0x61,0xf6,0xc7,0xca,0x88,0xa0,0xda,0x20,0xb8,0x63,0x7c,0x8b,0x4c,0xdc,0xce,0xcb,0x09,0x6c,0x8f,0xb6,0xd4,0x28,0xc8,0xa7,0x56,0xb5,0x25,0x04,0x98,0xe4,0x3b,0xe9,0x2f,0x07,0x68,0x12,0xf4,0x88,0xc5,0xcd,0x47,0x16,0x1f,0x7b,0xa9,0x94,0xe7,0xdb, - 0xc0,0xcc,0xeb,0xbb,0x01,0xd4,0x93,0x55,0xd9,0xa3,0x14,0x0d,0x0e,0xe6,0x93,0x49,0x8b,0x4b,0x0a,0xd6,0x01,0xcf,0xa8,0x2e,0x10,0xcf,0x9d,0x73,0x36,0x2c,0xc2,0x9c,0x3b,0x7c,0x18,0xa8,0x97,0x8a,0x68,0x8e,0x08,0xe0,0xd0,0x41,0x84,0xe0,0x9b,0x97,0xe7,0x5d,0x90,0xc6,0xb7,0xb4,0xd1,0x25,0x76,0xc2,0xa6,0x4c,0x42,0x6f,0x97,0x32, - 0x1d,0x1c,0x15,0xb9,0x2a,0xf3,0xbd,0x89,0xbc,0x86,0xa3,0xb5,0x95,0x06,0xf6,0xd7,0xb2,0x5e,0x19,0x21,0x4e,0xea,0x38,0x6f,0xb5,0x3c,0xb3,0x72,0x3d,0x2d,0xdb,0xdc,0x3b,0x6c,0x2a,0xf1,0x6e,0x74,0xbc,0x42,0xd1,0x1a,0xed,0xd5,0x36,0xa9,0xa1,0x3c,0x7e,0x6a,0x22,0x08,0xa9,0x54,0xb9,0x81,0x08,0x20,0x59,0x9b,0x05,0x47,0x1a,0xdc, - 0x57,0x46,0x4d,0x3a,0x58,0x45,0xaf,0xf2,0x91,0x26,0xff,0x1d,0x3c,0x1c,0x99,0x3d,0x10,0xd2,0x78,0x00,0x29,0x19,0x7f,0x20,0x77,0xa9,0xd3,0xd3,0x49,0x9e,0x6a,0x39,0xf1,0xe6,0xe7,0x01,0x55,0x93,0xee,0xdb,0x9c,0x5b,0x6b,0x39,0xd2,0xc7,0x89,0x14,0xee,0x6f,0x42,0xfd,0x77,0xdd,0xea,0x15,0x70,0xf9,0x96,0xaa,0xd3,0xf2,0xd8,0x07, - 0x60,0x3f,0xe1,0x29,0xf1,0x49,0xee,0x12,0xc5,0x98,0x65,0x0f,0xa1,0x82,0x7c,0x7a,0x1d,0xc1,0xdd,0xa4,0x6b,0x9a,0x1e,0x71,0x94,0xbc,0x8a,0x36,0x52,0x97,0xd9,0x96,0x02,0x80,0x6c,0x50,0x73,0xd0,0x95,0x32,0x6e,0xb0,0xf1,0x4a,0x4b,0x6c,0x20,0xca,0x9e,0x29,0x50,0x7c,0x32,0xab,0x8e,0xdb,0x03,0x2e,0xda,0x2d,0x1b,0x6f,0xa4,0x10, - 0xe5,0x3c,0x76,0x97,0x58,0xab,0x01,0x90,0x22,0x3c,0x10,0x8c,0xdd,0x19,0x6b,0x2d,0x39,0xfd,0x19,0x3d,0x96,0x0a,0x34,0x98,0x22,0x16,0xf5,0x0a,0xf0,0xfe,0xb9,0x2b,0xa1,0x35,0xbc,0xf7,0x20,0xbd,0x35,0x08,0xbc,0x0a,0x24,0xaf,0xea,0x7c,0x95,0xf2,0x41,0x6f,0x4e,0xcb,0xda,0xc2,0xe8,0x4e,0x38,0x02,0xeb,0xb7,0xbd,0x64,0xac,0x5b, - 0x2d,0x8c,0xdd,0x93,0xc7,0x45,0x5b,0x30,0x1f,0x92,0x27,0x3a,0x23,0x61,0xd7,0xf9,0x50,0xca,0xac,0xe0,0x99,0x05,0x56,0x07,0x2d,0x40,0x34,0x82,0xb0,0x4f,0x78,0xfa,0xf9,0x10,0xcd,0xd2,0x2f,0xb7,0x3d,0x98,0x62,0x81,0x54,0xe4,0x54,0xe5,0x8d,0xaf,0xb3,0x62,0xd4,0xeb,0xc0,0x7a,0x25,0xfe,0xeb,0x12,0x0f,0xfc,0x2b,0x8f,0xb3,0x46, - 0xae,0x25,0xe9,0x7c,0xa5,0xff,0x02,0xfc,0x09,0xfe,0x52,0x0d,0x88,0x9a,0x4d,0xdc,0x6c,0x6d,0x80,0x03,0x99,0xb3,0xe7,0xf3,0xf9,0xdf,0x67,0xd0,0x21,0xf9,0x88,0x28,0x95,0x6f,0xf2,0xe7,0xa8,0xea,0x80,0x5a,0xe0,0x7a,0x70,0xed,0xba,0xcb,0xe0,0xd0,0x81,0x28,0x9e,0x89,0x29,0xb3,0x0b,0x57,0xf7,0x13,0xaa,0x37,0x50,0xc5,0x47,0x1f, - 0x62,0x4d,0xde,0x13,0x32,0x1f,0x46,0xa1,0xcd,0xac,0xc6,0x54,0x53,0x92,0xc9,0x87,0x55,0x7d,0x06,0x23,0x67,0x67,0xf8,0xb7,0xb1,0x71,0x66,0x16,0xb8,0xdb,0x26,0x9c,0xab,0x8f,0xda,0x80,0x45,0xd8,0xa4,0x24,0x40,0x58,0xb3,0xaf,0x3c,0xe4,0xf9,0x6c,0x48,0xbd,0x4f,0xa2,0x0f,0xa7,0x30,0x7c,0xcd,0x0a,0x54,0x56,0xca,0x89,0xbb,0x2d, - 0xfd,0x92,0x09,0xec,0xfd,0x2c,0x14,0xcb,0xa3,0x74,0x28,0x6f,0x46,0xa8,0x5b,0xfc,0x59,0xa3,0xe0,0x6c,0xf1,0x61,0x5c,0x96,0x2d,0x40,0x79,0x2b,0x83,0xda,0xd3,0xfa,0xa7,0xb8,0xad,0xed,0x0b,0x04,0xa1,0x75,0xa3,0x70,0x53,0x82,0x08,0xf8,0x97,0x5b,0x0a,0x9c,0xa4,0xca,0x8c,0xce,0x90,0xd3,0x58,0xf9,0xa3,0x8d,0xa8,0xde,0x2b,0x35, - 0x3a,0x41,0xa3,0xcd,0xf2,0x75,0xbd,0xb7,0x2a,0xa0,0x88,0xff,0xdb,0x1a,0x06,0xd5,0xc5,0x66,0xdd,0x5e,0x87,0x20,0xef,0x51,0xc1,0x33,0xee,0x66,0x60,0x7a,0xca,0x53,0xf0,0x88,0xec,0xb4,0xdc,0xa8,0x18,0xd2,0x69,0xd0,0x71,0x5c,0x7a,0xf2,0x89,0xee,0x4c,0x03,0x26,0xa0,0x67,0xe0,0x1d,0x4d,0x76,0x35,0x23,0x39,0xbd,0x36,0x17,0x52, - 0x19,0x38,0xf6,0x8f,0x11,0x2d,0xe0,0x85,0x7b,0x23,0x65,0x3a,0xe4,0x20,0xa6,0xe5,0x3a,0x13,0x0c,0xe9,0x56,0x3c,0x99,0x55,0x2f,0x05,0x8d,0x18,0xec,0x51,0xa4,0xb4,0xc2,0x66,0x15,0x1f,0x89,0x7e,0xa0,0x68,0x6e,0x4d,0x32,0xd4,0x56,0x41,0xfa,0x99,0xca,0x87,0xfc,0x98,0xfd,0x68,0x8a,0x27,0x47,0xf6,0x74,0x57,0x07,0xe8,0xca,0xd1, - 0x5c,0x06,0xa5,0x74,0x43,0xac,0xa8,0x24,0xd4,0x45,0x17,0x2f,0xbe,0x09,0xcc,0x05,0x99,0x10,0x56,0x8a,0x18,0xf2,0xae,0xcf,0xf2,0x63,0xe1,0xdb,0x44,0xe6,0xa1,0x95,0x04,0xe6,0xa7,0x44,0x54,0x59,0xde,0x58,0xeb,0x12,0xb7,0xe0,0x51,0x1c,0x4a,0xd0,0xe2,0x4e,0xc9,0x8d,0xc3,0x5b,0x06,0x01,0xbe,0x24,0xde,0xd8,0x21,0x1d,0xc0,0xeb, - 0x87,0x75,0x3b,0x12,0x0d,0x13,0xfc,0xf4,0x29,0x47,0x68,0x5d,0x42,0x17,0x86,0xd4,0xa8,0x01,0x91,0x95,0x8a,0xf4,0xdb,0x3c,0x12,0x5d,0x4e,0x32,0x5e,0x1a,0xe8,0x56,0xea,0xea,0xf1,0x13,0x41,0x4d,0xc0,0x07,0x4e,0x6b,0xc5,0x24,0x46,0xd6,0x51,0x27,0x09,0x2b,0x2e,0x98,0xb3,0xdd,0xe9,0x05,0x4b,0xed,0xad,0x30,0x30,0xba,0x43,0x24, - 0x55,0xba,0xc9,0x49,0xf3,0x0c,0x5b,0x6e,0xc3,0x13,0x77,0xdb,0x5c,0xa4,0x02,0x71,0xcc,0x94,0x0a,0x70,0x7c,0xfb,0x65,0x43,0x6c,0x33,0x23,0xc6,0x45,0x28,0x92,0x0e,0x95,0x05,0x76,0x3c,0x96,0xf4,0xe2,0xbc,0x41,0xbf,0xdd,0x1d,0x68,0x71,0xdb,0xd0,0xc0,0x12,0x8f,0xfb,0x34,0x69,0x00,0x9a,0x72,0x67,0xc6,0x1f,0x23,0x3c,0x17,0x75, - 0xe7,0x44,0x39,0x30,0xff,0x04,0xde,0x18,0x0c,0x5e,0xb1,0x97,0xd0,0xc4,0xee,0xd5,0x94,0xb8,0x64,0x56,0x88,0xba,0xf1,0xba,0xad,0xa8,0xdc,0xbb,0x20,0x67,0xe0,0x4a,0x84,0x3a,0x67,0x4a,0x3f,0x3f,0x75,0xc3,0x11,0xb6,0xa1,0x90,0x97,0x66,0x70,0x70,0x9d,0x83,0xf3,0xcd,0xa5,0xaf,0x1d,0x50,0x0f,0x1f,0x13,0x8d,0xbf,0xc5,0x88,0x44, - 0x8a,0x07,0x6c,0xc5,0xbf,0xc6,0x9e,0xeb,0xbf,0xe6,0x2d,0x90,0xa3,0x30,0xa9,0x49,0xeb,0x0d,0xd0,0x87,0xc0,0xfa,0x9e,0x9c,0x47,0xd7,0x4c,0xe4,0x07,0x68,0x03,0xee,0x2a,0xc8,0xa4,0x85,0xa7,0x2e,0xef,0x73,0x3b,0x9b,0xaa,0x92,0x48,0x1b,0x1f,0x69,0x0e,0xc4,0xef,0xae,0x6e,0xa9,0x1f,0x64,0x55,0xab,0x26,0x5c,0x3d,0xe4,0xb1,0x98, - 0xad,0x26,0x9d,0x73,0xbf,0x97,0x31,0x38,0x18,0xd0,0x2b,0xe3,0xfb,0x78,0x14,0x6b,0x7c,0xaf,0x89,0x2b,0xa2,0x95,0xda,0xa2,0x04,0x96,0x70,0x91,0x4d,0xbf,0x60,0x8b,0x1c,0x48,0x85,0x58,0x83,0xca,0xd1,0x3e,0x0a,0x0e,0xd6,0x8e,0xdb,0x48,0xff,0xb2,0x0d,0xee,0xef,0x2b,0x1c,0x0e,0x41,0xf0,0x82,0x22,0xc7,0x32,0x32,0x51,0xe9,0x02, - 0xd3,0x6b,0xd0,0x50,0x63,0x15,0x64,0xd5,0xc2,0x0e,0xe3,0x64,0x8d,0xe1,0xf7,0x9e,0xc2,0x6e,0x35,0xd9,0x5a,0x41,0x57,0x3d,0x52,0xc4,0x15,0x4b,0xac,0x38,0x2d,0x9c,0x60,0xff,0x52,0xb3,0x27,0xc5,0x0b,0xde,0xfd,0x7f,0x44,0xd9,0x65,0xab,0xcd,0xa0,0x83,0x59,0xd3,0xe5,0x03,0xeb,0x34,0x90,0xba,0x0f,0x00,0x37,0x9f,0x68,0x03,0x4b, - 0x82,0x2e,0x02,0x7c,0xa8,0x5d,0x97,0x91,0x86,0xe5,0x7c,0xe5,0x26,0x0b,0xc3,0x49,0x3c,0xa3,0x53,0x3a,0xa2,0x37,0xd3,0x0c,0xeb,0xa6,0x1d,0x47,0x6c,0x4e,0xba,0x25,0x47,0xb6,0x7a,0x94,0x6a,0x3c,0x82,0xe9,0xa6,0xc5,0x0f,0xfb,0x64,0x33,0xfa,0x6e,0x0c,0x52,0x94,0x21,0x02,0x77,0xe9,0xa5,0x17,0x3f,0xae,0x63,0xb0,0xb6,0x3f,0x1d, - 0xde,0x79,0x95,0x30,0x20,0x3f,0x49,0x80,0xb3,0x28,0xcf,0xc6,0xb3,0x18,0xb7,0x57,0xb6,0xa7,0x8e,0x71,0xf5,0x67,0x88,0x9e,0xd1,0xa1,0x1d,0x6d,0xa2,0xfd,0x5b,0xff,0x6b,0x1e,0x07,0x85,0x7b,0xca,0x99,0x36,0xf4,0xe1,0xf7,0x79,0x77,0x31,0x8c,0x18,0xe6,0x9c,0xba,0xbe,0xd2,0x49,0xe3,0x86,0x14,0x9c,0x57,0x96,0xbf,0x34,0x06,0x2a, - 0x5b,0xa2,0x03,0x8a,0x1d,0x4e,0xa3,0xb3,0x76,0xd1,0x2e,0x82,0x16,0xd8,0xec,0x09,0xf7,0xa2,0x78,0x74,0x32,0x67,0x06,0x8b,0x58,0x87,0x0a,0x72,0xff,0xe0,0xe5,0xb7,0x0d,0x77,0xc8,0xf2,0x74,0x34,0x1b,0xde,0x14,0x06,0x3b,0xcc,0x15,0x64,0x23,0x25,0xec,0x8e,0x2b,0x1d,0x08,0x97,0x03,0x87,0xde,0x8a,0x4b,0x86,0x82,0x20,0x70,0x6b, - 0x4b,0x9c,0x3d,0x55,0x8d,0xbc,0x38,0xc3,0x34,0xbe,0x8e,0xa3,0x35,0xb5,0x37,0x2c,0x26,0x21,0x63,0xae,0x2d,0xc8,0x88,0x7f,0xf6,0xcb,0xc6,0x0a,0x93,0x4f,0xfd,0x72,0x85,0x97,0xdd,0x70,0xac,0xbd,0x31,0xb5,0xe5,0x90,0xb5,0x23,0xa1,0x7c,0xbb,0x0c,0x66,0x40,0x56,0xea,0x41,0x2f,0x19,0xc4,0x39,0x68,0x8f,0xf8,0xb0,0xf3,0xc5,0x4e, - 0xd4,0xf7,0xd2,0x07,0x74,0x05,0xe4,0xa5,0x2f,0x33,0x8d,0x75,0xa8,0x7a,0xa3,0x5a,0xcf,0x2d,0x3a,0x0f,0xbf,0xe2,0x3c,0x48,0x97,0x6b,0x78,0x65,0xbc,0x76,0xb3,0xb2,0x27,0x4d,0x1c,0xb5,0x20,0x71,0xa9,0x99,0xa1,0x4b,0xb2,0xaf,0x21,0xd8,0x8b,0xde,0xac,0x88,0x75,0x79,0x2a,0xb0,0x8c,0x89,0xa7,0x5e,0x30,0x62,0xec,0x26,0xa1,0x32, - 0xec,0xe5,0x4e,0x62,0xfc,0x3d,0x57,0x89,0x80,0xdb,0x3c,0x1b,0xda,0x89,0x9f,0x21,0xf1,0x6b,0x18,0xde,0x46,0xba,0x45,0xbf,0x63,0xad,0x7f,0x08,0xf2,0xa8,0x81,0x1a,0xe8,0x5f,0xe6,0xa8,0xbc,0xb1,0xfe,0x84,0x21,0x95,0x4c,0xc4,0x12,0x60,0x1e,0x92,0x20,0x14,0x09,0x0c,0xda,0xcf,0x00,0xad,0x38,0x86,0x1c,0x3f,0xb8,0x5f,0x39,0x31, - 0xcb,0xa7,0xbd,0x8a,0xe3,0x30,0x2d,0x44,0x82,0x05,0x09,0xc7,0x5d,0xa9,0x80,0x32,0x7b,0x0e,0xd8,0xdc,0xc3,0x85,0x92,0x82,0xf1,0x33,0xb3,0x30,0x0a,0x6a,0xbb,0x05,0x12,0xd6,0x0e,0x7a,0x6c,0xf9,0x4a,0x19,0x43,0xdc,0x4b,0x02,0xeb,0xe8,0x6b,0x42,0x74,0x71,0xae,0xf5,0x1c,0xe5,0x6f,0x61,0xcb,0x1a,0x1f,0x18,0x5c,0x06,0xec,0x16, - 0x6b,0x5e,0x4e,0x65,0x37,0x95,0x1b,0xaa,0xa2,0x9e,0xd6,0x76,0x6f,0x34,0xa4,0xc1,0x41,0x8f,0x81,0x66,0x05,0x79,0xd1,0x93,0xe5,0xc6,0xf2,0xc2,0xcd,0xa0,0x9f,0x62,0xb6,0x3b,0x87,0x8d,0x65,0x8a,0x14,0x05,0xd5,0x75,0xe6,0x4c,0x98,0x6f,0x9c,0x37,0x67,0xc7,0x7f,0x9d,0x15,0x11,0x34,0x84,0x0a,0x67,0xc0,0x9a,0x62,0xfe,0x31,0x36, - 0x6b,0x9d,0x30,0xa7,0x98,0x9d,0x32,0xab,0xe8,0xb5,0xeb,0xa1,0x30,0x39,0x0e,0x60,0xad,0xc0,0xf0,0xd4,0xea,0x51,0x3c,0xd4,0xe0,0xae,0x1d,0x30,0xe4,0x1d,0x4f,0xb8,0x4f,0xba,0x92,0x24,0xca,0xcd,0x58,0x94,0xd7,0xd6,0x75,0x74,0xf9,0x15,0xf4,0xe9,0x0c,0x86,0x4e,0xbe,0x98,0x98,0xa6,0x96,0xf0,0x3e,0xf2,0x2b,0x49,0xa5,0xb1,0x2a, - 0x73,0x91,0x3f,0x13,0x5d,0xda,0xc5,0xda,0x04,0xbd,0xc8,0x21,0xe7,0xea,0xe6,0xdd,0x97,0xa0,0x8e,0xc8,0x4a,0x4c,0xe6,0xac,0xaa,0xcd,0x41,0x72,0xe7,0x45,0x53,0xa2,0x21,0x34,0xeb,0x1d,0x1f,0xa9,0x2a,0x9a,0xaa,0x25,0xc6,0x3b,0x9c,0xf1,0xec,0x3a,0xb8,0x24,0x08,0xf0,0xe8,0x6e,0x17,0xbe,0xf0,0x89,0xea,0x5a,0x1f,0x36,0x2e,0x9b, - 0xcb,0x79,0x8d,0x21,0x02,0x9c,0x7f,0x9b,0xb4,0xa4,0xfb,0xec,0x87,0x20,0x26,0xb4,0x17,0x38,0x68,0xd0,0xf2,0xe9,0x50,0xab,0xc3,0x4d,0xe6,0xe6,0xad,0xf6,0x74,0xa5,0x22,0xbc,0xa1,0x89,0x93,0x54,0xbc,0x6b,0xd9,0x71,0x4d,0x88,0xf8,0xac,0x76,0xb1,0x7e,0xb7,0xfc,0x25,0xc6,0xc1,0x0f,0xb2,0xbf,0x2d,0xa7,0xea,0x10,0xc2,0x7b,0x2b, - 0x81,0xd5,0x59,0xbe,0x83,0xcb,0xed,0xd6,0xb3,0x9c,0x28,0x3f,0xde,0x27,0x26,0x97,0xf5,0x54,0xde,0x73,0x55,0xd9,0xd0,0x90,0x50,0x45,0x14,0xe3,0xbb,0x24,0x0f,0x21,0x10,0x54,0x21,0xa4,0x4b,0x6f,0xf4,0x81,0x94,0x23,0xaa,0xb3,0xa7,0xd6,0x24,0x43,0x39,0x00,0x04,0xcf,0x39,0xfa,0x3e,0x10,0xfe,0xb5,0xd1,0x5d,0x3a,0xae,0x0d,0xf3, - 0xe7,0x4e,0x27,0xc3,0xba,0x8b,0x3d,0x22,0x6a,0x61,0xc5,0xcc,0xe3,0x8b,0x33,0xe7,0xb0,0xaf,0xe7,0x4c,0x71,0xee,0x01,0xa3,0x14,0x46,0x34,0x35,0xcb,0xe8,0xdb,0xc5,0x03,0xb8,0xd8,0xa1,0x46,0x53,0xe8,0xdd,0x36,0x75,0x01,0x5a,0x76,0xe2,0x6a,0xbd,0xf3,0x07,0x10,0x9f,0x31,0xe5,0x54,0x73,0x48,0x15,0xf1,0xa2,0xc5,0x1c,0x8b,0x38, - 0x0e,0x6b,0x4b,0x70,0x5f,0x87,0xd4,0x30,0x08,0x5f,0x56,0x5b,0x5f,0x77,0x03,0x98,0x5e,0xcd,0x70,0x10,0x85,0xc8,0xb5,0x0a,0x3a,0x5b,0x20,0xc3,0x63,0x6f,0x79,0x63,0x69,0x2e,0x36,0x59,0xf2,0x6e,0x32,0x07,0x38,0xd2,0x0c,0xe7,0xf8,0x39,0xdd,0x14,0x43,0x3e,0xd8,0x51,0xd5,0xc1,0x2c,0x88,0x68,0x08,0x73,0xe5,0xf5,0x1c,0x85,0x56, - 0x70,0x0a,0xcd,0xba,0xeb,0x30,0xe5,0xb3,0x29,0x7c,0xf6,0x38,0xb6,0x26,0x48,0xaa,0x1c,0x6e,0x1b,0x34,0xb6,0xe9,0x0f,0xac,0x92,0xa7,0x97,0x17,0x19,0xf9,0x59,0x80,0xc6,0x3a,0x77,0x57,0xc3,0x3c,0x60,0xca,0xfb,0xf3,0x2d,0x50,0xea,0x31,0xa3,0xdf,0x69,0xa7,0xcf,0xf3,0x20,0x13,0xa2,0xab,0x5d,0xba,0xd4,0x72,0xbc,0x78,0x9b,0x51, - 0x79,0xa7,0x6e,0x5a,0xca,0x1a,0x96,0xf9,0x14,0x8d,0x50,0xc6,0x95,0xa8,0x7b,0xc8,0x10,0x87,0x0a,0xaf,0xb2,0x5b,0xa8,0xff,0x11,0x6c,0x52,0x53,0x28,0x7c,0x96,0x9f,0x96,0x5f,0xe3,0xbb,0xaf,0xc3,0x13,0x7e,0xc9,0xf9,0x70,0x08,0x1d,0x68,0x9c,0xda,0x53,0xc8,0x14,0x56,0x48,0x77,0x9f,0x47,0x74,0x02,0x3a,0x1d,0x48,0x6d,0xa2,0x41, - 0x4a,0x64,0x2b,0x97,0x6e,0x7c,0xa5,0x11,0x40,0xb6,0x7b,0x70,0xea,0x22,0xf3,0xa9,0x44,0xc6,0x72,0x7b,0x2b,0x70,0xab,0x78,0x82,0x75,0x26,0x4f,0x71,0xb7,0x84,0x01,0x61,0xab,0x60,0xfe,0x06,0x9a,0xe3,0x99,0xce,0x6e,0x39,0xf0,0xba,0x8b,0x28,0x5c,0x38,0xdf,0xcf,0x62,0x23,0x6a,0x40,0x67,0x12,0x6e,0x74,0xbf,0x70,0xad,0x2d,0x40, - 0x83,0x13,0xf3,0x90,0x7b,0xc7,0xcf,0x02,0xf1,0xba,0xc4,0x04,0x92,0xea,0x98,0xac,0xf7,0xe9,0xc9,0xab,0xc8,0xca,0x82,0xe1,0x09,0xd6,0x39,0x78,0xc6,0x38,0xbc,0xb7,0x7a,0x87,0x8b,0xc1,0xea,0x17,0x14,0x1b,0xa5,0x18,0xb3,0x17,0x44,0x7d,0x2b,0xa5,0xa3,0x3e,0xf9,0xf7,0x61,0xf7,0x37,0x3a,0xb1,0x5d,0x80,0x6b,0xb0,0xca,0x03,0xd4, - 0x5f,0xaf,0x63,0x39,0x10,0x86,0xfe,0x0c,0x48,0x5d,0x78,0xef,0x65,0x7a,0x67,0x9d,0x06,0xdf,0x29,0x65,0x59,0x11,0x2a,0x76,0xde,0xba,0x2e,0xdc,0xe8,0x83,0x39,0xfb,0xc4,0x61,0x01,0x24,0x80,0x66,0xe1,0x8c,0x4d,0x7c,0x58,0x0d,0x4c,0x9b,0x02,0x07,0xa7,0x9b,0x73,0x8f,0xba,0x66,0xe3,0xba,0x76,0xc4,0xa7,0x08,0xf5,0x1e,0x5e,0x6d, - 0x7f,0x99,0x2e,0xd9,0xf6,0xce,0x63,0x89,0xf0,0xd0,0x15,0xdb,0x4c,0x16,0xd5,0x04,0xf6,0x0e,0xae,0x82,0xb7,0x24,0x56,0x1a,0x1b,0x6e,0x8a,0x8d,0x70,0x0b,0xda,0xfc,0xe5,0x6b,0xe1,0xc6,0xd7,0xbd,0xc5,0xd1,0x96,0x7c,0x54,0x58,0xb5,0xa3,0x01,0x44,0xa6,0x43,0x43,0xc2,0x52,0xd8,0x11,0x33,0xe0,0xaa,0x20,0x06,0x8c,0xe0,0xfb,0x77, - 0xb5,0xab,0x28,0x30,0x55,0xda,0xf6,0xed,0xcd,0x68,0xca,0x53,0x1d,0x4e,0x41,0xb2,0x36,0x33,0xb4,0x92,0xe7,0x93,0x64,0xa0,0xed,0x3c,0xa3,0x20,0x95,0xc4,0x56,0x84,0x0d,0x6c,0x02,0xa1,0x22,0x27,0x57,0x21,0x27,0xb4,0xd6,0xe4,0xd3,0x10,0x7f,0x37,0x0a,0x64,0x78,0x9f,0x60,0xaa,0x04,0xf7,0x1f,0x30,0xc8,0xe5,0x37,0x56,0xc8,0x99, - 0x9d,0x3c,0x67,0x90,0xee,0xaa,0xb3,0x36,0xf5,0xba,0x7d,0x82,0xe8,0xa4,0x33,0xfa,0x74,0x70,0xdb,0x78,0xe5,0xea,0xd4,0x0e,0xec,0xfd,0xbc,0xc3,0x87,0xe5,0x44,0xd0,0x66,0x96,0x89,0xfa,0xfe,0x37,0x01,0xef,0x90,0x80,0xec,0x6d,0x0b,0x80,0x91,0x25,0x06,0xe7,0x1f,0x43,0xc0,0x14,0x73,0x96,0xd9,0xcc,0x70,0x83,0x54,0x06,0xf2,0x7b, - 0xd3,0x86,0xd9,0x7c,0xd8,0xb7,0x4a,0x51,0xad,0xac,0x28,0x88,0x5c,0xdf,0xda,0x75,0x50,0x97,0x16,0x9c,0x5e,0xd3,0x81,0xfd,0x34,0x70,0xba,0x0a,0x31,0x48,0xdf,0x53,0xcc,0xb4,0x02,0x2a,0x41,0x46,0xbf,0x19,0xf6,0x10,0x6c,0x49,0x1c,0xc0,0x35,0x36,0x17,0x9e,0x50,0x62,0xba,0x01,0x8f,0xee,0x98,0x34,0xaf,0x53,0x41,0xc7,0xc0,0x7d, - 0x4f,0xa5,0xc0,0x4c,0x7b,0x14,0xab,0xa5,0x16,0xf0,0xec,0xd8,0x5a,0xca,0xe8,0xd8,0x75,0xa7,0xd4,0x28,0x09,0x5a,0x57,0xf7,0x62,0xe2,0x8e,0x21,0x4d,0xb7,0x7e,0x16,0x59,0xc5,0xba,0x99,0x34,0x97,0x08,0xfc,0x4f,0x5d,0x5c,0x08,0xe4,0x96,0x49,0x9b,0xec,0x4c,0x56,0xde,0x78,0xe6,0xf6,0x35,0x4a,0x4c,0x8c,0x34,0xf7,0x4c,0x36,0xff, - 0x4c,0xb0,0xaa,0xa3,0x01,0x3b,0x2a,0x90,0xf7,0xfc,0x62,0xe9,0xbf,0x3a,0x34,0x6d,0x07,0x55,0x38,0xf5,0x89,0x36,0x08,0x35,0xad,0xca,0xe0,0x1d,0x5f,0x54,0xf1,0x75,0x43,0x2a,0xaa,0xa8,0xf2,0x49,0x9b,0x81,0xee,0x95,0xa6,0x27,0x02,0x2e,0xd5,0x1b,0x43,0xa0,0xaa,0x3c,0x57,0x52,0xc5,0xd2,0xdc,0x48,0x23,0xff,0x8a,0x5c,0x1f,0x6d, - 0xb8,0xc6,0xbd,0x7e,0xf7,0x08,0x52,0xda,0x54,0x75,0x5b,0x99,0x06,0x7b,0x8d,0x7f,0x52,0xaf,0x09,0x9d,0xb4,0x93,0x46,0xf2,0x6b,0x07,0xce,0xc0,0xad,0x09,0xfc,0x09,0x14,0x99,0xcf,0xdc,0x9c,0x65,0x4b,0x7f,0x89,0xad,0xef,0x1b,0x97,0x71,0x01,0xf7,0x63,0xdf,0x54,0x7a,0xd9,0xe9,0xc5,0x18,0x7b,0xff,0x93,0xd8,0x83,0xf1,0x3c,0x42, - 0x6c,0x6f,0x21,0x5d,0x99,0x57,0xe4,0x07,0xac,0x72,0x9f,0xad,0x4c,0xe6,0x18,0x02,0xfb,0xfd,0x99,0xc7,0xc4,0x91,0x05,0xc6,0x89,0x46,0x68,0xce,0xa8,0x5c,0x41,0x62,0x43,0x02,0xf3,0xa4,0x27,0xb0,0x98,0xcd,0x12,0x07,0x64,0x60,0x51,0xf4,0xc6,0x76,0x31,0xe3,0x25,0x4f,0xc2,0x74,0xce,0x07,0x19,0xf5,0x9b,0x4b,0xa4,0xdd,0xe4,0xd4, - 0x16,0x21,0x9a,0x0d,0xe4,0x83,0x86,0xe1,0x92,0xde,0x5d,0x1b,0xd0,0x98,0x15,0x3e,0x75,0x3e,0x81,0xf2,0xf8,0x18,0xba,0xc2,0x8a,0x99,0x8d,0xd3,0x35,0xb9,0xd1,0x66,0x7a,0xe7,0xe9,0x1d,0x8d,0x06,0xf2,0xac,0x78,0x55,0x66,0xa3,0x91,0x40,0x78,0x70,0x04,0xe3,0x67,0xec,0xea,0x54,0x4a,0x03,0x0a,0x01,0x76,0xb5,0x68,0xe3,0x93,0xf7, - 0xca,0x95,0x65,0xb8,0x69,0x0c,0x53,0xb9,0x77,0x0f,0x37,0xd8,0x43,0xb5,0x36,0xc4,0x4e,0xce,0xf1,0x5a,0xb0,0xe7,0xfa,0x31,0x43,0x43,0x68,0xb3,0xec,0x08,0xee,0x50,0xb1,0x64,0xfb,0x6f,0xca,0x61,0x8a,0xcf,0x2d,0x4d,0x8c,0x21,0x4d,0x86,0x14,0x8b,0xfd,0x2d,0x1c,0x05,0x6f,0x21,0xbd,0xb0,0x6d,0x1a,0xc2,0x71,0x11,0x20,0xcc,0x3d, - 0x85,0xea,0x84,0x37,0x24,0x65,0x9f,0xcf,0xf4,0xf2,0x48,0xa5,0x91,0x51,0xe7,0xc5,0x4b,0x9d,0xbc,0x82,0x06,0x66,0x5c,0x8c,0xeb,0xfe,0x58,0x1a,0x05,0x77,0x16,0x21,0x93,0x78,0x19,0x1e,0x9a,0x4d,0x38,0xde,0xda,0x19,0x80,0x6d,0x88,0x2c,0x91,0xdd,0x1d,0x27,0x4a,0xe0,0xe6,0xf7,0x9c,0x4e,0x26,0x47,0xa1,0x28,0xb0,0xa8,0xc3,0x15, - 0x45,0x7a,0x96,0x6d,0x45,0x77,0x7c,0xbb,0x08,0x24,0xb1,0x46,0x00,0x2f,0xc8,0xa1,0xe6,0x2e,0x56,0xff,0x7a,0x02,0x26,0xea,0xc3,0x6f,0x8f,0x30,0x00,0x4a,0x98,0x0b,0x61,0x65,0x75,0xce,0x67,0x38,0x26,0x3e,0xc5,0x08,0xc1,0x29,0x14,0x31,0xfa,0xb6,0x97,0xba,0x43,0x20,0x48,0xe9,0xe3,0x0f,0xa2,0x7d,0x36,0xc8,0x1f,0x5a,0x12,0xf5, - 0xcd,0x84,0x2d,0xd9,0xc3,0xdb,0x54,0x5b,0x6d,0x28,0x7e,0xe4,0x08,0x99,0x55,0x5b,0xe2,0x94,0x49,0xb2,0xdd,0x7a,0x92,0xbc,0xe8,0xb8,0xeb,0x1c,0x7d,0xa7,0x38,0xb6,0xf7,0x7f,0xa8,0xd7,0x54,0xe0,0x4c,0x50,0xc0,0xc8,0x4b,0xfb,0x43,0x3e,0x25,0xa4,0x08,0xe4,0xf0,0x45,0x53,0xf1,0xde,0xca,0x74,0xca,0xc9,0x9e,0x0b,0x5a,0xf8,0x08, - 0x19,0x1e,0x4c,0x92,0x14,0xed,0x04,0x52,0xb8,0x20,0x60,0xe6,0xd8,0x3e,0xca,0x3a,0x91,0xf5,0x51,0xa3,0x74,0xbf,0x88,0xd7,0x8c,0x4a,0xdc,0x11,0xd0,0xc2,0x3d,0x57,0x1c,0x9d,0x43,0xca,0xfd,0x21,0x99,0x2a,0xf2,0xd6,0xc8,0xa9,0xdf,0xde,0x2e,0x12,0xae,0x2a,0x21,0x16,0x61,0x10,0x7b,0x0e,0xea,0x1e,0xe1,0xad,0xab,0xd6,0xf0,0x91, - 0x21,0x7d,0xa7,0x79,0xad,0xfa,0x19,0x08,0x82,0x82,0xd8,0x6f,0x2b,0x90,0xcf,0x26,0x35,0xa7,0xb4,0x32,0x53,0xe8,0xc3,0x61,0x3a,0x43,0xd9,0x06,0x87,0x6a,0xda,0xfe,0xfc,0xfc,0x2e,0x41,0x0c,0x42,0x6b,0xa8,0xf9,0x32,0xc8,0x62,0x0d,0x94,0xe3,0xbf,0xdf,0xe8,0xec,0x40,0x7d,0xc0,0x12,0x14,0xb0,0x8a,0xd7,0x2b,0x4f,0x3c,0x98,0x29, - 0xef,0xd2,0x39,0xa7,0x8f,0xca,0x98,0x7c,0x73,0xd1,0x3e,0x12,0x0d,0x17,0xbb,0x93,0x0e,0x1e,0x55,0xa6,0xe9,0x73,0xee,0x00,0x68,0x3f,0x1c,0x8b,0x9d,0x1a,0x99,0x1f,0x62,0x27,0xa3,0x3c,0xfa,0xce,0x97,0xe2,0x91,0xc4,0xf7,0xc3,0x9e,0x81,0xef,0xad,0x26,0x53,0xf4,0xfc,0x0b,0x9d,0x2a,0x47,0x3b,0xfa,0x8c,0x3d,0x0f,0x9c,0xe6,0xdb, - 0x9b,0xae,0x7a,0xe5,0x7a,0xe7,0x12,0xf5,0x0b,0xc6,0xbb,0x99,0x48,0xfd,0xf1,0x8b,0xf3,0xcc,0x96,0xc0,0x7f,0x82,0x82,0x08,0xda,0x17,0x4b,0xe3,0x0b,0xd9,0x8f,0x8f,0xd8,0x45,0xef,0x42,0x8d,0x39,0xcc,0xbc,0xae,0xb8,0x1e,0x40,0xaf,0x10,0xd6,0x25,0x3c,0x43,0x02,0xcf,0x50,0xa7,0xa2,0x5d,0x58,0x58,0xb3,0x30,0x24,0xc5,0x7c,0xe3, - 0x66,0x49,0x78,0x91,0x0f,0x2e,0x3f,0x00,0x8a,0x65,0x60,0x07,0xe7,0xd5,0x66,0xe3,0x24,0xe1,0x0e,0x93,0x26,0xae,0xf9,0xd1,0xa5,0x8c,0x69,0xd0,0x61,0x7b,0x6b,0x7f,0xa7,0x2b,0x6d,0x86,0x5c,0x65,0x0a,0x8d,0xbc,0x0c,0xb0,0x47,0xed,0x2d,0xdf,0x14,0x6e,0xd0,0x78,0xe5,0xa7,0xb5,0xe7,0x9b,0xb4,0x30,0x0d,0x69,0xb4,0x2e,0x70,0xa3, - 0x64,0x19,0x28,0x75,0x8c,0x40,0x06,0x4a,0x2d,0x07,0x23,0x66,0xd1,0x44,0xc5,0x13,0xdd,0x62,0x60,0x5c,0xf6,0x9d,0xe8,0x61,0x12,0xea,0x83,0xbb,0xea,0x14,0x9f,0x4b,0x19,0x0e,0x24,0xb3,0x3f,0xf2,0xa4,0x19,0xec,0xd7,0x78,0xad,0xe3,0x17,0x8d,0xfa,0xe1,0xa1,0x93,0xd1,0x1a,0x61,0x6f,0xdc,0x84,0xf2,0xba,0x9d,0xb0,0xf0,0x91,0x43, - 0xa3,0x40,0xe4,0xda,0x64,0xc8,0x18,0x3b,0x0a,0x82,0xba,0x23,0xdc,0x06,0x1f,0x08,0xba,0xc7,0x5c,0x2a,0x3b,0x68,0xa7,0xf8,0x6c,0x81,0xca,0xa6,0x33,0xfe,0x46,0xa2,0x09,0x75,0x96,0xed,0x7e,0x35,0xa4,0x0b,0x39,0x7c,0x27,0xfe,0xe1,0x40,0x9a,0x2b,0xce,0x81,0x27,0xae,0xe2,0xbf,0xb9,0xbe,0xc1,0xb5,0x28,0xdf,0x8a,0x16,0x7f,0x28, - 0x73,0x93,0xe7,0xd4,0xc8,0x5e,0x6a,0x8e,0xdd,0xd4,0x39,0xad,0x5d,0xc9,0x6f,0x5e,0xc9,0xaf,0x43,0x19,0x79,0xe0,0x4a,0x18,0x6c,0xce,0xd9,0xc5,0x60,0x3e,0xb9,0xb6,0x7a,0xb4,0x7a,0x83,0x4b,0x3c,0x1e,0x78,0x76,0x87,0x1e,0x52,0xde,0x37,0x81,0x6f,0x88,0x97,0xbe,0xd4,0x82,0x0d,0x15,0xe9,0xcb,0x23,0xc1,0xd5,0xe3,0x81,0x6f,0xcf, - 0x21,0x0b,0x78,0xa8,0xb3,0x8b,0x17,0xe4,0x9e,0xc6,0x9a,0xd8,0x7c,0x9a,0x9c,0xe0,0x63,0x45,0xab,0xd2,0x08,0x77,0x9c,0x72,0xa9,0xb6,0x12,0xa2,0x05,0x07,0x81,0x1f,0xad,0x62,0x67,0x97,0x44,0x1a,0x95,0x94,0x4e,0x05,0xd0,0xfe,0x76,0x3f,0x21,0x10,0x36,0x2c,0x9e,0x8a,0xf8,0x57,0xe4,0x29,0x4c,0x63,0x62,0x91,0x49,0xcc,0x19,0x95, - 0x95,0xf1,0xe5,0xbd,0x6f,0x64,0x31,0x2c,0x12,0xd0,0xcc,0x91,0x0c,0xa5,0x69,0x86,0x99,0x59,0x06,0xa2,0x0b,0x7c,0x34,0x00,0xae,0x8b,0x3c,0x65,0x1b,0xfc,0x1e,0x3e,0x78,0xe0,0x0d,0xf2,0xb1,0x44,0x7e,0x12,0x5e,0x48,0x8e,0x07,0x16,0xf7,0x9e,0x80,0x3e,0xd1,0xf8,0xe5,0xe2,0x82,0x49,0x15,0x57,0x4e,0xca,0x03,0xc5,0x66,0xff,0x73, - 0x93,0x1c,0xf9,0xc9,0xa9,0xad,0x70,0x94,0x20,0x0c,0xf6,0x0d,0x83,0x83,0x14,0x89,0xb4,0x37,0xbd,0x3f,0xed,0xb5,0xf0,0xf9,0xbb,0x1b,0x9d,0x9e,0x33,0xb6,0x29,0xd0,0x91,0x21,0x76,0x2a,0x8b,0x05,0x11,0x5c,0x13,0xc4,0xec,0xc8,0x37,0xc6,0xd2,0xf3,0x21,0x5b,0xea,0xaa,0x2d,0x58,0x6e,0xfc,0x90,0x24,0xbb,0x3b,0xc0,0x7a,0xb7,0xd5, - 0x4a,0xdf,0x91,0xb3,0xb4,0x31,0xb5,0xa6,0xc4,0x32,0x31,0xfb,0x71,0x81,0x9c,0x56,0x3d,0xa6,0xf8,0x85,0xa7,0x78,0x1b,0xe5,0x66,0x6e,0x9d,0x32,0x7a,0xc8,0xf7,0x19,0x4a,0xe1,0x24,0xbe,0x64,0xe9,0x54,0x2e,0x6e,0x10,0x6a,0xd5,0x7d,0xce,0x8a,0x44,0x0f,0x60,0x90,0xe6,0x56,0x9e,0x1d,0xc1,0xe4,0xd1,0x5f,0xb4,0x3f,0x0f,0xd3,0xb2, - 0xb3,0x52,0x50,0x90,0xd3,0xd9,0xde,0xff,0x99,0x84,0x60,0x61,0xc2,0xda,0x0c,0x1a,0x65,0x53,0xc3,0x83,0x59,0x39,0x74,0x33,0x78,0x55,0x25,0xb3,0x79,0x89,0x68,0x8c,0x56,0xda,0xf2,0x5c,0x5a,0x98,0xea,0x82,0x11,0xfa,0xd6,0x32,0x02,0x2d,0x91,0xc7,0x5e,0x85,0x3c,0x4b,0xb2,0xcf,0x0b,0x73,0x9d,0xa0,0x1b,0x1c,0x0e,0x6b,0xf5,0x53, - 0xf9,0x0b,0x46,0xe0,0x23,0x16,0xe0,0x03,0xe8,0xb2,0x3f,0x9e,0x1b,0x01,0xf3,0xd6,0x8b,0x2f,0x06,0x62,0x17,0x7c,0x60,0xb6,0x96,0x61,0x80,0x65,0xad,0x51,0xbe,0x40,0x72,0x5a,0xd7,0xc0,0x73,0x36,0xc3,0x8e,0xe3,0x29,0x33,0x15,0x14,0x7e,0xc1,0x9d,0x64,0x9d,0x07,0x70,0x39,0xa3,0x06,0x7c,0xae,0x7b,0x95,0x7a,0xcf,0xda,0x21,0x4c, - 0x0e,0x68,0xb7,0x03,0x7c,0x85,0xb7,0xfc,0xc9,0x75,0x26,0xec,0x77,0xa8,0x00,0x14,0x43,0xfc,0x28,0x42,0xe8,0x7b,0x01,0xec,0xf9,0x69,0x1a,0xbb,0x8b,0xc3,0x5f,0x32,0x6a,0xe1,0xc0,0x49,0x0c,0x41,0x83,0xba,0xe9,0x2f,0x69,0xdf,0x4f,0xda,0xa0,0xb7,0x87,0x98,0x16,0x90,0x42,0x2c,0x45,0xd8,0xde,0x54,0x97,0xdb,0x77,0xbf,0xf9,0x18, - 0xea,0x36,0xf3,0x4f,0x7f,0x86,0x2c,0x99,0x82,0x6e,0x0d,0x99,0xf1,0xe0,0xce,0xf8,0x1c,0x19,0x9a,0x1c,0x49,0x1a,0xe0,0x91,0x3a,0x75,0x3e,0xff,0x8e,0xc5,0x7b,0x46,0x63,0xb8,0xef,0x2d,0xde,0x48,0x32,0x63,0x28,0x44,0xae,0x4a,0xf1,0x35,0xfd,0x8f,0xa8,0x38,0x9d,0xd0,0x0a,0x9d,0x3f,0x74,0xde,0xe6,0x3d,0xb0,0xd3,0x4b,0xc1,0x8b, - 0xb5,0x84,0x72,0x28,0xc2,0xd2,0xd6,0x81,0x82,0xea,0xfc,0x98,0xac,0xc3,0x68,0x81,0x85,0xbf,0x48,0xa9,0x4b,0x01,0xe9,0x0f,0x46,0xd5,0x65,0x91,0xb5,0xfe,0x95,0xf1,0xc3,0x7e,0xe2,0xa1,0xa4,0x25,0xe3,0x93,0x1b,0xf5,0x85,0x1e,0x99,0x48,0x36,0x50,0xe8,0x34,0xf3,0xf4,0x15,0xa6,0x06,0xc4,0xca,0x66,0xb5,0x8f,0xc8,0xbf,0xa9,0x97, - 0xa6,0x3c,0x66,0x9c,0x2d,0xc9,0x12,0x94,0x4b,0x0f,0xb8,0x37,0x84,0x66,0xd8,0xcc,0x47,0xd7,0xfc,0x5f,0x79,0xf5,0x92,0xb3,0x88,0xcc,0xf7,0xd6,0x2c,0xaf,0x9b,0x62,0x55,0x71,0xdb,0x3c,0xbf,0x8d,0x73,0x73,0x0e,0x71,0xf7,0xfc,0x11,0x9f,0x4b,0xca,0x12,0x68,0x12,0x14,0xc3,0x07,0x68,0xe5,0x98,0xc4,0x85,0x45,0x97,0xa7,0x66,0x41, - 0x2b,0x58,0xa4,0xcf,0x06,0xe4,0x67,0x4a,0x4f,0x18,0xb0,0xb7,0x73,0xfc,0xfe,0xd9,0xb5,0xe8,0x73,0xe0,0x89,0xd1,0x9c,0xd9,0xe7,0x24,0xe8,0xe7,0xf9,0xd7,0xf5,0x68,0x84,0xda,0x48,0xdf,0xc8,0x81,0xd2,0xf8,0xdf,0x0d,0x3e,0x3f,0x68,0x69,0xf0,0xdc,0xac,0x41,0xee,0xc4,0x47,0xff,0x61,0x9b,0x60,0xe1,0xae,0xd5,0x4f,0x70,0xd5,0xcd, - 0xb9,0x28,0x65,0xb7,0xc9,0xca,0xf8,0x52,0xcc,0xdb,0x24,0xa0,0xe9,0x67,0x4c,0xce,0x7b,0x0e,0x5c,0x1f,0xea,0xfe,0x62,0x66,0x70,0x40,0xab,0xbd,0x87,0x05,0x8e,0xb5,0x45,0x50,0x02,0x45,0xaa,0xc7,0x65,0x95,0x39,0xe4,0x6f,0x01,0x56,0x9c,0x81,0xdb,0x84,0xb8,0x82,0xf6,0xbe,0xe5,0xa7,0xb8,0xa4,0xe0,0x4c,0x63,0x65,0x91,0xee,0x60, - 0xec,0xa7,0x18,0x2b,0xba,0xd8,0x20,0x6d,0xbb,0xe5,0x15,0xc3,0x08,0x7f,0x81,0x2d,0x0b,0xaf,0xe2,0xa5,0xdf,0x13,0x85,0x3f,0xc0,0x4e,0x07,0x10,0x61,0xcb,0xf8,0x49,0xfb,0x09,0x2b,0x86,0x43,0xe1,0xe8,0x49,0x46,0x9a,0x7e,0x22,0xdb,0xfd,0x37,0x9f,0x09,0x80,0x5b,0xcd,0xa0,0xb3,0xe6,0x5b,0xab,0xa8,0x3a,0x87,0xa9,0x30,0xc9,0x9a, - 0xc5,0x63,0x5c,0xc3,0xe4,0xb4,0xdc,0xc2,0x32,0x18,0x78,0x81,0xad,0xe7,0xa6,0x8f,0xe8,0xa7,0xf8,0x2b,0x53,0x71,0xe7,0x44,0x94,0xb2,0xb1,0x8e,0xcf,0x8b,0x50,0x88,0x5e,0xa6,0xdd,0xef,0x7f,0x46,0x2e,0x5e,0x09,0x40,0x06,0x1d,0xe6,0x3f,0xae,0x88,0x6f,0x2f,0xa5,0x52,0xae,0xfb,0x7d,0xeb,0xca,0xd6,0xc4,0x6c,0x81,0x61,0x52,0x9c, - 0xda,0xe6,0x23,0xf9,0x2c,0xe4,0x99,0xbe,0xc7,0x43,0x0a,0xff,0xfd,0xff,0x06,0xb6,0x1b,0x93,0x21,0x9b,0xda,0xf7,0xaf,0xd5,0x09,0x74,0xc7,0x20,0x71,0x7d,0xe4,0x4d,0x91,0x95,0x7c,0xaa,0x5f,0x9d,0xd6,0x8a,0xe7,0x57,0xd4,0x64,0xef,0x33,0x94,0xb9,0x62,0xbf,0x7a,0x8e,0x77,0x2e,0x6e,0xb5,0x2b,0x36,0xa6,0xdd,0x0e,0xa7,0x37,0xab, - 0xdf,0x11,0x23,0x99,0x97,0x3f,0x01,0x2d,0xe9,0x68,0x41,0x26,0xa9,0x40,0x58,0x27,0x2b,0x44,0x99,0x66,0x1b,0x7b,0x37,0x68,0x9e,0x54,0x57,0xa1,0xa2,0x83,0xdc,0x10,0x74,0xda,0xcf,0x79,0x89,0x30,0xb1,0x22,0xbb,0x8e,0x4b,0x39,0xe4,0x21,0xc9,0x2b,0xae,0xe3,0x0b,0xd1,0x12,0x68,0x9e,0x58,0x0e,0x72,0x7a,0xaf,0x7d,0x36,0xbf,0x83, - 0x12,0x00,0xc0,0x12,0x83,0x55,0xa5,0xb4,0x7c,0xc4,0x18,0xb8,0x64,0x9b,0x4f,0x40,0xc5,0xa5,0xb2,0x2f,0x30,0x90,0x5c,0x32,0x81,0x25,0x74,0xda,0xdc,0x0b,0x36,0xe0,0x34,0x04,0x53,0x4e,0x3a,0x76,0x11,0xed,0x30,0x9d,0x3f,0x1b,0xb8,0xd1,0xf0,0xa8,0xb2,0xed,0x76,0x94,0x07,0x08,0x56,0x7e,0x03,0xcf,0x34,0x69,0x1b,0xe9,0x5c,0xfe, - 0xd2,0x62,0xa5,0xa2,0x75,0x9b,0x69,0xea,0x89,0x51,0xd4,0x67,0xb2,0xa2,0x30,0xe8,0x91,0x0c,0xd9,0xfd,0x9b,0x28,0xed,0xb3,0x4f,0xd6,0xcd,0x1c,0x37,0x90,0x87,0x4c,0x99,0xf1,0xd1,0xb0,0xd5,0xe1,0xc5,0x86,0x03,0x03,0xc5,0x36,0x3c,0xb8,0xe2,0x5e,0xa5,0x6b,0x93,0xad,0x58,0xd9,0x17,0x01,0x4d,0x74,0x31,0x96,0xb2,0x71,0x15,0x14, - 0x77,0xd8,0x7d,0xd4,0xe3,0x82,0xad,0xd1,0x37,0x25,0x7d,0x16,0x4e,0xc4,0x5c,0x0a,0xf3,0x48,0xf7,0x45,0xdf,0x2f,0x9d,0xd3,0x36,0x11,0xc4,0xfa,0x0d,0x28,0x07,0xb7,0xaa,0x70,0x69,0xce,0x02,0x9a,0xc9,0x4f,0x05,0x04,0x73,0x56,0x20,0xc5,0x75,0xea,0x73,0x97,0xa7,0x57,0xef,0x5c,0x5a,0xe9,0x4c,0x1c,0xaa,0x51,0xf6,0x92,0xdb,0x5c, - 0x28,0xb6,0x76,0x38,0x90,0x56,0xc8,0x0a,0x7d,0x4d,0x35,0xdb,0x27,0xe1,0xf5,0x94,0x51,0xe0,0x77,0x60,0xad,0xd0,0x6e,0xc7,0xc7,0xde,0x03,0x21,0x80,0x58,0x62,0xf2,0x70,0x7e,0x6f,0x29,0xbe,0xf0,0x1f,0xeb,0x81,0x0e,0x9a,0x8c,0xaf,0x1c,0x69,0x4a,0xc7,0x4d,0x82,0xa0,0x35,0xb6,0xe7,0x42,0x68,0x9a,0xba,0x7d,0xbb,0xc1,0xc9,0x77, - 0x7b,0x86,0xa4,0xf4,0xfb,0x83,0x2c,0x17,0xee,0xb8,0xa2,0x89,0x73,0xaf,0x5b,0x8c,0xed,0x63,0xc1,0x22,0x95,0x98,0xe3,0xa5,0x64,0xe6,0xb9,0xd1,0x51,0x36,0xe8,0xf3,0x2e,0xc4,0xd7,0x70,0x2f,0xe1,0xa6,0xb2,0x72,0xb1,0x8e,0x3e,0xe3,0xf7,0x24,0x85,0x26,0xe6,0x5f,0xfc,0xef,0x09,0x0c,0xf8,0xe2,0x0b,0xd6,0x18,0xc6,0x03,0x04,0xcc, - 0x42,0x7e,0x47,0xea,0x45,0xa5,0xcc,0x0c,0x1f,0xba,0xe3,0x15,0xba,0x93,0x38,0xef,0x73,0x30,0x84,0xbb,0x77,0x9e,0x8c,0x1d,0xef,0x96,0x09,0xcd,0x17,0x57,0xa5,0xf9,0x19,0x5c,0xf9,0x08,0x33,0xb9,0xe1,0x72,0xa7,0xc4,0x02,0x15,0xca,0x0e,0xeb,0x27,0x5b,0x3e,0xc4,0xd9,0x89,0xe8,0xd7,0xc4,0x7c,0x98,0xaa,0x2b,0xf0,0x14,0xd8,0x52, - 0x3c,0x90,0xed,0x4a,0xff,0x0a,0xa2,0x27,0x30,0xc6,0x12,0xf9,0x6c,0xfd,0xda,0x97,0xf9,0x07,0x73,0x23,0xe4,0x04,0xaf,0xab,0x44,0xb0,0x35,0x63,0x40,0xc8,0x34,0x3e,0x03,0xd0,0x25,0x40,0xab,0x1d,0x9a,0xbf,0xad,0x85,0x25,0x3e,0xf1,0xa5,0x0d,0xf4,0x8a,0xba,0x70,0xb0,0x2e,0x09,0x73,0x21,0x71,0x42,0x73,0xfa,0x6f,0x33,0x05,0x7f, - 0xd5,0xdb,0x76,0x0e,0xc7,0xf7,0x8f,0xad,0xfb,0xb5,0x2b,0x44,0xb2,0xae,0xda,0x29,0x05,0x91,0xf5,0xeb,0x32,0x9a,0xf3,0xf2,0x8e,0x14,0x61,0xf6,0x7b,0x4a,0xd6,0xf6,0x97,0xa0,0x5f,0x4c,0x19,0x56,0xc1,0xe7,0xba,0xc6,0x11,0x18,0x07,0x48,0xa4,0x34,0x52,0x6d,0x45,0xf4,0x0b,0x91,0xce,0xfb,0x81,0xce,0x97,0x9b,0xbd,0xa1,0x0a,0x36, - 0x9b,0xd2,0x02,0xe6,0x03,0x71,0x28,0xc1,0x36,0x0c,0xd2,0x89,0x71,0xbd,0x7b,0xd7,0x6a,0x5b,0x3c,0x01,0x47,0xb9,0x30,0x70,0x38,0xd8,0x2d,0x30,0xb8,0xa7,0xb8,0xc0,0xf5,0x5e,0x22,0x56,0xe8,0xd0,0x04,0x92,0xa7,0xce,0x4c,0x7f,0x34,0xfc,0xc2,0x7e,0xc4,0x56,0x63,0xea,0x3d,0x95,0xa6,0x9f,0xe7,0x12,0xda,0xfd,0xb8,0xa6,0x26,0x77, - 0xff,0x61,0x67,0x32,0x7b,0x3d,0x43,0xe4,0x27,0xd2,0xbf,0x40,0xfd,0x57,0xc6,0xce,0x45,0x55,0xba,0x94,0xc9,0x03,0xc5,0x31,0x40,0x3f,0xe5,0x7e,0x91,0x32,0x39,0xb9,0x6c,0xa5,0x7e,0x19,0xee,0x9c,0xb1,0xad,0xf5,0xa5,0xe9,0xea,0x02,0x37,0xfe,0x93,0xdd,0xe2,0xae,0x43,0xdb,0x3d,0xc0,0x6e,0xbf,0x1b,0xa2,0x44,0x1c,0x99,0xee,0xd6, - 0x9c,0x0a,0x19,0xe9,0xbd,0x4a,0x9b,0x74,0xca,0x91,0x19,0xff,0xf5,0x56,0xbf,0xa1,0x29,0x6c,0x87,0xfe,0xa7,0x4a,0x14,0xec,0x61,0xc7,0x9d,0x10,0xdc,0x39,0x03,0xbc,0x93,0x20,0xa3,0x6f,0x62,0x3e,0x2a,0xdc,0x11,0x93,0x1e,0x51,0xb7,0xa5,0x66,0xe2,0x85,0x05,0xc1,0xe9,0x9f,0x82,0x76,0xef,0xe8,0xcb,0xf2,0x8c,0x3c,0xa1,0x30,0x60, - 0x4c,0xf0,0xb1,0xbd,0x30,0x74,0x62,0x3d,0xc4,0x64,0xb7,0x89,0x91,0x15,0x34,0x46,0x7b,0xfa,0xa2,0x89,0xab,0x6b,0xc2,0x8d,0xba,0x2e,0x5a,0x73,0x81,0x30,0x49,0xb2,0x04,0xa8,0x1c,0x3f,0xbe,0x4c,0x79,0x8e,0x59,0x35,0x7d,0xf7,0x53,0xea,0x4a,0x56,0xbb,0x64,0x84,0xac,0x6f,0x0c,0x93,0x87,0xb5,0x5a,0xcc,0xda,0xfd,0x90,0xf8,0x0c, - 0xe3,0x56,0xdf,0xf2,0xed,0x44,0x15,0xf5,0xcf,0x96,0xc6,0x71,0x2c,0x02,0xa1,0xe7,0xc0,0xe0,0xc9,0x00,0x0f,0x78,0xe9,0xba,0x2b,0x9e,0x60,0xad,0x78,0x3a,0xe5,0x12,0xfe,0xeb,0x3d,0xc7,0xc3,0x4c,0x95,0xc5,0xc2,0xb3,0x0e,0x1c,0x84,0x92,0xab,0xf7,0x5d,0x04,0x4c,0x94,0x55,0x54,0x08,0xd3,0x3f,0x8e,0x49,0xd5,0xb9,0x2d,0x51,0xab, - 0x47,0x7f,0x95,0xe8,0x2c,0x21,0x8e,0x43,0xa7,0xe9,0x5c,0x92,0x65,0x32,0x87,0x48,0xce,0x56,0xdc,0xdf,0x24,0x27,0xdb,0x81,0x9d,0x3e,0xd2,0xae,0x6e,0x13,0x20,0x57,0xdc,0xe3,0xfe,0x78,0x7d,0xf0,0x18,0x8d,0x2f,0x02,0x0a,0xc5,0x67,0xc2,0x89,0x2d,0x84,0x21,0xf3,0x0e,0x69,0x80,0xcf,0xb0,0xe8,0xab,0xc5,0xab,0x19,0xec,0x82,0xe6, - 0x7c,0xec,0x99,0x4c,0xfd,0x43,0xfb,0x02,0x8d,0x4c,0x93,0x89,0x57,0x2a,0xba,0xfa,0x3f,0xde,0xac,0xd7,0x64,0x57,0x2c,0x0c,0xb2,0x73,0xc0,0x56,0xb5,0x46,0x81,0xfc,0xa6,0x23,0xa6,0xcd,0xf6,0xb3,0xb0,0x68,0xb7,0x4d,0xc5,0xdb,0x25,0x29,0x34,0x7a,0xd8,0x3a,0x24,0xf1,0x67,0x6e,0x57,0x2c,0x07,0xf5,0x13,0x28,0x99,0x2e,0x84,0x42, - 0x9f,0xef,0xbe,0xb5,0xf9,0x46,0xc6,0x4c,0x55,0xf1,0x76,0xbf,0xdf,0xd3,0xb0,0x3b,0x78,0xa3,0x6a,0xc8,0xc0,0x62,0x9d,0x4e,0x2c,0xd8,0x22,0x7b,0xff,0x95,0x1b,0xf5,0xfa,0x55,0x5f,0xce,0x5c,0x5e,0xec,0x5d,0xfa,0xc1,0xfc,0x45,0xf6,0x67,0xa0,0x30,0x14,0x4b,0x48,0xd4,0xb5,0xf6,0xb7,0xac,0x77,0x2d,0x17,0xa6,0xfc,0xe9,0x49,0xce, - 0x58,0x0f,0x88,0xb3,0x16,0x33,0x39,0x26,0x04,0xb2,0x61,0x9c,0x5e,0x83,0xa5,0x27,0x61,0xc9,0x1c,0x7d,0xa9,0xeb,0xba,0x8b,0x25,0xab,0xd5,0x6e,0x3c,0xfb,0x6e,0x2d,0xb4,0x14,0xa0,0x5e,0xf6,0x47,0x7a,0xfe,0x54,0x05,0xfc,0x8d,0x9a,0x1c,0x80,0x7d,0x91,0x95,0x86,0x80,0x94,0xee,0xd1,0x0c,0x34,0xca,0xf4,0x4a,0xfb,0x2c,0x96,0xed, - 0xba,0x71,0x80,0x0b,0x92,0x68,0x4f,0xa0,0x39,0x1c,0x41,0xe5,0xb9,0x3a,0x71,0x76,0x97,0xed,0x36,0x4f,0x9f,0xe3,0xa5,0xba,0x1d,0x0e,0x12,0x75,0xb0,0x92,0x40,0x92,0xca,0xf4,0x72,0xce,0x10,0x5b,0x1c,0x3c,0x4f,0x4b,0x02,0xaf,0x61,0xdc,0x54,0x1c,0x70,0x85,0xc5,0xee,0xec,0x80,0x0c,0x1a,0xe2,0xd0,0x45,0x8c,0xb1,0x6b,0x6d,0x8b, - 0xad,0x4b,0x22,0x0c,0xae,0x2e,0x9b,0x56,0x7a,0xad,0x80,0x13,0x28,0x60,0x3f,0x16,0x16,0xb4,0x18,0x73,0xe3,0x1e,0xdf,0x9a,0xbb,0x09,0xa0,0xfa,0x9e,0xdb,0x9c,0x14,0x63,0x29,0x7c,0x8e,0x26,0x23,0xcc,0xf0,0x9b,0x54,0x0d,0x14,0xd6,0xa7,0x48,0x36,0xbc,0xb4,0xe6,0x5b,0x05,0xc8,0x74,0x22,0xb8,0xd9,0x0a,0xd5,0xb8,0x3e,0x20,0xbe, - 0x12,0x34,0x50,0xeb,0xa8,0x55,0x38,0x1b,0x16,0x55,0xa8,0x17,0xb8,0xec,0xb4,0x46,0x8c,0x72,0x21,0xe5,0x90,0xdf,0x68,0x95,0xd2,0x58,0xc9,0x73,0x8f,0xb9,0x45,0x1d,0x53,0xcd,0xbf,0xd1,0x01,0xba,0x59,0x74,0x38,0xae,0x4b,0x6a,0xd9,0x7a,0x5c,0xaf,0x0e,0x37,0xcb,0x0d,0xe7,0xce,0x37,0x06,0x07,0xba,0xc8,0xc0,0xef,0xbe,0x88,0x39, - 0x69,0xa2,0xe1,0x77,0x8b,0x2a,0xbc,0x81,0x29,0x26,0xb1,0xaa,0x90,0x9c,0x0c,0x4d,0x4e,0xbc,0x66,0x7c,0x0b,0xad,0xbf,0x4e,0x8f,0x8b,0x26,0xfd,0x7f,0x1c,0x30,0xa4,0xf2,0x19,0xdb,0x06,0x2d,0xfd,0x47,0x05,0x7e,0xb4,0x96,0x92,0x03,0x1d,0xbe,0x94,0x4e,0x6f,0x68,0x35,0x14,0x8c,0x12,0xe6,0x83,0x1c,0x00,0x15,0xf7,0x8d,0xc0,0x93, - 0x0e,0x0c,0xf1,0xc7,0xde,0xa2,0xa3,0x7d,0x90,0x78,0xc0,0x37,0x81,0x05,0x93,0x6c,0xeb,0x79,0x06,0x3b,0xd4,0xc3,0x06,0xee,0xab,0x7a,0x1c,0xd1,0x5f,0x8e,0x63,0x0e,0x32,0xf1,0xa8,0xef,0x6a,0xe1,0x34,0x63,0x28,0xea,0x47,0xaf,0x23,0xc1,0xc2,0x53,0x5f,0x36,0x0a,0x97,0x68,0x94,0xfb,0x36,0xea,0x05,0xaa,0xac,0x8f,0x7a,0x07,0x81, - 0x71,0x18,0xa0,0x3f,0x1d,0xd9,0xf2,0x85,0x58,0x62,0xc5,0xb7,0x95,0x35,0x55,0x7b,0x95,0x90,0x3e,0xe4,0x4c,0x8a,0xe0,0x6f,0x41,0x2e,0x00,0x8e,0x05,0xd4,0xdb,0x79,0x90,0x5c,0x29,0x93,0x35,0x11,0x25,0x67,0xb2,0x86,0x12,0x5e,0x87,0xe6,0x43,0x59,0x80,0x5b,0xef,0x7a,0x44,0x55,0xc7,0x40,0x42,0xa8,0x13,0x16,0xe1,0xe5,0x09,0x26, - 0xb5,0x51,0xa5,0x89,0x11,0x50,0x39,0x4e,0x72,0x69,0x7f,0xd1,0x38,0x0c,0x11,0x5c,0xe8,0xa0,0x57,0xa7,0xdd,0x8d,0x38,0xe1,0x9f,0xf6,0xcb,0xa4,0xe8,0x85,0x82,0x9d,0x5f,0xbb,0x70,0x85,0x11,0x0e,0xe0,0x59,0xeb,0xf4,0x1c,0xa5,0xd7,0xf7,0x7e,0x93,0x06,0xd5,0xb8,0x9f,0xa7,0x4a,0xaa,0xa0,0x86,0x01,0x68,0x79,0x13,0x05,0x1f,0x4f, - 0x4d,0x8c,0x9a,0x7d,0x13,0xf4,0x4c,0x49,0x73,0x56,0xa9,0xb5,0xcb,0xa5,0x74,0x6a,0x7b,0x7e,0x09,0x04,0x9a,0xd5,0xac,0x3e,0x4c,0x3b,0xa3,0xeb,0x9a,0xed,0x81,0x73,0x11,0xd7,0xbb,0x60,0xb4,0x37,0x72,0x81,0x2e,0x73,0x3f,0x46,0xa7,0xa3,0xf9,0xa7,0xb3,0xdd,0x10,0x15,0x20,0x1b,0x27,0x22,0x7a,0x96,0x46,0x81,0x0f,0xe9,0x0b,0x09, - 0xbb,0x4f,0x4d,0x4d,0xa9,0x29,0x5d,0x39,0x62,0x9c,0xeb,0x42,0xab,0x84,0x57,0x27,0xc6,0x75,0xe7,0xda,0x50,0xe8,0x11,0x48,0x19,0x13,0x2a,0x6e,0x6f,0xf3,0xe6,0x65,0x08,0x49,0xc8,0xfc,0x69,0xf3,0xb6,0xb2,0x40,0x85,0x7b,0x2d,0x82,0x82,0x01,0x21,0xa8,0xaa,0x46,0xfc,0x06,0xd0,0xd7,0xa2,0x4d,0x25,0xf2,0x35,0x79,0xab,0xb4,0x55, - 0xb0,0xc2,0x8e,0x0d,0x10,0x16,0x8e,0x70,0x2f,0x28,0x19,0xd5,0x55,0x14,0x9f,0xd4,0x73,0x9a,0xb9,0x65,0x70,0x60,0x39,0x02,0x6f,0xe8,0xf1,0xc5,0x3d,0x99,0x2d,0x12,0x44,0x52,0x84,0xb5,0xdd,0xb7,0xf0,0xd2,0xec,0x87,0x5f,0x06,0x38,0x5b,0xb0,0x08,0x9e,0x5e,0x4e,0x78,0x9f,0x0f,0xcc,0x13,0x00,0xeb,0xef,0x36,0x65,0x4c,0x6e,0x42, - 0x4e,0x1e,0x87,0xfe,0xf4,0x07,0x96,0x1a,0xfb,0xc4,0x4c,0x1c,0x16,0xc6,0xb2,0xb8,0x12,0x11,0x10,0xa9,0xf0,0x82,0xc1,0xb8,0xb5,0xd7,0x87,0x92,0x53,0x82,0xf5,0xf6,0x7a,0x3d,0x7c,0xa8,0xd4,0x6a,0x06,0x36,0xe6,0xbf,0x88,0xfa,0x7e,0x83,0x3e,0x15,0x88,0xb9,0x84,0x71,0xee,0xab,0xa4,0xc6,0x38,0x74,0xaf,0x2f,0x1b,0xe1,0xcd,0x0d, - 0x8d,0x7a,0xcb,0xe6,0x1c,0xfe,0x29,0x24,0xa5,0xdd,0xfd,0x71,0xc0,0x26,0xdc,0x7b,0xd5,0xe6,0xd4,0x98,0x9d,0xd3,0xe8,0xd2,0xd6,0xd4,0x51,0x4e,0xfa,0x7f,0xc7,0x18,0xbd,0x47,0x77,0x88,0x28,0x0a,0xc4,0x73,0xf2,0x5e,0xff,0xef,0xca,0xb0,0x65,0xc1,0x47,0x18,0x80,0x26,0x5e,0xa1,0x4e,0x8b,0x94,0xf3,0xea,0x50,0x46,0xa3,0xad,0x8c, - 0x80,0xf6,0xbd,0xa7,0x31,0x20,0x5f,0xd9,0xf0,0x01,0xcc,0x7a,0x38,0xa7,0xd7,0xa0,0x4b,0x56,0x4b,0xe3,0x0a,0x81,0xa9,0xc3,0xc2,0x98,0x1b,0xb8,0xe4,0xb5,0xa4,0xdf,0x06,0xd3,0xd7,0x83,0xc2,0x35,0x03,0x59,0xdc,0xaf,0x2f,0x4b,0x4d,0x0f,0x36,0xa1,0xcd,0xba,0xfb,0x00,0x04,0xf3,0x55,0x16,0x7e,0x79,0x8b,0x54,0x74,0x21,0x74,0x72, - 0xd1,0x2b,0xc0,0x8d,0x74,0x68,0xe9,0xd7,0xe0,0xa6,0xdd,0x11,0x06,0x71,0x2f,0xca,0xb0,0xca,0xe7,0x9f,0x5a,0x1d,0x05,0xc1,0xfb,0xba,0xeb,0x3c,0x0b,0x01,0x40,0xc5,0x6b,0x69,0xb7,0xd0,0x20,0x34,0x1c,0x8b,0x49,0x71,0x83,0x61,0x7e,0xfc,0xfd,0x40,0x30,0x5d,0xda,0x2f,0x86,0x0e,0x0e,0xbe,0x40,0x12,0x73,0x4f,0x56,0xea,0x04,0x92, - 0x87,0x73,0x5b,0xa3,0x0f,0xb9,0xe3,0x38,0x0e,0x04,0xce,0x0b,0xd8,0x0f,0xf2,0xda,0x8f,0x36,0xf2,0x91,0xf2,0x03,0xd1,0xea,0x3e,0xe2,0x76,0xa2,0xa6,0xcd,0xb4,0xb4,0xaf,0x6b,0x02,0xee,0x9e,0x53,0xb3,0x78,0xc0,0xf4,0xe8,0x60,0xbc,0x84,0x4a,0x42,0xc0,0xd2,0x13,0x05,0x00,0xda,0x2b,0x1f,0xaa,0x9e,0x69,0x13,0x3c,0xa1,0x75,0x5b, - 0x44,0x1e,0xb7,0xc6,0xac,0x09,0xe6,0xb8,0xfa,0x29,0xb1,0xe3,0x40,0x44,0x4f,0xa5,0x85,0x37,0x3e,0xf3,0x0f,0xa2,0x2d,0x88,0x94,0x9f,0x95,0x9b,0xe9,0x17,0x9d,0xc2,0x26,0xf4,0xcf,0x51,0xad,0x6b,0x45,0xac,0x06,0x32,0x11,0x54,0x67,0x01,0xe3,0x99,0x64,0x37,0xcc,0x04,0xda,0xac,0xcb,0x70,0xa4,0x11,0xbd,0xe6,0x86,0xb2,0x87,0xfe, - 0x71,0xe1,0x2c,0x87,0xd3,0x7d,0x68,0x9c,0x41,0x8c,0xbd,0x34,0xaf,0xac,0x99,0x22,0x59,0x6e,0x92,0x8b,0x37,0xcd,0x39,0x17,0xd4,0x98,0x9e,0x9e,0xf1,0x04,0xa5,0x8e,0xb7,0xd8,0xf4,0x16,0x46,0x81,0x02,0x35,0xad,0x75,0xd8,0xc1,0xed,0xfe,0xc3,0x1c,0x2e,0x5f,0x42,0x7d,0xdd,0xf5,0x11,0x47,0xf5,0xe4,0x86,0x0c,0xaa,0x3b,0x00,0x83, - 0x2e,0xa3,0x81,0xa5,0x0b,0xc6,0x5d,0x41,0xc2,0x73,0x19,0xc0,0x1e,0x71,0x79,0x37,0xe9,0xc5,0x0d,0xdd,0x67,0x95,0xa3,0x6d,0xbe,0xff,0x1b,0x07,0xf6,0x53,0x42,0x31,0x73,0x06,0xde,0x1f,0x7f,0x3c,0xd1,0xc9,0xd3,0x6b,0xca,0xc9,0x1d,0xbe,0x55,0x90,0x7f,0x78,0xe3,0xec,0x6e,0x82,0x3e,0x4a,0x14,0x7e,0x98,0x7e,0x42,0xe9,0xde,0x9a, - 0x9e,0xc4,0x5c,0x13,0x53,0x02,0x7f,0xa9,0x63,0xed,0x08,0x9b,0xc5,0x94,0xd0,0x49,0x24,0x4e,0x4c,0x84,0xcb,0xfe,0xcb,0xe1,0x3f,0x00,0x37,0x38,0xe3,0x62,0xf2,0x2d,0xc9,0xaf,0x96,0x58,0x52,0x0d,0x5c,0x77,0x4f,0xeb,0xe6,0x07,0xc4,0x70,0x3b,0x60,0x1d,0x88,0x4f,0xf1,0xf8,0x59,0x3f,0xc5,0x25,0xe8,0x7c,0x57,0xea,0xe5,0x80,0xaa, - 0x1c,0x07,0xa0,0xbf,0xc8,0x52,0xdc,0x00,0x9d,0xe4,0xcf,0xbc,0xd2,0x49,0x57,0x84,0x75,0xb6,0x11,0xa8,0xeb,0x41,0x0d,0xa8,0xbe,0x36,0x6d,0x18,0xdc,0x6d,0x6a,0x00,0x8d,0x82,0x58,0xda,0x4a,0xcf,0x4d,0x66,0x19,0x26,0x37,0x3d,0x37,0x7f,0xa2,0xe1,0xe4,0xbf,0x69,0xfa,0xde,0xf5,0x43,0x90,0x98,0x5f,0x04,0xec,0xd7,0x96,0x24,0x58, - 0x9a,0xdb,0x38,0x3c,0x73,0x38,0xde,0x67,0x8a,0x9f,0x8c,0x8f,0xd5,0x1f,0x28,0x0e,0xa6,0x28,0xf8,0x97,0x27,0x6b,0x4e,0xfb,0x63,0x6d,0x3c,0xc6,0x4c,0xcd,0x5e,0xb2,0x9b,0xb9,0x54,0x05,0x67,0x06,0x4e,0x39,0x4d,0x8b,0x42,0x77,0xa6,0xbd,0xa0,0x11,0xda,0x1e,0xf1,0x0b,0x1b,0xe4,0x0e,0xb5,0xf1,0x14,0xff,0xb9,0x76,0x77,0xe5,0xdb, - 0xed,0xf9,0x4d,0x4f,0x53,0x65,0xc2,0x7d,0x00,0x18,0x70,0x74,0x5d,0xeb,0x4f,0x79,0x53,0xa0,0x42,0xd4,0x70,0x51,0x28,0xcc,0xa2,0x26,0x67,0x75,0xb1,0x5c,0x29,0x6a,0xe9,0x00,0x48,0x7d,0x13,0x3f,0x15,0xf6,0x0c,0xc6,0x25,0x7c,0xf7,0x71,0xa4,0x5d,0x15,0xc9,0x14,0xb2,0x28,0xb9,0x5d,0x81,0xa8,0x75,0x33,0xef,0x15,0xe2,0xa7,0xd9, - 0x75,0x15,0x89,0x7c,0x27,0xf8,0xc7,0x8d,0x88,0xea,0x51,0xb2,0x91,0x9b,0xba,0x2b,0xb4,0x23,0xb7,0x0b,0x5e,0x6b,0xde,0x8e,0x6a,0x19,0xe9,0x4f,0x1c,0x22,0xa7,0x5d,0xed,0x8e,0xe8,0x9d,0xb1,0x5d,0x05,0x70,0x2d,0x6c,0xe3,0x55,0x70,0x10,0x8c,0x2d,0x75,0x22,0x92,0x6d,0x83,0x02,0x42,0x5b,0xe1,0x6f,0xa0,0x0c,0x16,0xca,0x56,0x1f, - 0x39,0x17,0xc7,0x2c,0x9d,0x60,0xea,0x41,0x3c,0x33,0xeb,0x45,0x4c,0x20,0xe6,0xfc,0xe1,0x3b,0xc1,0x1a,0x02,0x80,0xb0,0x39,0xde,0x45,0x78,0xf1,0xce,0xfa,0x91,0x5a,0x8c,0x16,0x6a,0x6b,0x42,0x0e,0x8f,0xa4,0x21,0x91,0x22,0x0d,0xa2,0xf5,0xc7,0x31,0xee,0xb2,0xfa,0xe9,0x88,0xe9,0xf6,0xc1,0x1a,0xbc,0x49,0x85,0x53,0x44,0xd6,0xdb, - 0x69,0x64,0xac,0xf1,0x17,0xf8,0xcb,0x02,0x22,0x3d,0x2f,0xe5,0xee,0x08,0x4e,0x09,0x8c,0xbd,0xb1,0x47,0x2c,0x1a,0x21,0x23,0xf6,0xc9,0x6b,0x5d,0x0e,0x89,0xbc,0x99,0x98,0xf5,0x95,0x2f,0x57,0x2e,0x84,0xb1,0x57,0x2b,0xe6,0x9e,0x6b,0xad,0x27,0x59,0x8b,0x9a,0xcd,0xcd,0xfd,0x64,0x5a,0xf1,0x8e,0xee,0x01,0x08,0xf2,0x1c,0x87,0xb7, - 0xf7,0xa7,0x9e,0xfd,0x1f,0xa3,0x65,0xce,0x09,0x7d,0x01,0xa6,0xc3,0xdc,0x4f,0xb9,0xdb,0x4c,0x19,0xbd,0xb0,0x99,0x94,0xac,0xd0,0x4d,0x2b,0xec,0x2a,0x8a,0xf5,0x61,0xdf,0x96,0x89,0xf2,0x13,0x1e,0xbc,0xa7,0x21,0x13,0xec,0xef,0x44,0x9b,0x91,0x2f,0x36,0x1f,0xac,0x71,0xce,0x20,0x6c,0xc6,0xd3,0x03,0x5e,0x54,0x61,0x3e,0x21,0x0f, - 0x75,0xdc,0xa9,0x12,0x1a,0xf3,0x4b,0xbf,0x85,0xe0,0x64,0x36,0x3d,0xa8,0x32,0xad,0xdd,0xcf,0x8a,0x5b,0x87,0x00,0xa8,0x1b,0xa4,0x53,0xce,0xa4,0x1c,0x04,0x31,0x65,0x6b,0x4e,0xb8,0x75,0xcd,0x72,0x59,0xa2,0xb1,0xb5,0xf2,0x58,0x88,0x17,0x33,0x9d,0x87,0x48,0x30,0xc7,0x58,0x15,0xfb,0x89,0xd8,0xb1,0xee,0x57,0x97,0x80,0x8f,0x48, - 0x6f,0xd5,0x2d,0xea,0x07,0x4d,0x06,0x71,0x98,0x4f,0xf8,0x13,0x39,0xaa,0xfa,0x00,0xa9,0x9c,0x6d,0x66,0xa9,0x93,0xe0,0x21,0xc0,0x70,0xbe,0x25,0xe3,0x5b,0x84,0xc2,0x55,0x26,0x5f,0xc4,0x79,0x2a,0xde,0x95,0x4c,0x91,0x43,0xe3,0x77,0x9f,0xde,0x6f,0x25,0x58,0x26,0xd9,0x14,0x4c,0xa7,0x50,0x31,0xe5,0x70,0xfb,0xc8,0xac,0xf3,0x75, - 0x2c,0x18,0x81,0x1b,0x45,0xdd,0x31,0x6b,0xee,0xbd,0x96,0x18,0xb9,0x7b,0xde,0xbb,0x9e,0xd9,0x18,0x83,0xa5,0x97,0xc7,0x6c,0xc0,0xb9,0xe0,0x11,0x76,0xe8,0x3c,0x4d,0x03,0xa9,0xa7,0x05,0xc7,0x56,0xa5,0xb9,0x28,0x93,0xd4,0x2a,0xa1,0xeb,0x67,0x4d,0x64,0x0c,0xb8,0x4a,0x83,0x9c,0x6c,0x59,0x6e,0x0f,0xf9,0xfe,0x0d,0x5f,0x32,0x84, - 0x3a,0xb1,0x8a,0x34,0x0b,0x60,0x03,0xa1,0x35,0xa8,0x35,0xfe,0x4b,0xc2,0x71,0x7e,0x6e,0xbd,0x4f,0x4e,0x44,0xf4,0x69,0x07,0x1f,0x10,0xe1,0xf7,0x32,0xd7,0x50,0x70,0x5e,0x9b,0x77,0xd1,0x56,0x55,0xf2,0xc2,0x45,0xc5,0x8a,0x85,0xbc,0x32,0xa3,0x66,0x22,0x86,0x97,0x53,0x06,0x66,0x79,0x35,0xaf,0x8a,0x92,0x60,0xbc,0x6f,0xbe,0x7e, - 0xe0,0xd7,0x42,0x24,0xb6,0xfe,0xd7,0x6e,0xa8,0x3a,0x09,0x52,0x8f,0xb2,0x88,0xab,0x2a,0x88,0x67,0xdd,0x0a,0x9e,0x80,0x10,0x27,0x4b,0x21,0x09,0xa5,0x31,0x23,0x8e,0x34,0x51,0x23,0xc8,0xe0,0xd8,0xfd,0x4d,0x46,0xbf,0xc8,0x88,0xe4,0xd9,0x50,0xac, +static const uint8_t slh_dsa_sha2_128s_0_sig_digest[] = { + 0xc7, 0xdf, 0xf0, 0xed, 0x25, 0x38, 0x49, 0xef, 0x51, 0x1e, 0x90, 0xbe, 0x0e, 0x2e, 0xb7, 0x71, + 0x65, 0x98, 0x91, 0x23, 0x17, 0x52, 0x9a, 0x61, 0xda, 0xe4, 0x32, 0x9b, 0xf1, 0x49, 0xef, 0x8b }; static SLH_DSA_SIG_TEST_DATA slh_dsa_sig_testdata[] = { SLH_DSA_SIG_TEST_ITEM(slh_dsa_sha2_128s_0, "SLH-DSA-SHA2-128s"), }; - /* skSeed || skPrf */ static const uint8_t slh_dsa_sha2_128s_0_keygen_priv[] = { 0x2F, 0x89, 0x6D, 0x61, 0xD9, 0xCD, 0x90, 0x38, diff --git a/test/slh_dsa_test.c b/test/slh_dsa_test.c index 7f2901a49c5..261161679fc 100644 --- a/test/slh_dsa_test.c +++ b/test/slh_dsa_test.c @@ -179,10 +179,16 @@ end: return ret; } -static int slh_dsa_sig_verify_test(void) +/* + * Rather than having to store the full signature into a file, we just do a + * verify using the output of a sign. The sign test already does a Known answer + * test (KAT) using the digest of the signature, so this should be sufficient to + * run as a KAT for the verify. + */ +static int do_slh_dsa_verify(const SLH_DSA_SIG_TEST_DATA *td, + uint8_t *sig, size_t sig_len) { int ret = 0; - SLH_DSA_SIG_TEST_DATA *td = &slh_dsa_sig_testdata[0]; EVP_PKEY_CTX *vctx = NULL; EVP_PKEY *key = NULL; EVP_SIGNATURE *sig_alg = NULL; @@ -199,7 +205,7 @@ static int slh_dsa_sig_verify_test(void) if (!TEST_ptr(sig_alg = EVP_SIGNATURE_fetch(libctx, td->alg, NULL))) goto err; if (!TEST_int_eq(EVP_PKEY_verify_init_ex2(vctx, sig_alg, params), 1) - || !TEST_int_eq(EVP_PKEY_verify(vctx, td->sig, td->sig_len, + || !TEST_int_eq(EVP_PKEY_verify(vctx, sig, sig_len, td->msg, td->msg_len), 1)) goto err; ret = 1; @@ -210,6 +216,56 @@ err: return ret; } +static int slh_dsa_sign_verify_test(void) +{ + int ret = 0; + SLH_DSA_SIG_TEST_DATA *td = &slh_dsa_sig_testdata[0]; + EVP_PKEY_CTX *sctx = NULL; + EVP_PKEY *pkey = NULL; + EVP_SIGNATURE *sig_alg = NULL; + OSSL_PARAM params[3], *p = params; + uint8_t sig[64 * 1024]; + size_t sig_len = sizeof(sig); + uint8_t digest[32]; + size_t digest_len = sizeof(digest); + int encode = 0, deterministic = 1; + + *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, &deterministic); + *p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, &encode); + *p = OSSL_PARAM_construct_end(); + + /* + * This just uses from data here, but keygen also works. + * The keygen path is tested via slh_dsa_keygen_test + */ + if (!slh_dsa_create_keypair(&pkey, td->alg, td->priv, td->priv_len, + td->pub, td->pub_len)) + goto err; + + if (!TEST_ptr(sctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, NULL))) + goto err; + if (!TEST_ptr(sig_alg = EVP_SIGNATURE_fetch(libctx, td->alg, NULL))) + goto err; + if (!TEST_int_eq(EVP_PKEY_sign_init_ex2(sctx, sig_alg, params), 1) + || !TEST_int_eq(EVP_PKEY_sign(sctx, sig, &sig_len, + td->msg, td->msg_len), 1)) + goto err; + + if (!TEST_int_eq(EVP_Q_digest(libctx, "SHA256", NULL, sig, sig_len, + digest, &digest_len), 1)) + goto err; + if (!TEST_mem_eq(digest, digest_len, td->sig_digest, td->sig_digest_len)) + goto err; + if (!do_slh_dsa_verify(td, sig, sig_len)) + goto err; + ret = 1; +err: + EVP_SIGNATURE_free(sig_alg); + EVP_PKEY_free(pkey); + EVP_PKEY_CTX_free(sctx); + return ret; +} + static int slh_dsa_keygen_test(void) { int ret = 0; @@ -246,7 +302,7 @@ err: /* * Given raw values for the private key + public key seed - * generate the public root also when using from data. + * generate the public root using from data. */ static int slh_dsa_pub_root_from_data_test(void) { @@ -284,7 +340,7 @@ int setup_tests(void) ADD_TEST(slh_dsa_bad_pub_len_test); ADD_TEST(slh_dsa_key_validate_test); ADD_TEST(slh_dsa_key_eq_test); - ADD_TEST(slh_dsa_sig_verify_test); + ADD_TEST(slh_dsa_sign_verify_test); ADD_TEST(slh_dsa_keygen_test); ADD_TEST(slh_dsa_pub_root_from_data_test); return 1; diff --git a/util/perl/OpenSSL/paramnames.pm b/util/perl/OpenSSL/paramnames.pm index 372758db3c3..b90132d7a92 100644 --- a/util/perl/OpenSSL/paramnames.pm +++ b/util/perl/OpenSSL/paramnames.pm @@ -486,6 +486,7 @@ my %params = ( 'SIGNATURE_PARAM_DETERMINISTIC' => "deterministic", 'SIGNATURE_PARAM_MU' => "mu", # int 'SIGNATURE_PARAM_TEST_ENTROPY' => "test-entropy", + 'SIGNATURE_PARAM_ADD_RANDOM' => "additional-random", # Asym cipher parameters 'ASYM_CIPHER_PARAM_DIGEST' => '*PKEY_PARAM_DIGEST',