crypto/ec/ecx_meth.c

   1 /*
   2  * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include "internal/cryptlib.h"
  12 #include <openssl/x509.h>
  13 #include <openssl/ec.h>
  14 #include <openssl/rand.h>
  15 #include "internal/asn1_int.h"
  16 #include "internal/evp_int.h"
  17 #include "ec_lcl.h"
  18
  19 #define X25519_BITS          253
  20 #define X25519_SECURITY_BITS 128
  21
  22 #define ED25519_SIGSIZE      64
  23
  24 #define X448_BITS            448
  25 #define ED448_BITS           456
  26 #define X448_SECURITY_BITS   224
  27
  28 #define ED448_SIGSIZE        114
  29
  30 #define ISX448(id)      ((id) == EVP_PKEY_X448)
  31 #define IS25519(id)     ((id) == EVP_PKEY_X25519 || (id) == EVP_PKEY_ED25519)
  32 #define KEYLENID(id)    (IS25519(id) ? X25519_KEYLEN \
  33                                      : ((id) == EVP_PKEY_X448 ? X448_KEYLEN \
  34                                                               : ED448_KEYLEN))
  35 #define KEYLEN(p)       KEYLENID((p)->ameth->pkey_id)
  36
  37
  38 typedef enum {
  39     KEY_OP_PUBLIC,
  40     KEY_OP_PRIVATE,
  41     KEY_OP_KEYGEN
  42 } ecx_key_op_t;
  43
  44 /* Setup EVP_PKEY using public, private or generation */
  45 static int ecx_key_op(EVP_PKEY *pkey, int id, const X509_ALGOR *palg,
  46                       const unsigned char *p, int plen, ecx_key_op_t op)
  47 {
  48     ECX_KEY *key = NULL;
  49     unsigned char *privkey, *pubkey;
  50
  51     if (op != KEY_OP_KEYGEN) {
  52         if (palg != NULL) {
  53             int ptype;
  54
  55             /* Algorithm parameters must be absent */
  56             X509_ALGOR_get0(NULL, &ptype, NULL, palg);
  57             if (ptype != V_ASN1_UNDEF) {
  58                 ECerr(EC_F_ECX_KEY_OP, EC_R_INVALID_ENCODING);
  59                 return 0;
  60             }
  61         }
  62
  63         if (p == NULL || plen != KEYLENID(id)) {
  64             ECerr(EC_F_ECX_KEY_OP, EC_R_INVALID_ENCODING);
  65             return 0;
  66         }
  67     }
  68
  69     key = OPENSSL_zalloc(sizeof(*key));
  70     if (key == NULL) {
  71         ECerr(EC_F_ECX_KEY_OP, ERR_R_MALLOC_FAILURE);
  72         return 0;
  73     }
  74     pubkey = key->pubkey;
  75
  76     if (op == KEY_OP_PUBLIC) {
  77         memcpy(pubkey, p, plen);
  78     } else {
  79         privkey = key->privkey = OPENSSL_secure_malloc(KEYLENID(id));
  80         if (privkey == NULL) {
  81             ECerr(EC_F_ECX_KEY_OP, ERR_R_MALLOC_FAILURE);
  82             goto err;
  83         }
  84         if (op == KEY_OP_KEYGEN) {
  85             if (RAND_priv_bytes(privkey, KEYLENID(id)) <= 0) {
  86                 OPENSSL_secure_free(privkey);
  87                 key->privkey = NULL;
  88                 goto err;
  89             }
  90             if (id == EVP_PKEY_X25519) {
  91                 privkey[0] &= 248;
  92                 privkey[X25519_KEYLEN - 1] &= 127;
  93                 privkey[X25519_KEYLEN - 1] |= 64;
  94             } else if (id == EVP_PKEY_X448) {
  95                 privkey[0] &= 252;
  96                 privkey[X448_KEYLEN - 1] |= 128;
  97             }
  98         } else {
  99             memcpy(privkey, p, KEYLENID(id));
 100         }
 101         switch (id) {
 102         case EVP_PKEY_X25519:
 103             X25519_public_from_private(pubkey, privkey);
 104             break;
 105         case EVP_PKEY_ED25519:
 106             ED25519_public_from_private(pubkey, privkey);
 107             break;
 108         case EVP_PKEY_X448:
 109             X448_public_from_private(pubkey, privkey);
 110             break;
 111         case EVP_PKEY_ED448:
 112             ED448_public_from_private(pubkey, privkey);
 113             break;
 114         }
 115     }
 116
 117     EVP_PKEY_assign(pkey, id, key);
 118     return 1;
 119  err:
 120     OPENSSL_free(key);
 121     return 0;
 122 }
 123
 124 static int ecx_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
 125 {
 126     const ECX_KEY *ecxkey = pkey->pkey.ecx;
 127     unsigned char *penc;
 128
 129     if (ecxkey == NULL) {
 130         ECerr(EC_F_ECX_PUB_ENCODE, EC_R_INVALID_KEY);
 131         return 0;
 132     }
 133
 134     penc = OPENSSL_memdup(ecxkey->pubkey, KEYLEN(pkey));
 135     if (penc == NULL) {
 136         ECerr(EC_F_ECX_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
 137         return 0;
 138     }
 139
 140     if (!X509_PUBKEY_set0_param(pk, OBJ_nid2obj(pkey->ameth->pkey_id),
 141                                 V_ASN1_UNDEF, NULL, penc, KEYLEN(pkey))) {
 142         OPENSSL_free(penc);
 143         ECerr(EC_F_ECX_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
 144         return 0;
 145     }
 146     return 1;
 147 }
 148
 149 static int ecx_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
 150 {
 151     const unsigned char *p;
 152     int pklen;
 153     X509_ALGOR *palg;
 154
 155     if (!X509_PUBKEY_get0_param(NULL, &p, &pklen, &palg, pubkey))
 156         return 0;
 157     return ecx_key_op(pkey, pkey->ameth->pkey_id, palg, p, pklen,
 158                       KEY_OP_PUBLIC);
 159 }
 160
 161 static int ecx_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
 162 {
 163     const ECX_KEY *akey = a->pkey.ecx;
 164     const ECX_KEY *bkey = b->pkey.ecx;
 165
 166     if (akey == NULL || bkey == NULL)
 167         return -2;
 168
 169     return CRYPTO_memcmp(akey->pubkey, bkey->pubkey, KEYLEN(a)) == 0;
 170 }
 171
 172 static int ecx_priv_decode(EVP_PKEY *pkey, const PKCS8_PRIV_KEY_INFO *p8)
 173 {
 174     const unsigned char *p;
 175     int plen;
 176     ASN1_OCTET_STRING *oct = NULL;
 177     const X509_ALGOR *palg;
 178     int rv;
 179
 180     if (!PKCS8_pkey_get0(NULL, &p, &plen, &palg, p8))
 181         return 0;
 182
 183     oct = d2i_ASN1_OCTET_STRING(NULL, &p, plen);
 184     if (oct == NULL) {
 185         p = NULL;
 186         plen = 0;
 187     } else {
 188         p = ASN1_STRING_get0_data(oct);
 189         plen = ASN1_STRING_length(oct);
 190     }
 191
 192     rv = ecx_key_op(pkey, pkey->ameth->pkey_id, palg, p, plen, KEY_OP_PRIVATE);
 193     ASN1_OCTET_STRING_free(oct);
 194     return rv;
 195 }
 196
 197 static int ecx_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
 198 {
 199     const ECX_KEY *ecxkey = pkey->pkey.ecx;
 200     ASN1_OCTET_STRING oct;
 201     unsigned char *penc = NULL;
 202     int penclen;
 203
 204     if (ecxkey == NULL || ecxkey->privkey == NULL) {
 205         ECerr(EC_F_ECX_PRIV_ENCODE, EC_R_INVALID_PRIVATE_KEY);
 206         return 0;
 207     }
 208
 209     oct.data = ecxkey->privkey;
 210     oct.length = KEYLEN(pkey);
 211     oct.flags = 0;
 212
 213     penclen = i2d_ASN1_OCTET_STRING(&oct, &penc);
 214     if (penclen < 0) {
 215         ECerr(EC_F_ECX_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
 216         return 0;
 217     }
 218
 219     if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(pkey->ameth->pkey_id), 0,
 220                          V_ASN1_UNDEF, NULL, penc, penclen)) {
 221         OPENSSL_clear_free(penc, penclen);
 222         ECerr(EC_F_ECX_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
 223         return 0;
 224     }
 225
 226     return 1;
 227 }
 228
 229 static int ecx_size(const EVP_PKEY *pkey)
 230 {
 231     return KEYLEN(pkey);
 232 }
 233
 234 static int ecx_bits(const EVP_PKEY *pkey)
 235 {
 236     if (IS25519(pkey->ameth->pkey_id)) {
 237         return X25519_BITS;
 238     } else if(ISX448(pkey->ameth->pkey_id)) {
 239         return X448_BITS;
 240     } else {
 241         return ED448_BITS;
 242     }
 243 }
 244
 245 static int ecx_security_bits(const EVP_PKEY *pkey)
 246 {
 247     if (IS25519(pkey->ameth->pkey_id)) {
 248         return X25519_SECURITY_BITS;
 249     } else {
 250         return X448_SECURITY_BITS;
 251     }
 252 }
 253
 254 static void ecx_free(EVP_PKEY *pkey)
 255 {
 256     if (pkey->pkey.ecx != NULL)
 257         OPENSSL_secure_clear_free(pkey->pkey.ecx->privkey, KEYLEN(pkey));
 258     OPENSSL_free(pkey->pkey.ecx);
 259 }
 260
 261 /* "parameters" are always equal */
 262 static int ecx_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
 263 {
 264     return 1;
 265 }
 266
 267 static int ecx_key_print(BIO *bp, const EVP_PKEY *pkey, int indent,
 268                          ASN1_PCTX *ctx, ecx_key_op_t op)
 269 {
 270     const ECX_KEY *ecxkey = pkey->pkey.ecx;
 271     const char *nm = OBJ_nid2ln(pkey->ameth->pkey_id);
 272
 273     if (op == KEY_OP_PRIVATE) {
 274         if (ecxkey == NULL || ecxkey->privkey == NULL) {
 275             if (BIO_printf(bp, "%*s<INVALID PRIVATE KEY>\n", indent, "") <= 0)
 276                 return 0;
 277             return 1;
 278         }
 279         if (BIO_printf(bp, "%*s%s Private-Key:\n", indent, "", nm) <= 0)
 280             return 0;
 281         if (BIO_printf(bp, "%*spriv:\n", indent, "") <= 0)
 282             return 0;
 283         if (ASN1_buf_print(bp, ecxkey->privkey, KEYLEN(pkey),
 284                            indent + 4) == 0)
 285             return 0;
 286     } else {
 287         if (ecxkey == NULL) {
 288             if (BIO_printf(bp, "%*s<INVALID PUBLIC KEY>\n", indent, "") <= 0)
 289                 return 0;
 290             return 1;
 291         }
 292         if (BIO_printf(bp, "%*s%s Public-Key:\n", indent, "", nm) <= 0)
 293             return 0;
 294     }
 295     if (BIO_printf(bp, "%*spub:\n", indent, "") <= 0)
 296         return 0;
 297
 298     if (ASN1_buf_print(bp, ecxkey->pubkey, KEYLEN(pkey),
 299                        indent + 4) == 0)
 300         return 0;
 301     return 1;
 302 }
 303
 304 static int ecx_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
 305                           ASN1_PCTX *ctx)
 306 {
 307     return ecx_key_print(bp, pkey, indent, ctx, KEY_OP_PRIVATE);
 308 }
 309
 310 static int ecx_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
 311                          ASN1_PCTX *ctx)
 312 {
 313     return ecx_key_print(bp, pkey, indent, ctx, KEY_OP_PUBLIC);
 314 }
 315
 316 static int ecx_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
 317 {
 318     switch (op) {
 319
 320     case ASN1_PKEY_CTRL_SET1_TLS_ENCPT:
 321         return ecx_key_op(pkey, pkey->ameth->pkey_id, NULL, arg2, arg1,
 322                           KEY_OP_PUBLIC);
 323
 324     case ASN1_PKEY_CTRL_GET1_TLS_ENCPT:
 325         if (pkey->pkey.ecx != NULL) {
 326             unsigned char **ppt = arg2;
 327
 328             *ppt = OPENSSL_memdup(pkey->pkey.ecx->pubkey, KEYLEN(pkey));
 329             if (*ppt != NULL)
 330                 return KEYLEN(pkey);
 331         }
 332         return 0;
 333
 334     case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
 335         *(int *)arg2 = NID_sha256;
 336         return 2;
 337
 338     default:
 339         return -2;
 340
 341     }
 342 }
 343
 344 const EVP_PKEY_ASN1_METHOD ecx25519_asn1_meth = {
 345     EVP_PKEY_X25519,
 346     EVP_PKEY_X25519,
 347     0,
 348     "X25519",
 349     "OpenSSL X25519 algorithm",
 350
 351     ecx_pub_decode,
 352     ecx_pub_encode,
 353     ecx_pub_cmp,
 354     ecx_pub_print,
 355
 356     ecx_priv_decode,
 357     ecx_priv_encode,
 358     ecx_priv_print,
 359
 360     ecx_size,
 361     ecx_bits,
 362     ecx_security_bits,
 363
 364     0, 0, 0, 0,
 365     ecx_cmp_parameters,
 366     0, 0,
 367
 368     ecx_free,
 369     ecx_ctrl,
 370     NULL,
 371     NULL
 372 };
 373
 374 const EVP_PKEY_ASN1_METHOD ecx448_asn1_meth = {
 375     EVP_PKEY_X448,
 376     EVP_PKEY_X448,
 377     0,
 378     "X448",
 379     "OpenSSL X448 algorithm",
 380
 381     ecx_pub_decode,
 382     ecx_pub_encode,
 383     ecx_pub_cmp,
 384     ecx_pub_print,
 385
 386     ecx_priv_decode,
 387     ecx_priv_encode,
 388     ecx_priv_print,
 389
 390     ecx_size,
 391     ecx_bits,
 392     ecx_security_bits,
 393
 394     0, 0, 0, 0,
 395     ecx_cmp_parameters,
 396     0, 0,
 397
 398     ecx_free,
 399     ecx_ctrl,
 400     NULL,
 401     NULL
 402 };
 403
 404 static int ecd_size25519(const EVP_PKEY *pkey)
 405 {
 406     return ED25519_SIGSIZE;
 407 }
 408
 409 static int ecd_size448(const EVP_PKEY *pkey)
 410 {
 411     return ED448_SIGSIZE;
 412 }
 413
 414 static int ecd_item_verify(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
 415                            X509_ALGOR *sigalg, ASN1_BIT_STRING *str,
 416                            EVP_PKEY *pkey)
 417 {
 418     const ASN1_OBJECT *obj;
 419     int ptype;
 420     int nid;
 421
 422     /* Sanity check: make sure it is ED25519/ED448 with absent parameters */
 423     X509_ALGOR_get0(&obj, &ptype, NULL, sigalg);
 424     nid = OBJ_obj2nid(obj);
 425     if ((nid != NID_ED25519 && nid != NID_ED448) || ptype != V_ASN1_UNDEF) {
 426         ECerr(EC_F_ECD_ITEM_VERIFY, EC_R_INVALID_ENCODING);
 427         return 0;
 428     }
 429
 430     if (!EVP_DigestVerifyInit(ctx, NULL, NULL, NULL, pkey))
 431         return 0;
 432
 433     return 2;
 434 }
 435
 436 static int ecd_item_sign25519(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
 437                               X509_ALGOR *alg1, X509_ALGOR *alg2,
 438                               ASN1_BIT_STRING *str)
 439 {
 440     /* Set algorithms identifiers */
 441     X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_ED25519), V_ASN1_UNDEF, NULL);
 442     if (alg2)
 443         X509_ALGOR_set0(alg2, OBJ_nid2obj(NID_ED25519), V_ASN1_UNDEF, NULL);
 444     /* Algorithm idetifiers set: carry on as normal */
 445     return 3;
 446 }
 447
 448 static int ecd_sig_info_set25519(X509_SIG_INFO *siginf, const X509_ALGOR *alg,
 449                                  const ASN1_STRING *sig)
 450 {
 451     X509_SIG_INFO_set(siginf, NID_undef, NID_ED25519, X25519_SECURITY_BITS,
 452                       X509_SIG_INFO_TLS);
 453     return 1;
 454 }
 455
 456 static int ecd_item_sign448(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn,
 457                             X509_ALGOR *alg1, X509_ALGOR *alg2,
 458                             ASN1_BIT_STRING *str)
 459 {
 460     /* Set algorithm identifier */
 461     X509_ALGOR_set0(alg1, OBJ_nid2obj(NID_ED448), V_ASN1_UNDEF, NULL);
 462     if (alg2 != NULL)
 463         X509_ALGOR_set0(alg2, OBJ_nid2obj(NID_ED448), V_ASN1_UNDEF, NULL);
 464     /* Algorithm identifier set: carry on as normal */
 465     return 3;
 466 }
 467
 468 static int ecd_sig_info_set448(X509_SIG_INFO *siginf, const X509_ALGOR *alg,
 469                                const ASN1_STRING *sig)
 470 {
 471     X509_SIG_INFO_set(siginf, NID_undef, NID_ED448, X448_SECURITY_BITS,
 472                       X509_SIG_INFO_TLS);
 473     return 1;
 474 }
 475
 476
 477 const EVP_PKEY_ASN1_METHOD ed25519_asn1_meth = {
 478     EVP_PKEY_ED25519,
 479     EVP_PKEY_ED25519,
 480     0,
 481     "ED25519",
 482     "OpenSSL ED25519 algorithm",
 483
 484     ecx_pub_decode,
 485     ecx_pub_encode,
 486     ecx_pub_cmp,
 487     ecx_pub_print,
 488
 489     ecx_priv_decode,
 490     ecx_priv_encode,
 491     ecx_priv_print,
 492
 493     ecd_size25519,
 494     ecx_bits,
 495     ecx_security_bits,
 496
 497     0, 0, 0, 0,
 498     ecx_cmp_parameters,
 499     0, 0,
 500
 501     ecx_free,
 502     0,
 503     NULL,
 504     NULL,
 505     ecd_item_verify,
 506     ecd_item_sign25519,
 507     ecd_sig_info_set25519
 508 };
 509
 510 const EVP_PKEY_ASN1_METHOD ed448_asn1_meth = {
 511     EVP_PKEY_ED448,
 512     EVP_PKEY_ED448,
 513     0,
 514     "ED448",
 515     "OpenSSL ED448 algorithm",
 516
 517     ecx_pub_decode,
 518     ecx_pub_encode,
 519     ecx_pub_cmp,
 520     ecx_pub_print,
 521
 522     ecx_priv_decode,
 523     ecx_priv_encode,
 524     ecx_priv_print,
 525
 526     ecd_size448,
 527     ecx_bits,
 528     ecx_security_bits,
 529
 530     0, 0, 0, 0,
 531     ecx_cmp_parameters,
 532     0, 0,
 533
 534     ecx_free,
 535     0,
 536     NULL,
 537     NULL,
 538     ecd_item_verify,
 539     ecd_item_sign448,
 540     ecd_sig_info_set448
 541 };
 542
 543 static int pkey_ecx_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
 544 {
 545     return ecx_key_op(pkey, ctx->pmeth->pkey_id, NULL, NULL, 0, KEY_OP_KEYGEN);
 546 }
 547
 548 static int validate_ecx_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
 549                                           size_t *keylen,
 550                                           const unsigned char **privkey,
 551                                           const unsigned char **pubkey)
 552 {
 553     const ECX_KEY *ecxkey, *peerkey;
 554
 555     if (ctx->pkey == NULL || ctx->peerkey == NULL) {
 556         ECerr(EC_F_VALIDATE_ECX_DERIVE, EC_R_KEYS_NOT_SET);
 557         return 0;
 558     }
 559     ecxkey = ctx->pkey->pkey.ecx;
 560     peerkey = ctx->peerkey->pkey.ecx;
 561     if (ecxkey == NULL || ecxkey->privkey == NULL) {
 562         ECerr(EC_F_VALIDATE_ECX_DERIVE, EC_R_INVALID_PRIVATE_KEY);
 563         return 0;
 564     }
 565     if (peerkey == NULL) {
 566         ECerr(EC_F_VALIDATE_ECX_DERIVE, EC_R_INVALID_PEER_KEY);
 567         return 0;
 568     }
 569     *privkey = ecxkey->privkey;
 570     *pubkey = peerkey->pubkey;
 571
 572     return 1;
 573 }
 574
 575 static int pkey_ecx_derive25519(EVP_PKEY_CTX *ctx, unsigned char *key,
 576                                 size_t *keylen)
 577 {
 578     const unsigned char *privkey, *pubkey;
 579
 580     if (!validate_ecx_derive(ctx, key, keylen, &privkey, &pubkey)
 581             || (key != NULL
 582                 && X25519(key, privkey, pubkey) == 0))
 583         return 0;
 584     *keylen = X25519_KEYLEN;
 585     return 1;
 586 }
 587
 588 static int pkey_ecx_derive448(EVP_PKEY_CTX *ctx, unsigned char *key,
 589                               size_t *keylen)
 590 {
 591     const unsigned char *privkey, *pubkey;
 592
 593     if (!validate_ecx_derive(ctx, key, keylen, &privkey, &pubkey)
 594             || (key != NULL
 595                 && X448(key, privkey, pubkey) == 0))
 596         return 0;
 597     *keylen = X448_KEYLEN;
 598     return 1;
 599 }
 600
 601 static int pkey_ecx_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 602 {
 603     /* Only need to handle peer key for derivation */
 604     if (type == EVP_PKEY_CTRL_PEER_KEY)
 605         return 1;
 606     return -2;
 607 }
 608
 609 const EVP_PKEY_METHOD ecx25519_pkey_meth = {
 610     EVP_PKEY_X25519,
 611     0, 0, 0, 0, 0, 0, 0,
 612     pkey_ecx_keygen,
 613     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 614     pkey_ecx_derive25519,
 615     pkey_ecx_ctrl,
 616     0
 617 };
 618
 619 const EVP_PKEY_METHOD ecx448_pkey_meth = {
 620     EVP_PKEY_X448,
 621     0, 0, 0, 0, 0, 0, 0,
 622     pkey_ecx_keygen,
 623     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 624     pkey_ecx_derive448,
 625     pkey_ecx_ctrl,
 626     0
 627 };
 628
 629 static int pkey_ecd_digestsign25519(EVP_MD_CTX *ctx, unsigned char *sig,
 630                                     size_t *siglen, const unsigned char *tbs,
 631                                     size_t tbslen)
 632 {
 633     const ECX_KEY *edkey = EVP_MD_CTX_pkey_ctx(ctx)->pkey->pkey.ecx;
 634
 635     if (sig == NULL) {
 636         *siglen = ED25519_SIGSIZE;
 637         return 1;
 638     }
 639     if (*siglen < ED25519_SIGSIZE) {
 640         ECerr(EC_F_PKEY_ECD_DIGESTSIGN25519, EC_R_BUFFER_TOO_SMALL);
 641         return 0;
 642     }
 643
 644     if (ED25519_sign(sig, tbs, tbslen, edkey->pubkey, edkey->privkey) == 0)
 645         return 0;
 646     *siglen = ED25519_SIGSIZE;
 647     return 1;
 648 }
 649
 650 static int pkey_ecd_digestsign448(EVP_MD_CTX *ctx, unsigned char *sig,
 651                                   size_t *siglen, const unsigned char *tbs,
 652                                   size_t tbslen)
 653 {
 654     const ECX_KEY *edkey = EVP_MD_CTX_pkey_ctx(ctx)->pkey->pkey.ecx;
 655
 656     if (sig == NULL) {
 657         *siglen = ED448_SIGSIZE;
 658         return 1;
 659     }
 660     if (*siglen < ED448_SIGSIZE) {
 661         ECerr(EC_F_PKEY_ECD_DIGESTSIGN448, EC_R_BUFFER_TOO_SMALL);
 662         return 0;
 663     }
 664
 665     if (ED448_sign(sig, tbs, tbslen, edkey->pubkey, edkey->privkey, NULL,
 666                    0) == 0)
 667         return 0;
 668     *siglen = ED448_SIGSIZE;
 669     return 1;
 670 }
 671
 672 static int pkey_ecd_digestverify25519(EVP_MD_CTX *ctx, const unsigned char *sig,
 673                                       size_t siglen, const unsigned char *tbs,
 674                                       size_t tbslen)
 675 {
 676     const ECX_KEY *edkey = EVP_MD_CTX_pkey_ctx(ctx)->pkey->pkey.ecx;
 677
 678     if (siglen != ED25519_SIGSIZE)
 679         return 0;
 680
 681     return ED25519_verify(tbs, tbslen, sig, edkey->pubkey);
 682 }
 683
 684 static int pkey_ecd_digestverify448(EVP_MD_CTX *ctx, const unsigned char *sig,
 685                                     size_t siglen, const unsigned char *tbs,
 686                                     size_t tbslen)
 687 {
 688     const ECX_KEY *edkey = EVP_MD_CTX_pkey_ctx(ctx)->pkey->pkey.ecx;
 689
 690     if (siglen != ED448_SIGSIZE)
 691         return 0;
 692
 693     return ED448_verify(tbs, tbslen, sig, edkey->pubkey, NULL, 0);
 694 }
 695
 696 static int pkey_ecd_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 697 {
 698     switch (type) {
 699     case EVP_PKEY_CTRL_MD:
 700         /* Only NULL allowed as digest */
 701         if (p2 == NULL)
 702             return 1;
 703         ECerr(EC_F_PKEY_ECD_CTRL, EC_R_INVALID_DIGEST_TYPE);
 704         return 0;
 705
 706     case EVP_PKEY_CTRL_DIGESTINIT:
 707         return 1;
 708     }
 709     return -2;
 710 }
 711
 712 const EVP_PKEY_METHOD ed25519_pkey_meth = {
 713     EVP_PKEY_ED25519, EVP_PKEY_FLAG_SIGCTX_CUSTOM,
 714     0, 0, 0, 0, 0, 0,
 715     pkey_ecx_keygen,
 716     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 717     pkey_ecd_ctrl,
 718     0,
 719     pkey_ecd_digestsign25519,
 720     pkey_ecd_digestverify25519
 721 };
 722
 723 const EVP_PKEY_METHOD ed448_pkey_meth = {
 724     EVP_PKEY_ED448, EVP_PKEY_FLAG_SIGCTX_CUSTOM,
 725     0, 0, 0, 0, 0, 0,
 726     pkey_ecx_keygen,
 727     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 728     pkey_ecd_ctrl,
 729     0,
 730     pkey_ecd_digestsign448,
 731     pkey_ecd_digestverify448
 732 };