usr/src/lib/libkmf/plugins/kmf_openssl/common/compat.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright 2018 RackTop Systems.
   4  *
   5  * Licensed under the OpenSSL license (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <string.h>
  12 #include <openssl/bio.h>
  13 #include <openssl/engine.h>
  14 #include "compat.h"
  15
  16 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
  17
  18 static void *
  19 OPENSSL_zalloc(size_t num)
  20 {
  21         void *ret = OPENSSL_malloc(num);
  22
  23         if (ret != NULL)
  24                 (void) memset(ret, 0, num);
  25         return (ret);
  26 }
  27
  28 int
  29 RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d)
  30 {
  31         /*
  32          * If the fields n and e in r are NULL, the corresponding input
  33          * parameters MUST be non-NULL for n and e.  d may be
  34          * left NULL (in case only the public key is used).
  35          */
  36         if ((r->n == NULL && n == NULL) || (r->e == NULL && e == NULL))
  37                 return (0);
  38
  39         if (n != NULL) {
  40                 BN_free(r->n);
  41                 r->n = n;
  42         }
  43         if (e != NULL) {
  44                 BN_free(r->e);
  45                 r->e = e;
  46         }
  47         if (d != NULL) {
  48                 BN_free(r->d);
  49                 r->d = d;
  50         }
  51
  52         return (1);
  53 }
  54
  55 int
  56 RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q)
  57 {
  58         /*
  59          * If the fields p and q in r are NULL, the corresponding input
  60          * parameters MUST be non-NULL.
  61          */
  62         if ((r->p == NULL && p == NULL) || (r->q == NULL && q == NULL))
  63                 return (0);
  64
  65         if (p != NULL) {
  66                 BN_free(r->p);
  67                 r->p = p;
  68         }
  69         if (q != NULL) {
  70                 BN_free(r->q);
  71                 r->q = q;
  72         }
  73
  74         return (1);
  75 }
  76
  77 int
  78 RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp)
  79 {
  80         /*
  81          * If the fields dmp1, dmq1 and iqmp in r are NULL, the
  82          * corresponding input parameters MUST be non-NULL.
  83          */
  84         if ((r->dmp1 == NULL && dmp1 == NULL) ||
  85             (r->dmq1 == NULL && dmq1 == NULL) ||
  86             (r->iqmp == NULL && iqmp == NULL))
  87                 return (0);
  88
  89         if (dmp1 != NULL) {
  90                 BN_free(r->dmp1);
  91                 r->dmp1 = dmp1;
  92         }
  93         if (dmq1 != NULL) {
  94                 BN_free(r->dmq1);
  95                 r->dmq1 = dmq1;
  96         }
  97         if (iqmp != NULL) {
  98                 BN_free(r->iqmp);
  99                 r->iqmp = iqmp;
 100         }
 101
 102         return (1);
 103 }
 104
 105 void
 106 RSA_get0_key(const RSA *r, const BIGNUM **n, const BIGNUM **e, const BIGNUM **d)
 107 {
 108         if (n != NULL)
 109                 *n = r->n;
 110         if (e != NULL)
 111                 *e = r->e;
 112         if (d != NULL)
 113                 *d = r->d;
 114 }
 115
 116 void
 117 RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q)
 118 {
 119         if (p != NULL)
 120                 *p = r->p;
 121         if (q != NULL)
 122                 *q = r->q;
 123 }
 124
 125 void
 126 RSA_get0_crt_params(const RSA *r, const BIGNUM **dmp1, const BIGNUM **dmq1,
 127     const BIGNUM **iqmp)
 128 {
 129         if (dmp1 != NULL)
 130                 *dmp1 = r->dmp1;
 131         if (dmq1 != NULL)
 132                 *dmq1 = r->dmq1;
 133         if (iqmp != NULL)
 134                 *iqmp = r->iqmp;
 135 }
 136
 137 void
 138 DSA_get0_pqg(const DSA *d, const BIGNUM **p, const BIGNUM **q,
 139     const BIGNUM **g)
 140 {
 141         if (p != NULL)
 142                 *p = d->p;
 143         if (q != NULL)
 144                 *q = d->q;
 145         if (g != NULL)
 146                 *g = d->g;
 147 }
 148
 149 int
 150 DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g)
 151 {
 152         /*
 153          * If the fields p, q and g in d are NULL, the corresponding input
 154          * parameters MUST be non-NULL.
 155          */
 156         if ((d->p == NULL && p == NULL) || (d->q == NULL && q == NULL) ||
 157             (d->g == NULL && g == NULL))
 158                 return (0);
 159
 160         if (p != NULL) {
 161                 BN_free(d->p);
 162                 d->p = p;
 163         }
 164         if (q != NULL) {
 165                 BN_free(d->q);
 166                 d->q = q;
 167         }
 168         if (g != NULL) {
 169                 BN_free(d->g);
 170                 d->g = g;
 171         }
 172
 173         return (1);
 174 }
 175
 176 void
 177 DSA_get0_key(const DSA *d, const BIGNUM **pub_key, const BIGNUM **priv_key)
 178 {
 179         if (pub_key != NULL)
 180                 *pub_key = d->pub_key;
 181         if (priv_key != NULL)
 182                 *priv_key = d->priv_key;
 183 }
 184
 185 int
 186 DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key)
 187 {
 188         /*
 189          * If the field pub_key in d is NULL, the corresponding input
 190          * parameters MUST be non-NULL.  The priv_key field may
 191          * be left NULL.
 192          */
 193         if (d->pub_key == NULL && pub_key == NULL)
 194                 return (0);
 195
 196         if (pub_key != NULL) {
 197                 BN_free(d->pub_key);
 198                 d->pub_key = pub_key;
 199         }
 200         if (priv_key != NULL) {
 201                 BN_free(d->priv_key);
 202                 d->priv_key = priv_key;
 203         }
 204
 205         return (1);
 206 }
 207
 208 void
 209 DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
 210 {
 211         if (pr != NULL)
 212                 *pr = sig->r;
 213         if (ps != NULL)
 214                 *ps = sig->s;
 215 }
 216
 217 int
 218 DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s)
 219 {
 220         if (r == NULL || s == NULL)
 221                 return (0);
 222         BN_clear_free(sig->r);
 223         BN_clear_free(sig->s);
 224         sig->r = r;
 225         sig->s = s;
 226         return (1);
 227 }
 228
 229 DSA *
 230 EVP_PKEY_get0_DSA(EVP_PKEY *pkey)
 231 {
 232         if (pkey->type != EVP_PKEY_DSA)
 233                 return (NULL);
 234         return (pkey->pkey.dsa);
 235 }
 236
 237 void
 238 ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps)
 239 {
 240         if (pr != NULL)
 241                 *pr = sig->r;
 242         if (ps != NULL)
 243                 *ps = sig->s;
 244 }
 245
 246 int
 247 ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s)
 248 {
 249         if (r == NULL || s == NULL)
 250                 return (0);
 251         BN_clear_free(sig->r);
 252         BN_clear_free(sig->s);
 253         sig->r = r;
 254         sig->s = s;
 255         return (1);
 256 }
 257
 258 void
 259 DH_get0_pqg(const DH *dh, const BIGNUM **p, const BIGNUM **q, const BIGNUM **g)
 260 {
 261         if (p != NULL)
 262                 *p = dh->p;
 263         if (q != NULL)
 264                 *q = dh->q;
 265         if (g != NULL)
 266                 *g = dh->g;
 267 }
 268
 269 int
 270 DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g)
 271 {
 272         /*
 273          * If the fields p and g in d are NULL, the corresponding input
 274          * parameters MUST be non-NULL.  q may remain NULL.
 275          */
 276         if ((dh->p == NULL && p == NULL) || (dh->g == NULL && g == NULL))
 277                 return (0);
 278
 279         if (p != NULL) {
 280                 BN_free(dh->p);
 281                 dh->p = p;
 282         }
 283         if (q != NULL) {
 284                 BN_free(dh->q);
 285                 dh->q = q;
 286         }
 287         if (g != NULL) {
 288                 BN_free(dh->g);
 289                 dh->g = g;
 290         }
 291
 292         if (q != NULL) {
 293                 dh->length = BN_num_bits(q);
 294         }
 295
 296         return (1);
 297 }
 298
 299 void
 300 DH_get0_key(const DH *dh, const BIGNUM **pub_key, const BIGNUM **priv_key)
 301 {
 302         if (pub_key != NULL)
 303                 *pub_key = dh->pub_key;
 304         if (priv_key != NULL)
 305                 *priv_key = dh->priv_key;
 306 }
 307
 308 int
 309 DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key)
 310 {
 311         /*
 312          * If the field pub_key in dh is NULL, the corresponding input
 313          * parameters MUST be non-NULL.  The priv_key field may
 314          * be left NULL.
 315          */
 316         if (dh->pub_key == NULL && pub_key == NULL)
 317                 return (0);
 318
 319         if (pub_key != NULL) {
 320                 BN_free(dh->pub_key);
 321                 dh->pub_key = pub_key;
 322         }
 323         if (priv_key != NULL) {
 324                 BN_free(dh->priv_key);
 325                 dh->priv_key = priv_key;
 326         }
 327
 328         return (1);
 329 }
 330
 331 int
 332 DH_set_length(DH *dh, long length)
 333 {
 334         dh->length = length;
 335         return (1);
 336 }
 337
 338 const unsigned char *
 339 EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx)
 340 {
 341         return (ctx->iv);
 342 }
 343
 344 unsigned char *
 345 EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx)
 346 {
 347         return (ctx->iv);
 348 }
 349
 350 EVP_MD_CTX *
 351 EVP_MD_CTX_new(void)
 352 {
 353         return (OPENSSL_zalloc(sizeof (EVP_MD_CTX)));
 354 }
 355
 356 void
 357 EVP_MD_CTX_free(EVP_MD_CTX *ctx)
 358 {
 359         (void) EVP_MD_CTX_cleanup(ctx);
 360         OPENSSL_free(ctx);
 361 }
 362
 363 RSA_METHOD *
 364 RSA_meth_dup(const RSA_METHOD *meth)
 365 {
 366         RSA_METHOD *ret;
 367
 368         ret = OPENSSL_malloc(sizeof (RSA_METHOD));
 369
 370         if (ret != NULL) {
 371                 (void) memcpy(ret, meth, sizeof (*meth));
 372                 ret->name = OPENSSL_strdup(meth->name);
 373                 if (ret->name == NULL) {
 374                         OPENSSL_free(ret);
 375                         return (NULL);
 376                 }
 377         }
 378
 379         return (ret);
 380 }
 381
 382 int
 383 RSA_meth_set1_name(RSA_METHOD *meth, const char *name)
 384 {
 385         char *tmpname;
 386
 387         tmpname = OPENSSL_strdup(name);
 388         if (tmpname == NULL) {
 389                 return (0);
 390         }
 391
 392         OPENSSL_free((char *)meth->name);
 393         meth->name = tmpname;
 394
 395         return (1);
 396 }
 397
 398 int
 399 RSA_meth_set_priv_enc(RSA_METHOD *meth,
 400     int (*priv_enc) (int flen, const unsigned char *from,
 401     unsigned char *to, RSA *rsa, int padding))
 402 {
 403         meth->rsa_priv_enc = priv_enc;
 404         return (1);
 405 }
 406
 407 int
 408 RSA_meth_set_priv_dec(RSA_METHOD *meth,
 409     int (*priv_dec) (int flen, const unsigned char *from,
 410     unsigned char *to, RSA *rsa, int padding))
 411 {
 412         meth->rsa_priv_dec = priv_dec;
 413         return (1);
 414 }
 415
 416 int
 417 RSA_meth_set_finish(RSA_METHOD *meth, int (*finish) (RSA *rsa))
 418 {
 419         meth->finish = finish;
 420         return (1);
 421 }
 422
 423 void
 424 RSA_meth_free(RSA_METHOD *meth)
 425 {
 426         if (meth != NULL) {
 427                 OPENSSL_free((char *)meth->name);
 428                 OPENSSL_free(meth);
 429         }
 430 }
 431
 432 int
 433 RSA_bits(const RSA *r)
 434 {
 435         return (BN_num_bits(r->n));
 436 }
 437
 438 RSA *
 439 EVP_PKEY_get0_RSA(EVP_PKEY *pkey)
 440 {
 441         if (pkey->type != EVP_PKEY_RSA) {
 442                 return (NULL);
 443         }
 444         return (pkey->pkey.rsa);
 445 }
 446
 447 #endif /* OPENSSL_VERSION_NUMBER || LIBRESSL_VERSION_NUMBER */