1 files changed, 77 insertions, 104 deletions

diff --git a/src/lib/libcrypto/cms/cms_enc.c b/src/lib/libcrypto/cms/cms_enc.c
index 612fce6dde..75e08cdb1d 100644
--- a/src/lib/libcrypto/cms/cms_enc.c
+++ b/src/lib/libcrypto/cms/cms_enc.c
@@ -10,7 +10,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -66,8 +66,9 @@ DECLARE_ASN1_ITEM(CMS_EncryptedData)
 
 /* Return BIO based on EncryptedContentInfo and key */
 
-BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
-        {
+BIO *
+cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
+{
         BIO *b;
         EVP_CIPHER_CTX *ctx;
         const EVP_CIPHER *ciph;
@@ -75,87 +76,72 @@ BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
         unsigned char iv[EVP_MAX_IV_LENGTH], *piv = NULL;
         unsigned char *tkey = NULL;
         size_t tkeylen = 0;
-
         int ok = 0;
-
         int enc, keep_key = 0;
 
         enc = ec->cipher ? 1 : 0;
 
         b = BIO_new(BIO_f_cipher());
-        if (!b)
-                {
+        if (!b) {
                 CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                                        ERR_R_MALLOC_FAILURE);
+                    ERR_R_MALLOC_FAILURE);
                 return NULL;
-                }
+        }
 
         BIO_get_cipher_ctx(b, &ctx);
 
-        if (enc)
-                {
+        if (enc) {
                 ciph = ec->cipher;
                 /* If not keeping key set cipher to NULL so subsequent calls
                  * decrypt.
                  */
                 if (ec->key)
                         ec->cipher = NULL;
-                }
-        else
-                {
+        } else {
                 ciph = EVP_get_cipherbyobj(calg->algorithm);
 
-                if (!ciph)
-                        {
+                if (!ciph) {
                         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                                        CMS_R_UNKNOWN_CIPHER);
+                            CMS_R_UNKNOWN_CIPHER);
                         goto err;
-                        }
                 }
+        }
 
-        if (EVP_CipherInit_ex(ctx, ciph, NULL, NULL, NULL, enc) <= 0)
-                {
+        if (EVP_CipherInit_ex(ctx, ciph, NULL, NULL, NULL, enc) <= 0) {
                 CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                CMS_R_CIPHER_INITIALISATION_ERROR);
+                    CMS_R_CIPHER_INITIALISATION_ERROR);
                 goto err;
-                }
+        }
 
-        if (enc)
-                {
+        if (enc) {
                 int ivlen;
                 calg->algorithm = OBJ_nid2obj(EVP_CIPHER_CTX_type(ctx));
                 /* Generate a random IV if we need one */
                 ivlen = EVP_CIPHER_CTX_iv_length(ctx);
-                if (ivlen > 0)
-                        {
+                if (ivlen > 0) {
                         if (RAND_pseudo_bytes(iv, ivlen) <= 0)
                                 goto err;
                         piv = iv;
-                        }
                 }
-        else if (EVP_CIPHER_asn1_to_param(ctx, calg->parameter) <= 0)
-                {
+        } else if (EVP_CIPHER_asn1_to_param(ctx, calg->parameter) <= 0) {
                 CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
+                    CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
                 goto err;
-                }
+        }
         tkeylen = EVP_CIPHER_CTX_key_length(ctx);
         /* Generate random session key */
-        if (!enc || !ec->key)
-                {
+        if (!enc || !ec->key) {
                 tkey = malloc(tkeylen);
-                if (!tkey)
-                        {
+                if (!tkey) {
                         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                                        ERR_R_MALLOC_FAILURE);
+                            ERR_R_MALLOC_FAILURE);
                         goto err;
-                        }
+                }
                 if (EVP_CIPHER_CTX_rand_key(ctx, tkey) <= 0)
                         goto err;
-                }
+        }
 
-        if (!ec->key)
-                {
+        if (!ec->key) {
                 ec->key = tkey;
                 ec->keylen = tkeylen;
                 tkey = NULL;
@@ -163,25 +149,20 @@ BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
                         keep_key = 1;
                 else
                         ERR_clear_error();
-                
-                }
 
-        if (ec->keylen != tkeylen)
-                {
+        }
+
+        if (ec->keylen != tkeylen) {
                 /* If necessary set key length */
-                if (EVP_CIPHER_CTX_set_key_length(ctx, ec->keylen) <= 0)
-                        {
+                if (EVP_CIPHER_CTX_set_key_length(ctx, ec->keylen) <= 0) {
                         /* Only reveal failure if debugging so we don't
                          * leak information which may be useful in MMA.
                          */
-                        if (enc || ec->debug)
-                                {
+                        if (enc || ec->debug) {
                                 CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                                CMS_R_INVALID_KEY_LENGTH);
+                                    CMS_R_INVALID_KEY_LENGTH);
                                 goto err;
-                                }
-                        else
-                                {
+                        } else {
                                 /* Use random key */
                                 OPENSSL_cleanse(ec->key, ec->keylen);
                                 free(ec->key);
@@ -189,106 +170,98 @@ BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
                                 ec->keylen = tkeylen;
                                 tkey = NULL;
                                 ERR_clear_error();
-                                }
                         }
                 }
+        }
 
-        if (EVP_CipherInit_ex(ctx, NULL, NULL, ec->key, piv, enc) <= 0)
-                {
+        if (EVP_CipherInit_ex(ctx, NULL, NULL, ec->key, piv, enc) <= 0) {
                 CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                CMS_R_CIPHER_INITIALISATION_ERROR);
+                    CMS_R_CIPHER_INITIALISATION_ERROR);
                 goto err;
-                }
+        }
 
-        if (piv)
-                {
+        if (piv) {
                 calg->parameter = ASN1_TYPE_new();
-                if (!calg->parameter)
-                        {
+                if (!calg->parameter) {
                         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                                        ERR_R_MALLOC_FAILURE);
+                            ERR_R_MALLOC_FAILURE);
                         goto err;
-                        }
-                if (EVP_CIPHER_param_to_asn1(ctx, calg->parameter) <= 0)
-                        {
+                }
+                if (EVP_CIPHER_param_to_asn1(ctx, calg->parameter) <= 0) {
                         CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO,
-                                CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
+                            CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
                         goto err;
-                        }
                 }
+        }
         ok = 1;
 
-        err:
-        if (ec->key && !keep_key)
-                {
+err:
+        if (ec->key && !keep_key) {
                 OPENSSL_cleanse(ec->key, ec->keylen);
                 free(ec->key);
                 ec->key = NULL;
-                }
-        if (tkey)
-                {
+        }
+        if (tkey) {
                 OPENSSL_cleanse(tkey, tkeylen);
                 free(tkey);
-                }
+        }
         if (ok)
                 return b;
         BIO_free(b);
         return NULL;
-        }
+}
 
-int cms_EncryptedContent_init(CMS_EncryptedContentInfo *ec, 
-                                const EVP_CIPHER *cipher,
-                                const unsigned char *key, size_t keylen)
-        {
+int
+cms_EncryptedContent_init(CMS_EncryptedContentInfo *ec,
+    const EVP_CIPHER *cipher, const unsigned char *key, size_t keylen)
+{
         ec->cipher = cipher;
-        if (key)
-                {
+        if (key) {
                 ec->key = malloc(keylen);
                 if (!ec->key)
                         return 0;
                 memcpy(ec->key, key, keylen);
-                }
+        }
         ec->keylen = keylen;
         if (cipher)
                 ec->contentType = OBJ_nid2obj(NID_pkcs7_data);
         return 1;
-        }
+}
 
-int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph,
-                                const unsigned char *key, size_t keylen)
-        {
+int
+CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph,
+    const unsigned char *key, size_t keylen)
+{
         CMS_EncryptedContentInfo *ec;
-        if (!key || !keylen)
-                {
+
+        if (!key || !keylen) {
                 CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY, CMS_R_NO_KEY);
                 return 0;
-                }
-        if (ciph)
-                {
+        }
+        if (ciph) {
                 cms->d.encryptedData = M_ASN1_new_of(CMS_EncryptedData);
-                if (!cms->d.encryptedData)
-                        {
+                if (!cms->d.encryptedData) {
                         CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY,
-                                ERR_R_MALLOC_FAILURE);
+                            ERR_R_MALLOC_FAILURE);
                         return 0;
-                        }
+                }
                 cms->contentType = OBJ_nid2obj(NID_pkcs7_encrypted);
                 cms->d.encryptedData->version = 0;
-                }
-        else if (OBJ_obj2nid(cms->contentType) != NID_pkcs7_encrypted)
-                {
+        } else if (OBJ_obj2nid(cms->contentType) != NID_pkcs7_encrypted) {
                 CMSerr(CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY,
-                                                CMS_R_NOT_ENCRYPTED_DATA);
+                    CMS_R_NOT_ENCRYPTED_DATA);
                 return 0;
-                }
+        }
         ec = cms->d.encryptedData->encryptedContentInfo;
         return cms_EncryptedContent_init(ec, ciph, key, keylen);
-        }
+}
 
-BIO *cms_EncryptedData_init_bio(CMS_ContentInfo *cms)
-        {
+BIO *
+cms_EncryptedData_init_bio(CMS_ContentInfo *cms)
+{
         CMS_EncryptedData *enc = cms->d.encryptedData;
+
         if (enc->encryptedContentInfo->cipher && enc->unprotectedAttrs)
                 enc->version = 2;
         return cms_EncryptedContent_init_bio(enc->encryptedContentInfo);
-        }
+}