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