app/test/test_cryptodev_ecdsa_test_vectors.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright (C) 2020 Marvell International Ltd.
   3  */
   4
   5 #ifndef __TEST_CRYPTODEV_ECDSA_TEST_VECTORS_H__
   6 #define __TEST_CRYPTODEV_ECDSA_TEST_VECTORS_H__
   7
   8 #include "rte_crypto_asym.h"
   9
  10 /* EC curve id */
  11 enum curve {
  12         SECP192R1,
  13         SECP224R1,
  14         SECP256R1,
  15         SECP384R1,
  16         SECP521R1,
  17         END_OF_CURVE_LIST
  18 };
  19
  20 const char *curve[] = {"SECP192R1",
  21                        "SECP224R1",
  22                        "SECP256R1",
  23                        "SECP384R1",
  24                        "SECP521R1"};
  25
  26 struct crypto_testsuite_ecdsa_params {
  27         rte_crypto_param pubkey_qx;
  28         rte_crypto_param pubkey_qy;
  29         rte_crypto_param scalar;
  30         rte_crypto_param digest;
  31         rte_crypto_param sign_r;
  32         rte_crypto_param sign_s;
  33         rte_crypto_param pkey;
  34         int curve;
  35 };
  36
  37 /*
  38  * Test vector reference:
  39  * https://csrc.nist.gov/CSRC/media/Projects/
  40  * Cryptographic-Algorithm-Validation-Program/
  41  * documents/components/186-3ecdsasiggencomponenttestvectors.zip
  42  */
  43
  44 /* SECP192R1 (P-192 NIST) test vector */
  45
  46 static uint8_t digest_secp192r1[] = {
  47         0x5a, 0xe8, 0x31, 0x7d, 0x34, 0xd1, 0xe5, 0x95,
  48         0xe3, 0xfa, 0x72, 0x47, 0xdb, 0x80, 0xc0, 0xaf,
  49         0x43, 0x20, 0xcc, 0xe1, 0x11, 0x6d, 0xe1, 0x87,
  50         0xf8, 0xf7, 0xe2, 0xe0, 0x99, 0xc0, 0xd8, 0xd0
  51 };
  52
  53 static uint8_t pkey_secp192r1[] = {
  54         0x24, 0xed, 0xd2, 0x2f, 0x7d, 0xdd, 0x6f, 0xa5,
  55         0xbc, 0x61, 0xfc, 0x06, 0x53, 0x47, 0x9a, 0xa4,
  56         0x08, 0x09, 0xef, 0x86, 0x5c, 0xf2, 0x7a, 0x47
  57 };
  58
  59 static uint8_t scalar_secp192r1[] = {
  60         0xa5, 0xc8, 0x17, 0xa2, 0x36, 0xa5, 0xf7, 0xfa,
  61         0xa3, 0x29, 0xb8, 0xec, 0xc3, 0xc5, 0x96, 0x68,
  62         0x7c, 0x71, 0xaa, 0xaf, 0x86, 0xc7, 0x70, 0x3e
  63 };
  64
  65 static uint8_t pubkey_qx_secp192r1[] = {
  66         0x9b, 0xf1, 0x2d, 0x71, 0x74, 0xb7, 0x70, 0x8a,
  67         0x07, 0x6a, 0x38, 0xbc, 0x80, 0xaa, 0x28, 0x66,
  68         0x2f, 0x25, 0x1e, 0x2e, 0xd8, 0xd4, 0x14, 0xdc
  69 };
  70
  71 static uint8_t pubkey_qy_secp192r1[] = {
  72         0x48, 0x54, 0xc8, 0xd0, 0x7d, 0xfc, 0x08, 0x82,
  73         0x4e, 0x9e, 0x47, 0x1c, 0xa2, 0xfe, 0xdc, 0xfc,
  74         0xff, 0x3d, 0xdc, 0xb0, 0x11, 0x57, 0x34, 0x98
  75 };
  76
  77 static uint8_t sign_secp192r1_r[] = {
  78         0x35, 0x4a, 0xba, 0xec, 0xf4, 0x36, 0x1f, 0xea,
  79         0x90, 0xc2, 0x9b, 0x91, 0x99, 0x88, 0x2e, 0xdf,
  80         0x85, 0x73, 0xe6, 0x86, 0xa8, 0x13, 0xef, 0xf8
  81 };
  82
  83 static uint8_t sign_secp192r1_s[] = {
  84         0x80, 0xf5, 0x00, 0x00, 0xac, 0x86, 0x11, 0x1c,
  85         0x9b, 0x30, 0x47, 0x38, 0x5a, 0x15, 0xd7, 0x8e,
  86         0x63, 0x2c, 0x58, 0xb7, 0x94, 0x9e, 0x82, 0xc1
  87 };
  88
  89 /** ECDSA SECP192R1 elliptic curve param */
  90
  91 struct crypto_testsuite_ecdsa_params ecdsa_param_secp192r1 = {
  92         .pubkey_qx = {
  93                 .data = pubkey_qx_secp192r1,
  94                 .length = sizeof(pubkey_qx_secp192r1),
  95         },
  96         .pubkey_qy = {
  97                 .data = pubkey_qy_secp192r1,
  98                 .length = sizeof(pubkey_qy_secp192r1),
  99         },
 100         .scalar = {
 101                 .data = scalar_secp192r1,
 102                 .length = sizeof(scalar_secp192r1),
 103         },
 104         .digest = {
 105                 .data = digest_secp192r1,
 106                 .length = sizeof(digest_secp192r1),
 107         },
 108         .sign_r = {
 109                 .data = sign_secp192r1_r,
 110                 .length = sizeof(sign_secp192r1_r),
 111         },
 112         .sign_s = {
 113                 .data = sign_secp192r1_s,
 114                 .length = sizeof(sign_secp192r1_s),
 115         },
 116         .pkey = {
 117                 .data = pkey_secp192r1,
 118                 .length = sizeof(pkey_secp192r1),
 119         },
 120         .curve = RTE_CRYPTO_EC_GROUP_SECP192R1
 121 };
 122
 123 /* SECP224R1 (P-224 NIST) test vectors */
 124
 125 static uint8_t digest_secp224r1[] = {
 126         0x00, 0xc6, 0xfc, 0x53, 0xc1, 0x98, 0x6d, 0x19,
 127         0xa8, 0xa8, 0xb5, 0x80, 0xee, 0x55, 0x3d, 0xc1,
 128         0x24, 0x07, 0x45, 0xd7, 0x60, 0x64, 0x7d, 0x1c,
 129         0x0a, 0xdf, 0x44, 0x2c, 0x13, 0x3c, 0x7f, 0x56
 130 };
 131
 132 static uint8_t pkey_secp224r1[] = {
 133         0x88, 0x8f, 0xc9, 0x92, 0x89, 0x3b, 0xdd, 0x8a,
 134         0xa0, 0x2c, 0x80, 0x76, 0x88, 0x32, 0x60, 0x5d,
 135         0x02, 0x0b, 0x81, 0xae, 0x0b, 0x25, 0x47, 0x41,
 136         0x54, 0xec, 0x89, 0xaa
 137 };
 138
 139 static uint8_t scalar_secp224r1[] = {
 140         0x06, 0xf7, 0xa5, 0x60, 0x07, 0x82, 0x54, 0x33,
 141         0xc4, 0xc6, 0x11, 0x53, 0xdf, 0x1a, 0x13, 0x5e,
 142         0xee, 0x2f, 0x38, 0xec, 0x68, 0x7b, 0x49, 0x2e,
 143         0xd4, 0x0d, 0x9c, 0x90
 144 };
 145
 146 static uint8_t pubkey_qx_secp224r1[] = {
 147         0x4c, 0x74, 0x1e, 0x4d, 0x20, 0x10, 0x36, 0x70,
 148         0xb7, 0x16, 0x1a, 0xe7, 0x22, 0x71, 0x08, 0x21,
 149         0x55, 0x83, 0x84, 0x18, 0x08, 0x43, 0x35, 0x33,
 150         0x8a, 0xc3, 0x8f, 0xa4
 151 };
 152
 153 static uint8_t pubkey_qy_secp224r1[] = {
 154         0xdb, 0x79, 0x19, 0x15, 0x1a, 0xc2, 0x85, 0x87,
 155         0xb7, 0x2b, 0xad, 0x7a, 0xb1, 0x80, 0xec, 0x8e,
 156         0x95, 0xab, 0x9e, 0x2c, 0x8d, 0x81, 0xd9, 0xb9,
 157         0xd7, 0xe2, 0xe3, 0x83
 158 };
 159
 160 static uint8_t sign_secp224r1_r[] = {
 161         0x09, 0x09, 0xc9, 0xb9, 0xca, 0xe8, 0xd2, 0x79,
 162         0x0e, 0x29, 0xdb, 0x6a, 0xfd, 0xb4, 0x5c, 0x04,
 163         0xf5, 0xb0, 0x72, 0xc4, 0xc2, 0x04, 0x10, 0xc7,
 164         0xdc, 0x9b, 0x67, 0x72
 165 };
 166
 167 static uint8_t sign_secp224r1_s[] = {
 168         0x29, 0x8f, 0x4f, 0xca, 0xe1, 0xfe, 0x27, 0x1d,
 169         0xa1, 0xe0, 0x34, 0x5d, 0x11, 0xd0, 0x7a, 0x1f,
 170         0xca, 0x43, 0xf5, 0x8a, 0xf4, 0xc1, 0x13, 0xb9,
 171         0x09, 0xee, 0xde, 0xa0
 172 };
 173
 174 /** ECDSA SECP224R1 elliptic curve param */
 175
 176 struct crypto_testsuite_ecdsa_params ecdsa_param_secp224r1 = {
 177         .pubkey_qx = {
 178                 .data = pubkey_qx_secp224r1,
 179                 .length = sizeof(pubkey_qx_secp224r1),
 180         },
 181         .pubkey_qy = {
 182                 .data = pubkey_qy_secp224r1,
 183                 .length = sizeof(pubkey_qy_secp224r1),
 184         },
 185         .scalar = {
 186                 .data = scalar_secp224r1,
 187                 .length = sizeof(scalar_secp224r1),
 188         },
 189         .digest = {
 190                 .data = digest_secp224r1,
 191                 .length = sizeof(digest_secp224r1),
 192         },
 193         .sign_r = {
 194                 .data = sign_secp224r1_r,
 195                 .length = sizeof(sign_secp224r1_r),
 196         },
 197         .sign_s = {
 198                 .data = sign_secp224r1_s,
 199                 .length = sizeof(sign_secp224r1_s),
 200         },
 201         .pkey = {
 202                 .data = pkey_secp224r1,
 203                 .length = sizeof(pkey_secp224r1),
 204         },
 205         .curve = RTE_CRYPTO_EC_GROUP_SECP224R1
 206 };
 207
 208 /* SECP256R1 (P-256 NIST) test vectors */
 209
 210 static uint8_t digest_secp256r1[] = {
 211         0x44, 0xac, 0xf6, 0xb7, 0xe3, 0x6c, 0x13, 0x42,
 212         0xc2, 0xc5, 0x89, 0x72, 0x04, 0xfe, 0x09, 0x50,
 213         0x4e, 0x1e, 0x2e, 0xfb, 0x1a, 0x90, 0x03, 0x77,
 214         0xdb, 0xc4, 0xe7, 0xa6, 0xa1, 0x33, 0xec, 0x56
 215 };
 216
 217 static uint8_t pkey_secp256r1[] = {
 218         0x51, 0x9b, 0x42, 0x3d, 0x71, 0x5f, 0x8b, 0x58,
 219         0x1f, 0x4f, 0xa8, 0xee, 0x59, 0xf4, 0x77, 0x1a,
 220         0x5b, 0x44, 0xc8, 0x13, 0x0b, 0x4e, 0x3e, 0xac,
 221         0xca, 0x54, 0xa5, 0x6d, 0xda, 0x72, 0xb4, 0x64
 222 };
 223
 224 static uint8_t scalar_secp256r1[] = {
 225         0x94, 0xa1, 0xbb, 0xb1, 0x4b, 0x90, 0x6a, 0x61,
 226         0xa2, 0x80, 0xf2, 0x45, 0xf9, 0xe9, 0x3c, 0x7f,
 227         0x3b, 0x4a, 0x62, 0x47, 0x82, 0x4f, 0x5d, 0x33,
 228         0xb9, 0x67, 0x07, 0x87, 0x64, 0x2a, 0x68, 0xde
 229 };
 230
 231 static uint8_t pubkey_qx_secp256r1[] = {
 232         0x1c, 0xcb, 0xe9, 0x1c, 0x07, 0x5f, 0xc7, 0xf4,
 233         0xf0, 0x33, 0xbf, 0xa2, 0x48, 0xdb, 0x8f, 0xcc,
 234         0xd3, 0x56, 0x5d, 0xe9, 0x4b, 0xbf, 0xb1, 0x2f,
 235         0x3c, 0x59, 0xff, 0x46, 0xc2, 0x71, 0xbf, 0x83
 236 };
 237
 238 static uint8_t pubkey_qy_secp256r1[] = {
 239         0xce, 0x40, 0x14, 0xc6, 0x88, 0x11, 0xf9, 0xa2,
 240         0x1a, 0x1f, 0xdb, 0x2c, 0x0e, 0x61, 0x13, 0xe0,
 241         0x6d, 0xb7, 0xca, 0x93, 0xb7, 0x40, 0x4e, 0x78,
 242         0xdc, 0x7c, 0xcd, 0x5c, 0xa8, 0x9a, 0x4c, 0xa9
 243 };
 244
 245 static uint8_t sign_secp256r1_r[] = {
 246         0xf3, 0xac, 0x80, 0x61, 0xb5, 0x14, 0x79, 0x5b,
 247         0x88, 0x43, 0xe3, 0xd6, 0x62, 0x95, 0x27, 0xed,
 248         0x2a, 0xfd, 0x6b, 0x1f, 0x6a, 0x55, 0x5a, 0x7a,
 249         0xca, 0xbb, 0x5e, 0x6f, 0x79, 0xc8, 0xc2, 0xac
 250 };
 251
 252 static uint8_t sign_secp256r1_s[] = {
 253         0x8b, 0xf7, 0x78, 0x19, 0xca, 0x05, 0xa6, 0xb2,
 254         0x78, 0x6c, 0x76, 0x26, 0x2b, 0xf7, 0x37, 0x1c,
 255         0xef, 0x97, 0xb2, 0x18, 0xe9, 0x6f, 0x17, 0x5a,
 256         0x3c, 0xcd, 0xda, 0x2a, 0xcc, 0x05, 0x89, 0x03
 257 };
 258
 259 /** ECDSA SECP256R1 elliptic curve param */
 260
 261 struct crypto_testsuite_ecdsa_params ecdsa_param_secp256r1 = {
 262         .pubkey_qx = {
 263                 .data = pubkey_qx_secp256r1,
 264                 .length = sizeof(pubkey_qx_secp256r1),
 265         },
 266         .pubkey_qy = {
 267                 .data = pubkey_qy_secp256r1,
 268                 .length = sizeof(pubkey_qy_secp256r1),
 269         },
 270         .scalar = {
 271                 .data = scalar_secp256r1,
 272                 .length = sizeof(scalar_secp256r1),
 273         },
 274         .digest = {
 275                 .data = digest_secp256r1,
 276                 .length = sizeof(digest_secp256r1),
 277         },
 278         .sign_r = {
 279                 .data = sign_secp256r1_r,
 280                 .length = sizeof(sign_secp256r1_r),
 281         },
 282         .sign_s = {
 283                 .data = sign_secp256r1_s,
 284                 .length = sizeof(sign_secp256r1_s),
 285         },
 286         .pkey = {
 287                 .data = pkey_secp256r1,
 288                 .length = sizeof(pkey_secp256r1),
 289         },
 290         .curve = RTE_CRYPTO_EC_GROUP_SECP256R1
 291 };
 292
 293 /* SECP384R1 (P-384 NIST) test vectors */
 294
 295 static uint8_t digest_secp384r1[] = {
 296         0xbb, 0xbd, 0x0a, 0x5f, 0x64, 0x5d, 0x3f, 0xda,
 297         0x10, 0xe2, 0x88, 0xd1, 0x72, 0xb2, 0x99, 0x45,
 298         0x5f, 0x9d, 0xff, 0x00, 0xe0, 0xfb, 0xc2, 0x83,
 299         0x3e, 0x18, 0xcd, 0x01, 0x7d, 0x7f, 0x3e, 0xd1
 300 };
 301
 302 static uint8_t pkey_secp384r1[] = {
 303         0xc6, 0x02, 0xbc, 0x74, 0xa3, 0x45, 0x92, 0xc3,
 304         0x11, 0xa6, 0x56, 0x96, 0x61, 0xe0, 0x83, 0x2c,
 305         0x84, 0xf7, 0x20, 0x72, 0x74, 0x67, 0x6c, 0xc4,
 306         0x2a, 0x89, 0xf0, 0x58, 0x16, 0x26, 0x30, 0x18,
 307         0x4b, 0x52, 0xf0, 0xd9, 0x9b, 0x85, 0x5a, 0x77,
 308         0x83, 0xc9, 0x87, 0x47, 0x6d, 0x7f, 0x9e, 0x6b
 309 };
 310
 311 static uint8_t scalar_secp384r1[] = {
 312         0xc1, 0x0b, 0x5c, 0x25, 0xc4, 0x68, 0x3d, 0x0b,
 313         0x78, 0x27, 0xd0, 0xd8, 0x86, 0x97, 0xcd, 0xc0,
 314         0x93, 0x24, 0x96, 0xb5, 0x29, 0x9b, 0x79, 0x8c,
 315         0x0d, 0xd1, 0xe7, 0xaf, 0x6c, 0xc7, 0x57, 0xcc,
 316         0xb3, 0x0f, 0xcd, 0x3d, 0x36, 0xea, 0xd4, 0xa8,
 317         0x04, 0x87, 0x7e, 0x24, 0xf3, 0xa3, 0x24, 0x43
 318 };
 319
 320 static uint8_t pubkey_qx_secp384r1[] = {
 321         0x04, 0x00, 0x19, 0x3b, 0x21, 0xf0, 0x7c, 0xd0,
 322         0x59, 0x82, 0x6e, 0x94, 0x53, 0xd3, 0xe9, 0x6d,
 323         0xd1, 0x45, 0x04, 0x1c, 0x97, 0xd4, 0x9f, 0xf6,
 324         0xb7, 0x04, 0x7f, 0x86, 0xbb, 0x0b, 0x04, 0x39,
 325         0xe9, 0x09, 0x27, 0x4c, 0xb9, 0xc2, 0x82, 0xbf,
 326         0xab, 0x88, 0x67, 0x4c, 0x07, 0x65, 0xbc, 0x75
 327 };
 328
 329 static uint8_t pubkey_qy_secp384r1[] = {
 330         0xf7, 0x0d, 0x89, 0xc5, 0x2a, 0xcb, 0xc7, 0x04,
 331         0x68, 0xd2, 0xc5, 0xae, 0x75, 0xc7, 0x6d, 0x7f,
 332         0x69, 0xb7, 0x6a, 0xf6, 0x2d, 0xcf, 0x95, 0xe9,
 333         0x9e, 0xba, 0x5d, 0xd1, 0x1a, 0xdf, 0x8f, 0x42,
 334         0xec, 0x9a, 0x42, 0x5b, 0x0c, 0x5e, 0xc9, 0x8e,
 335         0x2f, 0x23, 0x4a, 0x92, 0x6b, 0x82, 0xa1, 0x47
 336 };
 337
 338 static uint8_t sign_secp384r1_r[] = {
 339         0xb1, 0x1d, 0xb0, 0x0c, 0xda, 0xf5, 0x32, 0x86,
 340         0xd4, 0x48, 0x3f, 0x38, 0xcd, 0x02, 0x78, 0x59,
 341         0x48, 0x47, 0x7e, 0xd7, 0xeb, 0xc2, 0xad, 0x60,
 342         0x90, 0x54, 0x55, 0x1d, 0xa0, 0xab, 0x03, 0x59,
 343         0x97, 0x8c, 0x61, 0x85, 0x17, 0x88, 0xaa, 0x2e,
 344         0xc3, 0x26, 0x79, 0x46, 0xd4, 0x40, 0xe8, 0x78
 345 };
 346
 347 static uint8_t sign_secp384r1_s[] = {
 348         0x16, 0x00, 0x78, 0x73, 0xc5, 0xb0, 0x60, 0x4c,
 349         0xe6, 0x81, 0x12, 0xa8, 0xfe, 0xe9, 0x73, 0xe8,
 350         0xe2, 0xb6, 0xe3, 0x31, 0x9c, 0x68, 0x3a, 0x76,
 351         0x2f, 0xf5, 0x06, 0x5a, 0x07, 0x65, 0x12, 0xd7,
 352         0xc9, 0x8b, 0x27, 0xe7, 0x4b, 0x78, 0x87, 0x67,
 353         0x10, 0x48, 0xac, 0x02, 0x7d, 0xf8, 0xcb, 0xf2
 354 };
 355
 356 /** ECDSA SECP384R1 elliptic curve param */
 357
 358 struct crypto_testsuite_ecdsa_params ecdsa_param_secp384r1 = {
 359         .pubkey_qx = {
 360                 .data = pubkey_qx_secp384r1,
 361                 .length = sizeof(pubkey_qx_secp384r1),
 362         },
 363         .pubkey_qy = {
 364                 .data = pubkey_qy_secp384r1,
 365                 .length = sizeof(pubkey_qy_secp384r1),
 366         },
 367         .scalar = {
 368                 .data = scalar_secp384r1,
 369                 .length = sizeof(scalar_secp384r1),
 370         },
 371         .digest = {
 372                 .data = digest_secp384r1,
 373                 .length = sizeof(digest_secp384r1),
 374         },
 375         .sign_r = {
 376                 .data = sign_secp384r1_r,
 377                 .length = sizeof(sign_secp384r1_r),
 378         },
 379         .sign_s = {
 380                 .data = sign_secp384r1_s,
 381                 .length = sizeof(sign_secp384r1_s),
 382         },
 383         .pkey = {
 384                 .data = pkey_secp384r1,
 385                 .length = sizeof(pkey_secp384r1),
 386         },
 387         .curve = RTE_CRYPTO_EC_GROUP_SECP384R1
 388 };
 389
 390 /* SECP521R1 (P-521 NIST) test vectors */
 391
 392 static uint8_t digest_secp521r1[] = {
 393         0x53, 0xe6, 0x53, 0x7c, 0xb6, 0xea, 0x68, 0xae,
 394         0x47, 0xa8, 0x16, 0x11, 0xc2, 0x27, 0x56, 0xd7,
 395         0x70, 0xd7, 0xa3, 0x7e, 0x33, 0x6c, 0x3a, 0xf0,
 396         0xb0, 0x81, 0x4b, 0x04, 0xfa, 0x39, 0x43, 0x4b
 397 };
 398
 399 static uint8_t pkey_secp521r1[] = {
 400         0x01, 0xe8, 0xc0, 0x59, 0x96, 0xb8, 0x5e, 0x6f,
 401         0x3f, 0x87, 0x57, 0x12, 0xa0, 0x9c, 0x1b, 0x40,
 402         0x67, 0x2b, 0x5e, 0x7a, 0x78, 0xd5, 0x85, 0x2d,
 403         0xe0, 0x15, 0x85, 0xc5, 0xfb, 0x99, 0x0b, 0xf3,
 404         0x81, 0x2c, 0x32, 0x45, 0x53, 0x4a, 0x71, 0x43,
 405         0x89, 0xae, 0x90, 0x14, 0xd6, 0x77, 0xa4, 0x49,
 406         0xef, 0xd6, 0x58, 0x25, 0x4e, 0x61, 0x0d, 0xa8,
 407         0xe6, 0xca, 0xd3, 0x34, 0x14, 0xb9, 0xd3, 0x3e,
 408         0x0d, 0x7a
 409 };
 410
 411 static uint8_t scalar_secp521r1[] = {
 412         0x00, 0xdc, 0x8d, 0xaa, 0xac, 0xdd, 0xb8, 0xfd,
 413         0x2f, 0xf5, 0xc3, 0x4a, 0x5c, 0xe1, 0x83, 0xa4,
 414         0x22, 0x61, 0xad, 0x3c, 0x64, 0xdb, 0xfc, 0x09,
 415         0x5e, 0x58, 0x92, 0x43, 0x64, 0xdc, 0x47, 0xea,
 416         0x1c, 0x05, 0xe2, 0x59, 0x9a, 0xae, 0x91, 0x7c,
 417         0x2c, 0x95, 0xf4, 0x7d, 0x6b, 0xb3, 0x7d, 0xa0,
 418         0x08, 0xaf, 0x9f, 0x55, 0x73, 0x0d, 0xdb, 0xe4,
 419         0xd8, 0xde, 0xd2, 0x4f, 0x9e, 0x8d, 0xaa, 0x46,
 420         0xdb, 0x6a
 421 };
 422
 423 static uint8_t pubkey_qx_secp521r1[] = {
 424         0x00, 0x7d, 0x04, 0x2c, 0xa1, 0x94, 0x08, 0x52,
 425         0x4e, 0x68, 0xb9, 0x81, 0xf1, 0x41, 0x93, 0x51,
 426         0xe3, 0xb8, 0x47, 0x36, 0xc7, 0x7f, 0xe5, 0x8f,
 427         0xee, 0x7d, 0x11, 0x31, 0x7d, 0xf2, 0xe8, 0x50,
 428         0xd9, 0x60, 0xc7, 0xdd, 0x10, 0xd1, 0x0b, 0xa7,
 429         0x14, 0xc8, 0xa6, 0x09, 0xd1, 0x63, 0x50, 0x2b,
 430         0x79, 0xd6, 0x82, 0xe8, 0xbb, 0xec, 0xd4, 0xf5,
 431         0x25, 0x91, 0xd2, 0x74, 0x85, 0x33, 0xe4, 0x5a,
 432         0x86, 0x7a
 433 };
 434
 435 static uint8_t pubkey_qy_secp521r1[] = {
 436         0x01, 0x97, 0xac, 0x64, 0x16, 0x11, 0x1c, 0xcf,
 437         0x98, 0x7d, 0x29, 0x04, 0x59, 0xeb, 0xc8, 0xad,
 438         0x9e, 0xc5, 0x6e, 0x49, 0x05, 0x9c, 0x99, 0x21,
 439         0x55, 0x53, 0x9a, 0x36, 0xa6, 0x26, 0x63, 0x1f,
 440         0x4a, 0x2d, 0x89, 0x16, 0x4b, 0x98, 0x51, 0x54,
 441         0xf2, 0xdd, 0xdc, 0x02, 0x81, 0xee, 0x5b, 0x51,
 442         0x78, 0x27, 0x1f, 0x3a, 0x76, 0xa0, 0x91, 0x4c,
 443         0x3f, 0xcd, 0x1f, 0x97, 0xbe, 0x8e, 0x83, 0x76,
 444         0xef, 0xb3
 445 };
 446
 447 static uint8_t sign_secp521r1_r[] = {
 448         0x00, 0x9d, 0xd1, 0xf2, 0xa7, 0x16, 0x84, 0x3e,
 449         0xed, 0xec, 0x7a, 0x66, 0x45, 0xac, 0x83, 0x4d,
 450         0x43, 0x36, 0xe7, 0xb1, 0x8e, 0x35, 0x70, 0x1f,
 451         0x06, 0xca, 0xe9, 0xd6, 0xb2, 0x90, 0xd4, 0x14,
 452         0x91, 0x42, 0x47, 0x35, 0xf3, 0xb5, 0x7e, 0x82,
 453         0x9a, 0xd5, 0xde, 0x05, 0x5e, 0xae, 0xef, 0x17,
 454         0x78, 0xf0, 0x51, 0xc1, 0xee, 0x15, 0x2b, 0xf2,
 455         0x13, 0x1a, 0x08, 0x1e, 0x53, 0xdf, 0x2a, 0x56,
 456         0x7a, 0x8a
 457 };
 458
 459 static uint8_t sign_secp521r1_s[] = {
 460         0x00, 0x21, 0x48, 0xe8, 0x42, 0x8d, 0x70, 0xa7,
 461         0x2b, 0xc9, 0xfa, 0x98, 0x6c, 0x38, 0xc2, 0xc9,
 462         0x7d, 0xed, 0xa0, 0x42, 0x0f, 0x22, 0x2f, 0x9d,
 463         0xc9, 0x9d, 0x32, 0xc0, 0xac, 0xba, 0x69, 0x9d,
 464         0xc7, 0xba, 0x0a, 0x2b, 0x79, 0xce, 0x59, 0x99,
 465         0xff, 0x61, 0xbd, 0x0b, 0x23, 0x3c, 0x74, 0x4a,
 466         0x89, 0x3b, 0xc1, 0x05, 0xbc, 0xa5, 0xc2, 0x35,
 467         0x42, 0x3e, 0x53, 0x16, 0x12, 0xda, 0x65, 0xd7,
 468         0x2e, 0x62
 469 };
 470
 471 /** ECDSA SECP521R1 elliptic curve param */
 472
 473 struct crypto_testsuite_ecdsa_params ecdsa_param_secp521r1 = {
 474         .pubkey_qx = {
 475                 .data = pubkey_qx_secp521r1,
 476                 .length = sizeof(pubkey_qx_secp521r1),
 477         },
 478         .pubkey_qy = {
 479                 .data = pubkey_qy_secp521r1,
 480                 .length = sizeof(pubkey_qy_secp521r1),
 481         },
 482         .scalar = {
 483                 .data = scalar_secp521r1,
 484                 .length = sizeof(scalar_secp521r1),
 485         },
 486         .digest = {
 487                 .data = digest_secp521r1,
 488                 .length = sizeof(digest_secp521r1),
 489         },
 490         .sign_r = {
 491                 .data = sign_secp521r1_r,
 492                 .length = sizeof(sign_secp521r1_r),
 493         },
 494         .sign_s = {
 495                 .data = sign_secp521r1_s,
 496                 .length = sizeof(sign_secp521r1_s),
 497         },
 498         .pkey = {
 499                 .data = pkey_secp521r1,
 500                 .length = sizeof(pkey_secp521r1),
 501         },
 502         .curve = RTE_CRYPTO_EC_GROUP_SECP521R1
 503 };
 504
 505 #endif /* __TEST_CRYPTODEV_ECDSA_TEST_VECTORS_H__ */