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

openssl/crypto/asn1/asn_mime.c

 /* asn_mime.c */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
 /* ====================================================================
  * Copyright (c) 1999-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 41 matching lines @@
  *
  */
 
 #include <stdio.h>
 #include <ctype.h>
 #include "cryptlib.h"
 #include <openssl/rand.h>
 #include <openssl/x509.h>
 #include <openssl/asn1.h>
 #include <openssl/asn1t.h>
+#include "asn1_locl.h"
 
 /* Generalised MIME like utilities for streaming ASN1. Although many
  * have a PKCS7/CMS like flavour others are more general purpose.
  */
 
 /* MIME format structures
  * Note that all are translated to lower case apart from
  * parameter values. Quotes are stripped off
  */
 
 typedef struct {
 char *param_name;                       /* Param name e.g. "micalg" */
 char *param_value;                      /* Param value e.g. "sha1" */
 } MIME_PARAM;
 
 DECLARE_STACK_OF(MIME_PARAM)
 IMPLEMENT_STACK_OF(MIME_PARAM)
 
 typedef struct {
 char *name;                             /* Name of line e.g. "content-type" */
 char *value;                            /* Value of line e.g. "text/plain" */
 STACK_OF(MIME_PARAM) *params;           /* Zero or more parameters */
 } MIME_HEADER;
 
 DECLARE_STACK_OF(MIME_HEADER)
 IMPLEMENT_STACK_OF(MIME_HEADER)
 
+static int asn1_output_data(BIO *out, BIO *data, ASN1_VALUE *val, int flags,
+                                        const ASN1_ITEM *it);
 static char * strip_ends(char *name);
 static char * strip_start(char *name);
 static char * strip_end(char *name);
 static MIME_HEADER *mime_hdr_new(char *name, char *value);
 static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value);
 static STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio);
 static int mime_hdr_cmp(const MIME_HEADER * const *a,
                         const MIME_HEADER * const *b);
 static int mime_param_cmp(const MIME_PARAM * const *a,
                         const MIME_PARAM * const *b);
 static void mime_param_free(MIME_PARAM *param);
 static int mime_bound_check(char *line, int linelen, char *bound, int blen);
 static int multi_split(BIO *bio, char *bound, STACK_OF(BIO) **ret);
 static int strip_eol(char *linebuf, int *plen);
 static MIME_HEADER *mime_hdr_find(STACK_OF(MIME_HEADER) *hdrs, char *name);
 static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name);
 static void mime_hdr_free(MIME_HEADER *hdr);
 
 #define MAX_SMLEN 1024
 #define mime_debug(x) /* x */
 
+/* Output an ASN1 structure in BER format streaming if necessary */
+
+int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
+                                const ASN1_ITEM *it)
+        {
+        /* If streaming create stream BIO and copy all content through it */
+        if (flags & SMIME_STREAM)
+                {
+                BIO *bio, *tbio;
+                bio = BIO_new_NDEF(out, val, it);
+                if (!bio)
+                        {
+                        ASN1err(ASN1_F_I2D_ASN1_BIO_STREAM,ERR_R_MALLOC_FAILURE);
+                        return 0;
+                        }
+                SMIME_crlf_copy(in, bio, flags);
+                (void)BIO_flush(bio);
+                /* Free up successive BIOs until we hit the old output BIO */
+                do
+                        {
+                        tbio = BIO_pop(bio);
+                        BIO_free(bio);
+                        bio = tbio;
+                        } while (bio != out);
+                }
+        /* else just write out ASN1 structure which will have all content
+         * stored internally
+         */
+        else
+                ASN1_item_i2d_bio(it, out, val);
+        return 1;
+        }
+
 /* Base 64 read and write of ASN1 structure */
 
 static int B64_write_ASN1(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
                                 const ASN1_ITEM *it)
         {
         BIO *b64;
         int r;
         b64 = BIO_new(BIO_f_base64());
         if(!b64)
                 {
                 ASN1err(ASN1_F_B64_WRITE_ASN1,ERR_R_MALLOC_FAILURE);
                 return 0;
                 }
         /* prepend the b64 BIO so all data is base64 encoded.
          */
         out = BIO_push(b64, out);
-        r = ASN1_item_i2d_bio(it, out, val);
+        r = i2d_ASN1_bio_stream(out, val, in, flags, it);
         (void)BIO_flush(out);
         BIO_pop(out);
         BIO_free(b64);
         return r;
         }
 
+/* Streaming ASN1 PEM write */
+
+int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
+                                const char *hdr,
+                                const ASN1_ITEM *it)
+        {
+        int r;
+        BIO_printf(out, "-----BEGIN %s-----\n", hdr);
+        r = B64_write_ASN1(out, val, in, flags, it);
+        BIO_printf(out, "-----END %s-----\n", hdr);
+        return r;
+        }
+
 static ASN1_VALUE *b64_read_asn1(BIO *bio, const ASN1_ITEM *it)
 {
         BIO *b64;
         ASN1_VALUE *val;
         if(!(b64 = BIO_new(BIO_f_base64()))) {
                 ASN1err(ASN1_F_B64_READ_ASN1,ERR_R_MALLOC_FAILURE);
                 return 0;
         }
         bio = BIO_push(b64, bio);
         val = ASN1_item_d2i_bio(it, bio, NULL);
         if(!val)
                 ASN1err(ASN1_F_B64_READ_ASN1,ASN1_R_DECODE_ERROR);
         (void)BIO_flush(bio);
         bio = BIO_pop(bio);
         BIO_free(b64);
         return val;
 }
 
 /* Generate the MIME "micalg" parameter from RFC3851, RFC4490 */
 
 static int asn1_write_micalg(BIO *out, STACK_OF(X509_ALGOR) *mdalgs)
         {
-        int i, have_unknown = 0, write_comma, md_nid;
+        const EVP_MD *md;
+        int i, have_unknown = 0, write_comma, ret = 0, md_nid;
         have_unknown = 0;
         write_comma = 0;
         for (i = 0; i < sk_X509_ALGOR_num(mdalgs); i++)
                 {
                 if (write_comma)
                         BIO_write(out, ",", 1);
                 write_comma = 1;
                 md_nid = OBJ_obj2nid(sk_X509_ALGOR_value(mdalgs, i)->algorithm);
+                md = EVP_get_digestbynid(md_nid);
+                if (md && md->md_ctrl)
+                        {
+                        int rv;
+                        char *micstr;
+                        rv = md->md_ctrl(NULL, EVP_MD_CTRL_MICALG, 0, &micstr);
+                        if (rv > 0)
+                                {
+                                BIO_puts(out, micstr);
+                                OPENSSL_free(micstr);
+                                continue;
+                                }
+                        if (rv != -2)
+                                goto err;
+                        }
                 switch(md_nid)
                         {
                         case NID_sha1:
                         BIO_puts(out, "sha1");
                         break;
 
                         case NID_md5:
                         BIO_puts(out, "md5");
                         break;
 
                         case NID_sha256:
                         BIO_puts(out, "sha-256");
                         break;
 
                         case NID_sha384:
                         BIO_puts(out, "sha-384");
                         break;
 
                         case NID_sha512:
                         BIO_puts(out, "sha-512");
                         break;
 
+                        case NID_id_GostR3411_94:
+                        BIO_puts(out, "gostr3411-94");
+                                goto err;
+                        break;
+
                         default:
                         if (have_unknown)
                                 write_comma = 0;
                         else
                                 {
                                 BIO_puts(out, "unknown");
                                 have_unknown = 1;
                                 }
                         break;
 
                         }
                 }
 
-        return 1;
+        ret = 1;
+        err:
+
+        return ret;
 
         }
 
 /* SMIME sender */
 
-int int_smime_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
+int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags,
                                 int ctype_nid, int econt_nid,
                                 STACK_OF(X509_ALGOR) *mdalgs,
-                                asn1_output_data_fn *data_fn,
                                 const ASN1_ITEM *it)
 {
         char bound[33], c;
         int i;
         const char *mime_prefix, *mime_eol, *cname = "smime.p7m";
         const char *msg_type=NULL;
         if (flags & SMIME_OLDMIME)
                 mime_prefix = "application/x-pkcs7-";
         else
                 mime_prefix = "application/pkcs7-";
@@ skipping 17 matching lines @@
                 BIO_printf(bio, "Content-Type: multipart/signed;");
                 BIO_printf(bio, " protocol=\"%ssignature\";", mime_prefix);
                 BIO_puts(bio, " micalg=\"");
                 asn1_write_micalg(bio, mdalgs);
                 BIO_printf(bio, "\"; boundary=\"----%s\"%s%s",
                                                 bound, mime_eol, mime_eol);
                 BIO_printf(bio, "This is an S/MIME signed message%s%s",
                                                 mime_eol, mime_eol);
                 /* Now write out the first part */
                 BIO_printf(bio, "------%s%s", bound, mime_eol);
-                if (!data_fn(bio, data, val, flags, it))
+                if (!asn1_output_data(bio, data, val, flags, it))
                         return 0;
                 BIO_printf(bio, "%s------%s%s", mime_eol, bound, mime_eol);
 
                 /* Headers for signature */
 
                 BIO_printf(bio, "Content-Type: %ssignature;", mime_prefix); 
                 BIO_printf(bio, " name=\"smime.p7s\"%s", mime_eol);
                 BIO_printf(bio, "Content-Transfer-Encoding: base64%s",
                                                                 mime_eol);
                 BIO_printf(bio, "Content-Disposition: attachment;");
@@ skipping 32 matching lines @@
                 BIO_printf(bio, " smime-type=%s;", msg_type);
         BIO_printf(bio, " name=\"%s\"%s", cname, mime_eol);
         BIO_printf(bio, "Content-Transfer-Encoding: base64%s%s",
                                                 mime_eol, mime_eol);
         if (!B64_write_ASN1(bio, val, data, flags, it))
                 return 0;
         BIO_printf(bio, "%s", mime_eol);
         return 1;
 }
 
-#if 0
-
 /* Handle output of ASN1 data */
 
 
 static int asn1_output_data(BIO *out, BIO *data, ASN1_VALUE *val, int flags,
                                         const ASN1_ITEM *it)
         {
         BIO *tmpbio;
         const ASN1_AUX *aux = it->funcs;
         ASN1_STREAM_ARG sarg;
 
@@ skipping 32 matching lines @@
                 {
                 tmpbio = BIO_pop(sarg.ndef_bio);
                 BIO_free(sarg.ndef_bio);
                 sarg.ndef_bio = tmpbio;
                 }
 
         return 1;
 
         }
 
-#endif
-
 /* SMIME reader: handle multipart/signed and opaque signing.
  * in multipart case the content is placed in a memory BIO
  * pointed to by "bcont". In opaque this is set to NULL
  */
 
 ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it)
 {
         BIO *asnin;
         STACK_OF(MIME_HEADER) *headers = NULL;
         STACK_OF(BIO) *parts = NULL;
@@ skipping 500 matching lines @@
                 {
                 c = *p;
                 if (c == '\n')
                         is_eol = 1;
                 else if (c != '\r')
                         break;
                 }
         *plen = len;
         return is_eol;
         }