crypto/evp/names.c

   1 /*
   2  * Copyright 1995-2018 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 "internal/cryptlib.h"
  12 #include <openssl/evp.h>
  13 #include <openssl/kdf.h>
  14 #include "internal/objects.h"
  15 #include <openssl/x509.h>
  16 #include "internal/evp_int.h"
  17
  18 int EVP_add_cipher(const EVP_CIPHER *c)
  19 {
  20     int r;
  21
  22     if (c == NULL)
  23         return 0;
  24
  25     r = OBJ_NAME_add(OBJ_nid2sn(c->nid), OBJ_NAME_TYPE_CIPHER_METH,
  26                      (const char *)c);
  27     if (r == 0)
  28         return 0;
  29     r = OBJ_NAME_add(OBJ_nid2ln(c->nid), OBJ_NAME_TYPE_CIPHER_METH,
  30                      (const char *)c);
  31     return r;
  32 }
  33
  34 int EVP_add_digest(const EVP_MD *md)
  35 {
  36     int r;
  37     const char *name;
  38
  39     name = OBJ_nid2sn(md->type);
  40     r = OBJ_NAME_add(name, OBJ_NAME_TYPE_MD_METH, (const char *)md);
  41     if (r == 0)
  42         return 0;
  43     r = OBJ_NAME_add(OBJ_nid2ln(md->type), OBJ_NAME_TYPE_MD_METH,
  44                      (const char *)md);
  45     if (r == 0)
  46         return 0;
  47
  48     if (md->pkey_type && md->type != md->pkey_type) {
  49         r = OBJ_NAME_add(OBJ_nid2sn(md->pkey_type),
  50                          OBJ_NAME_TYPE_MD_METH | OBJ_NAME_ALIAS, name);
  51         if (r == 0)
  52             return 0;
  53         r = OBJ_NAME_add(OBJ_nid2ln(md->pkey_type),
  54                          OBJ_NAME_TYPE_MD_METH | OBJ_NAME_ALIAS, name);
  55     }
  56     return r;
  57 }
  58
  59 int EVP_add_mac(const EVP_MAC *m)
  60 {
  61     int r;
  62
  63     if (m == NULL)
  64         return 0;
  65
  66     r = OBJ_NAME_add(OBJ_nid2sn(m->type), OBJ_NAME_TYPE_MAC_METH,
  67                      (const char *)m);
  68     if (r == 0)
  69         return 0;
  70     r = OBJ_NAME_add(OBJ_nid2ln(m->type), OBJ_NAME_TYPE_MAC_METH,
  71                      (const char *)m);
  72     return r;
  73 }
  74
  75 /* TODO(3.0) Is this needed after changing to providers? */
  76 int EVP_add_kdf(const EVP_KDF *k)
  77 {
  78     int r;
  79
  80     if (k == NULL)
  81         return 0;
  82
  83     r = OBJ_NAME_add(OBJ_nid2sn(k->type), OBJ_NAME_TYPE_KDF_METH,
  84                      (const char *)k);
  85     if (r == 0)
  86         return 0;
  87     r = OBJ_NAME_add(OBJ_nid2ln(k->type), OBJ_NAME_TYPE_KDF_METH,
  88                      (const char *)k);
  89     return r;
  90 }
  91
  92 const EVP_CIPHER *EVP_get_cipherbyname(const char *name)
  93 {
  94     const EVP_CIPHER *cp;
  95
  96     if (!OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL))
  97         return NULL;
  98
  99     cp = (const EVP_CIPHER *)OBJ_NAME_get(name, OBJ_NAME_TYPE_CIPHER_METH);
 100     return cp;
 101 }
 102
 103 const EVP_MD *EVP_get_digestbyname(const char *name)
 104 {
 105     const EVP_MD *cp;
 106
 107     if (!OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL))
 108         return NULL;
 109
 110     cp = (const EVP_MD *)OBJ_NAME_get(name, OBJ_NAME_TYPE_MD_METH);
 111     return cp;
 112 }
 113
 114 const EVP_MAC *EVP_get_macbyname(const char *name)
 115 {
 116     const EVP_MAC *mp;
 117
 118     if (!OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_MACS, NULL))
 119         return NULL;
 120
 121     mp = (const EVP_MAC *)OBJ_NAME_get(name, OBJ_NAME_TYPE_MAC_METH);
 122     return mp;
 123 }
 124
 125 /* TODO(3.0) Is this API needed after implementing providers? */
 126 const EVP_KDF *EVP_get_kdfbyname(const char *name)
 127 {
 128     const EVP_KDF *kdf;
 129
 130     if (!OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_KDFS, NULL))
 131         return NULL;
 132
 133     kdf = (const EVP_KDF *)OBJ_NAME_get(name, OBJ_NAME_TYPE_KDF_METH);
 134     return kdf;
 135 }
 136
 137 void evp_cleanup_int(void)
 138 {
 139     OBJ_NAME_cleanup(OBJ_NAME_TYPE_MAC_METH);
 140     OBJ_NAME_cleanup(OBJ_NAME_TYPE_KDF_METH);
 141     OBJ_NAME_cleanup(OBJ_NAME_TYPE_CIPHER_METH);
 142     OBJ_NAME_cleanup(OBJ_NAME_TYPE_MD_METH);
 143     /*
 144      * The above calls will only clean out the contents of the name hash
 145      * table, but not the hash table itself.  The following line does that
 146      * part.  -- Richard Levitte
 147      */
 148     OBJ_NAME_cleanup(-1);
 149
 150     EVP_PBE_cleanup();
 151     OBJ_sigid_free();
 152
 153     evp_app_cleanup_int();
 154 }
 155
 156 struct doall_cipher {
 157     void *arg;
 158     void (*fn) (const EVP_CIPHER *ciph,
 159                 const char *from, const char *to, void *arg);
 160 };
 161
 162 static void do_all_cipher_fn(const OBJ_NAME *nm, void *arg)
 163 {
 164     struct doall_cipher *dc = arg;
 165     if (nm->alias)
 166         dc->fn(NULL, nm->name, nm->data, dc->arg);
 167     else
 168         dc->fn((const EVP_CIPHER *)nm->data, nm->name, NULL, dc->arg);
 169 }
 170
 171 void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph,
 172                                    const char *from, const char *to, void *x),
 173                        void *arg)
 174 {
 175     struct doall_cipher dc;
 176
 177     /* Ignore errors */
 178     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL);
 179
 180     dc.fn = fn;
 181     dc.arg = arg;
 182     OBJ_NAME_do_all(OBJ_NAME_TYPE_CIPHER_METH, do_all_cipher_fn, &dc);
 183 }
 184
 185 void EVP_CIPHER_do_all_sorted(void (*fn) (const EVP_CIPHER *ciph,
 186                                           const char *from, const char *to,
 187                                           void *x), void *arg)
 188 {
 189     struct doall_cipher dc;
 190
 191     /* Ignore errors */
 192     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL);
 193
 194     dc.fn = fn;
 195     dc.arg = arg;
 196     OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH, do_all_cipher_fn, &dc);
 197 }
 198
 199 struct doall_md {
 200     void *arg;
 201     void (*fn) (const EVP_MD *ciph,
 202                 const char *from, const char *to, void *arg);
 203 };
 204
 205 static void do_all_md_fn(const OBJ_NAME *nm, void *arg)
 206 {
 207     struct doall_md *dc = arg;
 208     if (nm->alias)
 209         dc->fn(NULL, nm->name, nm->data, dc->arg);
 210     else
 211         dc->fn((const EVP_MD *)nm->data, nm->name, NULL, dc->arg);
 212 }
 213
 214 void EVP_MD_do_all(void (*fn) (const EVP_MD *md,
 215                                const char *from, const char *to, void *x),
 216                    void *arg)
 217 {
 218     struct doall_md dc;
 219
 220     /* Ignore errors */
 221     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
 222
 223     dc.fn = fn;
 224     dc.arg = arg;
 225     OBJ_NAME_do_all(OBJ_NAME_TYPE_MD_METH, do_all_md_fn, &dc);
 226 }
 227
 228 void EVP_MD_do_all_sorted(void (*fn) (const EVP_MD *md,
 229                                       const char *from, const char *to,
 230                                       void *x), void *arg)
 231 {
 232     struct doall_md dc;
 233
 234     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
 235
 236     dc.fn = fn;
 237     dc.arg = arg;
 238     OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_MD_METH, do_all_md_fn, &dc);
 239 }
 240
 241 /* TODO(3.0) Are these do_all API's needed for MAC? */
 242 struct doall_mac {
 243     void *arg;
 244     void (*fn) (const EVP_MAC *ciph,
 245                 const char *from, const char *to, void *arg);
 246 };
 247
 248 static void do_all_mac_fn(const OBJ_NAME *nm, void *arg)
 249 {
 250     struct doall_mac *dc = arg;
 251
 252     if (nm->alias)
 253         dc->fn(NULL, nm->name, nm->data, dc->arg);
 254     else
 255         dc->fn((const EVP_MAC *)nm->data, nm->name, NULL, dc->arg);
 256 }
 257
 258 void EVP_MAC_do_all(void (*fn)
 259                     (const EVP_MAC *ciph, const char *from, const char *to,
 260                      void *x), void *arg)
 261 {
 262     struct doall_mac dc;
 263
 264     /* Ignore errors */
 265     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_MACS, NULL);
 266
 267     dc.fn = fn;
 268     dc.arg = arg;
 269     OBJ_NAME_do_all(OBJ_NAME_TYPE_MAC_METH, do_all_mac_fn, &dc);
 270 }
 271
 272 void EVP_MAC_do_all_sorted(void (*fn)
 273                            (const EVP_MAC *ciph, const char *from,
 274                             const char *to, void *x), void *arg)
 275 {
 276     struct doall_mac dc;
 277
 278     /* Ignore errors */
 279     OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_MACS, NULL);
 280
 281     dc.fn = fn;
 282     dc.arg = arg;
 283     OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_MAC_METH, do_all_mac_fn, &dc);
 284 }