providers/implementations/serializers/serializer_common.c

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