crypto/evp/pmeth_gn.c

   1 /* pmeth_gn.c */
   2 /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL
   3  * project 2006.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include "cryptlib.h"
  62 #include <openssl/objects.h>
  63 #include <openssl/evp.h>
  64 #include "evp_locl.h"
  65
  66 int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx)
  67         {
  68         int ret;
  69         if (!ctx || !ctx->pmeth || !ctx->pmeth->paramgen)
  70                 {
  71                 EVPerr(EVP_F_EVP_PKEY_PARAMGEN_INIT,
  72                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
  73                 return -2;
  74                 }
  75         ctx->operation = EVP_PKEY_OP_PARAMGEN;
  76         if (!ctx->pmeth->paramgen_init)
  77                 return 1;
  78         ret = ctx->pmeth->paramgen_init(ctx);
  79         if (ret <= 0)
  80                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
  81         return ret;
  82         }
  83
  84 int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
  85         {
  86         int ret;
  87         if (!ctx || !ctx->pmeth || !ctx->pmeth->paramgen)
  88                 {
  89                 EVPerr(EVP_F_EVP_PKEY_PARAMGEN,
  90                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
  91                 return -2;
  92                 }
  93
  94         if (ctx->operation != EVP_PKEY_OP_PARAMGEN)
  95                 {
  96                 EVPerr(EVP_F_EVP_PKEY_PARAMGEN, EVP_R_OPERATON_NOT_INITIALIZED);
  97                 return -1;
  98                 }
  99
 100         if (!ppkey)
 101                 return -1;
 102
 103         if (!*ppkey)
 104                 *ppkey = EVP_PKEY_new();
 105
 106         ret = ctx->pmeth->paramgen(ctx, *ppkey);
 107         if (ret <= 0)
 108                 {
 109                 EVP_PKEY_free(*ppkey);
 110                 *ppkey = NULL;
 111                 }
 112         return ret;
 113         }
 114
 115 int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx)
 116         {
 117         int ret;
 118         if (!ctx || !ctx->pmeth || !ctx->pmeth->keygen)
 119                 {
 120                 EVPerr(EVP_F_EVP_PKEY_KEYGEN_INIT,
 121                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 122                 return -2;
 123                 }
 124         ctx->operation = EVP_PKEY_OP_KEYGEN;
 125         if (!ctx->pmeth->keygen_init)
 126                 return 1;
 127         ret = ctx->pmeth->keygen_init(ctx);
 128         if (ret <= 0)
 129                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
 130         return ret;
 131         }
 132
 133 int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey)
 134         {
 135         int ret;
 136
 137         if (!ctx || !ctx->pmeth || !ctx->pmeth->keygen)
 138                 {
 139                 EVPerr(EVP_F_EVP_PKEY_KEYGEN,
 140                         EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
 141                 return -2;
 142                 }
 143         if (ctx->operation != EVP_PKEY_OP_KEYGEN)
 144                 {
 145                 EVPerr(EVP_F_EVP_PKEY_KEYGEN, EVP_R_OPERATON_NOT_INITIALIZED);
 146                 return -1;
 147                 }
 148
 149         if (!ppkey)
 150                 return -1;
 151
 152         if (!*ppkey)
 153                 *ppkey = EVP_PKEY_new();
 154
 155         ret = ctx->pmeth->keygen(ctx, *ppkey);
 156         if (ret <= 0)
 157                 {
 158                 EVP_PKEY_free(*ppkey);
 159                 *ppkey = NULL;
 160                 }
 161         return ret;
 162         }
 163
 164 void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb)
 165         {
 166         ctx->pkey_gencb = cb;
 167         }
 168
 169 EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx)
 170         {
 171         return ctx->pkey_gencb;
 172         }
 173
 174 /* "translation callback" to call EVP_PKEY_CTX callbacks using BN_GENCB
 175  * style callbacks.
 176  */
 177
 178 static int trans_cb(int a, int b, BN_GENCB *gcb)
 179         {
 180         EVP_PKEY_CTX *ctx = gcb->arg;
 181         ctx->keygen_info[0] = a;
 182         ctx->keygen_info[1] = b;
 183         return ctx->pkey_gencb(ctx);
 184         }
 185
 186 void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx)
 187         {
 188         BN_GENCB_set(cb, trans_cb, ctx)
 189         }
 190
 191 int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx)
 192         {
 193         if (idx == -1)
 194                 return ctx->keygen_info_count;
 195         if (idx < 0 || idx > ctx->keygen_info_count)
 196                 return 0;
 197         return ctx->keygen_info[idx];
 198         }
 199
 200 EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e,
 201                                 unsigned char *key, int keylen)
 202         {
 203         EVP_PKEY_CTX *mac_ctx = NULL;
 204         EVP_PKEY *mac_key = NULL;
 205         mac_ctx = EVP_PKEY_CTX_new_id(type, e);
 206         if (!mac_ctx)
 207                 return NULL;
 208         if (EVP_PKEY_keygen_init(mac_ctx) <= 0)
 209                 goto merr;
 210         if (EVP_PKEY_CTX_ctrl(mac_ctx, -1, EVP_PKEY_OP_KEYGEN,
 211                                 EVP_PKEY_CTRL_SET_MAC_KEY, keylen, key) <= 0)
 212                 goto merr;
 213         if (EVP_PKEY_keygen(mac_ctx, &mac_key) <= 0)
 214                 goto merr;
 215         merr:
 216         if (mac_ctx)
 217                 EVP_PKEY_CTX_free(mac_ctx);
 218         return mac_key;
 219         }