crypto/dh/dh_meth.c

   1 /*
   2  * Copyright 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 "dh_locl.h"
  11 #include <string.h>
  12 #include <openssl/err.h>
  13
  14 DH_METHOD *DH_meth_new(const char *name, int flags)
  15 {
  16     DH_METHOD *dhm = OPENSSL_zalloc(sizeof(DH_METHOD));
  17
  18     if (dhm != NULL) {
  19         dhm->name = OPENSSL_strdup(name);
  20         if (dhm->name == NULL) {
  21             OPENSSL_free(dhm);
  22             DHerr(DH_F_DH_METH_NEW, ERR_R_MALLOC_FAILURE);
  23             return NULL;
  24         }
  25         dhm->flags = flags;
  26     }
  27
  28     return dhm;
  29 }
  30
  31 void DH_meth_free(DH_METHOD *dhm)
  32 {
  33     if (dhm != NULL) {
  34         OPENSSL_free(dhm->name);
  35         OPENSSL_free(dhm);
  36     }
  37 }
  38
  39 DH_METHOD *DH_meth_dup(const DH_METHOD *dhm)
  40 {
  41     DH_METHOD *ret;
  42
  43     ret = OPENSSL_malloc(sizeof(DH_METHOD));
  44
  45     if (ret != NULL) {
  46         memcpy(ret, dhm, sizeof(*dhm));
  47         ret->name = OPENSSL_strdup(dhm->name);
  48         if (ret->name == NULL) {
  49             OPENSSL_free(ret);
  50             DHerr(DH_F_DH_METH_DUP, ERR_R_MALLOC_FAILURE);
  51             return NULL;
  52         }
  53     }
  54
  55     return ret;
  56 }
  57
  58 const char *DH_meth_get0_name(const DH_METHOD *dhm)
  59 {
  60     return dhm->name;
  61 }
  62
  63 int DH_meth_set1_name(DH_METHOD *dhm, const char *name)
  64 {
  65     char *tmpname;
  66
  67     tmpname = OPENSSL_strdup(name);
  68     if (tmpname == NULL) {
  69         DHerr(DH_F_DH_METH_SET1_NAME, ERR_R_MALLOC_FAILURE);
  70         return 0;
  71     }
  72
  73     OPENSSL_free(dhm->name);
  74     dhm->name = tmpname;
  75
  76     return 1;
  77 }
  78
  79 int DH_meth_get_flags(DH_METHOD *dhm)
  80 {
  81     return dhm->flags;
  82 }
  83
  84 int DH_meth_set_flags(DH_METHOD *dhm, int flags)
  85 {
  86     dhm->flags = flags;
  87     return 1;
  88 }
  89
  90 void *DH_meth_get0_app_data(const DH_METHOD *dhm)
  91 {
  92     return dhm->app_data;
  93 }
  94
  95 int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data)
  96 {
  97     dhm->app_data = app_data;
  98     return 1;
  99 }
 100
 101 int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *)
 102 {
 103     return dhm->generate_key;
 104 }
 105
 106 int DH_meth_set_generate_key(DH_METHOD *dhm, int (*generate_key) (DH *))
 107 {
 108     dhm->generate_key = generate_key;
 109     return 1;
 110 }
 111
 112 int (*DH_meth_get_compute_key(const DH_METHOD *dhm))
 113         (unsigned char *key, const BIGNUM *pub_key, DH *dh)
 114 {
 115     return dhm->compute_key;
 116 }
 117
 118 int DH_meth_set_compute_key(DH_METHOD *dhm,
 119         int (*compute_key) (unsigned char *key, const BIGNUM *pub_key, DH *dh))
 120 {
 121     dhm->compute_key = compute_key;
 122     return 1;
 123 }
 124
 125
 126 int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm))
 127     (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
 128      BN_CTX *, BN_MONT_CTX *)
 129 {
 130     return dhm->bn_mod_exp;
 131 }
 132
 133 int DH_meth_set_bn_mod_exp(DH_METHOD *dhm,
 134     int (*bn_mod_exp) (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *,
 135                        const BIGNUM *, BN_CTX *, BN_MONT_CTX *))
 136 {
 137     dhm->bn_mod_exp = bn_mod_exp;
 138     return 1;
 139 }
 140
 141 int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *)
 142 {
 143     return dhm->init;
 144 }
 145
 146 int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *))
 147 {
 148     dhm->init = init;
 149     return 1;
 150 }
 151
 152 int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *)
 153 {
 154     return dhm->finish;
 155 }
 156
 157 int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *))
 158 {
 159     dhm->finish = finish;
 160     return 1;
 161 }
 162
 163 int (*DH_meth_get_generate_params(const DH_METHOD *dhm))
 164         (DH *, int, int, BN_GENCB *)
 165 {
 166     return dhm->generate_params;
 167 }
 168
 169 int DH_meth_set_generate_params(DH_METHOD *dhm,
 170         int (*generate_params) (DH *, int, int, BN_GENCB *))
 171 {
 172     dhm->generate_params = generate_params;
 173     return 1;
 174 }