crypto/evp/pmeth_gn.c

   1 /*
   2  * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 <stdlib.h>
  12 #include "internal/cryptlib.h"
  13 #include <openssl/objects.h>
  14 #include <openssl/evp.h>
  15 #include "crypto/bn.h"
  16 #include "crypto/asn1.h"
  17 #include "crypto/evp.h"
  18 #include "evp_local.h"
  19
  20 #ifndef FIPS_MODE
  21 int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx)
  22 {
  23     int ret;
  24     if (!ctx || !ctx->pmeth || !ctx->pmeth->paramgen) {
  25         EVPerr(EVP_F_EVP_PKEY_PARAMGEN_INIT,
  26                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
  27         return -2;
  28     }
  29     ctx->operation = EVP_PKEY_OP_PARAMGEN;
  30     if (!ctx->pmeth->paramgen_init)
  31         return 1;
  32     ret = ctx->pmeth->paramgen_init(ctx);
  33     if (ret <= 0)
  34         ctx->operation = EVP_PKEY_OP_UNDEFINED;
  35     return ret;
  36 }
  37
  38 int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
  39 {
  40     int ret;
  41     if (!ctx || !ctx->pmeth || !ctx->pmeth->paramgen) {
  42         EVPerr(EVP_F_EVP_PKEY_PARAMGEN,
  43                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
  44         return -2;
  45     }
  46
  47     if (ctx->operation != EVP_PKEY_OP_PARAMGEN) {
  48         EVPerr(EVP_F_EVP_PKEY_PARAMGEN, EVP_R_OPERATON_NOT_INITIALIZED);
  49         return -1;
  50     }
  51
  52     if (ppkey == NULL)
  53         return -1;
  54
  55     if (*ppkey == NULL)
  56         *ppkey = EVP_PKEY_new();
  57
  58     if (*ppkey == NULL) {
  59         EVPerr(EVP_F_EVP_PKEY_PARAMGEN, ERR_R_MALLOC_FAILURE);
  60         return -1;
  61     }
  62
  63     ret = ctx->pmeth->paramgen(ctx, *ppkey);
  64     if (ret <= 0) {
  65         EVP_PKEY_free(*ppkey);
  66         *ppkey = NULL;
  67     }
  68     return ret;
  69 }
  70
  71 int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx)
  72 {
  73     int ret;
  74     if (!ctx || !ctx->pmeth || !ctx->pmeth->keygen) {
  75         EVPerr(EVP_F_EVP_PKEY_KEYGEN_INIT,
  76                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
  77         return -2;
  78     }
  79     ctx->operation = EVP_PKEY_OP_KEYGEN;
  80     if (!ctx->pmeth->keygen_init)
  81         return 1;
  82     ret = ctx->pmeth->keygen_init(ctx);
  83     if (ret <= 0)
  84         ctx->operation = EVP_PKEY_OP_UNDEFINED;
  85     return ret;
  86 }
  87
  88 int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
  89 {
  90     int ret;
  91
  92     if (!ctx || !ctx->pmeth || !ctx->pmeth->keygen) {
  93         EVPerr(EVP_F_EVP_PKEY_KEYGEN,
  94                EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
  95         return -2;
  96     }
  97     if (ctx->operation != EVP_PKEY_OP_KEYGEN) {
  98         EVPerr(EVP_F_EVP_PKEY_KEYGEN, EVP_R_OPERATON_NOT_INITIALIZED);
  99         return -1;
 100     }
 101
 102     if (ppkey == NULL)
 103         return -1;
 104
 105     if (*ppkey == NULL)
 106         *ppkey = EVP_PKEY_new();
 107     if (*ppkey == NULL)
 108         return -1;
 109
 110     ret = ctx->pmeth->keygen(ctx, *ppkey);
 111     if (ret <= 0) {
 112         EVP_PKEY_free(*ppkey);
 113         *ppkey = NULL;
 114     }
 115     return ret;
 116 }
 117
 118 void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb)
 119 {
 120     ctx->pkey_gencb = cb;
 121 }
 122
 123 EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx)
 124 {
 125     return ctx->pkey_gencb;
 126 }
 127
 128 /*
 129  * "translation callback" to call EVP_PKEY_CTX callbacks using BN_GENCB style
 130  * callbacks.
 131  */
 132
 133 static int trans_cb(int a, int b, BN_GENCB *gcb)
 134 {
 135     EVP_PKEY_CTX *ctx = BN_GENCB_get_arg(gcb);
 136     ctx->keygen_info[0] = a;
 137     ctx->keygen_info[1] = b;
 138     return ctx->pkey_gencb(ctx);
 139 }
 140
 141 void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx)
 142 {
 143     BN_GENCB_set(cb, trans_cb, ctx);
 144 }
 145
 146 int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx)
 147 {
 148     if (idx == -1)
 149         return ctx->keygen_info_count;
 150     if (idx < 0 || idx > ctx->keygen_info_count)
 151         return 0;
 152     return ctx->keygen_info[idx];
 153 }
 154
 155 EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
 156                                const unsigned char *key, int keylen)
 157 {
 158     EVP_PKEY_CTX *mac_ctx = NULL;
 159     EVP_PKEY *mac_key = NULL;
 160     mac_ctx = EVP_PKEY_CTX_new_id(type, e);
 161     if (!mac_ctx)
 162         return NULL;
 163     if (EVP_PKEY_keygen_init(mac_ctx) <= 0)
 164         goto merr;
 165     if (EVP_PKEY_CTX_set_mac_key(mac_ctx, key, keylen) <= 0)
 166         goto merr;
 167     if (EVP_PKEY_keygen(mac_ctx, &mac_key) <= 0)
 168         goto merr;
 169  merr:
 170     EVP_PKEY_CTX_free(mac_ctx);
 171     return mac_key;
 172 }
 173
 174 #endif /* FIPS_MODE */
 175
 176 /*- All methods below can also be used in FIPS_MODE */
 177
 178 static int fromdata_init(EVP_PKEY_CTX *ctx, int operation)
 179 {
 180     if (ctx == NULL || ctx->keytype == NULL)
 181         goto not_supported;
 182
 183     evp_pkey_ctx_free_old_ops(ctx);
 184     ctx->operation = operation;
 185     if (ctx->keymgmt == NULL)
 186         ctx->keymgmt = EVP_KEYMGMT_fetch(ctx->libctx, ctx->keytype,
 187                                          ctx->propquery);
 188     if (ctx->keymgmt == NULL)
 189         goto not_supported;
 190
 191     return 1;
 192
 193  not_supported:
 194     ctx->operation = EVP_PKEY_OP_UNDEFINED;
 195     ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 196     return -2;
 197 }
 198
 199 int EVP_PKEY_param_fromdata_init(EVP_PKEY_CTX *ctx)
 200 {
 201     return fromdata_init(ctx, EVP_PKEY_OP_PARAMFROMDATA);
 202 }
 203
 204 int EVP_PKEY_key_fromdata_init(EVP_PKEY_CTX *ctx)
 205 {
 206     return fromdata_init(ctx, EVP_PKEY_OP_KEYFROMDATA);
 207 }
 208
 209 int EVP_PKEY_fromdata(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey, OSSL_PARAM params[])
 210 {
 211     void *provdata = NULL;
 212
 213     if (ctx == NULL || (ctx->operation & EVP_PKEY_OP_TYPE_FROMDATA) == 0) {
 214         ERR_raise(ERR_LIB_EVP, EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 215         return -2;
 216     }
 217
 218     if (ppkey == NULL)
 219         return -1;
 220
 221     if (*ppkey == NULL)
 222         *ppkey = EVP_PKEY_new();
 223
 224     if (*ppkey == NULL) {
 225         ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
 226         return -1;
 227     }
 228
 229     provdata =
 230         evp_keymgmt_util_fromdata(*ppkey, ctx->keymgmt, params,
 231                                   ctx->operation == EVP_PKEY_OP_PARAMFROMDATA);
 232
 233     if (provdata == NULL)
 234         return 0;
 235     /* provdata is cached in *ppkey, so we need not bother with it further */
 236     return 1;
 237 }
 238
 239 /*
 240  * TODO(3.0) Re-evaluate the names, it's possible that we find these to be
 241  * better:
 242  *
 243  * EVP_PKEY_param_settable()
 244  * EVP_PKEY_param_gettable()
 245  */
 246 const OSSL_PARAM *EVP_PKEY_param_fromdata_settable(EVP_PKEY_CTX *ctx)
 247 {
 248     /* We call fromdata_init to get ctx->keymgmt populated */
 249     if (fromdata_init(ctx, EVP_PKEY_OP_UNDEFINED))
 250         return evp_keymgmt_importdomparam_types(ctx->keymgmt);
 251     return NULL;
 252 }
 253
 254 const OSSL_PARAM *EVP_PKEY_key_fromdata_settable(EVP_PKEY_CTX *ctx)
 255 {
 256     /* We call fromdata_init to get ctx->keymgmt populated */
 257     if (fromdata_init(ctx, EVP_PKEY_OP_UNDEFINED))
 258         return evp_keymgmt_importdomparam_types(ctx->keymgmt);
 259     return NULL;
 260 }