Home | History | Annotate | Line # | Download | only in dh 
      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     ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
     35     return NULL;
     36 }
     37 
     38 void DH_meth_free(DH_METHOD *dhm)
     39 {
     40     if (dhm != NULL) {
     41         OPENSSL_free(dhm->name);
     42         OPENSSL_free(dhm);
     43     }
     44 }
     45 
     46 DH_METHOD *DH_meth_dup(const DH_METHOD *dhm)
     47 {
     48     DH_METHOD *ret = OPENSSL_malloc(sizeof(*ret));
     49 
     50     if (ret != NULL) {
     51         memcpy(ret, dhm, sizeof(*dhm));
     52 
     53         ret->name = OPENSSL_strdup(dhm->name);
     54         if (ret->name != NULL)
     55             return ret;
     56 
     57         OPENSSL_free(ret);
     58     }
     59 
     60     ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
     61     return NULL;
     62 }
     63 
     64 const char *DH_meth_get0_name(const DH_METHOD *dhm)
     65 {
     66     return dhm->name;
     67 }
     68 
     69 int DH_meth_set1_name(DH_METHOD *dhm, const char *name)
     70 {
     71     char *tmpname = OPENSSL_strdup(name);
     72 
     73     if (tmpname == NULL) {
     74         ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
     75         return 0;
     76     }
     77 
     78     OPENSSL_free(dhm->name);
     79     dhm->name = tmpname;
     80 
     81     return 1;
     82 }
     83 
     84 int DH_meth_get_flags(const DH_METHOD *dhm)
     85 {
     86     return dhm->flags;
     87 }
     88 
     89 int DH_meth_set_flags(DH_METHOD *dhm, int flags)
     90 {
     91     dhm->flags = flags;
     92     return 1;
     93 }
     94 
     95 void *DH_meth_get0_app_data(const DH_METHOD *dhm)
     96 {
     97     return dhm->app_data;
     98 }
     99 
    100 int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data)
    101 {
    102     dhm->app_data = app_data;
    103     return 1;
    104 }
    105 
    106 int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *)
    107 {
    108     return dhm->generate_key;
    109 }
    110 
    111 int DH_meth_set_generate_key(DH_METHOD *dhm, int (*generate_key) (DH *))
    112 {
    113     dhm->generate_key = generate_key;
    114     return 1;
    115 }
    116 
    117 int (*DH_meth_get_compute_key(const DH_METHOD *dhm))
    118         (unsigned char *key, const BIGNUM *pub_key, DH *dh)
    119 {
    120     return dhm->compute_key;
    121 }
    122 
    123 int DH_meth_set_compute_key(DH_METHOD *dhm,
    124         int (*compute_key) (unsigned char *key, const BIGNUM *pub_key, DH *dh))
    125 {
    126     dhm->compute_key = compute_key;
    127     return 1;
    128 }
    129 
    130 
    131 int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm))
    132     (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
    133      BN_CTX *, BN_MONT_CTX *)
    134 {
    135     return dhm->bn_mod_exp;
    136 }
    137 
    138 int DH_meth_set_bn_mod_exp(DH_METHOD *dhm,
    139     int (*bn_mod_exp) (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *,
    140                        const BIGNUM *, BN_CTX *, BN_MONT_CTX *))
    141 {
    142     dhm->bn_mod_exp = bn_mod_exp;
    143     return 1;
    144 }
    145 
    146 int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *)
    147 {
    148     return dhm->init;
    149 }
    150 
    151 int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *))
    152 {
    153     dhm->init = init;
    154     return 1;
    155 }
    156 
    157 int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *)
    158 {
    159     return dhm->finish;
    160 }
    161 
    162 int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *))
    163 {
    164     dhm->finish = finish;
    165     return 1;
    166 }
    167 
    168 int (*DH_meth_get_generate_params(const DH_METHOD *dhm))
    169         (DH *, int, int, BN_GENCB *)
    170 {
    171     return dhm->generate_params;
    172 }
    173 
    174 int DH_meth_set_generate_params(DH_METHOD *dhm,
    175         int (*generate_params) (DH *, int, int, BN_GENCB *))
    176 {
    177     dhm->generate_params = generate_params;
    178     return 1;
    179 }
    180