crypto/cms/cms_enc.c

   1 /*
   2  * Copyright 2008-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 "internal/cryptlib.h"
  11 #include <openssl/asn1t.h>
  12 #include <openssl/pem.h>
  13 #include <openssl/x509v3.h>
  14 #include <openssl/err.h>
  15 #include <openssl/cms.h>
  16 #include <openssl/rand.h>
  17 #include "cms_local.h"
  18
  19 /* CMS EncryptedData Utilities */
  20
  21 /* Return BIO based on EncryptedContentInfo and key */
  22
  23 BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec,
  24                                    const CMS_CTX *cms_ctx)
  25 {
  26     BIO *b;
  27     EVP_CIPHER_CTX *ctx;
  28     EVP_CIPHER *fetched_ciph = NULL;
  29     const EVP_CIPHER *cipher = NULL;
  30     X509_ALGOR *calg = ec->contentEncryptionAlgorithm;
  31     unsigned char iv[EVP_MAX_IV_LENGTH], *piv = NULL;
  32     unsigned char *tkey = NULL;
  33     int len;
  34     size_t tkeylen = 0;
  35     int ok = 0;
  36     int enc, keep_key = 0;
  37
  38     enc = ec->cipher ? 1 : 0;
  39
  40     b = BIO_new(BIO_f_cipher());
  41     if (b == NULL) {
  42         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
  43         return NULL;
  44     }
  45
  46     BIO_get_cipher_ctx(b, &ctx);
  47
  48     if (enc) {
  49         cipher = ec->cipher;
  50         /*
  51          * If not keeping key set cipher to NULL so subsequent calls decrypt.
  52          */
  53         if (ec->key != NULL)
  54             ec->cipher = NULL;
  55     } else {
  56         cipher = EVP_get_cipherbyobj(calg->algorithm);
  57     }
  58     if (cipher != NULL) {
  59         fetched_ciph = EVP_CIPHER_fetch(cms_ctx->libctx, EVP_CIPHER_name(cipher),
  60                                         cms_ctx->propq);
  61         if (fetched_ciph == NULL) {
  62             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, CMS_R_UNKNOWN_CIPHER);
  63             goto err;
  64         }
  65     }
  66     if (EVP_CipherInit_ex(ctx, fetched_ciph, NULL, NULL, NULL, enc) <= 0) {
  67         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
  68                CMS_R_CIPHER_INITIALISATION_ERROR);
  69         goto err;
  70     }
  71     EVP_CIPHER_free(fetched_ciph);
  72
  73     if (enc) {
  74         int ivlen;
  75         calg->algorithm = OBJ_nid2obj(EVP_CIPHER_CTX_type(ctx));
  76         /* Generate a random IV if we need one */
  77         ivlen = EVP_CIPHER_CTX_iv_length(ctx);
  78         if (ivlen > 0) {
  79             if (RAND_bytes_ex(cms_ctx->libctx, iv, ivlen) <= 0)
  80                 goto err;
  81             piv = iv;
  82         }
  83     } else if (EVP_CIPHER_asn1_to_param(ctx, calg->parameter) <= 0) {
  84         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
  85                CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
  86         goto err;
  87     }
  88     len = EVP_CIPHER_CTX_key_length(ctx);
  89     if (len <= 0)
  90         goto err;
  91     tkeylen = (size_t)len;
  92
  93     /* Generate random session key */
  94     if (!enc || !ec->key) {
  95         tkey = OPENSSL_malloc(tkeylen);
  96         if (tkey == NULL) {
  97             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
  98             goto err;
  99         }
 100         if (EVP_CIPHER_CTX_rand_key(ctx, tkey) <= 0)
 101             goto err;
 102     }
 103
 104     if (!ec->key) {
 105         ec->key = tkey;
 106         ec->keylen = tkeylen;
 107         tkey = NULL;
 108         if (enc)
 109             keep_key = 1;
 110         else
 111             ERR_clear_error();
 112
 113     }
 114
 115     if (ec->keylen != tkeylen) {
 116         /* If necessary set key length */
 117         if (EVP_CIPHER_CTX_set_key_length(ctx, ec->keylen) <= 0) {
 118             /*
 119              * Only reveal failure if debugging so we don't leak information
 120              * which may be useful in MMA.
 121              */
 122             if (enc || ec->debug) {
 123                 CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
 124                        CMS_R_INVALID_KEY_LENGTH);
 125                 goto err;
 126             } else {
 127                 /* Use random key */
 128                 OPENSSL_clear_free(ec->key, ec->keylen);
 129                 ec->key = tkey;
 130                 ec->keylen = tkeylen;
 131                 tkey = NULL;
 132                 ERR_clear_error();
 133             }
 134         }
 135     }
 136
 137     if (EVP_CipherInit_ex(ctx, NULL, NULL, ec->key, piv, enc) <= 0) {
 138         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
 139                CMS_R_CIPHER_INITIALISATION_ERROR);
 140         goto err;
 141     }
 142     if (enc) {
 143         calg->parameter = ASN1_TYPE_new();
 144         if (calg->parameter == NULL) {
 145             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
 146             goto err;
 147         }
 148         if (EVP_CIPHER_param_to_asn1(ctx, calg->parameter) <= 0) {
 149             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
 150                    CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
 151             goto err;
 152         }
 153         /* If parameter type not set omit parameter */
 154         if (calg->parameter->type == V_ASN1_UNDEF) {
 155             ASN1_TYPE_free(calg->parameter);
 156             calg->parameter = NULL;
 157         }
 158     }
 159     ok = 1;
 160
 161  err:
 162     if (!keep_key || !ok) {
 163         OPENSSL_clear_free(ec->key, ec->keylen);
 164         ec->key = NULL;
 165     }
 166     OPENSSL_clear_free(tkey, tkeylen);
 167     if (ok)
 168         return b;
 169     BIO_free(b);
 170     return NULL;
 171 }
 172
 173 int cms_EncryptedContent_init(CMS_EncryptedContentInfo *ec,
 174                               const EVP_CIPHER *cipher,
 175                               const unsigned char *key, size_t keylen,
 176                               const CMS_CTX *cms_ctx)
 177 {
 178     ec->cipher = cipher;
 179     if (key) {
 180         if ((ec->key = OPENSSL_malloc(keylen)) == NULL) {
 181             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT, ERR_R_MALLOC_FAILURE);
 182             return 0;
 183         }
 184         memcpy(ec->key, key, keylen);
 185     }
 186     ec->keylen = keylen;
 187     if (cipher != NULL)
 188         ec->contentType = OBJ_nid2obj(NID_pkcs7_data);
 189     return 1;
 190 }
 191
 192 int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph,
 193                                const unsigned char *key, size_t keylen)
 194 {
 195     CMS_EncryptedContentInfo *ec;
 196
 197     if (!key || !keylen) {
 198         CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY, CMS_R_NO_KEY);
 199         return 0;
 200     }
 201     if (ciph) {
 202         cms->d.encryptedData = M_ASN1_new_of(CMS_EncryptedData);
 203         if (!cms->d.encryptedData) {
 204             CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY, ERR_R_MALLOC_FAILURE);
 205             return 0;
 206         }
 207         cms->contentType = OBJ_nid2obj(NID_pkcs7_encrypted);
 208         cms->d.encryptedData->version = 0;
 209     } else if (OBJ_obj2nid(cms->contentType) != NID_pkcs7_encrypted) {
 210         CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY, CMS_R_NOT_ENCRYPTED_DATA);
 211         return 0;
 212     }
 213     ec = cms->d.encryptedData->encryptedContentInfo;
 214     return cms_EncryptedContent_init(ec, ciph, key, keylen, cms_get0_cmsctx(cms));
 215 }
 216
 217 BIO *cms_EncryptedData_init_bio(const CMS_ContentInfo *cms)
 218 {
 219     CMS_EncryptedData *enc = cms->d.encryptedData;
 220     if (enc->encryptedContentInfo->cipher && enc->unprotectedAttrs)
 221         enc->version = 2;
 222     return cms_EncryptedContent_init_bio(enc->encryptedContentInfo,
 223                                          cms_get0_cmsctx(cms));
 224 }