providers/implementations/serializers/serializer_common.c

   1 /*
   2  * Copyright 2019 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 <openssl/opensslconf.h> /* SIXTY_FOUR_BIT_LONG, ... */
  11 #include <openssl/err.h>
  12 #include <openssl/pem.h>         /* PEM_BUFSIZE */
  13 #include <openssl/pkcs12.h>      /* PKCS8_encrypt() */
  14 #include <openssl/types.h>
  15 #include <openssl/x509.h>        /* i2d_X509_PUBKEY_bio() */
  16 #include "crypto/bn.h"           /* bn_get_words() */
  17 #include "prov/bio.h"            /* ossl_prov_bio_printf() */
  18 #include "prov/implementations.h"
  19 #include "prov/providercommonerr.h" /* PROV_R_READ_KEY */
  20 #include "serializer_local.h"
  21
  22 static PKCS8_PRIV_KEY_INFO *
  23 ossl_prov_p8info_from_obj(const void *obj, int obj_nid,
  24                           ASN1_STRING *params,
  25                           int params_type,
  26                           int (*k2d)(const void *obj,
  27                                      unsigned char **pder))
  28 {
  29     /* der, derlen store the key DER output and its length */
  30     unsigned char *der = NULL;
  31     int derlen;
  32     /* The final PKCS#8 info */
  33     PKCS8_PRIV_KEY_INFO *p8info = NULL;
  34
  35
  36     if ((p8info = PKCS8_PRIV_KEY_INFO_new()) == NULL
  37         || (derlen = k2d(obj, &der)) <= 0
  38         || !PKCS8_pkey_set0(p8info, OBJ_nid2obj(obj_nid), 0,
  39                             params_type, params, der, derlen)) {
  40         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
  41         PKCS8_PRIV_KEY_INFO_free(p8info);
  42         OPENSSL_free(der);
  43         p8info = NULL;
  44     }
  45
  46     return p8info;
  47 }
  48
  49 static X509_SIG *ossl_prov_encp8_from_p8info(PKCS8_PRIV_KEY_INFO *p8info,
  50                                              struct pkcs8_encrypt_ctx_st *ctx)
  51 {
  52     X509_SIG *p8 = NULL;
  53     char buf[PEM_BUFSIZE];
  54     const void *kstr = ctx->cipher_pass;
  55     size_t klen = ctx->cipher_pass_length;
  56
  57     if (ctx->cipher == NULL)
  58         return NULL;
  59
  60     if (kstr == NULL) {
  61         if (!ctx->cb(buf, sizeof(buf), &klen, NULL, ctx->cbarg)) {
  62             ERR_raise(ERR_LIB_PROV, PROV_R_READ_KEY);
  63             return NULL;
  64         }
  65         kstr = buf;
  66     }
  67     /* NID == -1 means "standard" */
  68     p8 = PKCS8_encrypt(-1, ctx->cipher, kstr, klen, NULL, 0, 0, p8info);
  69     if (kstr == buf)
  70         OPENSSL_cleanse(buf, klen);
  71     return p8;
  72 }
  73
  74 static X509_SIG *ossl_prov_encp8_from_obj(const void *obj, int obj_nid,
  75                                           ASN1_STRING *params,
  76                                           int params_type,
  77                                           int (*k2d)(const void *obj,
  78                                                      unsigned char **pder),
  79                                           struct pkcs8_encrypt_ctx_st *ctx)
  80 {
  81     PKCS8_PRIV_KEY_INFO *p8info =
  82         ossl_prov_p8info_from_obj(obj, obj_nid, params, params_type, k2d);
  83     X509_SIG *p8 = ossl_prov_encp8_from_p8info(p8info, ctx);
  84
  85     PKCS8_PRIV_KEY_INFO_free(p8info);
  86     return p8;
  87 }
  88
  89 static X509_PUBKEY *ossl_prov_pubkey_from_obj(const void *obj, int obj_nid,
  90                                               ASN1_STRING *params,
  91                                               int params_type,
  92                                               int (*k2d)(const void *obj,
  93                                                          unsigned char **pder))
  94 {
  95     /* der, derlen store the key DER output and its length */
  96     unsigned char *der = NULL;
  97     int derlen;
  98     /* The final X509_PUBKEY */
  99     X509_PUBKEY *xpk = NULL;
 100
 101
 102     if ((xpk = X509_PUBKEY_new()) == NULL
 103         || (derlen = k2d(obj, &der)) <= 0
 104         || !X509_PUBKEY_set0_param(xpk, OBJ_nid2obj(obj_nid),
 105                                    params_type, params, der, derlen)) {
 106         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 107         X509_PUBKEY_free(xpk);
 108         OPENSSL_free(der);
 109         xpk = NULL;
 110     }
 111
 112     return xpk;
 113 }
 114
 115 OSSL_OP_keymgmt_new_fn *ossl_prov_get_keymgmt_new(const OSSL_DISPATCH *fns)
 116 {
 117     /* Pilfer the keymgmt dispatch table */
 118     for (; fns->function_id != 0; fns++)
 119         if (fns->function_id == OSSL_FUNC_KEYMGMT_NEW)
 120             return OSSL_get_OP_keymgmt_new(fns);
 121
 122     return NULL;
 123 }
 124
 125 OSSL_OP_keymgmt_free_fn *ossl_prov_get_keymgmt_free(const OSSL_DISPATCH *fns)
 126 {
 127     /* Pilfer the keymgmt dispatch table */
 128     for (; fns->function_id != 0; fns++)
 129         if (fns->function_id == OSSL_FUNC_KEYMGMT_FREE)
 130             return OSSL_get_OP_keymgmt_free(fns);
 131
 132     return NULL;
 133 }
 134
 135 OSSL_OP_keymgmt_import_fn *ossl_prov_get_keymgmt_import(const OSSL_DISPATCH *fns)
 136 {
 137     /* Pilfer the keymgmt dispatch table */
 138     for (; fns->function_id != 0; fns++)
 139         if (fns->function_id == OSSL_FUNC_KEYMGMT_IMPORT)
 140             return OSSL_get_OP_keymgmt_import(fns);
 141
 142     return NULL;
 143 }
 144
 145 # ifdef SIXTY_FOUR_BIT_LONG
 146 #  define BN_FMTu "%lu"
 147 #  define BN_FMTx "%lx"
 148 # endif
 149
 150 # ifdef SIXTY_FOUR_BIT
 151 #  define BN_FMTu "%llu"
 152 #  define BN_FMTx "%llx"
 153 # endif
 154
 155 # ifdef THIRTY_TWO_BIT
 156 #  define BN_FMTu "%u"
 157 #  define BN_FMTx "%x"
 158 # endif
 159
 160 int ossl_prov_print_labeled_bignum(BIO *out, const char *label,
 161                                    const BIGNUM *bn)
 162 {
 163     const char *neg;
 164     const char *post_label_spc = " ";
 165     int bytes;
 166     BN_ULONG *words;
 167     int n, i;
 168
 169     if (bn == NULL)
 170         return 0;
 171     if (label == NULL) {
 172         label = "";
 173         post_label_spc = "";
 174     }
 175
 176     bytes = BN_num_bytes(bn);
 177     words = bn_get_words(bn);
 178     neg = BN_is_negative(bn) ? "-" : "";
 179
 180     if (BN_is_zero(bn))
 181         return ossl_prov_bio_printf(out, "%s%s0\n", label, post_label_spc);
 182
 183     if (BN_num_bytes(bn) <= BN_BYTES)
 184         return ossl_prov_bio_printf(out,
 185                                     "%s%s%s" BN_FMTu " (%s0x" BN_FMTx ")\n",
 186                                     label, post_label_spc, neg, words[0],
 187                                     neg, words[0]);
 188
 189     if (neg[0] == '-')
 190         neg = " (Negative)";
 191
 192     if (ossl_prov_bio_printf(out, "%s%s\n", label, neg) <= 0)
 193         return 0;
 194
 195     /* Keep track of how many bytes we have printed out so far */
 196     n = 0;
 197
 198     /*
 199      * OpenSSL BIGNUMs are little endian limbs, so we print them last to
 200      * first limb.
 201      * i is used as limb index, j is used as the "byte index" in the limb
 202      */
 203     for (i = bytes / BN_BYTES - 1; i >= 0; i--) {
 204         BN_ULONG l = words[i];
 205         int  j;
 206
 207         for (j = BN_BYTES - 1; j >= 0; j--) {
 208             int o = 8 * j;
 209             int b = ((l & (0xffLU << o)) >> o) & 0xff;
 210
 211             /* Indent every new line with 4 spaces */
 212             if ((n % 15) == 0) {
 213                 if (n > 0)
 214                     if (ossl_prov_bio_printf(out, "\n") <= 0)
 215                         return 0;
 216                 if (ossl_prov_bio_printf(out, "    ") <= 0)
 217                     return 0;
 218             }
 219
 220             /*
 221              * Upper bit set, then we print an extra zero and pretend the
 222              * BIGNUM was one byte longer
 223              */
 224             if (n == 0 && b > 127) {
 225                 if (ossl_prov_bio_printf(out, "%02x:", 0) <= 0)
 226                     return 0;
 227                 n++;
 228                 bytes++;
 229             }
 230
 231             if (++n < bytes) {
 232                 if (ossl_prov_bio_printf(out, "%02x:", b) <= 0)
 233                     return 0;
 234             } else {
 235                 if (ossl_prov_bio_printf(out, "%02x", b) <= 0)
 236                     return 0;
 237             }
 238         }
 239     }
 240     if (ossl_prov_bio_printf(out, "\n") <= 0)
 241         return 0;
 242
 243     return 1;
 244 }
 245
 246 /* p2s = param to asn1_string, k2d = key to der */
 247 int ossl_prov_write_priv_der_from_obj(BIO *out, const void *obj, int obj_nid,
 248                                       int (*p2s)(const void *obj, int nid,
 249                                                  ASN1_STRING **str,
 250                                                  int *strtype),
 251                                       int (*k2d)(const void *obj,
 252                                                  unsigned char **pder),
 253                                       struct pkcs8_encrypt_ctx_st *ctx)
 254 {
 255     int ret = 0;
 256     ASN1_STRING *str = NULL;
 257     int strtype = 0;
 258
 259     if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
 260         return 0;
 261
 262     if (ctx->cipher_intent) {
 263         X509_SIG *p8 =
 264             ossl_prov_encp8_from_obj(obj, obj_nid, str, strtype, k2d, ctx);
 265
 266         if (p8 != NULL)
 267             ret = i2d_PKCS8_bio(out, p8);
 268
 269         X509_SIG_free(p8);
 270     } else {
 271         PKCS8_PRIV_KEY_INFO *p8info =
 272             ossl_prov_p8info_from_obj(obj, obj_nid, str, strtype, k2d);
 273
 274         if (p8info != NULL)
 275             ret = i2d_PKCS8_PRIV_KEY_INFO_bio(out, p8info);
 276
 277         PKCS8_PRIV_KEY_INFO_free(p8info);
 278     }
 279
 280     return ret;
 281 }
 282
 283 int ossl_prov_write_priv_pem_from_obj(BIO *out, const void *obj, int obj_nid,
 284                                       int (*p2s)(const void *obj, int nid,
 285                                                  ASN1_STRING **str,
 286                                                  int *strtype),
 287                                       int (*k2d)(const void *obj,
 288                                                  unsigned char **pder),
 289                                       struct pkcs8_encrypt_ctx_st *ctx)
 290 {
 291     int ret = 0;
 292     ASN1_STRING *str = NULL;
 293     int strtype = 0;
 294
 295     if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
 296         return 0;
 297
 298     if (ctx->cipher_intent) {
 299         X509_SIG *p8 = ossl_prov_encp8_from_obj(obj, obj_nid, str, strtype,
 300                                                 k2d, ctx);
 301
 302         if (p8 != NULL)
 303             ret = PEM_write_bio_PKCS8(out, p8);
 304
 305         X509_SIG_free(p8);
 306     } else {
 307         PKCS8_PRIV_KEY_INFO *p8info =
 308             ossl_prov_p8info_from_obj(obj, obj_nid, str, strtype, k2d);
 309
 310         if (p8info != NULL)
 311             ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(out, p8info);
 312
 313         PKCS8_PRIV_KEY_INFO_free(p8info);
 314     }
 315
 316     return ret;
 317 }
 318
 319 int ossl_prov_write_pub_der_from_obj(BIO *out, const void *obj, int obj_nid,
 320                                      int (*p2s)(const void *obj, int nid,
 321                                                 ASN1_STRING **str,
 322                                                 int *strtype),
 323                                      int (*k2d)(const void *obj,
 324                                                 unsigned char **pder))
 325 {
 326     int ret = 0;
 327     ASN1_STRING *str = NULL;
 328     int strtype = 0;
 329     X509_PUBKEY *xpk = NULL;
 330
 331     if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
 332         return 0;
 333
 334     xpk = ossl_prov_pubkey_from_obj(obj, obj_nid, str, strtype, k2d);
 335
 336     if (xpk != NULL)
 337         ret = i2d_X509_PUBKEY_bio(out, xpk);
 338
 339     /* Also frees |str| */
 340     X509_PUBKEY_free(xpk);
 341     return ret;
 342 }
 343
 344 int ossl_prov_write_pub_pem_from_obj(BIO *out, const void *obj, int obj_nid,
 345                                      int (*p2s)(const void *obj, int nid,
 346                                                 ASN1_STRING **str,
 347                                                 int *strtype),
 348                                      int (*k2d)(const void *obj,
 349                                                 unsigned char **pder))
 350 {
 351     int ret = 0;
 352     ASN1_STRING *str = NULL;
 353     int strtype = 0;
 354     X509_PUBKEY *xpk = NULL;
 355
 356     if (p2s != NULL && !p2s(obj, obj_nid, &str, &strtype))
 357         return 0;
 358
 359     xpk = ossl_prov_pubkey_from_obj(obj, obj_nid, str, strtype, k2d);
 360
 361     if (xpk != NULL)
 362         ret = PEM_write_bio_X509_PUBKEY(out, xpk);
 363
 364     /* Also frees |str| */
 365     X509_PUBKEY_free(xpk);
 366     return ret;
 367 }
 368