diff -Nru libica-3.4.0/ChangeLog libica-3.5.0/ChangeLog --- libica-3.4.0/ChangeLog 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/ChangeLog 2019-04-23 16:02:53.000000000 +0000 @@ -1,3 +1,5 @@ +v3.5.0 + - [FEATURE] Add MSA9 CPACF support for ECDSA sign/verify v3.4.0 - [FEATURE] Add SHA-512/224 and SHA-512/256 support v3.3.3 diff -Nru libica-3.4.0/configure.ac libica-3.5.0/configure.ac --- libica-3.4.0/configure.ac 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/configure.ac 2019-04-23 16:02:53.000000000 +0000 @@ -1,4 +1,4 @@ -AC_INIT([libica], [3.4.0], [steuer@linux.vnet.ibm.com],, [https://github.com/opencryptoki/libica]) +AC_INIT([libica], [3.5.0], [steuer@linux.vnet.ibm.com],, [https://github.com/opencryptoki/libica]) # save cmdline flags cmdline_CFLAGS="$CFLAGS" @@ -76,6 +76,18 @@ AC_MSG_RESULT([*** Enabling sanitizer at user request ***]) fi +dnl --- enable_internal tests +AC_ARG_ENABLE(internal_tests, + [ --enable-internal-tests built internal tests], + [enable_internal_tests="yes"],[enable_internal_tests="no"]) +AM_CONDITIONAL(ICA_INTERNAL_TESTS, test x$enable_internal_tests = xyes) + +if test "x$enable_internal_tests" = xyes; then + AC_MSG_RESULT([*** Building internal tests at user request ***]) +fi + + + if test "x$enable_coverage" = xno && test "x$enable_debug" = xno && test "x$enable_sanitizer" = xno; then FLAGS="$FLAGS -O3 -D_FORTIFY_SOURCE=2" fi @@ -97,3 +109,4 @@ echo " Debug build: $enable_debug" echo " Sanitizer build: $enable_sanitizer" echo " Coverage build: $enable_coverage" +echo " Internal tests: $enable_internal_tests" diff -Nru libica-3.4.0/debian/changelog libica-3.5.0/debian/changelog --- libica-3.4.0/debian/changelog 2018-12-10 00:45:54.000000000 +0000 +++ libica-3.5.0/debian/changelog 2019-04-30 10:58:10.000000000 +0000 @@ -1,3 +1,10 @@ +libica (3.5.0-0ubuntu1) eoan; urgency=medium + + * New upstream release LP: #1826194 + * Update packaging to debhelper 11. + + -- Dimitri John Ledkov Tue, 30 Apr 2019 11:58:10 +0100 + libica (3.4.0-0ubuntu1) disco; urgency=medium * New upstream release LP: #1803962 diff -Nru libica-3.4.0/debian/compat libica-3.5.0/debian/compat --- libica-3.4.0/debian/compat 2017-10-04 09:28:19.000000000 +0000 +++ libica-3.5.0/debian/compat 2019-04-30 10:58:10.000000000 +0000 @@ -1 +1 @@ -10 +11 diff -Nru libica-3.4.0/debian/control libica-3.5.0/debian/control --- libica-3.4.0/debian/control 2018-06-14 06:53:21.000000000 +0000 +++ libica-3.5.0/debian/control 2019-04-30 10:58:10.000000000 +0000 @@ -1,7 +1,7 @@ Source: libica Priority: optional Maintainer: Dimitri John Ledkov -Build-Depends: debhelper (>= 10), libssl-dev, autoconf-archive +Build-Depends: debhelper (>= 11), libssl-dev, autoconf-archive Standards-Version: 4.1.0 Section: libs Homepage: http://sourceforge.net/projects/opencryptoki/files/libica/ diff -Nru libica-3.4.0/debian/libica3.symbols libica-3.5.0/debian/libica3.symbols --- libica-3.4.0/debian/libica3.symbols 2018-12-10 00:45:54.000000000 +0000 +++ libica-3.5.0/debian/libica3.symbols 2019-04-30 10:58:10.000000000 +0000 @@ -6,6 +6,7 @@ LIBICA_3.2.0@LIBICA_3.2.0 3.2.0 LIBICA_3.3.0@LIBICA_3.3.0 3.3.3 LIBICA_3.4.0@LIBICA_3.4.0 3.4.0 + LIBICA_3.5.0@LIBICA_3.5.0 3.5.0 ica_3des_cbc@LIBICA_3.0.0 3.2.0 ica_3des_cbc_cs@LIBICA_3.0.0 3.2.0 ica_3des_cfb@LIBICA_3.0.0 3.2.0 @@ -81,6 +82,8 @@ ica_rsa_key_generate_mod_expo@LIBICA_3.0.0 3.2.0 ica_rsa_mod_expo@LIBICA_3.0.0 3.2.0 ica_set_fallback_mode@LIBICA_3.3.0 3.3.3 + ica_set_offload_mode@LIBICA_3.5.0 3.5.0 + ica_set_stats_mode@LIBICA_3.5.0 3.5.0 ica_sha1@LIBICA_3.0.0 3.2.0 ica_sha224@LIBICA_3.0.0 3.2.0 ica_sha256@LIBICA_3.0.0 3.2.0 diff -Nru libica-3.4.0/debian/patches/pthread-missing.patch libica-3.5.0/debian/patches/pthread-missing.patch --- libica-3.4.0/debian/patches/pthread-missing.patch 1970-01-01 00:00:00.000000000 +0000 +++ libica-3.5.0/debian/patches/pthread-missing.patch 2019-04-30 10:58:10.000000000 +0000 @@ -0,0 +1,15 @@ +Description: lots of pthread symbols used but not found in linked libraries +Author: Dimitri John Ledkov + + +--- libica-3.5.0.orig/src/Makefile.am ++++ libica-3.5.0/src/Makefile.am +@@ -11,7 +11,7 @@ libica_la_CFLAGS = ${AM_CFLAGS} -I${srcd + libica_la_CCASFLAGS = ${AM_CFLAGS} + libica_la_LIBADD = @LIBS@ -lrt -lcrypto + libica_la_LDFLAGS = -Wl,--version-script=${srcdir}/../libica.map \ +- -version-number ${VERSION} ++ -version-number ${VERSION} -pthread + libica_la_SOURCES = ica_api.c init.c icastats_shared.c s390_rsa.c \ + s390_crypto.c s390_ecc.c s390_prng.c s390_sha.c \ + s390_drbg.c s390_drbg_sha512.c test_vec.c fips.c \ diff -Nru libica-3.4.0/debian/patches/series libica-3.5.0/debian/patches/series --- libica-3.4.0/debian/patches/series 1970-01-01 00:00:00.000000000 +0000 +++ libica-3.5.0/debian/patches/series 2019-04-30 10:58:10.000000000 +0000 @@ -0,0 +1 @@ +pthread-missing.patch diff -Nru libica-3.4.0/debian/rules libica-3.5.0/debian/rules --- libica-3.4.0/debian/rules 2018-06-14 06:53:21.000000000 +0000 +++ libica-3.5.0/debian/rules 2019-04-30 10:58:10.000000000 +0000 @@ -1,6 +1,6 @@ #!/usr/bin/make -f %: - dh $@ --with autoreconf + dh $@ override_dh_auto_configure: dh_auto_configure -- --enable-testcases @@ -8,4 +8,7 @@ override_dh_install: rm debian/tmp/usr/lib/*/libica.a rm debian/tmp/usr/lib/*/libica.la - dh_install --list-missing + dh_install + +override_dh_missing: + dh_missing --list-missing diff -Nru libica-3.4.0/include/ica_api.h libica-3.5.0/include/ica_api.h --- libica-3.4.0/include/ica_api.h 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/include/ica_api.h 2019-04-23 16:02:53.000000000 +0000 @@ -127,6 +127,12 @@ #define SHA512_DRNG 94 #define SHA512_224 95 #define SHA512_256 96 +#define ED25519_KEYGEN 100 +#define ED25519_SIGN 101 +#define ED25519_VERIFY 102 +#define ED448_KEYGEN 103 +#define ED448_SIGN 104 +#define ED448_VERIFY 105 /* * Key length for DES/3DES encryption/decryption @@ -320,6 +326,19 @@ AES_256_GCM_DECRYPT, } kma_functions_t; +typedef enum { + ECDSA_VERIFY_P256, + ECDSA_VERIFY_P384, + ECDSA_VERIFY_P521, + ECDSA_SIGN_P256, + ECDSA_SIGN_P384, + ECDSA_SIGN_P521, + EDDSA_VERIFY_ED25519, + EDDSA_VERIFY_ED448, + EDDSA_SIGN_ED25519, + EDDSA_SIGN_ED448, +} kdsa_functions_t; + typedef struct { unsigned int key_length; unsigned char* modulus; @@ -336,20 +355,6 @@ } ica_rsa_key_crt_t; /** - * ECC defines and typedefs - */ -typedef struct { - unsigned int version; - unsigned int encflag; - unsigned int curve_nid; - unsigned int pubkey_length; - unsigned int privkey_length; - unsigned char* pub_x; - unsigned char* pub_y; - unsigned char* priv_d; -} ica_ecc_key_t; - -/** * DES and AES defines and typedefs */ typedef unsigned char ica_des_vector_t[8]; @@ -454,6 +459,40 @@ void ica_set_fallback_mode(int fallback_mode); /** + * Environment variable for setting libica offload mode. + * By default libica may prefer to do crypto in cpacf instead of adapters. + * If this environment variable is defined to be an integer not equal to zero, + * adapters will always be preferred. + */ +#define ICA_OFFLOAD_ENV "LIBICA_OFFLOAD_MODE" + +/** + * Set libica offload mode. + * By default libica may prefer to do crypto in cpacf instead of adapters. + * If this function is called with offload_mode != 0, adapters will always + * be preferred. + */ +ICA_EXPORT +void ica_set_offload_mode(int offload_mode); + +/** + * Environment variable for setting libica stats mode. + * By default libica counts its crypto operations in shared memory. + * If this environment variable is defined to be zero, libica will not + * count crypto operations. + */ +#define ICA_STATS_ENV "LIBICA_STATS_MODE" + +/** + * Set libica stats mode. + * By default libica counts its crypto operations in shared memory. + * If this function is called with stats_mode = 0, libica will not + * count crypto operations. + */ +ICA_EXPORT +void ica_set_stats_mode(int stats_mode); + +/** * Opens the specified adapter * @param adapter_handle Pointer to the file descriptor for the adapter or * to DRIVER_NOT_LOADED if opening the crypto adapter failed. @@ -854,6 +893,12 @@ * * Begin of ECC API */ +#ifndef NID_ED25519 +# define NID_ED25519 1087 +#endif +#ifndef NID_ED448 +# define NID_ED448 1088 +#endif typedef struct ec_key_t ICA_EC_KEY; @@ -864,9 +909,6 @@ * The identifier of the elliptic curve, on which the new ICA_EC_KEY * shall be based. * - * The following elliptic curves are supported. - * - * 
  * NID Value  NID Name (OpenSSL)     Elliptic Curve    D Length (bytes)
  * ---------  ---------------------- ----------------  ----------------
  *       409  NID_X9_62_prime192v    secp192r1            24
@@ -881,7 +923,10 @@
  *       929  NID_brainpoolP320r1    brainpoolP320r1      40
  *       931  NID_brainpoolP384r1    brainpoolP384r1      48
  *       933  NID_brainpoolP512r1    brainpoolP512r1      64
- *
+ * 1034 NID_X25519 X25519 + * 1035 NID_X448 X448 + * 1087 NID_ED25519 Ed25519 32 + * 1088 NID_ED448 Ed448 57 * * @param privlen * A pointer to an unsigned integer buffer where the length of the diff -Nru libica-3.4.0/libica.map libica-3.5.0/libica.map --- libica-3.4.0/libica.map 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/libica.map 2019-04-23 16:02:53.000000000 +0000 @@ -133,3 +133,10 @@ ica_sha512_256; local: *; } LIBICA_3.3.0; + +LIBICA_3.5.0 { + global: + ica_set_offload_mode; + ica_set_stats_mode; + local: *; +} LIBICA_3.4.0; diff -Nru libica-3.4.0/libica.spec libica-3.5.0/libica.spec --- libica-3.4.0/libica.spec 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/libica.spec 2019-04-23 16:02:53.000000000 +0000 @@ -1,5 +1,5 @@ Name: libica -Version: 3.4.0 +Version: 3.5.0 Release: 1%{?dist} Summary: Interface library to the ICA device driver @@ -62,6 +62,8 @@ %{_includedir}/ica_api.h %changelog +* Tue Apr 23 2019 Patrick Steuer +- Version v3.5.0 * Fri Nov 08 2018 Patrick Steuer - Version v3.4.0 * Fri Jun 08 2018 Patrick Steuer diff -Nru libica-3.4.0/README.md libica-3.5.0/README.md --- libica-3.4.0/README.md 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/README.md 2019-04-23 16:02:53.000000000 +0000 @@ -13,6 +13,8 @@ `--enable-coverage` : enable coverage testing build (gcov required) +`--enable-internal-tests` : build internal tests + See `configure -help`. diff -Nru libica-3.4.0/src/ica_api.c libica-3.5.0/src/ica_api.c --- libica-3.4.0/src/ica_api.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/ica_api.c 2019-04-23 16:02:53.000000000 +0000 @@ -59,6 +59,20 @@ ica_fallbacks_enabled = 0; } +int ica_offload_enabled = 0; + +void ica_set_offload_mode(int offload_mode) +{ + ica_offload_enabled = offload_mode ? 1 : 0; +} + +int ica_stats_enabled = 1; + +void ica_set_stats_mode(int stats_mode) +{ + ica_stats_enabled = stats_mode ? 1 : 0; +} + static unsigned int check_des_parms(unsigned int mode, unsigned long data_length, const unsigned char *in_data, diff -Nru libica-3.4.0/src/icastats.c libica-3.5.0/src/icastats.c --- libica-3.4.0/src/icastats.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/icastats.c 2019-04-23 16:02:53.000000000 +0000 @@ -72,21 +72,21 @@ #define CELL_SIZE 10 void print_stats(stats_entry_t *stats) { - printf(" function | hardware | software\n"); - printf("--------------+--------------------------+-------------------------\n"); - printf(" | ENC CRYPT DEC | ENC CRYPT DEC \n"); - printf("--------------+--------------------------+-------------------------\n"); + printf(" function | hardware | software\n"); + printf("----------------+--------------------------+-------------------------\n"); + printf(" | ENC CRYPT DEC | ENC CRYPT DEC \n"); + printf("----------------+--------------------------+-------------------------\n"); unsigned int i; for (i = 0; i < ICA_NUM_STATS; ++i){ if(i<=ICA_STATS_RSA_CRT){ - printf(" %12s | %*d | %*d\n", + printf(" %14s | %*d | %*d\n", STATS_DESC[i], CELL_SIZE, stats[i].enc.hw, CELL_SIZE, stats[i].enc.sw); } else{ - printf(" %12s |%*d %*d |%*d %*d\n", + printf(" %14s |%*d %*d |%*d %*d\n", STATS_DESC[i], CELL_SIZE, stats[i].enc.hw, diff -Nru libica-3.4.0/src/icastats_shared.c libica-3.5.0/src/icastats_shared.c --- libica-3.4.0/src/icastats_shared.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/icastats_shared.c 2019-04-23 16:02:53.000000000 +0000 @@ -25,6 +25,7 @@ #include #include #include "icastats.h" +#include "init.h" #define NOT_INITIALIZED (-1) #define NAME_LENGHT 20 @@ -33,8 +34,7 @@ volatile int stats_shm_handle = NOT_INITIALIZED; - -static void atomic_add(int *x, int i) +static inline void atomic_add(int *x, int i) { int old; int new; @@ -258,6 +258,7 @@ return NULL; } +#ifndef ICASTATS /* increments a field of the shared memory segment * arguments: * @field - the enum of the field see icastats.h @@ -266,9 +267,11 @@ * @direction - valid values are ENCRYPT and DECRYPT */ - void stats_increment(stats_fields_t field, int hardware, int direction) { + if (!ica_stats_enabled) + return; + if (stats == NULL) return; @@ -283,6 +286,7 @@ else atomic_add((int *)&stats[field].dec.sw, 1); } +#endif /* Reset the shared memory segment to zero diff -Nru libica-3.4.0/src/include/init.h libica-3.5.0/src/include/init.h --- libica-3.4.0/src/include/init.h 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/include/init.h 2019-04-23 16:02:53.000000000 +0000 @@ -23,6 +23,8 @@ void end_sigill_section(struct sigaction *oldact, sigset_t * oldset); extern int ica_fallbacks_enabled; +extern int ica_offload_enabled; +extern int ica_stats_enabled; #endif diff -Nru libica-3.4.0/src/include/s390_crypto.h libica-3.5.0/src/include/s390_crypto.h --- libica-3.4.0/src/include/s390_crypto.h 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/include/s390_crypto.h 2019-04-23 16:02:53.000000000 +0000 @@ -33,6 +33,7 @@ #define ADAPTER 5 #define PPNO 6 #define MSA8 7 +#define MSA9 8 enum s390_crypto_instruction { S390_CRYPTO_DIRECTION_MASK = 0x80, @@ -96,14 +97,39 @@ */ S390_CRYPTO_SHA512_DRNG_GEN = 0x03, S390_CRYPTO_SHA512_DRNG_SEED = 0x03 | 0x80, - S390_CRYPTO_TRNG = 0x72 + S390_CRYPTO_TRNG = 0x72, + + /* + * The following functions are available for the KDSA instruction. + */ + S390_CRYPTO_ECDSA_VERIFY_P256 = 0x01, + S390_CRYPTO_ECDSA_VERIFY_P384 = 0x02, + S390_CRYPTO_ECDSA_VERIFY_P521 = 0x03, + S390_CRYPTO_ECDSA_SIGN_P256 = 0x09, + S390_CRYPTO_ECDSA_SIGN_P384 = 0x0a, + S390_CRYPTO_ECDSA_SIGN_P521 = 0x0b, + S390_CRYPTO_EDDSA_VERIFY_ED25519 = 0x20, + S390_CRYPTO_EDDSA_VERIFY_ED448 = 0x24, + S390_CRYPTO_EDDSA_SIGN_ED25519 = 0x28, + S390_CRYPTO_EDDSA_SIGN_ED448 = 0x2c, + + /* + * The following functions are available for the PCC instruction. + */ + S390_CRYPTO_SCALAR_MULTIPLY_P256 = 0x40, + S390_CRYPTO_SCALAR_MULTIPLY_P384 = 0x41, + S390_CRYPTO_SCALAR_MULTIPLY_P521 = 0x42, + S390_CRYPTO_SCALAR_MULTIPLY_ED25519 = 0x48, + S390_CRYPTO_SCALAR_MULTIPLY_ED448 = 0x49, + S390_CRYPTO_SCALAR_MULTIPLY_X25519 = 0x50, + S390_CRYPTO_SCALAR_MULTIPLY_X448 = 0x51 }; extern unsigned long long facility_bits[3]; extern unsigned int sha1_switch, sha256_switch, sha512_switch, sha3_switch, des_switch, tdes_switch, aes128_switch, aes192_switch, aes256_switch, prng_switch, tdea128_switch, tdea192_switch, sha512_drng_switch, - msa4_switch, msa5_switch, msa8_switch, trng_switch; + msa4_switch, msa5_switch, msa8_switch, trng_switch, msa9_switch; typedef struct { unsigned int dummy_fc; @@ -136,7 +162,14 @@ CMAC_AES_192_GENERATE, CMAC_AES_192_VERIFY, CMAC_AES_256_GENERATE, - CMAC_AES_256_VERIFY + CMAC_AES_256_VERIFY, + SCALAR_MULTIPLY_P256, + SCALAR_MULTIPLY_P384, + SCALAR_MULTIPLY_P521, + SCALAR_MULTIPLY_ED25519, + SCALAR_MULTIPLY_ED448, + SCALAR_MULTIPLY_X25519, + SCALAR_MULTIPLY_X448 } pcc_functions_t; typedef enum { @@ -147,15 +180,17 @@ extern s390_supported_function_t s390_kmc_functions[]; extern s390_supported_function_t s390_msa4_functions[]; +extern s390_supported_function_t s390_pcc_functions[]; extern s390_supported_function_t s390_kma_functions[]; extern s390_supported_function_t s390_kimd_functions[]; extern s390_supported_function_t s390_ppno_functions[]; +extern s390_supported_function_t s390_kdsa_functions[]; void s390_crypto_switches_init(void); /** * s390_pcc: - * @func: the function code passed to KM; see s390_kmc_func * + * @func: the function code passed to KM; see s390_pcc_functions * @param: address of parameter block; see POP for details on each func * * Executes the PCC operation of the CPU. @@ -165,15 +200,16 @@ */ static inline int s390_pcc(unsigned long func, void *param) { - register long __func asm("0") = func; - register void *__param asm("1") = param; + register unsigned long r0 asm("0") = (unsigned long)func; + register unsigned long r1 asm("1") = (unsigned long)param; asm volatile ( - "0: .long 0xb92c0000 \n" - " brc 1, 0b \n" + "0: .long %[opc] << 16\n" + " brc 1,0b\n" : - : "d"(__func), "a"(__param) + : [fc] "d" (r0), [param] "a" (r1), [opc] "i" (0xb92c) : "cc", "memory"); + return 0; } @@ -513,6 +549,42 @@ return func ? src_len - __src_len : __src_len; } +/** + * s390_kdsa: + * @func: the function code passed to KDSA; see s390_kdsa_functions + * @param: address of parameter block; see POP for details on each func + * @src: address of source memory area + * @srclen: length of src operand in bytes + * + * Executes the KDSA (COMPUTE DIGITAL SIGNATURE AUTHENTICATION) operation of + * the CPU. + * + * Returns 0 on success. Fails in case of sign if the random number was not + * invertible. Fails in case of verify if the signature is invalid or the + * public key is not on the curve. + */ +static inline int s390_kdsa(unsigned long func, void *param, + const unsigned char *src, unsigned long srclen) +{ + register unsigned long r0 asm("0") = (unsigned long)func; + register unsigned long r1 asm("1") = (unsigned long)param; + register unsigned long r2 asm("2") = (unsigned long)src; + register unsigned long r3 asm("3") = (unsigned long)srclen; + + unsigned long rc = 1; + + asm volatile( + "0: .insn rre,%[opc] << 16,0,%[src]\n" + " brc 1,0b\n" /* handle partial completion */ + " brc 7,1f\n" + " lghi %[rc],0\n" + "1:\n" + : [src] "+a" (r2), [srclen] "+d" (r3), [rc] "+d" (rc) + : [fc] "d" (r0), [param] "a" (r1), [opc] "i" (0xb93a) + : "cc", "memory"); + + return (int)rc; +} /* * s390_ppno: diff -Nru libica-3.4.0/src/include/s390_ecc.h libica-3.5.0/src/include/s390_ecc.h --- libica-3.4.0/src/include/s390_ecc.h 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/include/s390_ecc.h 2019-04-23 16:02:53.000000000 +0000 @@ -28,6 +28,7 @@ unsigned char* D; }; /* ICA_EC_KEY */ + /** * Refer to z/OS ICSF Application Programmer's Guide, * Appendix A. ICSF and cryptographic coprocessor return and reason codes @@ -400,6 +401,7 @@ case NID_brainpoolP224r1: return 28; #endif + case NID_ED25519: case NID_X9_62_prime256v1: #if OPENSSL_VERSION_NUMBER >= 0x010002000 case NID_brainpoolP256r1: @@ -412,6 +414,8 @@ case NID_brainpoolP384r1: #endif return 48; + case NID_ED448: + return 57; #if OPENSSL_VERSION_NUMBER >= 0x010002000 case NID_brainpoolP512r1: return 64; diff -Nru libica-3.4.0/src/include/test_vec.h libica-3.5.0/src/include/test_vec.h --- libica-3.4.0/src/include/test_vec.h 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/include/test_vec.h 2019-04-23 16:02:53.000000000 +0000 @@ -12,6 +12,8 @@ #include #include +#include "s390_ecc.h" + #define AES128_KEYLEN (128 / 8) #define AES192_KEYLEN (192 / 8) #define AES256_KEYLEN (256 / 8) @@ -234,6 +236,31 @@ unsigned char *prnd; }; +struct ecdsa_tv { + /* sign inputs */ + const ICA_EC_KEY *key; + int hash; + unsigned char *msg; /* should be qualified const, + but sha api lacks const ... */ + size_t msglen; + const unsigned char *k; + /* sign expected outputs */ + const unsigned char *r; + const unsigned char *s; + size_t siglen; +}; + +struct scalar_mul_tv { + /* scalar mul inputs */ + int curve_nid; + size_t len; + const unsigned char *scalar; + + /* scalar mul outputs */ + const unsigned char *x; + const unsigned char *y; +}; + #ifdef ICA_FIPS extern const struct aes_ecb_tv AES_ECB_TV[]; extern const size_t AES_ECB_TV_LEN; @@ -305,6 +332,14 @@ extern const size_t SHA512_TV_LEN; #endif /* ICA_FIPS */ +#ifdef ICA_INTERNAL_TEST_EC +extern const struct ecdsa_tv ECDSA_TV[]; +extern const size_t ECDSA_TV_LEN; + +extern const struct scalar_mul_tv SCALAR_MUL_TV[]; +extern const size_t SCALAR_MUL_TV_LEN; +#endif /* ICA_INTERNAL_TEST_EC */ + extern const struct drbg_sha512_tv DRBG_SHA512_TV[]; extern const size_t DRBG_SHA512_TV_LEN; diff -Nru libica-3.4.0/src/init.c libica-3.5.0/src/init.c --- libica-3.4.0/src/init.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/init.c 2019-04-23 16:02:53.000000000 +0000 @@ -76,6 +76,21 @@ */ s390_crypto_switches_init(); + /* check for fallback mode environment variable */ + ptr = getenv(ICA_FALLBACK_ENV); + if (ptr && sscanf(ptr, "%i", &value) == 1) + ica_set_fallback_mode(value); + + /* check for offload mode environment variable */ + ptr = getenv(ICA_OFFLOAD_ENV); + if (ptr && sscanf(ptr, "%i", &value) == 1) + ica_set_offload_mode(value); + + /* check for stats mode environment variable */ + ptr = getenv(ICA_STATS_ENV); + if (ptr && sscanf(ptr, "%i", &value) == 1) + ica_set_stats_mode(value); + #ifdef ICA_FIPS fips_init(); fips_powerup_tests(); @@ -88,11 +103,6 @@ s390_prng_init(); s390_initialize_functionlist(); - - /* check for fallback mode environment variable */ - ptr = getenv(ICA_FALLBACK_ENV); - if (ptr && sscanf(ptr, "%i", &value) == 1) - ica_set_fallback_mode(value); } void __attribute__ ((destructor)) icaexit(void) diff -Nru libica-3.4.0/src/Makefile.am libica-3.5.0/src/Makefile.am --- libica-3.4.0/src/Makefile.am 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/Makefile.am 2019-04-23 16:02:53.000000000 +0000 @@ -1,4 +1,4 @@ -VERSION = 3:4:0 +VERSION = 3:5:0 AM_CFLAGS = @FLAGS@ @@ -15,7 +15,7 @@ libica_la_SOURCES = ica_api.c init.c icastats_shared.c s390_rsa.c \ s390_crypto.c s390_ecc.c s390_prng.c s390_sha.c \ s390_drbg.c s390_drbg_sha512.c test_vec.c fips.c \ - mp.S \ + mp.S \ include/fips.h include/icastats.h include/init.h \ include/s390_aes.h include/s390_cbccs.h \ include/s390_ccm.h include/s390_cmac.h \ @@ -38,6 +38,33 @@ icainfo_SOURCES = icainfo.c include/fips.h include/s390_crypto.h \ ../include/ica_api.h -icastats_CFLAGS = ${AM_CFLAGS} -I${srcdir}/include +icastats_CFLAGS = ${AM_CFLAGS} -I${srcdir}/include -DICASTATS icastats_LDADD = @LIBS@ -lrt icastats_SOURCES = icastats.c icastats_shared.c include/icastats.h + +# internal tests + +if ICA_INTERNAL_TESTS +bin_PROGRAMS += internal_tests/ec_internal_test + +internal_tests_ec_internal_test_CFLAGS = ${AM_CFLAGS} -I${srcdir}/include \ + -I${srcdir}/../include \ + -DICA_INTERNAL_TEST \ + -DICA_INTERNAL_TEST_EC +internal_tests_ec_internal_test_CCASFLAGS = ${AM_CFLAGS} +internal_tests_ec_internal_test_LDADD = @LIBS@ -lrt -lcrypto -lpthread +internal_tests_ec_internal_test_SOURCES = \ + ica_api.c init.c icastats_shared.c s390_rsa.c \ + s390_crypto.c s390_ecc.c s390_prng.c s390_sha.c \ + s390_drbg.c s390_drbg_sha512.c test_vec.c fips.c \ + mp.S \ + include/fips.h include/icastats.h include/init.h \ + include/s390_aes.h include/s390_cbccs.h \ + include/s390_ccm.h include/s390_cmac.h \ + include/s390_common.h include/s390_crypto.h \ + include/s390_ctr.h include/s390_des.h \ + include/s390_drbg.h include/s390_drbg_sha512.h \ + include/s390_ecc.h include/s390_gcm.h include/s390_prng.h \ + include/s390_rsa.h include/s390_sha.h include/test_vec.h \ + ../test/testcase.h +endif diff -Nru libica-3.4.0/src/s390_crypto.c libica-3.5.0/src/s390_crypto.c --- libica-3.4.0/src/s390_crypto.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/s390_crypto.c 2019-04-23 16:02:53.000000000 +0000 @@ -33,7 +33,7 @@ unsigned int sha1_switch, sha256_switch, sha512_switch, sha3_switch, des_switch, tdes_switch, aes128_switch, aes192_switch, aes256_switch, prng_switch, tdea128_switch, tdea192_switch, sha512_drng_switch, - msa4_switch, msa5_switch, msa8_switch, trng_switch; + msa4_switch, msa5_switch, msa8_switch, trng_switch, msa9_switch; s390_supported_function_t s390_kimd_functions[] = { {SHA_1, S390_CRYPTO_SHA_1, &sha1_switch}, @@ -87,6 +87,22 @@ {AES_256_XTS_DECRYPT, S390_CRYPTO_AES_256_XTS_DECRYPT, &msa4_switch} }; +s390_supported_function_t s390_pcc_functions[] = { + {0, 0, &msa4_switch}, /* CMAC_AES not supported */ + {0, 0, &msa4_switch}, + {0, 0, &msa4_switch}, + {0, 0, &msa4_switch}, + {0, 0, &msa4_switch}, + {0, 0, &msa4_switch}, + {SCALAR_MULTIPLY_P256, S390_CRYPTO_SCALAR_MULTIPLY_P256, &msa9_switch}, + {SCALAR_MULTIPLY_P384, S390_CRYPTO_SCALAR_MULTIPLY_P384, &msa9_switch}, + {SCALAR_MULTIPLY_P521, S390_CRYPTO_SCALAR_MULTIPLY_P521, &msa9_switch}, + {SCALAR_MULTIPLY_ED25519, S390_CRYPTO_SCALAR_MULTIPLY_ED25519, &msa9_switch}, + {SCALAR_MULTIPLY_ED448, S390_CRYPTO_SCALAR_MULTIPLY_ED448, &msa9_switch}, + {SCALAR_MULTIPLY_X25519, S390_CRYPTO_SCALAR_MULTIPLY_X25519, &msa9_switch}, + {SCALAR_MULTIPLY_X448, S390_CRYPTO_SCALAR_MULTIPLY_X448, &msa9_switch}, +}; + s390_supported_function_t s390_ppno_functions[] = { {SHA512_DRNG_GEN, S390_CRYPTO_SHA512_DRNG_GEN, &sha512_drng_switch}, {SHA512_DRNG_SEED, S390_CRYPTO_SHA512_DRNG_SEED, &sha512_drng_switch}, @@ -106,6 +122,19 @@ {AES_256_GCM_DECRYPT, S390_CRYPTO_AES_256_GCM_DECRYPT, &msa8_switch} }; +s390_supported_function_t s390_kdsa_functions[] = { + {ECDSA_VERIFY_P256, S390_CRYPTO_ECDSA_VERIFY_P256, &msa9_switch}, + {ECDSA_VERIFY_P384, S390_CRYPTO_ECDSA_VERIFY_P384, &msa9_switch}, + {ECDSA_VERIFY_P521, S390_CRYPTO_ECDSA_VERIFY_P521, &msa9_switch}, + {ECDSA_SIGN_P256, S390_CRYPTO_ECDSA_SIGN_P256, &msa9_switch}, + {ECDSA_SIGN_P384, S390_CRYPTO_ECDSA_SIGN_P384, &msa9_switch}, + {ECDSA_SIGN_P521, S390_CRYPTO_ECDSA_SIGN_P521, &msa9_switch}, + {EDDSA_VERIFY_ED25519, S390_CRYPTO_EDDSA_VERIFY_ED25519, &msa9_switch}, + {EDDSA_VERIFY_ED448, S390_CRYPTO_EDDSA_VERIFY_ED448, &msa9_switch}, + {EDDSA_SIGN_ED25519, S390_CRYPTO_EDDSA_SIGN_ED25519, &msa9_switch}, + {EDDSA_SIGN_ED448, S390_CRYPTO_EDDSA_SIGN_ED448, &msa9_switch}, +}; + static int read_cpuinfo(void) { int msa = 0; @@ -180,6 +209,8 @@ msa = 5; if (facility_bits[2] & (1ULL << (191 - 146))) msa = 8; + if (facility_bits[2] & (1ULL << (191 - 155))) + msa = 9; } /** @@ -210,16 +241,6 @@ memset(&oldact, 0, sizeof(oldact)); memset(&oldset, 0, sizeof(oldset)); - /* The function arrays contain integers. Thus to compute the amount of - * their elements the result of sizeof(*functions) has to be divided by - * sizeof(int). - * The msa4_switch will be set in the kimd function. Because this is - * the only switch for all MSA4 functions we just set it through the - * kimd query and do not need to over the whole array. Therfore there - * is also no distict setting of the switch needed in form - * msa4_switch = 1. */ - - /* kmc query */ memset(mask, 0, sizeof(mask)); if (msa) { @@ -244,6 +265,19 @@ if (S390_CRYPTO_TEST_MASK(mask, s390_kimd_functions[n].hw_fc)) *s390_kimd_functions[n].enabled = 1; + /* pcc query */ + memset(mask, 0, sizeof(mask)); + if (4 <= msa) { + msa4_switch = 1; + if (begin_sigill_section(&oldact, &oldset) == 0) + s390_pcc(S390_CRYPTO_QUERY, mask); + end_sigill_section(&oldact, &oldset); + } + for (n = 0; n < (sizeof(s390_ppno_functions) / + sizeof(s390_supported_function_t)); n++) + if (S390_CRYPTO_TEST_MASK(mask, s390_pcc_functions[n].hw_fc)) + *s390_pcc_functions[n].enabled = 1; + /* ppno query */ memset(mask, 0, sizeof(mask)); if (5 <= msa) { @@ -269,6 +303,19 @@ sizeof(s390_supported_function_t)); n++) if (S390_CRYPTO_TEST_MASK(mask, s390_kma_functions[n].hw_fc)) *s390_kma_functions[n].enabled = 1; + + /* kdsa query */ + memset(mask, 0, sizeof(mask)); + if (9 <= msa) { + msa9_switch = 1; + if (begin_sigill_section(&oldact, &oldset) == 0) + s390_kdsa(S390_CRYPTO_QUERY, mask, NULL, 0); + end_sigill_section(&oldact, &oldset); + } + for (n = 0; n < (sizeof(s390_kdsa_functions) / + sizeof(s390_supported_function_t)); n++) + if (S390_CRYPTO_TEST_MASK(mask, s390_kdsa_functions[n].hw_fc)) + *s390_kdsa_functions[n].enabled = 1; } void s390_crypto_switches_init(void) @@ -339,6 +386,12 @@ {EC_DSA_SIGN, ADAPTER, 0, ICA_FLAG_DHW | ICA_FLAG_SW, 0x0F}, {EC_DSA_VERIFY, ADAPTER, 0, ICA_FLAG_DHW | ICA_FLAG_SW, 0x0F}, {EC_KGEN, ADAPTER, 0, ICA_FLAG_DHW | ICA_FLAG_SW, 0x0F}, + {ED25519_KEYGEN, MSA9, SCALAR_MULTIPLY_ED25519, 0, 0}, + {ED25519_SIGN, MSA9, EDDSA_SIGN_ED25519, 0, 0}, + {ED25519_VERIFY, MSA9, EDDSA_VERIFY_ED25519, 0, 0}, + {ED448_KEYGEN, MSA9, SCALAR_MULTIPLY_ED448, 0, 0}, + {ED448_SIGN, MSA9, EDDSA_SIGN_ED448, 0, 0}, + {ED448_VERIFY, MSA9, EDDSA_VERIFY_ED448, 0, 0}, {RSA_ME, ADAPTER, 0, ICA_FLAG_DHW | ICA_FLAG_SW, 0x0F}, // DHW (CEX) + SW / 512,1024,2048, 4096 bit key length {RSA_CRT, ADAPTER, 0, ICA_FLAG_DHW | ICA_FLAG_SW, 0x0F}, // DHW (CEX) + SW / 512,1024,2048, 4096 bit key length {RSA_KEY_GEN_ME, ADAPTER, 0, ICA_FLAG_SW, 0}, // SW (openssl) @@ -346,9 +399,6 @@ {SHA512_DRNG, PPNO, SHA512_DRNG_GEN, ICA_FLAG_SW, 0}, -/* available for the MSA4 instruction */ -/* available for the RSA instruction */ - }; /* @@ -400,6 +450,26 @@ case MSA8: e->flags |= *s390_kma_functions[e->id].enabled ? 4 : 0; break; + case MSA9: + if (e->mech_mode_id == ED25519_KEYGEN + || e->mech_mode_id == ED448_KEYGEN) + e->flags |= *s390_pcc_functions[e->id].enabled ? 4 : 0; + else + e->flags |= *s390_kdsa_functions[e->id].enabled ? 4 : 0; + break; + default: + /* Do nothing. */ + break; + } + + switch ((int) e->mech_mode_id) + { + case EC_DH: /* fall-trough */ + case EC_DSA_SIGN: /* fall-trough */ + case EC_DSA_VERIFY: /* fall-trough */ + case EC_KGEN: + e->flags |= *s390_kdsa_functions[e->id].enabled ? ICA_FLAG_SHW : 0; + break; default: /* Do nothing. */ break; diff -Nru libica-3.4.0/src/s390_ecc.c libica-3.5.0/src/s390_ecc.c --- libica-3.4.0/src/s390_ecc.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/s390_ecc.c 2019-04-23 16:02:53.000000000 +0000 @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -25,6 +26,8 @@ #include "fips.h" #include "s390_ecc.h" +#include "s390_crypto.h" +#include "init.h" #define CPRBXSIZE (sizeof(struct CPRBX)) #define PARMBSIZE (2048) @@ -42,6 +45,17 @@ } while (0) #endif +static int eckeygen_cpacf(ICA_EC_KEY *key); +static int ecdsa_sign_cpacf(const ICA_EC_KEY *priv, const unsigned char *hash, + size_t hashlen, unsigned char *sig, + void (*rng_cb)(unsigned char *, size_t)); +static int ecdsa_verify_cpacf(const ICA_EC_KEY *pub, const unsigned char *hash, + size_t hashlen, const unsigned char *sig); +static int scalar_mul_cpacf(unsigned char *res_x, unsigned char *res_y, + const unsigned char *scalar, + const unsigned char *x, + const unsigned char *y, int curve_nid); + /** * Check if openssl does support this ec curve */ @@ -399,9 +413,110 @@ return (ECDH_REPLY*)prepcblk; } +static int scalar_mul_cpacf(unsigned char *res_x, unsigned char *res_y, + const unsigned char *scalar, + const unsigned char *x, + const unsigned char *y, int curve_nid) +{ +#define DEF_PARAM(curve, size) \ +struct { \ + unsigned char res_x[size]; \ + unsigned char res_y[size]; \ + unsigned char x[size]; \ + unsigned char y[size]; \ + unsigned char scalar[size]; \ +} curve + + union { + long long buff[512]; /* 4k buffer: params + reserved area */ + DEF_PARAM(P256, 32); + DEF_PARAM(P384, 48); + DEF_PARAM(P521, 80); + DEF_PARAM(ED25519, 32); + DEF_PARAM(ED448, 64); + DEF_PARAM(X25519, 32); + DEF_PARAM(X448, 64); + } param; + +#undef DEF_PARAM + + unsigned long fc; + size_t off; + int rc; + + const size_t len = privlen_from_nid(curve_nid); + + memset(¶m, 0, sizeof(param)); + + switch (curve_nid) { + case NID_X9_62_prime256v1: + off = sizeof(param.P256.scalar) - len; + + memcpy(param.P256.x + off, x, + sizeof(param.P256.x) - off); + memcpy(param.P256.y + off, y, + sizeof(param.P256.y) - off); + memcpy(param.P256.scalar + off, scalar, + sizeof(param.P256.scalar) - off); + + fc = s390_pcc_functions[SCALAR_MULTIPLY_P256].hw_fc; + rc = s390_pcc(fc, ¶m) ? EIO : 0; + + if (res_x != NULL) + memcpy(res_x, param.P256.res_x + off, len); + if (res_y != NULL) + memcpy(res_y, param.P256.res_y + off, len); + break; + + case NID_secp384r1: + off = sizeof(param.P384.scalar) - len; + + memcpy(param.P384.x + off, x, + sizeof(param.P384.x) - off); + memcpy(param.P384.y + off, y, + sizeof(param.P384.y) - off); + memcpy(param.P384.scalar + off, scalar, + sizeof(param.P384.scalar) - off); + + fc = s390_pcc_functions[SCALAR_MULTIPLY_P384].hw_fc; + rc = s390_pcc(fc, ¶m) ? EIO : 0; + + if (res_x != NULL) + memcpy(res_x, param.P384.res_x + off, len); + if (res_y != NULL) + memcpy(res_y, param.P384.res_y + off, len); + break; + + case NID_secp521r1: + off = sizeof(param.P521.scalar) - len; + + memcpy(param.P521.x + off, x, + sizeof(param.P521.x) - off); + memcpy(param.P521.y + off, y, + sizeof(param.P521.y) - off); + memcpy(param.P521.scalar + off, scalar, + sizeof(param.P521.scalar) - off); + + fc = s390_pcc_functions[SCALAR_MULTIPLY_P521].hw_fc; + rc = s390_pcc(fc, ¶m) ? EIO : 0; + + if (res_x != NULL) + memcpy(res_x, param.P521.res_x + off, len); + if (res_y != NULL) + memcpy(res_y, param.P521.res_y + off, len); + break; + + default: + rc = EINVAL; + } + + OPENSSL_cleanse(param.buff, sizeof(param.buff)); + return rc; +} + /** * Perform an ECDH shared secret calculation with given EC private key A (D) - * and EC public key B (X,Y) via Crypto Express CCA coprocessor. + * and EC public key B (X,Y) via CPACF Crypto Express CCA coprocessor. * * Returns 0 if successful * EIO if an internal error occurred @@ -417,6 +532,13 @@ ECDH_REPLY* reply_p; int privlen = privlen_from_nid(privkey_A->nid); + if (msa9_switch && !ica_offload_enabled) { + rc = scalar_mul_cpacf(z, NULL, privkey_A->D, pubkey_B->X, + pubkey_B->Y, privkey_A->nid); + if (rc != EINVAL) /* EINVAL: curve not supported by cpacf */ + return rc; + } + if (adapter_handle == DRIVER_NOT_LOADED) return EIO; @@ -777,7 +899,7 @@ } /** - * creates an ECDSA signature via Crypto Express CCA coprocessor. + * creates an ECDSA signature via CPACF or Crypto Express CCA coprocessor. * * Returns 0 if successful * EIO if an internal error occurred @@ -795,6 +917,13 @@ unsigned char X[MAX_ECC_PRIV_SIZE]; unsigned char Y[MAX_ECC_PRIV_SIZE]; + if (msa9_switch && !ica_offload_enabled) { + rc = ecdsa_sign_cpacf(privkey, hash, hash_length, signature, + NULL); + if (rc != EINVAL) /* EINVAL: curve not supported by cpacf */ + return rc; + } + if (adapter_handle == DRIVER_NOT_LOADED) return EIO; @@ -874,13 +1003,13 @@ /* Insert leading 0x00's if r or s shorter than privlen */ n = privlen - BN_num_bytes(r); - for (i=0;inid) { + case NID_X9_62_prime256v1: + off = sizeof(param.P256.hash) + - (hashlen > sizeof(param.P256.hash) ? + sizeof(param.P256.hash) : hashlen); + + memcpy(param.P256.hash + off, hash, + sizeof(param.P256.hash) - off); + + off = sizeof(param.P256.pub_x) + - privlen_from_nid(pub->nid); + + memcpy(param.P256.sig_r + off, sig, + sizeof(param.P256.sig_r) - off); + memcpy(param.P256.sig_s + off, sig + + sizeof(param.P256.sig_r) - off, + sizeof(param.P256.sig_s) - off); + memcpy(param.P256.pub_x + off, pub->X, + sizeof(param.P256.pub_x) - off); + memcpy(param.P256.pub_y + off, pub->Y, + sizeof(param.P256.pub_y) - off); + + fc = s390_kdsa_functions[ECDSA_VERIFY_P256].hw_fc; + break; + + case NID_secp384r1: + off = sizeof(param.P384.hash) + - (hashlen > sizeof(param.P384.hash) ? + sizeof(param.P384.hash) : hashlen); + + memcpy(param.P384.hash + off, hash, + sizeof(param.P384.hash) - off); + + off = sizeof(param.P384.pub_x) + - privlen_from_nid(pub->nid); + + memcpy(param.P384.sig_r + off, sig, + sizeof(param.P384.sig_r) - off); + memcpy(param.P384.sig_s + off, sig + + sizeof(param.P384.sig_r) - off, + sizeof(param.P384.sig_s) - off); + memcpy(param.P384.pub_x + off, pub->X, + sizeof(param.P384.pub_x) - off); + memcpy(param.P384.pub_y + off, pub->Y, + sizeof(param.P384.pub_y) - off); + + fc = s390_kdsa_functions[ECDSA_VERIFY_P384].hw_fc; + break; + + case NID_secp521r1: + off = sizeof(param.P521.hash) + - (hashlen > sizeof(param.P521.hash) ? + sizeof(param.P521.hash) : hashlen); + + memcpy(param.P521.hash + off, hash, + sizeof(param.P521.hash) - off); + + off = sizeof(param.P521.pub_x) + - privlen_from_nid(pub->nid); + + memcpy(param.P521.sig_r + off, sig, + sizeof(param.P521.sig_r) - off); + memcpy(param.P521.sig_s + off, sig + + sizeof(param.P521.sig_r) - off, + sizeof(param.P521.sig_s) - off); + memcpy(param.P521.pub_x + off, pub->X, + sizeof(param.P521.pub_x) - off); + memcpy(param.P521.pub_y + off, pub->Y, + sizeof(param.P521.pub_y) - off); + + fc = s390_kdsa_functions[ECDSA_VERIFY_P521].hw_fc; + break; + + default: + rc = EINVAL; + break; + } + + if (!rc) + rc = s390_kdsa(fc, param.buff, NULL, 0) ? EFAULT : 0; + + return rc; +} + +/* + * Sign a hashed message using under a private key. + * Returns 0 if successful. If cpacf doesnt support the curve, + * EINVAL is returned. + */ +static int ecdsa_sign_cpacf(const ICA_EC_KEY *priv, const unsigned char *hash, + size_t hashlen, unsigned char *sig, + void (*rng_cb)(unsigned char *, size_t)) +{ +#define DEF_PARAM(curve, size) \ +struct { \ + unsigned char sig_r[size]; \ + unsigned char sig_s[size]; \ + unsigned char hash[size]; \ + unsigned char priv[size]; \ + unsigned char rand[size]; \ +} curve + + union { + long long buff[512]; /* 4k buffer: params + reserved area */ + DEF_PARAM(P256, 32); + DEF_PARAM(P384, 48); + DEF_PARAM(P521, 80); + } param; + +#undef DEF_PARAM + + unsigned long fc; + size_t off; + int rc; + + memset(¶m, 0, sizeof(param)); + rc = 0; + + switch (priv->nid) { + case NID_X9_62_prime256v1: + off = sizeof(param.P256.hash) + - (hashlen > sizeof(param.P256.hash) ? + sizeof(param.P256.hash) : hashlen); + + memcpy(param.P256.hash + off, hash, + sizeof(param.P256.hash) - off); + + off = sizeof(param.P256.priv) + - privlen_from_nid(priv->nid); + + memcpy(param.P256.priv + off, priv->D, + sizeof(param.P256.priv) - off); + + + fc = s390_kdsa_functions[ECDSA_SIGN_P256].hw_fc; + + if (rng_cb == NULL) { + rc = s390_kdsa(fc, param.buff, NULL, 0); + } else { + fc |= 0x80; /* deterministic signature */ + do { + rng_cb(param.P256.rand + off, + sizeof(param.P256.rand)); + } while (s390_kdsa(fc, param.buff, NULL, 0)); + } + + memcpy(sig, param.P256.sig_r + off, + sizeof(param.P256.sig_r) - off); + memcpy(sig + sizeof(param.P256.sig_r) - off, + param.P256.sig_s + off, + sizeof(param.P256.sig_s) - off); + + OPENSSL_cleanse(param.P256.priv, + sizeof(param.P256.priv)); + OPENSSL_cleanse(param.P256.rand, + sizeof(param.P256.rand)); + break; + + case NID_secp384r1: + off = sizeof(param.P384.hash) + - (hashlen > sizeof(param.P384.hash) ? + sizeof(param.P384.hash) : hashlen); + + memcpy(param.P384.hash + off, hash, + sizeof(param.P384.hash) - off); + + off = sizeof(param.P384.priv) + - privlen_from_nid(priv->nid); + + memcpy(param.P384.priv + off, priv->D, + sizeof(param.P384.priv) - off); + + fc = s390_kdsa_functions[ECDSA_SIGN_P384].hw_fc; + + if (rng_cb == NULL) { + rc = s390_kdsa(fc, param.buff, NULL, 0); + } else { + fc |= 0x80; /* deterministic signature */ + do { + rng_cb(param.P384.rand + off, + sizeof(param.P384.rand)); + } while (s390_kdsa(fc, param.buff, NULL, 0)); + } + + memcpy(sig, param.P384.sig_r + off, + sizeof(param.P384.sig_r) - off); + memcpy(sig + sizeof(param.P384.sig_r) - off, + param.P384.sig_s + off, + sizeof(param.P384.sig_s) - off); + + OPENSSL_cleanse(param.P384.priv, + sizeof(param.P384.priv)); + OPENSSL_cleanse(param.P384.rand, + sizeof(param.P384.rand)); + break; + + case NID_secp521r1: + off = sizeof(param.P521.hash) + - (hashlen > sizeof(param.P521.hash) ? + sizeof(param.P521.hash) : hashlen); + + memcpy(param.P521.hash + off, hash, + sizeof(param.P521.hash) - off); + + off = sizeof(param.P521.priv) + - privlen_from_nid(priv->nid); + + memcpy(param.P521.priv + off, priv->D, + sizeof(param.P521.priv) - off); + + fc = s390_kdsa_functions[ECDSA_SIGN_P521].hw_fc; + + if (rng_cb == NULL) { + rc = s390_kdsa(fc, param.buff, NULL, 0); + } else { + fc |= 0x80; /* deterministic signature */ + do { + rng_cb(param.P521.rand + off, + sizeof(param.P521.rand)); + } while (s390_kdsa(fc, param.buff, NULL, 0)); + } + + memcpy(sig, param.P521.sig_r + off, + sizeof(param.P521.sig_r) - off); + memcpy(sig + sizeof(param.P521.sig_r) - off, + param.P521.sig_s + off, + sizeof(param.P521.sig_s) - off); + + OPENSSL_cleanse(param.P521.priv, + sizeof(param.P521.priv)); + OPENSSL_cleanse(param.P521.rand, + sizeof(param.P521.rand)); + break; + + default: + rc = EINVAL; + break; + } + + return rc; +} + /** - * verifies an ECDSA signature via Crypto Express CCA coprocessor. + * verifies an ECDSA signature via CPACF or Crypto Express CCA coprocessor. * * Returns 0 if successful * EIO if an internal error occurred @@ -961,6 +1365,12 @@ struct ica_xcRB xcrb; ECDSA_VERIFY_REPLY* reply_p; + if (msa9_switch && !ica_offload_enabled) { + rc = ecdsa_verify_cpacf(pubkey, hash, hash_length, signature); + if (rc != EINVAL) /* EINVAL: curve not supported by cpacf */ + return rc; + } + if (adapter_handle == DRIVER_NOT_LOADED) return EIO; @@ -1166,6 +1576,134 @@ return (ECKEYGEN_REPLY*)prepcblk; } +static int eckeygen_cpacf(ICA_EC_KEY *key) +{ + static const unsigned char p256_base_x[] = { + 0x6B, 0x17, 0xD1, 0xF2, 0xE1, 0x2C, 0x42, 0x47, 0xF8, 0xBC, 0xE6, 0xE5, + 0x63, 0xA4, 0x40, 0xF2, 0x77, 0x03, 0x7D, 0x81, 0x2D, 0xEB, 0x33, 0xA0, + 0xF4, 0xA1, 0x39, 0x45, 0xD8, 0x98, 0xC2, 0x96 + }; + static const unsigned char p256_base_y[] = { + 0x4F, 0xE3, 0x42, 0xE2, 0xFE, 0x1A, 0x7F, 0x9B, 0x8E, 0xE7, 0xEB, 0x4A, + 0x7C, 0x0F, 0x9E, 0x16, 0x2B, 0xCE, 0x33, 0x57, 0x6B, 0x31, 0x5E, 0xCE, + 0xCB, 0xB6, 0x40, 0x68, 0x37, 0xBF, 0x51, 0xF5 + }; + static const unsigned char p256_ord[] = { + 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, + 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51 + }; + + static const unsigned char p384_base_x[] = { + 0xAA, 0x87, 0xCA, 0x22, 0xBE, 0x8B, 0x05, 0x37, 0x8E, 0xB1, 0xC7, 0x1E, + 0xF3, 0x20, 0xAD, 0x74, 0x6E, 0x1D, 0x3B, 0x62, 0x8B, 0xA7, 0x9B, 0x98, + 0x59, 0xF7, 0x41, 0xE0, 0x82, 0x54, 0x2A, 0x38, 0x55, 0x02, 0xF2, 0x5D, + 0xBF, 0x55, 0x29, 0x6C, 0x3A, 0x54, 0x5E, 0x38, 0x72, 0x76, 0x0A, 0xB7 + }; + static const unsigned char p384_base_y[] = { + 0x36, 0x17, 0xDE, 0x4A, 0x96, 0x26, 0x2C, 0x6F, 0x5D, 0x9E, 0x98, 0xBF, + 0x92, 0x92, 0xDC, 0x29, 0xF8, 0xF4, 0x1D, 0xBD, 0x28, 0x9A, 0x14, 0x7C, + 0xE9, 0xDA, 0x31, 0x13, 0xB5, 0xF0, 0xB8, 0xC0, 0x0A, 0x60, 0xB1, 0xCE, + 0x1D, 0x7E, 0x81, 0x9D, 0x7A, 0x43, 0x1D, 0x7C, 0x90, 0xEA, 0x0E, 0x5F + }; + static const unsigned char p384_ord[] = { + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xC7, 0x63, 0x4D, 0x81, 0xF4, 0x37, 0x2D, 0xDF, 0x58, 0x1A, 0x0D, 0xB2, + 0x48, 0xB0, 0xA7, 0x7A, 0xEC, 0xEC, 0x19, 0x6A, 0xCC, 0xC5, 0x29, 0x73 + }; + + static const unsigned char p521_base_x[] = { + 0x00, 0xC6, 0x85, 0x8E, 0x06, 0xB7, 0x04, 0x04, 0xE9, 0xCD, 0x9E, 0x3E, + 0xCB, 0x66, 0x23, 0x95, 0xB4, 0x42, 0x9C, 0x64, 0x81, 0x39, 0x05, 0x3F, + 0xB5, 0x21, 0xF8, 0x28, 0xAF, 0x60, 0x6B, 0x4D, 0x3D, 0xBA, 0xA1, 0x4B, + 0x5E, 0x77, 0xEF, 0xE7, 0x59, 0x28, 0xFE, 0x1D, 0xC1, 0x27, 0xA2, 0xFF, + 0xA8, 0xDE, 0x33, 0x48, 0xB3, 0xC1, 0x85, 0x6A, 0x42, 0x9B, 0xF9, 0x7E, + 0x7E, 0x31, 0xC2, 0xE5, 0xBD, 0x66 + }; + static const unsigned char p521_base_y[] = { + 0x01, 0x18, 0x39, 0x29, 0x6A, 0x78, 0x9A, 0x3B, 0xC0, 0x04, 0x5C, 0x8A, + 0x5F, 0xB4, 0x2C, 0x7D, 0x1B, 0xD9, 0x98, 0xF5, 0x44, 0x49, 0x57, 0x9B, + 0x44, 0x68, 0x17, 0xAF, 0xBD, 0x17, 0x27, 0x3E, 0x66, 0x2C, 0x97, 0xEE, + 0x72, 0x99, 0x5E, 0xF4, 0x26, 0x40, 0xC5, 0x50, 0xB9, 0x01, 0x3F, 0xAD, + 0x07, 0x61, 0x35, 0x3C, 0x70, 0x86, 0xA2, 0x72, 0xC2, 0x40, 0x88, 0xBE, + 0x94, 0x76, 0x9F, 0xD1, 0x66, 0x50 + }; + static const unsigned char p521_ord[] = { + 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0x51, 0x86, + 0x87, 0x83, 0xBF, 0x2F, 0x96, 0x6B, 0x7F, 0xCC, 0x01, 0x48, 0xF7, 0x09, + 0xA5, 0xD0, 0x3B, 0xB5, 0xC9, 0xB8, 0x89, 0x9C, 0x47, 0xAE, 0xBB, 0x6F, + 0xB7, 0x1E, 0x91, 0x38, 0x64, 0x09 + }; + + const unsigned int privlen = privlen_from_nid(key->nid); + const unsigned char *base_x, *base_y; + + BIGNUM *priv, *ord; + BN_CTX *ctx; + int rv, numbytes; + + ctx = BN_CTX_new(); + priv = BN_new(); + ord = BN_new(); + + if (ctx == NULL || priv == NULL || ord == NULL) { + rv = ENOMEM; + goto out; + } + + switch (key->nid) { + case NID_X9_62_prime256v1: + base_x = p256_base_x; + base_y = p256_base_y; + BN_bin2bn(p256_ord, sizeof(p256_ord), ord); + break; + case NID_secp384r1: + base_x = p384_base_x; + base_y = p384_base_y; + BN_bin2bn(p384_ord, sizeof(p384_ord), ord); + break; + case NID_secp521r1: + base_x = p521_base_x; + base_y = p521_base_y; + BN_bin2bn(p521_ord, sizeof(p521_ord), ord); + break; + default: + rv = EINVAL; + goto out; + } + + do { + if (!BN_rand_range(priv, ord)) + goto out; + } while (BN_is_zero(priv)); + + memset(key->D, 0, privlen); + numbytes = BN_num_bytes(priv); + + rv = BN_bn2bin(priv, key->D + privlen - numbytes); + BN_clear(priv); + if (rv != numbytes) { + rv = EIO; + goto out; + } + + rv = scalar_mul_cpacf(key->X, key->Y, key->D, base_x, base_y, + key->nid); + + out: + if (ctx != NULL) + BN_CTX_free(ctx); + if (priv != NULL) + BN_free(priv); + if (ord != NULL) + BN_free(ord); + + return rv; +} + /** * generates an EC key via Crypto Express CCA coprocessor. * @@ -1183,6 +1721,12 @@ ECC_PUBLIC_KEY_TOKEN* pub_p; unsigned char* p; + if (msa9_switch) { + rc = eckeygen_cpacf(key); + if (rc != EINVAL) /* curve not supported by cpacf */ + return rc; + } + reply_p = make_eckeygen_request(key, &xcrb, &buf, &len); if (!reply_p) return EIO; @@ -1297,3 +1841,229 @@ return rc; } + +#ifdef ICA_INTERNAL_TEST_EC + +#include "../test/testcase.h" +#include "test_vec.h" + +#define TEST_ERROR(msg, alg, tv) \ +do { \ + fprintf(stderr, "ERROR: %s. (%s test vector %lu)\n", msg, alg, tv); \ + exit(TEST_FAIL); \ +} while(0) + +static const unsigned char *deterministic_rng_output; + +static void deterministic_rng(unsigned char *buf, size_t buflen) +{ + memcpy(buf, deterministic_rng_output, buflen); +} + +static void ecdsa_test(void) +{ + sha_context_t sha_ctx; + sha256_context_t sha256_ctx; + sha512_context_t sha512_ctx; + unsigned char hash[1024]; + unsigned char sig[4096]; + size_t hashlen; + const struct ecdsa_tv *t; + size_t i; + int rc; + + verbosity_ = 2; + t = &ECDSA_TV[0]; + + for (i = 0; i < ECDSA_TV_LEN; i++) { + switch (t->hash) { + case SHA1: + rc = ica_sha1(SHA_MSG_PART_ONLY, t->msglen, t->msg, + &sha_ctx, hash); + hashlen = SHA1_HASH_LENGTH; + break; + case SHA224: + rc = ica_sha224(SHA_MSG_PART_ONLY, t->msglen, t->msg, + &sha256_ctx, hash); + hashlen = SHA224_HASH_LENGTH; + break; + case SHA256: + rc = ica_sha256(SHA_MSG_PART_ONLY, t->msglen, t->msg, + &sha256_ctx, hash); + hashlen = SHA256_HASH_LENGTH; + break; + case SHA384: + rc = ica_sha384(SHA_MSG_PART_ONLY, t->msglen, t->msg, + &sha512_ctx, hash); + hashlen = SHA384_HASH_LENGTH; + break; + case SHA512: + rc = ica_sha512(SHA_MSG_PART_ONLY, t->msglen, t->msg, + &sha512_ctx, hash); + hashlen = SHA512_HASH_LENGTH; + break; + default: + TEST_ERROR("Unknown hash", "ECDSA", i); + } + + if (rc) + TEST_ERROR("Hashing failed", "ECDSA", i); + + deterministic_rng_output = t->k; + + /* Sign hashed message */ + + rc = ecdsa_sign_cpacf(t->key, hash, hashlen, sig, + deterministic_rng); + if (rc) + TEST_ERROR("Signing failed", "ECDSA", i); + + /* Compare signature to expected result */ + + if (memcmp(sig, t->r, t->siglen) + || memcmp(sig + t->siglen, t->s, t->siglen)) { + printf("Result R:\n"); + dump_array(sig, t->siglen); + printf("Correct R:\n"); + dump_array((unsigned char *)t->r, t->siglen); + printf("Result S:\n"); + dump_array(sig + t->siglen, t->siglen); + printf("Correct S:\n"); + dump_array((unsigned char *)t->s, t->siglen); + TEST_ERROR("Wrong signature", "ECDSA", i); + } + + /* Verify signature */ + + rc = ecdsa_verify_cpacf(t->key, hash, hashlen, sig); + if (rc) + TEST_ERROR("Verification failed", "ECDSA", i); + + /* Try to verify forged signature */ + + sig[0] ^= 0x01; + + rc = ecdsa_verify_cpacf(t->key, hash, hashlen, sig); + if (!rc) + TEST_ERROR("Verification expected to fail but" + " succeeded", "ECDSA", i); + + t++; + } +} + +static void scalar_mul_test(void) +{ + const unsigned char *base_x, *base_y; + unsigned char res_x[4096], res_y[4096]; + const struct scalar_mul_tv *t; + size_t i; + int rc; + + static const unsigned char p256_base_x[] = { + 0x6B, 0x17, 0xD1, 0xF2, 0xE1, 0x2C, 0x42, 0x47, 0xF8, 0xBC, 0xE6, 0xE5, + 0x63, 0xA4, 0x40, 0xF2, 0x77, 0x03, 0x7D, 0x81, 0x2D, 0xEB, 0x33, 0xA0, + 0xF4, 0xA1, 0x39, 0x45, 0xD8, 0x98, 0xC2, 0x96 + }; + static const unsigned char p256_base_y[] = { + 0x4F, 0xE3, 0x42, 0xE2, 0xFE, 0x1A, 0x7F, 0x9B, 0x8E, 0xE7, 0xEB, 0x4A, + 0x7C, 0x0F, 0x9E, 0x16, 0x2B, 0xCE, 0x33, 0x57, 0x6B, 0x31, 0x5E, 0xCE, + 0xCB, 0xB6, 0x40, 0x68, 0x37, 0xBF, 0x51, 0xF5 + }; + + static const unsigned char p384_base_x[] = { + 0xAA, 0x87, 0xCA, 0x22, 0xBE, 0x8B, 0x05, 0x37, 0x8E, 0xB1, 0xC7, 0x1E, + 0xF3, 0x20, 0xAD, 0x74, 0x6E, 0x1D, 0x3B, 0x62, 0x8B, 0xA7, 0x9B, 0x98, + 0x59, 0xF7, 0x41, 0xE0, 0x82, 0x54, 0x2A, 0x38, 0x55, 0x02, 0xF2, 0x5D, + 0xBF, 0x55, 0x29, 0x6C, 0x3A, 0x54, 0x5E, 0x38, 0x72, 0x76, 0x0A, 0xB7 + }; + static const unsigned char p384_base_y[] = { + 0x36, 0x17, 0xDE, 0x4A, 0x96, 0x26, 0x2C, 0x6F, 0x5D, 0x9E, 0x98, 0xBF, + 0x92, 0x92, 0xDC, 0x29, 0xF8, 0xF4, 0x1D, 0xBD, 0x28, 0x9A, 0x14, 0x7C, + 0xE9, 0xDA, 0x31, 0x13, 0xB5, 0xF0, 0xB8, 0xC0, 0x0A, 0x60, 0xB1, 0xCE, + 0x1D, 0x7E, 0x81, 0x9D, 0x7A, 0x43, 0x1D, 0x7C, 0x90, 0xEA, 0x0E, 0x5F + }; + + static const unsigned char p521_base_x[] = { + 0x00, 0xC6, 0x85, 0x8E, 0x06, 0xB7, 0x04, 0x04, 0xE9, 0xCD, 0x9E, 0x3E, + 0xCB, 0x66, 0x23, 0x95, 0xB4, 0x42, 0x9C, 0x64, 0x81, 0x39, 0x05, 0x3F, + 0xB5, 0x21, 0xF8, 0x28, 0xAF, 0x60, 0x6B, 0x4D, 0x3D, 0xBA, 0xA1, 0x4B, + 0x5E, 0x77, 0xEF, 0xE7, 0x59, 0x28, 0xFE, 0x1D, 0xC1, 0x27, 0xA2, 0xFF, + 0xA8, 0xDE, 0x33, 0x48, 0xB3, 0xC1, 0x85, 0x6A, 0x42, 0x9B, 0xF9, 0x7E, + 0x7E, 0x31, 0xC2, 0xE5, 0xBD, 0x66 + }; + static const unsigned char p521_base_y[] = { + 0x01, 0x18, 0x39, 0x29, 0x6A, 0x78, 0x9A, 0x3B, 0xC0, 0x04, 0x5C, 0x8A, + 0x5F, 0xB4, 0x2C, 0x7D, 0x1B, 0xD9, 0x98, 0xF5, 0x44, 0x49, 0x57, 0x9B, + 0x44, 0x68, 0x17, 0xAF, 0xBD, 0x17, 0x27, 0x3E, 0x66, 0x2C, 0x97, 0xEE, + 0x72, 0x99, 0x5E, 0xF4, 0x26, 0x40, 0xC5, 0x50, 0xB9, 0x01, 0x3F, 0xAD, + 0x07, 0x61, 0x35, 0x3C, 0x70, 0x86, 0xA2, 0x72, 0xC2, 0x40, 0x88, 0xBE, + 0x94, 0x76, 0x9F, 0xD1, 0x66, 0x50 + }; + + verbosity_ = 2; + t = &SCALAR_MUL_TV[0]; + + for (i = 0; i < SCALAR_MUL_TV_LEN; i++) { + memset(res_x, 0, sizeof(res_x)); + memset(res_y, 0, sizeof(res_y)); + + switch (t->curve_nid) { + case NID_X9_62_prime256v1: + base_x = p256_base_x; + base_y = p256_base_y; + break; + case NID_secp384r1: + base_x = p384_base_x; + base_y = p384_base_y; + break; + case NID_secp521r1: + base_x = p521_base_x; + base_y = p521_base_y; + break; + default: + TEST_ERROR("Unknown curve", "SCALAR-MUL", i); + } + + rc = scalar_mul_cpacf(res_x, res_y, t->scalar, base_x, base_y, + t->curve_nid); + if (rc) { + TEST_ERROR("Scalar multipication failed", + "SCALAR-MUL", i); + } + + if (memcmp(res_x, t->x, t->len)) { + printf("Result X:\n"); + dump_array(res_x, t->len); + printf("Correct X:\n"); + dump_array((unsigned char *)t->x, t->len); + TEST_ERROR("Scalar multipication calculated wrong X", + "SCALAR-MUL", i); + } + + if (memcmp(res_y, t->y, t->len)) { + printf("Result Y:\n"); + dump_array(res_y, t->len); + printf("Correct Y:\n"); + dump_array((unsigned char *)t->y, t->len); + TEST_ERROR("Scalar multipication calculated wrong X", + "SCALAR-MUL", i); + } + + t++; + } +} + +int main(void) +{ + if (!msa9_switch) + exit(TEST_SKIP); + + /* test exit on first failure */ + scalar_mul_test(); + ecdsa_test(); + + return TEST_SUCC; +} + +#endif diff -Nru libica-3.4.0/src/s390_prng.c libica-3.5.0/src/s390_prng.c --- libica-3.4.0/src/s390_prng.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/s390_prng.c 2019-04-23 16:02:53.000000000 +0000 @@ -31,7 +31,9 @@ #define STCK_BUFFER 8 /* - * State handle for the global ica_drbg instantiation. + * State handle for the global ica_drbg instantiation that replaces + * the old prng implementation (if available) which feeds + * the ica_random_number_generate api, */ ica_drbg_t *ica_drbg_global = ICA_DRBG_NEW_STATE_HANDLE; diff -Nru libica-3.4.0/src/test_vec.c libica-3.5.0/src/test_vec.c --- libica-3.4.0/src/test_vec.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/src/test_vec.c 2019-04-23 16:02:53.000000000 +0000 @@ -2450,6 +2450,1633 @@ }; #endif /* ICA_FIPS */ +#ifdef ICA_INTERNAL_TEST_EC +const struct ecdsa_tv ECDSA_TV[] = { +/* RFC 6979 */ +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA1, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x88, 0x29, 0x05, 0xF1, 0x22, 0x7F, 0xD6, 0x20, 0xFB, 0xF2, 0xAB, 0xF2, +0x12, 0x44, 0xF0, 0xBA, 0x83, 0xD0, 0xDC, 0x3A, 0x91, 0x03, 0xDB, 0xBE, +0xE4, 0x3A, 0x1F, 0xB8, 0x58, 0x10, 0x9D, 0xB4 +}, +.r = (const unsigned char []){ +0x61, 0x34, 0x0C, 0x88, 0xC3, 0xAA, 0xEB, 0xEB, 0x4F, 0x6D, 0x66, 0x7F, +0x67, 0x2C, 0xA9, 0x75, 0x9A, 0x6C, 0xCA, 0xA9, 0xFA, 0x88, 0x11, 0x31, +0x30, 0x39, 0xEE, 0x4A, 0x35, 0x47, 0x1D, 0x32 +}, +.s = (const unsigned char []){ +0x6D, 0x7F, 0x14, 0x7D, 0xAC, 0x08, 0x94, 0x41, 0xBB, 0x2E, 0x2F, 0xE8, +0xF7, 0xA3, 0xFA, 0x26, 0x4B, 0x9C, 0x47, 0x50, 0x98, 0xFD, 0xCF, 0x6E, +0x00, 0xD7, 0xC9, 0x96, 0xE1, 0xB8, 0xB7, 0xEB +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA224, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x10, 0x3F, 0x90, 0xEE, 0x9D, 0xC5, 0x2E, 0x5E, 0x7F, 0xB5, 0x13, 0x2B, +0x70, 0x33, 0xC6, 0x30, 0x66, 0xD1, 0x94, 0x32, 0x14, 0x91, 0x86, 0x20, +0x59, 0x96, 0x7C, 0x71, 0x59, 0x85, 0xD4, 0x73 +}, +.r = (const unsigned char []){ +0x53, 0xB2, 0xFF, 0xF5, 0xD1, 0x75, 0x2B, 0x2C, 0x68, 0x9D, 0xF2, 0x57, +0xC0, 0x4C, 0x40, 0xA5, 0x87, 0xFA, 0xBA, 0xBB, 0x3F, 0x6F, 0xC2, 0x70, +0x2F, 0x13, 0x43, 0xAF, 0x7C, 0xA9, 0xAA, 0x3F +}, +.s = (const unsigned char []){ +0xB9, 0xAF, 0xB6, 0x4F, 0xDC, 0x03, 0xDC, 0x1A, 0x13, 0x1C, 0x7D, 0x23, +0x86, 0xD1, 0x1E, 0x34, 0x9F, 0x07, 0x0A, 0xA4, 0x32, 0xA4, 0xAC, 0xC9, +0x18, 0xBE, 0xA9, 0x88, 0xBF, 0x75, 0xC7, 0x4C +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA256, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0xA6, 0xE3, 0xC5, 0x7D, 0xD0, 0x1A, 0xBE, 0x90, 0x08, 0x65, 0x38, 0x39, +0x83, 0x55, 0xDD, 0x4C, 0x3B, 0x17, 0xAA, 0x87, 0x33, 0x82, 0xB0, 0xF2, +0x4D, 0x61, 0x29, 0x49, 0x3D, 0x8A, 0xAD, 0x60 +}, +.r = (const unsigned char []){ +0xEF, 0xD4, 0x8B, 0x2A, 0xAC, 0xB6, 0xA8, 0xFD, 0x11, 0x40, 0xDD, 0x9C, +0xD4, 0x5E, 0x81, 0xD6, 0x9D, 0x2C, 0x87, 0x7B, 0x56, 0xAA, 0xF9, 0x91, +0xC3, 0x4D, 0x0E, 0xA8, 0x4E, 0xAF, 0x37, 0x16 +}, +.s = (const unsigned char []){ +0xF7, 0xCB, 0x1C, 0x94, 0x2D, 0x65, 0x7C, 0x41, 0xD4, 0x36, 0xC7, 0xA1, +0xB6, 0xE2, 0x9F, 0x65, 0xF3, 0xE9, 0x00, 0xDB, 0xB9, 0xAF, 0xF4, 0x06, +0x4D, 0xC4, 0xAB, 0x2F, 0x84, 0x3A, 0xCD, 0xA8 +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA384, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x09, 0xF6, 0x34, 0xB1, 0x88, 0xCE, 0xFD, 0x98, 0xE7, 0xEC, 0x88, 0xB1, +0xAA, 0x98, 0x52, 0xD7, 0x34, 0xD0, 0xBC, 0x27, 0x2F, 0x7D, 0x2A, 0x47, +0xDE, 0xCC, 0x6E, 0xBE, 0xB3, 0x75, 0xAA, 0xD4 +}, +.r = (const unsigned char []){ +0x0E, 0xAF, 0xEA, 0x03, 0x9B, 0x20, 0xE9, 0xB4, 0x23, 0x09, 0xFB, 0x1D, +0x89, 0xE2, 0x13, 0x05, 0x7C, 0xBF, 0x97, 0x3D, 0xC0, 0xCF, 0xC8, 0xF1, +0x29, 0xED, 0xDD, 0xC8, 0x00, 0xEF, 0x77, 0x19 +}, +.s = (const unsigned char []){ +0x48, 0x61, 0xF0, 0x49, 0x1E, 0x69, 0x98, 0xB9, 0x45, 0x51, 0x93, 0xE3, +0x4E, 0x7B, 0x0D, 0x28, 0x4D, 0xDD, 0x71, 0x49, 0xA7, 0x4B, 0x95, 0xB9, +0x26, 0x1F, 0x13, 0xAB, 0xDE, 0x94, 0x09, 0x54 +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA512, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x5F, 0xA8, 0x1C, 0x63, 0x10, 0x9B, 0xAD, 0xB8, 0x8C, 0x1F, 0x36, 0x7B, +0x47, 0xDA, 0x60, 0x6D, 0xA2, 0x8C, 0xAD, 0x69, 0xAA, 0x22, 0xC4, 0xFE, +0x6A, 0xD7, 0xDF, 0x73, 0xA7, 0x17, 0x3A, 0xA5 +}, +.r = (const unsigned char []){ +0x84, 0x96, 0xA6, 0x0B, 0x5E, 0x9B, 0x47, 0xC8, 0x25, 0x48, 0x88, 0x27, +0xE0, 0x49, 0x5B, 0x0E, 0x3F, 0xA1, 0x09, 0xEC, 0x45, 0x68, 0xFD, 0x3F, +0x8D, 0x10, 0x97, 0x67, 0x8E, 0xB9, 0x7F, 0x00 +}, +.s = (const unsigned char []){ +0x23, 0x62, 0xAB, 0x1A, 0xDB, 0xE2, 0xB8, 0xAD, 0xF9, 0xCB, 0x9E, 0xDA, +0xB7, 0x40, 0xEA, 0x60, 0x49, 0xC0, 0x28, 0x11, 0x4F, 0x24, 0x60, 0xF9, +0x65, 0x54, 0xF6, 0x1F, 0xAE, 0x33, 0x02, 0xFE +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA1, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x8C, 0x95, 0x20, 0x26, 0x7C, 0x55, 0xD6, 0xB9, 0x80, 0xDF, 0x74, 0x1E, +0x56, 0xB4, 0xAD, 0xEE, 0x11, 0x4D, 0x84, 0xFB, 0xFA, 0x2E, 0x62, 0x13, +0x79, 0x54, 0x16, 0x40, 0x28, 0x63, 0x2A, 0x2E +}, +.r = (const unsigned char []){ +0x0C, 0xBC, 0xC8, 0x6F, 0xD6, 0xAB, 0xD1, 0xD9, 0x9E, 0x70, 0x3E, 0x1E, +0xC5, 0x00, 0x69, 0xEE, 0x5C, 0x0B, 0x4B, 0xA4, 0xB9, 0xAC, 0x60, 0xE4, +0x09, 0xE8, 0xEC, 0x59, 0x10, 0xD8, 0x1A, 0x89 +}, +.s = (const unsigned char []){ +0x01, 0xB9, 0xD7, 0xB7, 0x3D, 0xFA, 0xA6, 0x0D, 0x56, 0x51, 0xEC, 0x45, +0x91, 0xA0, 0x13, 0x6F, 0x87, 0x65, 0x3E, 0x0F, 0xD7, 0x80, 0xC3, 0xB1, +0xBC, 0x87, 0x2F, 0xFD, 0xEA, 0xE4, 0x79, 0xB1 +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA224, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x66, 0x9F, 0x44, 0x26, 0xF2, 0x68, 0x8B, 0x8B, 0xE0, 0xDB, 0x3A, 0x6B, +0xD1, 0x98, 0x9B, 0xDA, 0xEF, 0xFF, 0x84, 0xB6, 0x49, 0xEE, 0xB8, 0x4F, +0x3D, 0xD2, 0x60, 0x80, 0xF6, 0x67, 0xFA, 0xA7 +}, +.r = (const unsigned char []){ +0xC3, 0x7E, 0xDB, 0x6F, 0x0A, 0xE7, 0x9D, 0x47, 0xC3, 0xC2, 0x7E, 0x96, +0x2F, 0xA2, 0x69, 0xBB, 0x4F, 0x44, 0x17, 0x70, 0x35, 0x7E, 0x11, 0x4E, +0xE5, 0x11, 0xF6, 0x62, 0xEC, 0x34, 0xA6, 0x92 +}, +.s = (const unsigned char []){ +0xC8, 0x20, 0x05, 0x3A, 0x05, 0x79, 0x1E, 0x52, 0x1F, 0xCA, 0xAD, 0x60, +0x42, 0xD4, 0x0A, 0xEA, 0x1D, 0x6B, 0x1A, 0x54, 0x01, 0x38, 0x55, 0x8F, +0x47, 0xD0, 0x71, 0x98, 0x00, 0xE1, 0x8F, 0x2D +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA256, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0xD1, 0x6B, 0x6A, 0xE8, 0x27, 0xF1, 0x71, 0x75, 0xE0, 0x40, 0x87, 0x1A, +0x1C, 0x7E, 0xC3, 0x50, 0x01, 0x92, 0xC4, 0xC9, 0x26, 0x77, 0x33, 0x6E, +0xC2, 0x53, 0x7A, 0xCA, 0xEE, 0x00, 0x08, 0xE0 +}, +.r = (const unsigned char []){ +0xF1, 0xAB, 0xB0, 0x23, 0x51, 0x83, 0x51, 0xCD, 0x71, 0xD8, 0x81, 0x56, +0x7B, 0x1E, 0xA6, 0x63, 0xED, 0x3E, 0xFC, 0xF6, 0xC5, 0x13, 0x2B, 0x35, +0x4F, 0x28, 0xD3, 0xB0, 0xB7, 0xD3, 0x83, 0x67 +}, +.s = (const unsigned char []){ +0x01, 0x9F, 0x41, 0x13, 0x74, 0x2A, 0x2B, 0x14, 0xBD, 0x25, 0x92, 0x6B, +0x49, 0xC6, 0x49, 0x15, 0x5F, 0x26, 0x7E, 0x60, 0xD3, 0x81, 0x4B, 0x4C, +0x0C, 0xC8, 0x42, 0x50, 0xE4, 0x6F, 0x00, 0x83 +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA384, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x16, 0xAE, 0xFF, 0xA3, 0x57, 0x26, 0x0B, 0x04, 0xB1, 0xDD, 0x19, 0x96, +0x93, 0x96, 0x07, 0x40, 0x06, 0x6C, 0x1A, 0x8F, 0x3E, 0x8E, 0xDD, 0x79, +0x07, 0x0A, 0xA9, 0x14, 0xD3, 0x61, 0xB3, 0xB8 +}, +.r = (const unsigned char []){ +0x83, 0x91, 0x0E, 0x8B, 0x48, 0xBB, 0x0C, 0x74, 0x24, 0x4E, 0xBD, 0xF7, +0xF0, 0x7A, 0x1C, 0x54, 0x13, 0xD6, 0x14, 0x72, 0xBD, 0x94, 0x1E, 0xF3, +0x92, 0x0E, 0x62, 0x3F, 0xBC, 0xCE, 0xBE, 0xB6 +}, +.s = (const unsigned char []){ +0x8D, 0xDB, 0xEC, 0x54, 0xCF, 0x8C, 0xD5, 0x87, 0x48, 0x83, 0x84, 0x1D, +0x71, 0x21, 0x42, 0xA5, 0x6A, 0x8D, 0x0F, 0x21, 0x8F, 0x50, 0x03, 0xCB, +0x02, 0x96, 0xB6, 0xB5, 0x09, 0x61, 0x9F, 0x2C +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_X9_62_prime256v1, +.D = (unsigned char []){ +0xC9, 0xAF, 0xA9, 0xD8, 0x45, 0xBA, 0x75, 0x16, 0x6B, 0x5C, 0x21, 0x57, +0x67, 0xB1, 0xD6, 0x93, 0x4E, 0x50, 0xC3, 0xDB, 0x36, 0xE8, 0x9B, 0x12, +0x7B, 0x8A, 0x62, 0x2B, 0x12, 0x0F, 0x67, 0x21 +}, +.X = (unsigned char []){ +0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D, 0x31, 0xC9, 0x61, 0xEB, 0x74, +0xC6, 0x35, 0x6D, 0x68, 0xC0, 0x49, 0xB8, 0x92, 0x3B, 0x61, 0xFA, 0x6C, +0xE6, 0x69, 0x62, 0x2E, 0x60, 0xF2, 0x9F, 0xB6 +}, +.Y = (unsigned char []){ +0x79, 0x03, 0xFE, 0x10, 0x08, 0xB8, 0xBC, 0x99, 0xA4, 0x1A, 0xE9, 0xE9, +0x56, 0x28, 0xBC, 0x64, 0xF2, 0xF1, 0xB2, 0x0C, 0x2D, 0x7E, 0x9F, 0x51, +0x77, 0xA3, 0xC2, 0x94, 0xD4, 0x46, 0x22, 0x99 +}, +}, +.hash = SHA512, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x69, 0x15, 0xD1, 0x16, 0x32, 0xAC, 0xA3, 0xC4, 0x0D, 0x5D, 0x51, 0xC0, +0x8D, 0xAF, 0x9C, 0x55, 0x59, 0x33, 0x81, 0x95, 0x48, 0x78, 0x44, 0x80, +0xE9, 0x34, 0x99, 0x00, 0x0D, 0x9F, 0x0B, 0x7F +}, +.r = (const unsigned char []){ +0x46, 0x1D, 0x93, 0xF3, 0x1B, 0x65, 0x40, 0x89, 0x47, 0x88, 0xFD, 0x20, +0x6C, 0x07, 0xCF, 0xA0, 0xCC, 0x35, 0xF4, 0x6F, 0xA3, 0xC9, 0x18, 0x16, +0xFF, 0xF1, 0x04, 0x0A, 0xD1, 0x58, 0x1A, 0x04 +}, +.s = (const unsigned char []){ +0x39, 0xAF, 0x9F, 0x15, 0xDE, 0x0D, 0xB8, 0xD9, 0x7E, 0x72, 0x71, 0x9C, +0x74, 0x82, 0x0D, 0x30, 0x4C, 0xE5, 0x22, 0x6E, 0x32, 0xDE, 0xDA, 0xE6, +0x75, 0x19, 0xE8, 0x40, 0xD1, 0x19, 0x4E, 0x55 +}, +.siglen = 32, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA1, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x44, 0x71, 0xEF, 0x75, 0x18, 0xBB, 0x2C, 0x7C, 0x20, 0xF6, 0x2E, 0xAE, +0x1C, 0x38, 0x7A, 0xD0, 0xC5, 0xE8, 0xE4, 0x70, 0x99, 0x5D, 0xB4, 0xAC, +0xF6, 0x94, 0x46, 0x6E, 0x6A, 0xB0, 0x96, 0x63, 0x0F, 0x29, 0xE5, 0x93, +0x8D, 0x25, 0x10, 0x6C, 0x3C, 0x34, 0x00, 0x45, 0xA2, 0xDB, 0x01, 0xA7 +}, +.r = (const unsigned char []){ +0xEC, 0x74, 0x8D, 0x83, 0x92, 0x43, 0xD6, 0xFB, 0xEF, 0x4F, 0xC5, 0xC4, +0x85, 0x9A, 0x7D, 0xFF, 0xD7, 0xF3, 0xAB, 0xDD, 0xF7, 0x20, 0x14, 0x54, +0x0C, 0x16, 0xD7, 0x33, 0x09, 0x83, 0x4F, 0xA3, 0x7B, 0x9B, 0xA0, 0x02, +0x89, 0x9F, 0x6F, 0xDA, 0x3A, 0x4A, 0x93, 0x86, 0x79, 0x0D, 0x4E, 0xB2 +}, +.s = (const unsigned char []){ +0xA3, 0xBC, 0xFA, 0x94, 0x7B, 0xEE, 0xF4, 0x73, 0x2B, 0xF2, 0x47, 0xAC, +0x17, 0xF7, 0x16, 0x76, 0xCB, 0x31, 0xA8, 0x47, 0xB9, 0xFF, 0x0C, 0xBC, +0x9C, 0x9E, 0xD4, 0xC1, 0xA5, 0xB3, 0xFA, 0xCF, 0x26, 0xF4, 0x9C, 0xA0, +0x31, 0xD4, 0x85, 0x75, 0x70, 0xCC, 0xB5, 0xCA, 0x44, 0x24, 0xA4, 0x43 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA224, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0xA4, 0xE4, 0xD2, 0xF0, 0xE7, 0x29, 0xEB, 0x78, 0x6B, 0x31, 0xFC, 0x20, +0xAD, 0x5D, 0x84, 0x9E, 0x30, 0x44, 0x50, 0xE0, 0xAE, 0x8E, 0x3E, 0x34, +0x11, 0x34, 0xA5, 0xC1, 0xAF, 0xA0, 0x3C, 0xAB, 0x80, 0x83, 0xEE, 0x4E, +0x3C, 0x45, 0xB0, 0x6A, 0x58, 0x99, 0xEA, 0x56, 0xC5, 0x1B, 0x58, 0x79 +}, +.r = (const unsigned char []){ +0x42, 0x35, 0x6E, 0x76, 0xB5, 0x5A, 0x6D, 0x9B, 0x46, 0x31, 0xC8, 0x65, +0x44, 0x5D, 0xBE, 0x54, 0xE0, 0x56, 0xD3, 0xB3, 0x43, 0x17, 0x66, 0xD0, +0x50, 0x92, 0x44, 0x79, 0x3C, 0x3F, 0x93, 0x66, 0x45, 0x0F, 0x76, 0xEE, +0x3D, 0xE4, 0x3F, 0x5A, 0x12, 0x53, 0x33, 0xA6, 0xBE, 0x06, 0x01, 0x22 +}, +.s = (const unsigned char []){ +0x9D, 0xA0, 0xC8, 0x17, 0x87, 0x06, 0x40, 0x21, 0xE7, 0x8D, 0xF6, 0x58, +0xF2, 0xFB, 0xB0, 0xB0, 0x42, 0xBF, 0x30, 0x46, 0x65, 0xDB, 0x72, 0x1F, +0x07, 0x7A, 0x42, 0x98, 0xB0, 0x95, 0xE4, 0x83, 0x4C, 0x08, 0x2C, 0x03, +0xD8, 0x30, 0x28, 0xEF, 0xBF, 0x93, 0xA3, 0xC2, 0x39, 0x40, 0xCA, 0x8D +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA256, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x18, 0x0A, 0xE9, 0xF9, 0xAE, 0xC5, 0x43, 0x8A, 0x44, 0xBC, 0x15, 0x9A, +0x1F, 0xCB, 0x27, 0x7C, 0x7B, 0xE5, 0x4F, 0xA2, 0x0E, 0x7C, 0xF4, 0x04, +0xB4, 0x90, 0x65, 0x0A, 0x8A, 0xCC, 0x41, 0x4E, 0x37, 0x55, 0x72, 0x34, +0x28, 0x63, 0xC8, 0x99, 0xF9, 0xF2, 0xED, 0xF9, 0x74, 0x7A, 0x9B, 0x60 +}, +.r = (const unsigned char []){ +0x21, 0xB1, 0x3D, 0x1E, 0x01, 0x3C, 0x7F, 0xA1, 0x39, 0x2D, 0x03, 0xC5, +0xF9, 0x9A, 0xF8, 0xB3, 0x0C, 0x57, 0x0C, 0x6F, 0x98, 0xD4, 0xEA, 0x8E, +0x35, 0x4B, 0x63, 0xA2, 0x1D, 0x3D, 0xAA, 0x33, 0xBD, 0xE1, 0xE8, 0x88, +0xE6, 0x33, 0x55, 0xD9, 0x2F, 0xA2, 0xB3, 0xC3, 0x6D, 0x8F, 0xB2, 0xCD +}, +.s = (const unsigned char []){ +0xF3, 0xAA, 0x44, 0x3F, 0xB1, 0x07, 0x74, 0x5B, 0xF4, 0xBD, 0x77, 0xCB, +0x38, 0x91, 0x67, 0x46, 0x32, 0x06, 0x8A, 0x10, 0xCA, 0x67, 0xE3, 0xD4, +0x5D, 0xB2, 0x26, 0x6F, 0xA7, 0xD1, 0xFE, 0xEB, 0xEF, 0xDC, 0x63, 0xEC, +0xCD, 0x1A, 0xC4, 0x2E, 0xC0, 0xCB, 0x86, 0x68, 0xA4, 0xFA, 0x0A, 0xB0 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA384, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x94, 0xED, 0x91, 0x0D, 0x1A, 0x09, 0x9D, 0xAD, 0x32, 0x54, 0xE9, 0x24, +0x2A, 0xE8, 0x5A, 0xBD, 0xE4, 0xBA, 0x15, 0x16, 0x8E, 0xAF, 0x0C, 0xA8, +0x7A, 0x55, 0x5F, 0xD5, 0x6D, 0x10, 0xFB, 0xCA, 0x29, 0x07, 0xE3, 0xE8, +0x3B, 0xA9, 0x53, 0x68, 0x62, 0x3B, 0x8C, 0x46, 0x86, 0x91, 0x5C, 0xF9 +}, +.r = (const unsigned char []){ +0x94, 0xED, 0xBB, 0x92, 0xA5, 0xEC, 0xB8, 0xAA, 0xD4, 0x73, 0x6E, 0x56, +0xC6, 0x91, 0x91, 0x6B, 0x3F, 0x88, 0x14, 0x06, 0x66, 0xCE, 0x9F, 0xA7, +0x3D, 0x64, 0xC4, 0xEA, 0x95, 0xAD, 0x13, 0x3C, 0x81, 0xA6, 0x48, 0x15, +0x2E, 0x44, 0xAC, 0xF9, 0x6E, 0x36, 0xDD, 0x1E, 0x80, 0xFA, 0xBE, 0x46 +}, +.s = (const unsigned char []){ +0x99, 0xEF, 0x4A, 0xEB, 0x15, 0xF1, 0x78, 0xCE, 0xA1, 0xFE, 0x40, 0xDB, +0x26, 0x03, 0x13, 0x8F, 0x13, 0x0E, 0x74, 0x0A, 0x19, 0x62, 0x45, 0x26, +0x20, 0x3B, 0x63, 0x51, 0xD0, 0xA3, 0xA9, 0x4F, 0xA3, 0x29, 0xC1, 0x45, +0x78, 0x6E, 0x67, 0x9E, 0x7B, 0x82, 0xC7, 0x1A, 0x38, 0x62, 0x8A, 0xC8 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA512, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x92, 0xFC, 0x3C, 0x71, 0x83, 0xA8, 0x83, 0xE2, 0x42, 0x16, 0xD1, 0x14, +0x1F, 0x1A, 0x89, 0x76, 0xC5, 0xB0, 0xDD, 0x79, 0x7D, 0xFA, 0x59, 0x7E, +0x3D, 0x7B, 0x32, 0x19, 0x8B, 0xD3, 0x53, 0x31, 0xA4, 0xE9, 0x66, 0x53, +0x25, 0x93, 0xA5, 0x29, 0x80, 0xD0, 0xE3, 0xAA, 0xA5, 0xE1, 0x0E, 0xC3 +}, +.r = (const unsigned char []){ +0xED, 0x09, 0x59, 0xD5, 0x88, 0x0A, 0xB2, 0xD8, 0x69, 0xAE, 0x7F, 0x6C, +0x29, 0x15, 0xC6, 0xD6, 0x0F, 0x96, 0x50, 0x7F, 0x9C, 0xB3, 0xE0, 0x47, +0xC0, 0x04, 0x68, 0x61, 0xDA, 0x4A, 0x79, 0x9C, 0xFE, 0x30, 0xF3, 0x5C, +0xC9, 0x00, 0x05, 0x6D, 0x7C, 0x99, 0xCD, 0x78, 0x82, 0x43, 0x37, 0x09 +}, +.s = (const unsigned char []){ +0x51, 0x2C, 0x8C, 0xCE, 0xEE, 0x38, 0x90, 0xA8, 0x40, 0x58, 0xCE, 0x1E, +0x22, 0xDB, 0xC2, 0x19, 0x8F, 0x42, 0x32, 0x3C, 0xE8, 0xAC, 0xA9, 0x13, +0x53, 0x29, 0xF0, 0x3C, 0x06, 0x8E, 0x51, 0x12, 0xDC, 0x7C, 0xC3, 0xEF, +0x34, 0x46, 0xDE, 0xFC, 0xEB, 0x01, 0xA4, 0x5C, 0x26, 0x67, 0xFD, 0xD5 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA1, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x66, 0xCC, 0x2C, 0x8F, 0x4D, 0x30, 0x3F, 0xC9, 0x62, 0xE5, 0xFF, 0x6A, +0x27, 0xBD, 0x79, 0xF8, 0x4E, 0xC8, 0x12, 0xDD, 0xAE, 0x58, 0xCF, 0x52, +0x43, 0xB6, 0x4A, 0x4A, 0xD8, 0x09, 0x4D, 0x47, 0xEC, 0x37, 0x27, 0xF3, +0xA3, 0xC1, 0x86, 0xC1, 0x50, 0x54, 0x49, 0x2E, 0x30, 0x69, 0x84, 0x97 +}, +.r = (const unsigned char []){ +0x4B, 0xC3, 0x5D, 0x3A, 0x50, 0xEF, 0x4E, 0x30, 0x57, 0x6F, 0x58, 0xCD, +0x96, 0xCE, 0x6B, 0xF6, 0x38, 0x02, 0x5E, 0xE6, 0x24, 0x00, 0x4A, 0x1F, +0x77, 0x89, 0xA8, 0xB8, 0xE4, 0x3D, 0x06, 0x78, 0xAC, 0xD9, 0xD2, 0x98, +0x76, 0xDA, 0xF4, 0x66, 0x38, 0x64, 0x5F, 0x7F, 0x40, 0x4B, 0x11, 0xC7 +}, +.s = (const unsigned char []){ +0xD5, 0xA6, 0x32, 0x6C, 0x49, 0x4E, 0xD3, 0xFF, 0x61, 0x47, 0x03, 0x87, +0x89, 0x61, 0xC0, 0xFD, 0xE7, 0xB2, 0xC2, 0x78, 0xF9, 0xA6, 0x5F, 0xD8, +0xC4, 0xB7, 0x18, 0x62, 0x01, 0xA2, 0x99, 0x16, 0x95, 0xBA, 0x1C, 0x84, +0x54, 0x13, 0x27, 0xE9, 0x66, 0xFA, 0x7B, 0x50, 0xF7, 0x38, 0x22, 0x82 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA224, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x18, 0xFA, 0x39, 0xDB, 0x95, 0xAA, 0x5F, 0x56, 0x1F, 0x30, 0xFA, 0x35, +0x91, 0xDC, 0x59, 0xC0, 0xFA, 0x36, 0x53, 0xA8, 0x0D, 0xAF, 0xFA, 0x0B, +0x48, 0xD1, 0xA4, 0xC6, 0xDF, 0xCB, 0xFF, 0x6E, 0x3D, 0x33, 0xBE, 0x4D, +0xC5, 0xEB, 0x88, 0x86, 0xA8, 0xEC, 0xD0, 0x93, 0xF2, 0x93, 0x57, 0x26 +}, +.r = (const unsigned char []){ +0xE8, 0xC9, 0xD0, 0xB6, 0xEA, 0x72, 0xA0, 0xE7, 0x83, 0x7F, 0xEA, 0x1D, +0x14, 0xA1, 0xA9, 0x55, 0x7F, 0x29, 0xFA, 0xA4, 0x5D, 0x3E, 0x7E, 0xE8, +0x88, 0xFC, 0x5B, 0xF9, 0x54, 0xB5, 0xE6, 0x24, 0x64, 0xA9, 0xA8, 0x17, +0xC4, 0x7F, 0xF7, 0x8B, 0x8C, 0x11, 0x06, 0x6B, 0x24, 0x08, 0x0E, 0x72 +}, +.s = (const unsigned char []){ +0x07, 0x04, 0x1D, 0x4A, 0x7A, 0x03, 0x79, 0xAC, 0x72, 0x32, 0xFF, 0x72, +0xE6, 0xF7, 0x7B, 0x6D, 0xDB, 0x8F, 0x09, 0xB1, 0x6C, 0xCE, 0x0E, 0xC3, +0x28, 0x6B, 0x2B, 0xD4, 0x3F, 0xA8, 0xC6, 0x14, 0x1C, 0x53, 0xEA, 0x5A, +0xBE, 0xF0, 0xD8, 0x23, 0x10, 0x77, 0xA0, 0x45, 0x40, 0xA9, 0x6B, 0x66 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA256, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x0C, 0xFA, 0xC3, 0x75, 0x87, 0x53, 0x23, 0x47, 0xDC, 0x33, 0x89, 0xFD, +0xC9, 0x82, 0x86, 0xBB, 0xA8, 0xC7, 0x38, 0x07, 0x28, 0x5B, 0x18, 0x4C, +0x83, 0xE6, 0x2E, 0x26, 0xC4, 0x01, 0xC0, 0xFA, 0xA4, 0x8D, 0xD0, 0x70, +0xBA, 0x79, 0x92, 0x1A, 0x34, 0x57, 0xAB, 0xFF, 0x2D, 0x63, 0x0A, 0xD7 +}, +.r = (const unsigned char []){ +0x6D, 0x6D, 0xEF, 0xAC, 0x9A, 0xB6, 0x4D, 0xAB, 0xAF, 0xE3, 0x6C, 0x6B, +0xF5, 0x10, 0x35, 0x2A, 0x4C, 0xC2, 0x70, 0x01, 0x26, 0x36, 0x38, 0xE5, +0xB1, 0x6D, 0x9B, 0xB5, 0x1D, 0x45, 0x15, 0x59, 0xF9, 0x18, 0xEE, 0xDA, +0xF2, 0x29, 0x3B, 0xE5, 0xB4, 0x75, 0xCC, 0x8F, 0x01, 0x88, 0x63, 0x6B +}, +.s = (const unsigned char []){ +0x2D, 0x46, 0xF3, 0xBE, 0xCB, 0xCC, 0x52, 0x3D, 0x5F, 0x1A, 0x12, 0x56, +0xBF, 0x0C, 0x9B, 0x02, 0x4D, 0x87, 0x9B, 0xA9, 0xE8, 0x38, 0x14, 0x4C, +0x8B, 0xA6, 0xBA, 0xEB, 0x4B, 0x53, 0xB4, 0x7D, 0x51, 0xAB, 0x37, 0x3F, +0x98, 0x45, 0xC0, 0x51, 0x4E, 0xEF, 0xB1, 0x40, 0x24, 0x78, 0x72, 0x65 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA384, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x01, 0x5E, 0xE4, 0x6A, 0x5B, 0xF8, 0x87, 0x73, 0xED, 0x91, 0x23, 0xA5, +0xAB, 0x08, 0x07, 0x96, 0x2D, 0x19, 0x37, 0x19, 0x50, 0x3C, 0x52, 0x7B, +0x03, 0x1B, 0x4C, 0x2D, 0x22, 0x50, 0x92, 0xAD, 0xA7, 0x1F, 0x4A, 0x45, +0x9B, 0xC0, 0xDA, 0x98, 0xAD, 0xB9, 0x58, 0x37, 0xDB, 0x83, 0x12, 0xEA +}, +.r = (const unsigned char []){ +0x82, 0x03, 0xB6, 0x3D, 0x3C, 0x85, 0x3E, 0x8D, 0x77, 0x22, 0x7F, 0xB3, +0x77, 0xBC, 0xF7, 0xB7, 0xB7, 0x72, 0xE9, 0x78, 0x92, 0xA8, 0x0F, 0x36, +0xAB, 0x77, 0x5D, 0x50, 0x9D, 0x7A, 0x5F, 0xEB, 0x05, 0x42, 0xA7, 0xF0, +0x81, 0x29, 0x98, 0xDA, 0x8F, 0x1D, 0xD3, 0xCA, 0x3C, 0xF0, 0x23, 0xDB +}, +.s = (const unsigned char []){ +0xDD, 0xD0, 0x76, 0x04, 0x48, 0xD4, 0x2D, 0x8A, 0x43, 0xAF, 0x45, 0xAF, +0x83, 0x6F, 0xCE, 0x4D, 0xE8, 0xBE, 0x06, 0xB4, 0x85, 0xE9, 0xB6, 0x1B, +0x82, 0x7C, 0x2F, 0x13, 0x17, 0x39, 0x23, 0xE0, 0x6A, 0x73, 0x9F, 0x04, +0x06, 0x49, 0xA6, 0x67, 0xBF, 0x3B, 0x82, 0x82, 0x46, 0xBA, 0xA5, 0xA5 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp384r1, +.D = (unsigned char []){ +0x6B, 0x9D, 0x3D, 0xAD, 0x2E, 0x1B, 0x8C, 0x1C, 0x05, 0xB1, 0x98, 0x75, +0xB6, 0x65, 0x9F, 0x4D, 0xE2, 0x3C, 0x3B, 0x66, 0x7B, 0xF2, 0x97, 0xBA, +0x9A, 0xA4, 0x77, 0x40, 0x78, 0x71, 0x37, 0xD8, 0x96, 0xD5, 0x72, 0x4E, +0x4C, 0x70, 0xA8, 0x25, 0xF8, 0x72, 0xC9, 0xEA, 0x60, 0xD2, 0xED, 0xF5 +}, +.X = (unsigned char []){ +0xEC, 0x3A, 0x4E, 0x41, 0x5B, 0x4E, 0x19, 0xA4, 0x56, 0x86, 0x18, 0x02, +0x9F, 0x42, 0x7F, 0xA5, 0xDA, 0x9A, 0x8B, 0xC4, 0xAE, 0x92, 0xE0, 0x2E, +0x06, 0xAA, 0xE5, 0x28, 0x6B, 0x30, 0x0C, 0x64, 0xDE, 0xF8, 0xF0, 0xEA, +0x90, 0x55, 0x86, 0x60, 0x64, 0xA2, 0x54, 0x51, 0x54, 0x80, 0xBC, 0x13 +}, +.Y = (unsigned char []){ +0x80, 0x15, 0xD9, 0xB7, 0x2D, 0x7D, 0x57, 0x24, 0x4E, 0xA8, 0xEF, 0x9A, +0xC0, 0xC6, 0x21, 0x89, 0x67, 0x08, 0xA5, 0x93, 0x67, 0xF9, 0xDF, 0xB9, +0xF5, 0x4C, 0xA8, 0x4B, 0x3F, 0x1C, 0x9D, 0xB1, 0x28, 0x8B, 0x23, 0x1C, +0x3A, 0xE0, 0xD4, 0xFE, 0x73, 0x44, 0xFD, 0x25, 0x33, 0x26, 0x47, 0x20 +}, +}, +.hash = SHA512, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x37, 0x80, 0xC4, 0xF6, 0x7C, 0xB1, 0x55, 0x18, 0xB6, 0xAC, 0xAE, 0x34, +0xC9, 0xF8, 0x35, 0x68, 0xD2, 0xE1, 0x2E, 0x47, 0xDE, 0xAB, 0x6C, 0x50, +0xA4, 0xE4, 0xEE, 0x53, 0x19, 0xD1, 0xE8, 0xCE, 0x0E, 0x2C, 0xC8, 0xA1, +0x36, 0x03, 0x6D, 0xC4, 0xB9, 0xC0, 0x0E, 0x68, 0x88, 0xF6, 0x6B, 0x6C +}, +.r = (const unsigned char []){ +0xA0, 0xD5, 0xD0, 0x90, 0xC9, 0x98, 0x0F, 0xAF, 0x3C, 0x2C, 0xE5, 0x7B, +0x7A, 0xE9, 0x51, 0xD3, 0x19, 0x77, 0xDD, 0x11, 0xC7, 0x75, 0xD3, 0x14, +0xAF, 0x55, 0xF7, 0x6C, 0x67, 0x64, 0x47, 0xD0, 0x6F, 0xB6, 0x49, 0x5C, +0xD2, 0x1B, 0x4B, 0x6E, 0x34, 0x0F, 0xC2, 0x36, 0x58, 0x4F, 0xB2, 0x77 +}, +.s = (const unsigned char []){ +0x97, 0x69, 0x84, 0xE5, 0x9B, 0x4C, 0x77, 0xB0, 0xE8, 0xE4, 0x46, 0x0D, +0xCA, 0x3D, 0x9F, 0x20, 0xE0, 0x7B, 0x9B, 0xB1, 0xF6, 0x3B, 0xEE, 0xFA, +0xF5, 0x76, 0xF6, 0xB2, 0xE8, 0xB2, 0x24, 0x63, 0x4A, 0x20, 0x92, 0xCD, +0x37, 0x92, 0xE0, 0x15, 0x9A, 0xD9, 0xCE, 0xE3, 0x76, 0x59, 0xC7, 0x36 +}, +.siglen = 48, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA1, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x00, 0x89, 0xC0, 0x71, 0xB4, 0x19, 0xE1, 0xC2, 0x82, 0x09, 0x62, 0x32, +0x17, 0x87, 0x25, 0x84, 0x69, 0x51, 0x19, 0x58, 0xE8, 0x05, 0x82, 0xE9, +0x5D, 0x83, 0x78, 0xE0, 0xC2, 0xCC, 0xDB, 0x3C, 0xB4, 0x2B, 0xED, 0xE4, +0x2F, 0x50, 0xE3, 0xFA, 0x3C, 0x71, 0xF5, 0xA7, 0x67, 0x24, 0x28, 0x1D, +0x31, 0xD9, 0xC8, 0x9F, 0x0F, 0x91, 0xFC, 0x1B, 0xE4, 0x91, 0x8D, 0xB1, +0xC0, 0x3A, 0x58, 0x38, 0xD0, 0xF9 +}, +.r = (const unsigned char []){ +0x00, 0x34, 0x3B, 0x6E, 0xC4, 0x57, 0x28, 0x97, 0x5E, 0xA5, 0xCB, 0xA6, +0x65, 0x9B, 0xBB, 0x60, 0x62, 0xA5, 0xFF, 0x89, 0xEE, 0xA5, 0x8B, 0xE3, +0xC8, 0x0B, 0x61, 0x9F, 0x32, 0x2C, 0x87, 0x91, 0x0F, 0xE0, 0x92, 0xF7, +0xD4, 0x5B, 0xB0, 0xF8, 0xEE, 0xE0, 0x1E, 0xD3, 0xF2, 0x0B, 0xAB, 0xEC, +0x07, 0x9D, 0x20, 0x2A, 0xE6, 0x77, 0xB2, 0x43, 0xAB, 0x40, 0xB5, 0x43, +0x1D, 0x49, 0x7C, 0x55, 0xD7, 0x5D +}, +.s = (const unsigned char []){ +0x00, 0xE7, 0xB0, 0xE6, 0x75, 0xA9, 0xB2, 0x44, 0x13, 0xD4, 0x48, 0xB8, +0xCC, 0x11, 0x9D, 0x2B, 0xF7, 0xB2, 0xD2, 0xDF, 0x03, 0x27, 0x41, 0xC0, +0x96, 0x63, 0x4D, 0x6D, 0x65, 0xD0, 0xDB, 0xE3, 0xD5, 0x69, 0x46, 0x25, +0xFB, 0x9E, 0x81, 0x04, 0xD3, 0xB8, 0x42, 0xC1, 0xB0, 0xE2, 0xD0, 0xB9, +0x8B, 0xEA, 0x19, 0x34, 0x1E, 0x86, 0x76, 0xAE, 0xF6, 0x6A, 0xE4, 0xEB, +0xA3, 0xD5, 0x47, 0x5D, 0x5D, 0x16 +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA224, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x01, 0x21, 0x41, 0x5E, 0xC2, 0xCD, 0x77, 0x26, 0x33, 0x0A, 0x61, 0xF7, +0xF3, 0xFA, 0x5D, 0xE1, 0x4B, 0xE9, 0x43, 0x60, 0x19, 0xC4, 0xDB, 0x8C, +0xB4, 0x04, 0x1F, 0x3B, 0x54, 0xCF, 0x31, 0xBE, 0x04, 0x93, 0xEE, 0x3F, +0x42, 0x7F, 0xB9, 0x06, 0x39, 0x3D, 0x89, 0x5A, 0x19, 0xC9, 0x52, 0x3F, +0x3A, 0x1D, 0x54, 0xBB, 0x87, 0x02, 0xBD, 0x4A, 0xA9, 0xC9, 0x9D, 0xAB, +0x25, 0x97, 0xB9, 0x21, 0x13, 0xF3 +}, +.r = (const unsigned char []){ +0x01, 0x77, 0x63, 0x31, 0xCF, 0xCD, 0xF9, 0x27, 0xD6, 0x66, 0xE0, 0x32, +0xE0, 0x0C, 0xF7, 0x76, 0x18, 0x7B, 0xC9, 0xFD, 0xD8, 0xE6, 0x9D, 0x0D, +0xAB, 0xB4, 0x10, 0x9F, 0xFE, 0x1B, 0x5E, 0x2A, 0x30, 0x71, 0x5F, 0x4C, +0xC9, 0x23, 0xA4, 0xA5, 0xE9, 0x4D, 0x25, 0x03, 0xE9, 0xAC, 0xFE, 0xD9, +0x28, 0x57, 0xB7, 0xF3, 0x1D, 0x71, 0x52, 0xE0, 0xF8, 0xC0, 0x0C, 0x15, +0xFF, 0x3D, 0x87, 0xE2, 0xED, 0x2E +}, +.s = (const unsigned char []){ +0x00, 0x50, 0xCB, 0x52, 0x65, 0x41, 0x7F, 0xE2, 0x32, 0x0B, 0xBB, 0x5A, +0x12, 0x2B, 0x8E, 0x1A, 0x32, 0xBD, 0x69, 0x90, 0x89, 0x85, 0x11, 0x28, +0xE3, 0x60, 0xE6, 0x20, 0xA3, 0x0C, 0x7E, 0x17, 0xBA, 0x41, 0xA6, 0x66, +0xAF, 0x12, 0x6C, 0xE1, 0x00, 0xE5, 0x79, 0x9B, 0x15, 0x3B, 0x60, 0x52, +0x8D, 0x53, 0x00, 0xD0, 0x84, 0x89, 0xCA, 0x91, 0x78, 0xFB, 0x61, 0x0A, +0x20, 0x06, 0xC2, 0x54, 0xB4, 0x1F +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA256, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x00, 0xED, 0xF3, 0x8A, 0xFC, 0xAA, 0xEC, 0xAB, 0x43, 0x83, 0x35, 0x8B, +0x34, 0xD6, 0x7C, 0x9F, 0x22, 0x16, 0xC8, 0x38, 0x2A, 0xAE, 0xA4, 0x4A, +0x3D, 0xAD, 0x5F, 0xDC, 0x9C, 0x32, 0x57, 0x57, 0x61, 0x79, 0x3F, 0xEF, +0x24, 0xEB, 0x0F, 0xC2, 0x76, 0xDF, 0xC4, 0xF6, 0xE3, 0xEC, 0x47, 0x67, +0x52, 0xF0, 0x43, 0xCF, 0x01, 0x41, 0x53, 0x87, 0x47, 0x0B, 0xCB, 0xD8, +0x67, 0x8E, 0xD2, 0xC7, 0xE1, 0xA0 +}, +.r = (const unsigned char []){ +0x01, 0x51, 0x1B, 0xB4, 0xD6, 0x75, 0x11, 0x4F, 0xE2, 0x66, 0xFC, 0x43, +0x72, 0xB8, 0x76, 0x82, 0xBA, 0xEC, 0xC0, 0x1D, 0x3C, 0xC6, 0x2C, 0xF2, +0x30, 0x3C, 0x92, 0xB3, 0x52, 0x60, 0x12, 0x65, 0x9D, 0x16, 0x87, 0x6E, +0x25, 0xC7, 0xC1, 0xE5, 0x76, 0x48, 0xF2, 0x3B, 0x73, 0x56, 0x4D, 0x67, +0xF6, 0x1C, 0x6F, 0x14, 0xD5, 0x27, 0xD5, 0x49, 0x72, 0x81, 0x04, 0x21, +0xE7, 0xD8, 0x75, 0x89, 0xE1, 0xA7 +}, +.s = (const unsigned char []){ +0x00, 0x4A, 0x17, 0x11, 0x43, 0xA8, 0x31, 0x63, 0xD6, 0xDF, 0x46, 0x0A, +0xAF, 0x61, 0x52, 0x26, 0x95, 0xF2, 0x07, 0xA5, 0x8B, 0x95, 0xC0, 0x64, +0x4D, 0x87, 0xE5, 0x2A, 0xA1, 0xA3, 0x47, 0x91, 0x6E, 0x4F, 0x7A, 0x72, +0x93, 0x0B, 0x1B, 0xC0, 0x6D, 0xBE, 0x22, 0xCE, 0x3F, 0x58, 0x26, 0x4A, +0xFD, 0x23, 0x70, 0x4C, 0xBB, 0x63, 0xB2, 0x9B, 0x93, 0x1F, 0x7D, 0xE6, +0xC9, 0xD9, 0x49, 0xA7, 0xEC, 0xFC +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA384, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x01, 0x54, 0x6A, 0x10, 0x8B, 0xC2, 0x3A, 0x15, 0xD6, 0xF2, 0x18, 0x72, +0xF7, 0xDE, 0xD6, 0x61, 0xFA, 0x84, 0x31, 0xDD, 0xBD, 0x92, 0x2D, 0x0D, +0xCD, 0xB7, 0x7C, 0xC8, 0x78, 0xC8, 0x55, 0x3F, 0xFA, 0xD0, 0x64, 0xC9, +0x5A, 0x92, 0x0A, 0x75, 0x0A, 0xC9, 0x13, 0x7E, 0x52, 0x73, 0x90, 0xD2, +0xD9, 0x2F, 0x15, 0x3E, 0x66, 0x19, 0x69, 0x66, 0xEA, 0x55, 0x4D, 0x9A, +0xDF, 0xCB, 0x10, 0x9C, 0x42, 0x11 +}, +.r = (const unsigned char []){ +0x01, 0xEA, 0x84, 0x2A, 0x0E, 0x17, 0xD2, 0xDE, 0x4F, 0x92, 0xC1, 0x53, +0x15, 0xC6, 0x3D, 0xDF, 0x72, 0x68, 0x5C, 0x18, 0x19, 0x5C, 0x2B, 0xB9, +0x5E, 0x57, 0x2B, 0x9C, 0x51, 0x36, 0xCA, 0x4B, 0x4B, 0x57, 0x6A, 0xD7, +0x12, 0xA5, 0x2B, 0xE9, 0x73, 0x06, 0x27, 0xD1, 0x60, 0x54, 0xBA, 0x40, +0xCC, 0x0B, 0x8D, 0x3F, 0xF0, 0x35, 0xB1, 0x2A, 0xE7, 0x51, 0x68, 0x39, +0x7F, 0x5D, 0x50, 0xC6, 0x74, 0x51 +}, +.s = (const unsigned char []){ +0x01, 0xF2, 0x1A, 0x3C, 0xEE, 0x06, 0x6E, 0x19, 0x61, 0x02, 0x5F, 0xB0, +0x48, 0xBD, 0x5F, 0xE2, 0xB7, 0x92, 0x4D, 0x0C, 0xD7, 0x97, 0xBA, 0xBE, +0x0A, 0x83, 0xB6, 0x6F, 0x1E, 0x35, 0xEE, 0xAF, 0x5F, 0xDE, 0x14, 0x3F, +0xA8, 0x5D, 0xC3, 0x94, 0xA7, 0xDE, 0xE7, 0x66, 0x52, 0x33, 0x93, 0x78, +0x44, 0x84, 0xBD, 0xF3, 0xE0, 0x01, 0x14, 0xA1, 0xC8, 0x57, 0xCD, 0xE1, +0xAA, 0x20, 0x3D, 0xB6, 0x5D, 0x61 +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA512, +.msg = (unsigned char *)"sample", +.msglen = sizeof("sample") - 1, +.k = (const unsigned char []){ +0x01, 0xDA, 0xE2, 0xEA, 0x07, 0x1F, 0x81, 0x10, 0xDC, 0x26, 0x88, 0x2D, +0x4D, 0x5E, 0xAE, 0x06, 0x21, 0xA3, 0x25, 0x6F, 0xC8, 0x84, 0x7F, 0xB9, +0x02, 0x2E, 0x2B, 0x7D, 0x28, 0xE6, 0xF1, 0x01, 0x98, 0xB1, 0x57, 0x4F, +0xDD, 0x03, 0xA9, 0x05, 0x3C, 0x08, 0xA1, 0x85, 0x4A, 0x16, 0x8A, 0xA5, +0xA5, 0x74, 0x70, 0xEC, 0x97, 0xDD, 0x5C, 0xE0, 0x90, 0x12, 0x4E, 0xF5, +0x2A, 0x2F, 0x7E, 0xCB, 0xFF, 0xD3 +}, +.r = (const unsigned char []){ +0x00, 0xC3, 0x28, 0xFA, 0xFC, 0xBD, 0x79, 0xDD, 0x77, 0x85, 0x03, 0x70, +0xC4, 0x63, 0x25, 0xD9, 0x87, 0xCB, 0x52, 0x55, 0x69, 0xFB, 0x63, 0xC5, +0xD3, 0xBC, 0x53, 0x95, 0x0E, 0x6D, 0x4C, 0x5F, 0x17, 0x4E, 0x25, 0xA1, +0xEE, 0x90, 0x17, 0xB5, 0xD4, 0x50, 0x60, 0x6A, 0xDD, 0x15, 0x2B, 0x53, +0x49, 0x31, 0xD7, 0xD4, 0xE8, 0x45, 0x5C, 0xC9, 0x1F, 0x9B, 0x15, 0xBF, +0x05, 0xEC, 0x36, 0xE3, 0x77, 0xFA +}, +.s = (const unsigned char []){ +0x00, 0x61, 0x7C, 0xCE, 0x7C, 0xF5, 0x06, 0x48, 0x06, 0xC4, 0x67, 0xF6, +0x78, 0xD3, 0xB4, 0x08, 0x0D, 0x6F, 0x1C, 0xC5, 0x0A, 0xF2, 0x6C, 0xA2, +0x09, 0x41, 0x73, 0x08, 0x28, 0x1B, 0x68, 0xAF, 0x28, 0x26, 0x23, 0xEA, +0xA6, 0x3E, 0x5B, 0x5C, 0x07, 0x23, 0xD8, 0xB8, 0xC3, 0x7F, 0xF0, 0x77, +0x7B, 0x1A, 0x20, 0xF8, 0xCC, 0xB1, 0xDC, 0xCC, 0x43, 0x99, 0x7F, 0x1E, +0xE0, 0xE4, 0x4D, 0xA4, 0xA6, 0x7A +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA1, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x00, 0xBB, 0x9F, 0x2B, 0xF4, 0xFE, 0x10, 0x38, 0xCC, 0xF4, 0xDA, 0xBD, +0x71, 0x39, 0xA5, 0x6F, 0x6F, 0xD8, 0xBB, 0x13, 0x86, 0x56, 0x1B, 0xD3, +0xC6, 0xA4, 0xFC, 0x81, 0x8B, 0x20, 0xDF, 0x5D, 0xDB, 0xA8, 0x07, 0x95, +0xA9, 0x47, 0x10, 0x7A, 0x1A, 0xB9, 0xD1, 0x2D, 0xAA, 0x61, 0x5B, 0x1A, +0xDE, 0x4F, 0x7A, 0x9D, 0xC0, 0x5E, 0x8E, 0x63, 0x11, 0x15, 0x0F, 0x47, +0xF5, 0xC5, 0x7C, 0xE8, 0xB2, 0x22 +}, +.r = (const unsigned char []){ +0x01, 0x3B, 0xAD, 0x9F, 0x29, 0xAB, 0xE2, 0x0D, 0xE3, 0x7E, 0xBE, 0xB8, +0x23, 0xC2, 0x52, 0xCA, 0x0F, 0x63, 0x36, 0x12, 0x84, 0x01, 0x5A, 0x3B, +0xF4, 0x30, 0xA4, 0x6A, 0xAA, 0x80, 0xB8, 0x7B, 0x06, 0x93, 0xF0, 0x69, +0x4B, 0xD8, 0x8A, 0xFE, 0x4E, 0x66, 0x1F, 0xC3, 0x3B, 0x09, 0x4C, 0xD3, +0xB7, 0x96, 0x3B, 0xED, 0x5A, 0x72, 0x7E, 0xD8, 0xBD, 0x6A, 0x3A, 0x20, +0x2A, 0xBE, 0x00, 0x9D, 0x03, 0x67 +}, +.s = (const unsigned char []){ +0x01, 0xE9, 0xBB, 0x81, 0xFF, 0x79, 0x44, 0xCA, 0x40, 0x9A, 0xD1, 0x38, +0xDB, 0xBE, 0xE2, 0x28, 0xE1, 0xAF, 0xCC, 0x0C, 0x89, 0x0F, 0xC7, 0x8E, +0xC8, 0x60, 0x46, 0x39, 0xCB, 0x0D, 0xBD, 0xC9, 0x0F, 0x71, 0x7A, 0x99, +0xEA, 0xD9, 0xD2, 0x72, 0x85, 0x5D, 0x00, 0x16, 0x2E, 0xE9, 0x52, 0x75, +0x67, 0xDD, 0x6A, 0x92, 0xCB, 0xD6, 0x29, 0x80, 0x5C, 0x04, 0x45, 0x28, +0x2B, 0xBC, 0x91, 0x67, 0x97, 0xFF +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA224, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x00, 0x40, 0xD0, 0x9F, 0xCF, 0x3C, 0x8A, 0x5F, 0x62, 0xCF, 0x4F, 0xB2, +0x23, 0xCB, 0xBB, 0x2B, 0x99, 0x37, 0xF6, 0xB0, 0x57, 0x7C, 0x27, 0x02, +0x0A, 0x99, 0x60, 0x2C, 0x25, 0xA0, 0x11, 0x36, 0x98, 0x7E, 0x45, 0x29, +0x88, 0x78, 0x14, 0x84, 0xED, 0xBB, 0xCF, 0x1C, 0x47, 0xE5, 0x54, 0xE7, +0xFC, 0x90, 0x1B, 0xC3, 0x08, 0x5E, 0x52, 0x06, 0xD9, 0xF6, 0x19, 0xCF, +0xF0, 0x7E, 0x73, 0xD6, 0xF7, 0x06 +}, +.r = (const unsigned char []){ +0x01, 0xC7, 0xED, 0x90, 0x2E, 0x12, 0x3E, 0x68, 0x15, 0x54, 0x60, 0x65, +0xA2, 0xC4, 0xAF, 0x97, 0x7B, 0x22, 0xAA, 0x8E, 0xAD, 0xDB, 0x68, 0xB2, +0xC1, 0x11, 0x0E, 0x7E, 0xA4, 0x4D, 0x42, 0x08, 0x6B, 0xFE, 0x4A, 0x34, +0xB6, 0x7D, 0xDC, 0x0E, 0x17, 0xE9, 0x65, 0x36, 0xE3, 0x58, 0x21, 0x9B, +0x23, 0xA7, 0x06, 0xC6, 0xA6, 0xE1, 0x6B, 0xA7, 0x7B, 0x65, 0xE1, 0xC5, +0x95, 0xD4, 0x3C, 0xAE, 0x17, 0xFB +}, +.s = (const unsigned char []){ +0x01, 0x77, 0x33, 0x66, 0x76, 0x30, 0x4F, 0xCB, 0x34, 0x3C, 0xE0, 0x28, +0xB3, 0x8E, 0x7B, 0x4F, 0xBA, 0x76, 0xC1, 0xC1, 0xB2, 0x77, 0xDA, 0x18, +0xCA, 0xD2, 0xA8, 0x47, 0x8B, 0x2A, 0x9A, 0x9F, 0x5B, 0xEC, 0x0F, 0x3B, +0xA0, 0x4F, 0x35, 0xDB, 0x3E, 0x42, 0x63, 0x56, 0x9E, 0xC6, 0xAA, 0xDE, +0x8C, 0x92, 0x74, 0x6E, 0x4C, 0x82, 0xF8, 0x29, 0x9A, 0xE1, 0xB8, 0xF1, +0x73, 0x9F, 0x8F, 0xD5, 0x19, 0xA4 +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA256, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x00, 0x1D, 0xE7, 0x49, 0x55, 0xEF, 0xAA, 0xBC, 0x4C, 0x4F, 0x17, 0xF8, +0xE8, 0x4D, 0x88, 0x1D, 0x13, 0x10, 0xB5, 0x39, 0x2D, 0x77, 0x00, 0x27, +0x5F, 0x82, 0xF1, 0x45, 0xC6, 0x1E, 0x84, 0x38, 0x41, 0xAF, 0x09, 0x03, +0x5B, 0xF7, 0xA6, 0x21, 0x0F, 0x5A, 0x43, 0x1A, 0x6A, 0x9E, 0x81, 0xC9, +0x32, 0x33, 0x54, 0xA9, 0xE6, 0x91, 0x35, 0xD4, 0x4E, 0xBD, 0x2F, 0xCA, +0xA7, 0x73, 0x1B, 0x90, 0x92, 0x58 +}, +.r = (const unsigned char []){ +0x00, 0x0E, 0x87, 0x1C, 0x4A, 0x14, 0xF9, 0x93, 0xC6, 0xC7, 0x36, 0x95, +0x01, 0x90, 0x0C, 0x4B, 0xC1, 0xE9, 0xC7, 0xB0, 0xB4, 0xBA, 0x44, 0xE0, +0x48, 0x68, 0xB3, 0x0B, 0x41, 0xD8, 0x07, 0x10, 0x42, 0xEB, 0x28, 0xC4, +0xC2, 0x50, 0x41, 0x1D, 0x0C, 0xE0, 0x8C, 0xD1, 0x97, 0xE4, 0x18, 0x8E, +0xA4, 0x87, 0x6F, 0x27, 0x9F, 0x90, 0xB3, 0xD8, 0xD7, 0x4A, 0x3C, 0x76, +0xE6, 0xF1, 0xE4, 0x65, 0x6A, 0xA8 +}, +.s = (const unsigned char []){ +0x00, 0xCD, 0x52, 0xDB, 0xAA, 0x33, 0xB0, 0x63, 0xC3, 0xA6, 0xCD, 0x80, +0x58, 0xA1, 0xFB, 0x0A, 0x46, 0xA4, 0x75, 0x4B, 0x03, 0x4F, 0xCC, 0x64, +0x47, 0x66, 0xCA, 0x14, 0xDA, 0x8C, 0xA5, 0xCA, 0x9F, 0xDE, 0x00, 0xE8, +0x8C, 0x1A, 0xD6, 0x0C, 0xCB, 0xA7, 0x59, 0x02, 0x52, 0x99, 0x07, 0x9D, +0x7A, 0x42, 0x7E, 0xC3, 0xCC, 0x5B, 0x61, 0x9B, 0xFB, 0xC8, 0x28, 0xE7, +0x76, 0x9B, 0xCD, 0x69, 0x4E, 0x86 +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA384, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x01, 0xF1, 0xFC, 0x4A, 0x34, 0x9A, 0x7D, 0xA9, 0xA9, 0xE1, 0x16, 0xBF, +0xDD, 0x05, 0x5D, 0xC0, 0x8E, 0x78, 0x25, 0x2F, 0xF8, 0xE2, 0x3A, 0xC2, +0x76, 0xAC, 0x88, 0xB1, 0x77, 0x0A, 0xE0, 0xB5, 0xDC, 0xEB, 0x1E, 0xD1, +0x4A, 0x49, 0x16, 0xB7, 0x69, 0xA5, 0x23, 0xCE, 0x1E, 0x90, 0xBA, 0x22, +0x84, 0x6A, 0xF1, 0x1D, 0xF8, 0xB3, 0x00, 0xC3, 0x88, 0x18, 0xF7, 0x13, +0xDA, 0xDD, 0x85, 0xDE, 0x0C, 0x88 +}, +.r = (const unsigned char []){ +0x01, 0x4B, 0xEE, 0x21, 0xA1, 0x8B, 0x6D, 0x8B, 0x3C, 0x93, 0xFA, 0xB0, +0x8D, 0x43, 0xE7, 0x39, 0x70, 0x79, 0x53, 0x24, 0x4F, 0xDB, 0xE9, 0x24, +0xFA, 0x92, 0x6D, 0x76, 0x66, 0x9E, 0x7A, 0xC8, 0xC8, 0x9D, 0xF6, 0x2E, +0xD8, 0x97, 0x5C, 0x2D, 0x83, 0x97, 0xA6, 0x5A, 0x49, 0xDC, 0xC0, 0x9F, +0x6B, 0x0A, 0xC6, 0x22, 0x72, 0x74, 0x19, 0x24, 0xD4, 0x79, 0x35, 0x4D, +0x74, 0xFF, 0x60, 0x75, 0x57, 0x8C +}, +.s = (const unsigned char []){ +0x01, 0x33, 0x33, 0x08, 0x65, 0xC0, 0x67, 0xA0, 0xEA, 0xF7, 0x23, 0x62, +0xA6, 0x5E, 0x2D, 0x7B, 0xC4, 0xE4, 0x61, 0xE8, 0xC8, 0x99, 0x5C, 0x3B, +0x62, 0x26, 0xA2, 0x1B, 0xD1, 0xAA, 0x78, 0xF0, 0xED, 0x94, 0xFE, 0x53, +0x6A, 0x0D, 0xCA, 0x35, 0x53, 0x4F, 0x0C, 0xD1, 0x51, 0x0C, 0x41, 0x52, +0x5D, 0x16, 0x3F, 0xE9, 0xD7, 0x4D, 0x13, 0x48, 0x81, 0xE3, 0x51, 0x41, +0xED, 0x5E, 0x8E, 0x95, 0xB9, 0x79 +}, +.siglen = 66, +}, +{ +.key = &(ICA_EC_KEY){ +.nid = NID_secp521r1, +.D = (unsigned char []){ +0x00, 0xFA, 0xD0, 0x6D, 0xAA, 0x62, 0xBA, 0x3B, 0x25, 0xD2, 0xFB, 0x40, +0x13, 0x3D, 0xA7, 0x57, 0x20, 0x5D, 0xE6, 0x7F, 0x5B, 0xB0, 0x01, 0x8F, +0xEE, 0x8C, 0x86, 0xE1, 0xB6, 0x8C, 0x7E, 0x75, 0xCA, 0xA8, 0x96, 0xEB, +0x32, 0xF1, 0xF4, 0x7C, 0x70, 0x85, 0x58, 0x36, 0xA6, 0xD1, 0x6F, 0xCC, +0x14, 0x66, 0xF6, 0xD8, 0xFB, 0xEC, 0x67, 0xDB, 0x89, 0xEC, 0x0C, 0x08, +0xB0, 0xE9, 0x96, 0xB8, 0x35, 0x38 +}, +.X = (unsigned char []){ +0x01, 0x89, 0x45, 0x50, 0xD0, 0x78, 0x59, 0x32, 0xE0, 0x0E, 0xAA, 0x23, +0xB6, 0x94, 0xF2, 0x13, 0xF8, 0xC3, 0x12, 0x1F, 0x86, 0xDC, 0x97, 0xA0, +0x4E, 0x5A, 0x71, 0x67, 0xDB, 0x4E, 0x5B, 0xCD, 0x37, 0x11, 0x23, 0xD4, +0x6E, 0x45, 0xDB, 0x6B, 0x5D, 0x53, 0x70, 0xA7, 0xF2, 0x0F, 0xB6, 0x33, +0x15, 0x5D, 0x38, 0xFF, 0xA1, 0x6D, 0x2B, 0xD7, 0x61, 0xDC, 0xAC, 0x47, +0x4B, 0x9A, 0x2F, 0x50, 0x23, 0xA4 +}, +.Y = (unsigned char []){ +0x00, 0x49, 0x31, 0x01, 0xC9, 0x62, 0xCD, 0x4D, 0x2F, 0xDD, 0xF7, 0x82, +0x28, 0x5E, 0x64, 0x58, 0x41, 0x39, 0xC2, 0xF9, 0x1B, 0x47, 0xF8, 0x7F, +0xF8, 0x23, 0x54, 0xD6, 0x63, 0x0F, 0x74, 0x6A, 0x28, 0xA0, 0xDB, 0x25, +0x74, 0x1B, 0x5B, 0x34, 0xA8, 0x28, 0x00, 0x8B, 0x22, 0xAC, 0xC2, 0x3F, +0x92, 0x4F, 0xAA, 0xFB, 0xD4, 0xD3, 0x3F, 0x81, 0xEA, 0x66, 0x95, 0x6D, +0xFE, 0xAA, 0x2B, 0xFD, 0xFC, 0xF5 +}, +}, +.hash = SHA512, +.msg = (unsigned char *)"test", +.msglen = sizeof("test") - 1, +.k = (const unsigned char []){ +0x01, 0x62, 0x00, 0x81, 0x30, 0x20, 0xEC, 0x98, 0x68, 0x63, 0xBE, 0xDF, +0xC1, 0xB1, 0x21, 0xF6, 0x05, 0xC1, 0x21, 0x56, 0x45, 0x01, 0x8A, 0xEA, +0x1A, 0x7B, 0x21, 0x5A, 0x56, 0x4D, 0xE9, 0xEB, 0x1B, 0x38, 0xA6, 0x7A, +0xA1, 0x12, 0x8B, 0x80, 0xCE, 0x39, 0x1C, 0x4F, 0xB7, 0x11, 0x87, 0x65, +0x4A, 0xAA, 0x34, 0x31, 0x02, 0x7B, 0xFC, 0x7F, 0x39, 0x57, 0x66, 0xCA, +0x98, 0x8C, 0x96, 0x4D, 0xC5, 0x6D +}, +.r = (const unsigned char []){ +0x01, 0x3E, 0x99, 0x02, 0x0A, 0xBF, 0x5C, 0xEE, 0x75, 0x25, 0xD1, 0x6B, +0x69, 0xB2, 0x29, 0x65, 0x2A, 0xB6, 0xBD, 0xF2, 0xAF, 0xFC, 0xAE, 0xF3, +0x87, 0x73, 0xB4, 0xB7, 0xD0, 0x87, 0x25, 0xF1, 0x0C, 0xDB, 0x93, 0x48, +0x2F, 0xDC, 0xC5, 0x4E, 0xDC, 0xEE, 0x91, 0xEC, 0xA4, 0x16, 0x6B, 0x2A, +0x7C, 0x62, 0x65, 0xEF, 0x0C, 0xE2, 0xBD, 0x70, 0x51, 0xB7, 0xCE, 0xF9, +0x45, 0xBA, 0xBD, 0x47, 0xEE, 0x6D +}, +.s = (const unsigned char []){ +0x01, 0xFB, 0xD0, 0x01, 0x3C, 0x67, 0x4A, 0xA7, 0x9C, 0xB3, 0x98, 0x49, +0x52, 0x79, 0x16, 0xCE, 0x30, 0x1C, 0x66, 0xEA, 0x7C, 0xE8, 0xB8, 0x06, +0x82, 0x78, 0x6A, 0xD6, 0x0F, 0x98, 0xF7, 0xE7, 0x8A, 0x19, 0xCA, 0x69, +0xEF, 0xF5, 0xC5, 0x74, 0x00, 0xE3, 0xB3, 0xA0, 0xAD, 0x66, 0xCE, 0x09, +0x78, 0x21, 0x4D, 0x13, 0xBA, 0xF4, 0xE9, 0xAC, 0x60, 0x75, 0x2F, 0x7B, +0x15, 0x5E, 0x2D, 0xE4, 0xDC, 0xE3 +}, +.siglen = 66, +}, + +}; + +const struct scalar_mul_tv SCALAR_MUL_TV[] = { +{ +.curve_nid = NID_X9_62_prime256v1, +.len = 32, +.scalar = (unsigned char[]){ +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 +}, +.x = (unsigned char[]){ +0x6B, 0x17, 0xD1, 0xF2, 0xE1, 0x2C, 0x42, 0x47, 0xF8, 0xBC, 0xE6, 0xE5, +0x63, 0xA4, 0x40, 0xF2, 0x77, 0x03, 0x7D, 0x81, 0x2D, 0xEB, 0x33, 0xA0, +0xF4, 0xA1, 0x39, 0x45, 0xD8, 0x98, 0xC2, 0x96 +}, +.y = (unsigned char[]){ +0x4F, 0xE3, 0x42, 0xE2, 0xFE, 0x1A, 0x7F, 0x9B, 0x8E, 0xE7, 0xEB, 0x4A, +0x7C, 0x0F, 0x9E, 0x16, 0x2B, 0xCE, 0x33, 0x57, 0x6B, 0x31, 0x5E, 0xCE, +0xCB, 0xB6, 0x40, 0x68, 0x37, 0xBF, 0x51, 0xF5 +}, +}, +{ +.curve_nid = NID_X9_62_prime256v1, +.len = 32, +.scalar = (unsigned char[]){ +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09 +}, +.x = (unsigned char[]){ +0xEA, 0x68, 0xD7, 0xB6, 0xFE, 0xDF, 0x0B, 0x71, 0x87, 0x89, 0x38, 0xD5, +0x1D, 0x71, 0xF8, 0x72, 0x9E, 0x0A, 0xCB, 0x8C, 0x2C, 0x6D, 0xF8, 0xB3, +0xD7, 0x9E, 0x8A, 0x4B, 0x90, 0x94, 0x9E, 0xE0 +}, +.y = (unsigned char[]){ +0x2A, 0x27, 0x44, 0xC9, 0x72, 0xC9, 0xFC, 0xE7, 0x87, 0x01, 0x4A, 0x96, +0x4A, 0x8E, 0xA0, 0xC8, 0x4D, 0x71, 0x4F, 0xEA, 0xA4, 0xDE, 0x82, 0x3F, +0xE8, 0x5A, 0x22, 0x4A, 0x4D, 0xD0, 0x48, 0xFA +}, +}, +{ +.curve_nid = NID_X9_62_prime256v1, +.len = 32, +.scalar = (unsigned char[]){ +0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, +0xff, 0xff, 0xff, 0xff, 0xbc, 0xe6, 0xfa, 0xad, 0xa7, 0x17, 0x9e, 0x84, +0xf3, 0xb9, 0xca, 0xc2, 0xfc, 0x63, 0x25, 0x50 +}, +.x = (unsigned char[]){ +0x6B, 0x17, 0xD1, 0xF2, 0xE1, 0x2C, 0x42, 0x47, 0xF8, 0xBC, 0xE6, 0xE5, +0x63, 0xA4, 0x40, 0xF2, 0x77, 0x03, 0x7D, 0x81, 0x2D, 0xEB, 0x33, 0xA0, +0xF4, 0xA1, 0x39, 0x45, 0xD8, 0x98, 0xC2, 0x96 +}, +.y = (unsigned char[]){ +0xB0, 0x1C, 0xBD, 0x1C, 0x01, 0xE5, 0x80, 0x65, 0x71, 0x18, 0x14, 0xB5, +0x83, 0xF0, 0x61, 0xE9, 0xD4, 0x31, 0xCC, 0xA9, 0x94, 0xCE, 0xA1, 0x31, +0x34, 0x49, 0xBF, 0x97, 0xC8, 0x40, 0xAE, 0x0A +}, +}, +{ +.curve_nid = NID_secp384r1, +.len = 48, +.scalar = (unsigned char[]){ +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 +}, +.x = (unsigned char[]){ +0xAA, 0x87, 0xCA, 0x22, 0xBE, 0x8B, 0x05, 0x37, 0x8E, 0xB1, 0xC7, 0x1E, +0xF3, 0x20, 0xAD, 0x74, 0x6E, 0x1D, 0x3B, 0x62, 0x8B, 0xA7, 0x9B, 0x98, +0x59, 0xF7, 0x41, 0xE0, 0x82, 0x54, 0x2A, 0x38, 0x55, 0x02, 0xF2, 0x5D, +0xBF, 0x55, 0x29, 0x6C, 0x3A, 0x54, 0x5E, 0x38, 0x72, 0x76, 0x0A, 0xB7 +}, +.y = (unsigned char[]){ +0x36, 0x17, 0xDE, 0x4A, 0x96, 0x26, 0x2C, 0x6F, 0x5D, 0x9E, 0x98, 0xBF, +0x92, 0x92, 0xDC, 0x29, 0xF8, 0xF4, 0x1D, 0xBD, 0x28, 0x9A, 0x14, 0x7C, +0xE9, 0xDA, 0x31, 0x13, 0xB5, 0xF0, 0xB8, 0xC0, 0x0A, 0x60, 0xB1, 0xCE, +0x1D, 0x7E, 0x81, 0x9D, 0x7A, 0x43, 0x1D, 0x7C, 0x90, 0xEA, 0x0E, 0x5F +}, +}, +{ +.curve_nid = NID_secp384r1, +.len = 48, +.scalar = (unsigned char[]){ +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09 +}, +.x = (unsigned char[]){ +0x8F, 0x0A, 0x39, 0xA4, 0x04, 0x9B, 0xCB, 0x3E, 0xF1, 0xBF, 0x29, 0xB8, +0xB0, 0x25, 0xB7, 0x8F, 0x22, 0x16, 0xF7, 0x29, 0x1E, 0x6F, 0xD3, 0xBA, +0xC6, 0xCB, 0x1E, 0xE2, 0x85, 0xFB, 0x6E, 0x21, 0xC3, 0x88, 0x52, 0x8B, +0xFE, 0xE2, 0xB9, 0x53, 0x5C, 0x55, 0xE4, 0x46, 0x10, 0x79, 0x11, 0x8B +}, +.y = (unsigned char[]){ +0x62, 0xC7, 0x7E, 0x14, 0x38, 0xB6, 0x01, 0xD6, 0x45, 0x2C, 0x4A, 0x53, +0x22, 0xC3, 0xA9, 0x79, 0x9A, 0x9B, 0x3D, 0x7C, 0xA3, 0xC4, 0x00, 0xC6, +0xB7, 0x67, 0x88, 0x54, 0xAE, 0xD9, 0xB3, 0x02, 0x9E, 0x74, 0x3E, 0xFE, +0xDF, 0xD5, 0x1B, 0x68, 0x26, 0x2D, 0xA4, 0xF9, 0xAC, 0x66, 0x4A, 0xF8 +}, +}, +{ +.curve_nid = NID_secp384r1, +.len = 48, +.scalar = (unsigned char[]){ +0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +0xc7, 0x63, 0x4d, 0x81, 0xf4, 0x37, 0x2d, 0xdf, 0x58, 0x1a, 0x0d, 0xb2, +0x48, 0xb0, 0xa7, 0x7a, 0xec, 0xec, 0x19, 0x6a, 0xcc, 0xc5, 0x29, 0x72 +}, +.x = (unsigned char[]){ +0xAA, 0x87, 0xCA, 0x22, 0xBE, 0x8B, 0x05, 0x37, 0x8E, 0xB1, 0xC7, 0x1E, +0xF3, 0x20, 0xAD, 0x74, 0x6E, 0x1D, 0x3B, 0x62, 0x8B, 0xA7, 0x9B, 0x98, +0x59, 0xF7, 0x41, 0xE0, 0x82, 0x54, 0x2A, 0x38, 0x55, 0x02, 0xF2, 0x5D, +0xBF, 0x55, 0x29, 0x6C, 0x3A, 0x54, 0x5E, 0x38, 0x72, 0x76, 0x0A, 0xB7 +}, +.y = (unsigned char[]){ +0xC9, 0xE8, 0x21, 0xB5, 0x69, 0xD9, 0xD3, 0x90, 0xA2, 0x61, 0x67, 0x40, +0x6D, 0x6D, 0x23, 0xD6, 0x07, 0x0B, 0xE2, 0x42, 0xD7, 0x65, 0xEB, 0x83, +0x16, 0x25, 0xCE, 0xEC, 0x4A, 0x0F, 0x47, 0x3E, 0xF5, 0x9F, 0x4E, 0x30, +0xE2, 0x81, 0x7E, 0x62, 0x85, 0xBC, 0xE2, 0x84, 0x6F, 0x15, 0xF1, 0xA0 +}, +}, +{ +.curve_nid = NID_secp521r1, +.len = 66, +.scalar = (unsigned char[]){ +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x01 +}, +.x = (unsigned char[]){ +0x00, 0xC6, 0x85, 0x8E, 0x06, 0xB7, 0x04, 0x04, 0xE9, 0xCD, 0x9E, 0x3E, +0xCB, 0x66, 0x23, 0x95, 0xB4, 0x42, 0x9C, 0x64, 0x81, 0x39, 0x05, 0x3F, +0xB5, 0x21, 0xF8, 0x28, 0xAF, 0x60, 0x6B, 0x4D, 0x3D, 0xBA, 0xA1, 0x4B, +0x5E, 0x77, 0xEF, 0xE7, 0x59, 0x28, 0xFE, 0x1D, 0xC1, 0x27, 0xA2, 0xFF, +0xA8, 0xDE, 0x33, 0x48, 0xB3, 0xC1, 0x85, 0x6A, 0x42, 0x9B, 0xF9, 0x7E, +0x7E, 0x31, 0xC2, 0xE5, 0xBD, 0x66 +}, +.y = (unsigned char[]){ +0x01, 0x18, 0x39, 0x29, 0x6A, 0x78, 0x9A, 0x3B, 0xC0, 0x04, 0x5C, 0x8A, +0x5F, 0xB4, 0x2C, 0x7D, 0x1B, 0xD9, 0x98, 0xF5, 0x44, 0x49, 0x57, 0x9B, +0x44, 0x68, 0x17, 0xAF, 0xBD, 0x17, 0x27, 0x3E, 0x66, 0x2C, 0x97, 0xEE, +0x72, 0x99, 0x5E, 0xF4, 0x26, 0x40, 0xC5, 0x50, 0xB9, 0x01, 0x3F, 0xAD, +0x07, 0x61, 0x35, 0x3C, 0x70, 0x86, 0xA2, 0x72, 0xC2, 0x40, 0x88, 0xBE, +0x94, 0x76, 0x9F, 0xD1, 0x66, 0x50 +}, +}, +{ +.curve_nid = NID_secp521r1, +.len = 66, +.scalar = (unsigned char[]){ +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x09 +}, +.x = (unsigned char[]){ +0x01, 0x58, 0x53, 0x89, 0xE3, 0x59, 0xE1, 0xE2, 0x18, 0x26, 0xA2, 0xF5, +0xBF, 0x15, 0x71, 0x56, 0xD4, 0x88, 0xED, 0x34, 0x54, 0x1B, 0x98, 0x87, +0x46, 0x99, 0x2C, 0x4A, 0xB1, 0x45, 0xB8, 0xC6, 0xB6, 0x65, 0x74, 0x29, +0xE1, 0x39, 0x61, 0x34, 0xDA, 0x35, 0xF3, 0xC5, 0x56, 0xDF, 0x72, 0x5A, +0x31, 0x8F, 0x4F, 0x50, 0xBA, 0xBD, 0x85, 0xCD, 0x28, 0x66, 0x1F, 0x45, +0x62, 0x79, 0x67, 0xCB, 0xE2, 0x07 +}, +.y = (unsigned char[]){ +0x00, 0x2A, 0x2E, 0x61, 0x8C, 0x9A, 0x8A, 0xED, 0xF3, 0x9F, 0x0B, 0x55, +0x55, 0x7A, 0x27, 0xAE, 0x93, 0x8E, 0x30, 0x88, 0xA6, 0x54, 0xEE, 0x1C, +0xEB, 0xB6, 0xC8, 0x25, 0xBA, 0x26, 0x3D, 0xDB, 0x44, 0x6E, 0x0D, 0x69, +0xE5, 0x75, 0x60, 0x57, 0xAC, 0x84, 0x0F, 0xF5, 0x6E, 0xCF, 0x4A, 0xBF, +0xD8, 0x7D, 0x73, 0x6C, 0x2A, 0xE9, 0x28, 0x88, 0x0F, 0x34, 0x3A, 0xA0, +0xEA, 0x86, 0xB9, 0xAD, 0x2A, 0x4E +}, +}, +{ +.curve_nid = NID_secp521r1, +.len = 66, +.scalar = (unsigned char[]){ +0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x51, 0x86, +0x87, 0x83, 0xbf, 0x2f, 0x96, 0x6b, 0x7f, 0xcc, 0x01, 0x48, 0xf7, 0x09, +0xa5, 0xd0, 0x3b, 0xb5, 0xc9, 0xb8, 0x89, 0x9c, 0x47, 0xae, 0xbb, 0x6f, +0xb7, 0x1e, 0x91, 0x38, 0x64, 0x08 +}, +.x = (unsigned char[]){ +0x00, 0xC6, 0x85, 0x8E, 0x06, 0xB7, 0x04, 0x04, 0xE9, 0xCD, 0x9E, 0x3E, +0xCB, 0x66, 0x23, 0x95, 0xB4, 0x42, 0x9C, 0x64, 0x81, 0x39, 0x05, 0x3F, +0xB5, 0x21, 0xF8, 0x28, 0xAF, 0x60, 0x6B, 0x4D, 0x3D, 0xBA, 0xA1, 0x4B, +0x5E, 0x77, 0xEF, 0xE7, 0x59, 0x28, 0xFE, 0x1D, 0xC1, 0x27, 0xA2, 0xFF, +0xA8, 0xDE, 0x33, 0x48, 0xB3, 0xC1, 0x85, 0x6A, 0x42, 0x9B, 0xF9, 0x7E, +0x7E, 0x31, 0xC2, 0xE5, 0xBD, 0x66 +}, +.y = (unsigned char[]){ +0x00, 0xE7, 0xC6, 0xD6, 0x95, 0x87, 0x65, 0xC4, 0x3F, 0xFB, 0xA3, 0x75, +0xA0, 0x4B, 0xD3, 0x82, 0xE4, 0x26, 0x67, 0x0A, 0xBB, 0xB6, 0xA8, 0x64, +0xBB, 0x97, 0xE8, 0x50, 0x42, 0xE8, 0xD8, 0xC1, 0x99, 0xD3, 0x68, 0x11, +0x8D, 0x66, 0xA1, 0x0B, 0xD9, 0xBF, 0x3A, 0xAF, 0x46, 0xFE, 0xC0, 0x52, +0xF8, 0x9E, 0xCA, 0xC3, 0x8F, 0x79, 0x5D, 0x8D, 0x3D, 0xBF, 0x77, 0x41, +0x6B, 0x89, 0x60, 0x2E, 0x99, 0xAF +}, +}, +}; +#endif /* ICA_INTERNAL_TEST_EC */ + const struct drbg_sha512_tv DRBG_SHA512_TV[] = { { .no_reseed = true, @@ -3907,5 +5534,10 @@ const size_t SHA384_TV_LEN = sizeof(SHA384_TV) / sizeof(SHA384_TV[0]); const size_t SHA512_TV_LEN = sizeof(SHA512_TV) / sizeof(SHA512_TV[0]); #endif /* ICA_FIPS */ +#ifdef ICA_INTERNAL_TEST_EC +const size_t ECDSA_TV_LEN = sizeof(ECDSA_TV) / sizeof(ECDSA_TV[0]); +const size_t SCALAR_MUL_TV_LEN + = sizeof(SCALAR_MUL_TV) / sizeof(SCALAR_MUL_TV[0]); +#endif /* ICA_INTERNAL_TEST_EC */ const size_t DRBG_SHA512_TV_LEN = sizeof(DRBG_SHA512_TV) / sizeof(DRBG_SHA512_TV[0]); diff -Nru libica-3.4.0/test/icastats_test.c libica-3.5.0/test/icastats_test.c --- libica-3.4.0/test/icastats_test.c 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/test/icastats_test.c 2019-04-23 16:02:53.000000000 +0000 @@ -46,6 +46,8 @@ int main (int argc, char **argv) { int rc = 0; + int value; + const char *ptr; ica_adapter_handle_t adapter_handle; unsigned char *cmac; @@ -54,6 +56,11 @@ set_verbosity(argc, argv); + /* Skip test if stats are not counted. */ + ptr = getenv(ICA_STATS_ENV); + if (ptr && sscanf(ptr, "%i", &value) == 1 && !value) + exit(TEST_SKIP); + if((cmac = malloc(AES_CIPHER_BLOCK*sizeof(char))) == NULL){ perror("Error in malloc: "); exit(TEST_FAIL); diff -Nru libica-3.4.0/test/Makefile.am libica-3.5.0/test/Makefile.am --- libica-3.4.0/test/Makefile.am 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/test/Makefile.am 2019-04-23 16:02:53.000000000 +0000 @@ -56,6 +56,11 @@ ecdsa2_test.sh \ mp_test +if ICA_INTERNAL_TESTS +TESTS += \ +${top_builddir}/src/internal_tests/ec_internal_test +endif + TEST_EXTENSIONS = .sh .pl TESTS_ENVIRONMENT = export LD_LIBRARY_PATH=${builddir}/../src/.libs/ \ PATH=${builddir}/../src/:$$PATH \ diff -Nru libica-3.4.0/test/testcase.h libica-3.5.0/test/testcase.h --- libica-3.4.0/test/testcase.h 2018-11-15 15:44:38.000000000 +0000 +++ libica-3.5.0/test/testcase.h 2019-04-23 16:02:53.000000000 +0000 @@ -135,6 +135,7 @@ return rc; } +#ifndef ICA_INTERNAL_TEST static inline unsigned int getenv_icapath() { @@ -155,15 +156,6 @@ return icapath; } -static inline int -is_supported_openssl_curve(int nid) -{ - EC_GROUP *ptr = EC_GROUP_new_by_curve_name(nid); - if (ptr) - EC_GROUP_free(ptr); - return ptr ? 1 : 0; -} - static inline void toggle_env_icapath() { @@ -179,4 +171,14 @@ unsetenv("ICAPATH"); } +static inline int +is_supported_openssl_curve(int nid) +{ + EC_GROUP *ptr = EC_GROUP_new_by_curve_name(nid); + if (ptr) + EC_GROUP_free(ptr); + return ptr ? 1 : 0; +} +#endif + #endif /* TESTCASE_H */