crypto/dh/dh_meth.c

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