Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/cms/cms_env.c

 /* crypto/cms/cms_env.c */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
 /* ====================================================================
  * Copyright (c) 2008 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 42 matching lines @@
 
 #include "cryptlib.h"
 #include <openssl/asn1t.h>
 #include <openssl/pem.h>
 #include <openssl/x509v3.h>
 #include <openssl/err.h>
 #include <openssl/cms.h>
 #include <openssl/rand.h>
 #include <openssl/aes.h>
 #include "cms_lcl.h"
+#include "asn1_locl.h"
 
 /* CMS EnvelopedData Utilities */
 
 DECLARE_ASN1_ITEM(CMS_EnvelopedData)
 DECLARE_ASN1_ITEM(CMS_RecipientInfo)
 DECLARE_ASN1_ITEM(CMS_KeyTransRecipientInfo)
 DECLARE_ASN1_ITEM(CMS_KEKRecipientInfo)
 DECLARE_ASN1_ITEM(CMS_OtherKeyAttribute)
 
 DECLARE_STACK_OF(CMS_RecipientInfo)
@@ skipping 71 matching lines @@
  * If we ever handle key agreement will need updating.
  */
 
 CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms,
                                         X509 *recip, unsigned int flags)
         {
         CMS_RecipientInfo *ri = NULL;
         CMS_KeyTransRecipientInfo *ktri;
         CMS_EnvelopedData *env;
         EVP_PKEY *pk = NULL;
-        int type;
+        int i, type;
         env = cms_get0_enveloped(cms);
         if (!env)
                 goto err;
 
         /* Initialize recipient info */
         ri = M_ASN1_new_of(CMS_RecipientInfo);
         if (!ri)
                 goto merr;
 
         /* Initialize and add key transport recipient info */
@@ skipping 28 matching lines @@
                 type = CMS_RECIPINFO_ISSUER_SERIAL;
                 }
 
         /* Not a typo: RecipientIdentifier and SignerIdentifier are the
          * same structure.
          */
 
         if (!cms_set1_SignerIdentifier(ktri->rid, recip, type))
                 goto err;
 
-        /* Since we have no EVP_PKEY_ASN1_METHOD in OpenSSL 0.9.8,
-         * hard code algorithm parameters.
-         */
-
-        if (pk->type == EVP_PKEY_RSA)
+        if (pk->ameth && pk->ameth->pkey_ctrl)
                 {
-                X509_ALGOR_set0(ktri->keyEncryptionAlgorithm,
-                                        OBJ_nid2obj(NID_rsaEncryption), 
-                                        V_ASN1_NULL, 0);
-                }
-        else
-                {
-                CMSerr(CMS_F_CMS_ADD1_RECIPIENT_CERT,
+                i = pk->ameth->pkey_ctrl(pk, ASN1_PKEY_CTRL_CMS_ENVELOPE,
+                                                0, ri);
+                if (i == -2)
+                        {
+                        CMSerr(CMS_F_CMS_ADD1_RECIPIENT_CERT,
                                 CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE);
-                goto err;
+                        goto err;
+                        }
+                if (i <= 0)
+                        {
+                        CMSerr(CMS_F_CMS_ADD1_RECIPIENT_CERT,
+                                CMS_R_CTRL_FAILURE);
+                        goto err;
+                        }
                 }
 
         if (!sk_CMS_RecipientInfo_push(env->recipientInfos, ri))
                 goto merr;
 
         return ri;
 
         merr:
         CMSerr(CMS_F_CMS_ADD1_RECIPIENT_CERT, ERR_R_MALLOC_FAILURE);
         err:
@@ skipping 66 matching lines @@
         return 1;
         }
 
 /* Encrypt content key in key transport recipient info */
 
 static int cms_RecipientInfo_ktri_encrypt(CMS_ContentInfo *cms,
                                         CMS_RecipientInfo *ri)
         {
         CMS_KeyTransRecipientInfo *ktri;
         CMS_EncryptedContentInfo *ec;
+        EVP_PKEY_CTX *pctx = NULL;
         unsigned char *ek = NULL;
-        int eklen;
+        size_t eklen;
 
         int ret = 0;
 
         if (ri->type != CMS_RECIPINFO_TRANS)
                 {
                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT,
                         CMS_R_NOT_KEY_TRANSPORT);
                 return 0;
                 }
         ktri = ri->d.ktri;
         ec = cms->d.envelopedData->encryptedContentInfo;
 
-        eklen = EVP_PKEY_size(ktri->pkey);
+        pctx = EVP_PKEY_CTX_new(ktri->pkey, NULL);
+        if (!pctx)
+                return 0;
+
+        if (EVP_PKEY_encrypt_init(pctx) <= 0)
+                goto err;
+
+        if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_ENCRYPT,
+                                EVP_PKEY_CTRL_CMS_ENCRYPT, 0, ri) <= 0)
+                {
+                CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT, CMS_R_CTRL_ERROR);
+                goto err;
+                }
+
+        if (EVP_PKEY_encrypt(pctx, NULL, &eklen, ec->key, ec->keylen) <= 0)
+                goto err;
 
         ek = OPENSSL_malloc(eklen);
 
         if (ek == NULL)
                 {
                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT,
                                                         ERR_R_MALLOC_FAILURE);
                 goto err;
                 }
 
-        eklen = EVP_PKEY_encrypt(ek, ec->key, ec->keylen, ktri->pkey);
-
-        if (eklen <= 0)
+        if (EVP_PKEY_encrypt(pctx, ek, &eklen, ec->key, ec->keylen) <= 0)
                 goto err;
 
         ASN1_STRING_set0(ktri->encryptedKey, ek, eklen);
         ek = NULL;
 
         ret = 1;
 
         err:
+        if (pctx)
+                EVP_PKEY_CTX_free(pctx);
         if (ek)
                 OPENSSL_free(ek);
         return ret;
 
         }
 
 /* Decrypt content key from KTRI */
 
 static int cms_RecipientInfo_ktri_decrypt(CMS_ContentInfo *cms,
                                                         CMS_RecipientInfo *ri)
         {
         CMS_KeyTransRecipientInfo *ktri = ri->d.ktri;
+        EVP_PKEY_CTX *pctx = NULL;
         unsigned char *ek = NULL;
-        int eklen;
+        size_t eklen;
         int ret = 0;
 
         if (ktri->pkey == NULL)
                 {
                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT,
                         CMS_R_NO_PRIVATE_KEY);
                 return 0;
                 }
 
-        eklen = EVP_PKEY_size(ktri->pkey);
+        pctx = EVP_PKEY_CTX_new(ktri->pkey, NULL);
+        if (!pctx)
+                return 0;
+
+        if (EVP_PKEY_decrypt_init(pctx) <= 0)
+                goto err;
+
+        if (EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DECRYPT,
+                                EVP_PKEY_CTRL_CMS_DECRYPT, 0, ri) <= 0)
+                {
+                CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT, CMS_R_CTRL_ERROR);
+                goto err;
+                }
+
+        if (EVP_PKEY_decrypt(pctx, NULL, &eklen,
+                                ktri->encryptedKey->data,
+                                ktri->encryptedKey->length) <= 0)
+                goto err;
 
         ek = OPENSSL_malloc(eklen);
 
         if (ek == NULL)
                 {
                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT,
                                                         ERR_R_MALLOC_FAILURE);
                 goto err;
                 }
 
-        eklen = EVP_PKEY_decrypt(ek, 
+        if (EVP_PKEY_decrypt(pctx, ek, &eklen,
                                 ktri->encryptedKey->data,
-                                ktri->encryptedKey->length, ktri->pkey);
-        if (eklen <= 0)
+                                ktri->encryptedKey->length) <= 0)
                 {
                 CMSerr(CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT, CMS_R_CMS_LIB);
                 goto err;
                 }
 
         ret = 1;
 
         cms->d.envelopedData->encryptedContentInfo->key = ek;
         cms->d.envelopedData->encryptedContentInfo->keylen = eklen;
 
         err:
+        if (pctx)
+                EVP_PKEY_CTX_free(pctx);
         if (!ret && ek)
                 OPENSSL_free(ek);
 
         return ret;
         }
 
 /* Key Encrypted Key (KEK) RecipientInfo routines */
 
 int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri, 
                                         const unsigned char *id, size_t idlen)
@@ skipping 417 matching lines @@
                 OPENSSL_free(ec->key);
                 ec->key = NULL;
                 ec->keylen = 0;
                 }
         if (ok)
                 return ret;
         BIO_free(ret);
         return NULL;
 
         }