crypto/cms/cms_enc.c

   1 /*
   2  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
   3  * project.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2008 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  */
  53
  54 #include "internal/cryptlib.h"
  55 #include <openssl/asn1t.h>
  56 #include <openssl/pem.h>
  57 #include <openssl/x509v3.h>
  58 #include <openssl/err.h>
  59 #include <openssl/cms.h>
  60 #include <openssl/rand.h>
  61 #include "cms_lcl.h"
  62
  63 /* CMS EncryptedData Utilities */
  64
  65 /* Return BIO based on EncryptedContentInfo and key */
  66
  67 BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
  68 {
  69     BIO *b;
  70     EVP_CIPHER_CTX *ctx;
  71     const EVP_CIPHER *ciph;
  72     X509_ALGOR *calg = ec->contentEncryptionAlgorithm;
  73     unsigned char iv[EVP_MAX_IV_LENGTH], *piv = NULL;
  74     unsigned char *tkey = NULL;
  75     size_t tkeylen = 0;
  76
  77     int ok = 0;
  78
  79     int enc, keep_key = 0;
  80
  81     enc = ec->cipher ? 1 : 0;
  82
  83     b = BIO_new(BIO_f_cipher());
  84     if (b == NULL) {
  85         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
  86         return NULL;
  87     }
  88
  89     BIO_get_cipher_ctx(b, &ctx);
  90
  91     if (enc) {
  92         ciph = ec->cipher;
  93         /*
  94          * If not keeping key set cipher to NULL so subsequent calls decrypt.
  95          */
  96         if (ec->key)
  97             ec->cipher = NULL;
  98     } else {
  99         ciph = EVP_get_cipherbyobj(calg->algorithm);
 100
 101         if (!ciph) {
 102             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, CMS_R_UNKNOWN_CIPHER);
 103             goto err;
 104         }
 105     }
 106
 107     if (EVP_CipherInit_ex(ctx, ciph, NULL, NULL, NULL, enc) <= 0) {
 108         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
 109                CMS_R_CIPHER_INITIALISATION_ERROR);
 110         goto err;
 111     }
 112
 113     if (enc) {
 114         int ivlen;
 115         calg->algorithm = OBJ_nid2obj(EVP_CIPHER_CTX_type(ctx));
 116         /* Generate a random IV if we need one */
 117         ivlen = EVP_CIPHER_CTX_iv_length(ctx);
 118         if (ivlen > 0) {
 119             if (RAND_bytes(iv, ivlen) <= 0)
 120                 goto err;
 121             piv = iv;
 122         }
 123     } else if (EVP_CIPHER_asn1_to_param(ctx, calg->parameter) <= 0) {
 124         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
 125                CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
 126         goto err;
 127     }
 128     tkeylen = EVP_CIPHER_CTX_key_length(ctx);
 129     /* Generate random session key */
 130     if (!enc || !ec->key) {
 131         tkey = OPENSSL_malloc(tkeylen);
 132         if (tkey == NULL) {
 133             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
 134             goto err;
 135         }
 136         if (EVP_CIPHER_CTX_rand_key(ctx, tkey) <= 0)
 137             goto err;
 138     }
 139
 140     if (!ec->key) {
 141         ec->key = tkey;
 142         ec->keylen = tkeylen;
 143         tkey = NULL;
 144         if (enc)
 145             keep_key = 1;
 146         else
 147             ERR_clear_error();
 148
 149     }
 150
 151     if (ec->keylen != tkeylen) {
 152         /* If necessary set key length */
 153         if (EVP_CIPHER_CTX_set_key_length(ctx, ec->keylen) <= 0) {
 154             /*
 155              * Only reveal failure if debugging so we don't leak information
 156              * which may be useful in MMA.
 157              */
 158             if (enc || ec->debug) {
 159                 CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
 160                        CMS_R_INVALID_KEY_LENGTH);
 161                 goto err;
 162             } else {
 163                 /* Use random key */
 164                 OPENSSL_clear_free(ec->key, ec->keylen);
 165                 ec->key = tkey;
 166                 ec->keylen = tkeylen;
 167                 tkey = NULL;
 168                 ERR_clear_error();
 169             }
 170         }
 171     }
 172
 173     if (EVP_CipherInit_ex(ctx, NULL, NULL, ec->key, piv, enc) <= 0) {
 174         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
 175                CMS_R_CIPHER_INITIALISATION_ERROR);
 176         goto err;
 177     }
 178
 179     if (piv) {
 180         calg->parameter = ASN1_TYPE_new();
 181         if (calg->parameter == NULL) {
 182             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
 183             goto err;
 184         }
 185         if (EVP_CIPHER_param_to_asn1(ctx, calg->parameter) <= 0) {
 186             CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
 187                    CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
 188             goto err;
 189         }
 190     }
 191     ok = 1;
 192
 193  err:
 194     if (!keep_key || !ok) {
 195         OPENSSL_clear_free(ec->key, ec->keylen);
 196         ec->key = NULL;
 197     }
 198     OPENSSL_clear_free(tkey, tkeylen);
 199     if (ok)
 200         return b;
 201     BIO_free(b);
 202     return NULL;
 203 }
 204
 205 int cms_EncryptedContent_init(CMS_EncryptedContentInfo *ec,
 206                               const EVP_CIPHER *cipher,
 207                               const unsigned char *key, size_t keylen)
 208 {
 209     ec->cipher = cipher;
 210     if (key) {
 211         ec->key = OPENSSL_malloc(keylen);
 212         if (ec->key == NULL)
 213             return 0;
 214         memcpy(ec->key, key, keylen);
 215     }
 216     ec->keylen = keylen;
 217     if (cipher)
 218         ec->contentType = OBJ_nid2obj(NID_pkcs7_data);
 219     return 1;
 220 }
 221
 222 int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph,
 223                                const unsigned char *key, size_t keylen)
 224 {
 225     CMS_EncryptedContentInfo *ec;
 226     if (!key || !keylen) {
 227         CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY, CMS_R_NO_KEY);
 228         return 0;
 229     }
 230     if (ciph) {
 231         cms->d.encryptedData = M_ASN1_new_of(CMS_EncryptedData);
 232         if (!cms->d.encryptedData) {
 233             CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY, ERR_R_MALLOC_FAILURE);
 234             return 0;
 235         }
 236         cms->contentType = OBJ_nid2obj(NID_pkcs7_encrypted);
 237         cms->d.encryptedData->version = 0;
 238     } else if (OBJ_obj2nid(cms->contentType) != NID_pkcs7_encrypted) {
 239         CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY, CMS_R_NOT_ENCRYPTED_DATA);
 240         return 0;
 241     }
 242     ec = cms->d.encryptedData->encryptedContentInfo;
 243     return cms_EncryptedContent_init(ec, ciph, key, keylen);
 244 }
 245
 246 BIO *cms_EncryptedData_init_bio(CMS_ContentInfo *cms)
 247 {
 248     CMS_EncryptedData *enc = cms->d.encryptedData;
 249     if (enc->encryptedContentInfo->cipher && enc->unprotectedAttrs)
 250         enc->version = 2;
 251     return cms_EncryptedContent_init_bio(enc->encryptedContentInfo);
 252 }