crypto/ec/ecx_meth.c

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