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

openssl/crypto/pem/pem_lib.c

 /* crypto/pem/pem_lib.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 39 matching lines @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * 
  * The licence and distribution terms for any publically available version or
  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
 
 #include <stdio.h>
+#include <ctype.h>
 #include "cryptlib.h"
 #include <openssl/buffer.h>
 #include <openssl/objects.h>
 #include <openssl/evp.h>
 #include <openssl/rand.h>
 #include <openssl/x509.h>
 #include <openssl/pem.h>
 #include <openssl/pkcs12.h>
+#include "asn1_locl.h"
 #ifndef OPENSSL_NO_DES
 #include <openssl/des.h>
 #endif
+#ifndef OPENSSL_NO_ENGINE
+#include <openssl/engine.h>
+#endif
 
 const char PEM_version[]="PEM" OPENSSL_VERSION_PTEXT;
 
 #define MIN_LENGTH      4
 
 static int load_iv(char **fromp,unsigned char *to, int num);
 static int check_pem(const char *nm, const char *name);
+int pem_check_suffix(const char *pem_str, const char *suffix);
 
 int PEM_def_callback(char *buf, int num, int w, void *key)
         {
 #ifdef OPENSSL_NO_FP_API
         /* We should not ever call the default callback routine from
          * windows. */
         PEMerr(PEM_F_PEM_DEF_CALLBACK,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
         return(-1);
 #else
         int i,j;
         const char *prompt;
         if(key) {
                 i=strlen(key);
                 i=(i > num)?num:i;
                 memcpy(buf,key,i);
                 return(i);
         }
 
         prompt=EVP_get_pw_prompt();
         if (prompt == NULL)
                 prompt="Enter PEM pass phrase:";
 
         for (;;)
                 {
-                i=EVP_read_pw_string(buf,num,prompt,w);
+                i=EVP_read_pw_string_min(buf,MIN_LENGTH,num,prompt,w);
                 if (i != 0)
                         {
                         PEMerr(PEM_F_PEM_DEF_CALLBACK,PEM_R_PROBLEMS_GETTING_PASSWORD);
                         memset(buf,0,(unsigned int)num);
                         return(-1);
                         }
                 j=strlen(buf);
                 if (j < MIN_LENGTH)
                         {
                         fprintf(stderr,"phrase is too short, needs to be at least %d chars\n",MIN_LENGTH);
@@ skipping 63 matching lines @@
         }
 #endif
 
 static int check_pem(const char *nm, const char *name)
 {
         /* Normal matching nm and name */
         if (!strcmp(nm,name)) return 1;
 
         /* Make PEM_STRING_EVP_PKEY match any private key */
 
-        if(!strcmp(nm,PEM_STRING_PKCS8) &&
-                !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
+        if(!strcmp(name,PEM_STRING_EVP_PKEY))
+                {
+                int slen;
+                const EVP_PKEY_ASN1_METHOD *ameth;
+                if(!strcmp(nm,PEM_STRING_PKCS8))
+                        return 1;
+                if(!strcmp(nm,PEM_STRING_PKCS8INF))
+                        return 1;
+                slen = pem_check_suffix(nm, "PRIVATE KEY"); 
+                if (slen > 0)
+                        {
+                        /* NB: ENGINE implementations wont contain
+                         * a deprecated old private key decode function
+                         * so don't look for them.
+                         */
+                        ameth = EVP_PKEY_asn1_find_str(NULL, nm, slen);
+                        if (ameth && ameth->old_priv_decode)
+                                return 1;
+                        }
+                return 0;
+                }
 
-        if(!strcmp(nm,PEM_STRING_PKCS8INF) &&
-                 !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
+        if(!strcmp(name,PEM_STRING_PARAMETERS))
+                {
+                int slen;
+                const EVP_PKEY_ASN1_METHOD *ameth;
+                slen = pem_check_suffix(nm, "PARAMETERS"); 
+                if (slen > 0)
+                        {
+                        ENGINE *e;
+                        ameth = EVP_PKEY_asn1_find_str(&e, nm, slen);
+                        if (ameth)
+                                {
+                                int r;
+                                if (ameth->param_decode)
+                                        r = 1;
+                                else
+                                        r = 0;
+#ifndef OPENSSL_NO_ENGINE
+                                if (e)
+                                        ENGINE_finish(e);
+#endif
+                                return r;
+                                }
+                        }
+                return 0;
+                }
 
-        if(!strcmp(nm,PEM_STRING_RSA) &&
-                !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
-
-        if(!strcmp(nm,PEM_STRING_DSA) &&
-                 !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
-
-        if(!strcmp(nm,PEM_STRING_ECPRIVATEKEY) &&
-                 !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
         /* Permit older strings */
 
         if(!strcmp(nm,PEM_STRING_X509_OLD) &&
                 !strcmp(name,PEM_STRING_X509)) return 1;
 
         if(!strcmp(nm,PEM_STRING_X509_REQ_OLD) &&
                 !strcmp(name,PEM_STRING_X509_REQ)) return 1;
 
         /* Allow normal certs to be read as trusted certs */
         if(!strcmp(nm,PEM_STRING_X509) &&
                 !strcmp(name,PEM_STRING_X509_TRUSTED)) return 1;
 
         if(!strcmp(nm,PEM_STRING_X509_OLD) &&
                 !strcmp(name,PEM_STRING_X509_TRUSTED)) return 1;
 
         /* Some CAs use PKCS#7 with CERTIFICATE headers */
         if(!strcmp(nm, PEM_STRING_X509) &&
                 !strcmp(name, PEM_STRING_PKCS7)) return 1;
 
         if(!strcmp(nm, PEM_STRING_PKCS7_SIGNED) &&
                 !strcmp(name, PEM_STRING_PKCS7)) return 1;
 
+#ifndef OPENSSL_NO_CMS
+        if(!strcmp(nm, PEM_STRING_X509) &&
+                !strcmp(name, PEM_STRING_CMS)) return 1;
+        /* Allow CMS to be read from PKCS#7 headers */
+        if(!strcmp(nm, PEM_STRING_PKCS7) &&
+                !strcmp(name, PEM_STRING_CMS)) return 1;
+#endif
+
         return 0;
 }
 
 int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,
              pem_password_cb *cb, void *u)
         {
         EVP_CIPHER_INFO cipher;
         char *nm=NULL,*header=NULL;
         unsigned char *data=NULL;
         long len;
@@ skipping 25 matching lines @@
 
 err:
         if (!ret || !pnm) OPENSSL_free(nm);
         OPENSSL_free(header);
         if (!ret) OPENSSL_free(data);
         return ret;
         }
 
 #ifndef OPENSSL_NO_FP_API
 int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp,
-                   char *x, const EVP_CIPHER *enc, unsigned char *kstr,
+                   void *x, const EVP_CIPHER *enc, unsigned char *kstr,
                    int klen, pem_password_cb *callback, void *u)
         {
         BIO *b;
         int ret;
 
         if ((b=BIO_new(BIO_s_file())) == NULL)
                 {
                 PEMerr(PEM_F_PEM_ASN1_WRITE,ERR_R_BUF_LIB);
                 return(0);
                 }
         BIO_set_fp(b,fp,BIO_NOCLOSE);
         ret=PEM_ASN1_write_bio(i2d,name,b,x,enc,kstr,klen,callback,u);
         BIO_free(b);
         return(ret);
         }
 #endif
 
 int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp,
-                       char *x, const EVP_CIPHER *enc, unsigned char *kstr,
+                       void *x, const EVP_CIPHER *enc, unsigned char *kstr,
                        int klen, pem_password_cb *callback, void *u)
         {
         EVP_CIPHER_CTX ctx;
         int dsize=0,i,j,ret=0;
         unsigned char *p,*data=NULL;
         const char *objstr=NULL;
         char buf[PEM_BUFSIZE];
         unsigned char key[EVP_MAX_KEY_LENGTH];
         unsigned char iv[EVP_MAX_IV_LENGTH];
         
@@ skipping 130 matching lines @@
                 {
                 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_DECRYPT);
                 return(0);
                 }
         *plen=j;
         return(1);
         }
 
 int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher)
         {
-        int o;
         const EVP_CIPHER *enc=NULL;
         char *p,c;
         char **header_pp = &header;
 
         cipher->cipher=NULL;
         if ((header == NULL) || (*header == '\0') || (*header == '\n'))
                 return(1);
         if (strncmp(header,"Proc-Type: ",11) != 0)
                 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_PROC_TYPE); return(0); }
         header+=11;
@@ skipping 19 matching lines @@
                         ((c >= '0') && (c <= '9'))))
                         break;
 #else
                 if (!(  isupper(c) || (c == '-') ||
                         isdigit(c)))
                         break;
 #endif
                 header++;
                 }
         *header='\0';
-        o=OBJ_sn2nid(p);
         cipher->cipher=enc=EVP_get_cipherbyname(p);
         *header=c;
         header++;
 
         if (enc == NULL)
                 {
                 PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_UNSUPPORTED_ENCRYPTION);
                 return(0);
                 }
         if (!load_iv(header_pp,&(cipher->iv[0]),enc->iv_len))
@@ skipping 287 matching lines @@
         OPENSSL_free(nameB);
         OPENSSL_free(headerB);
         OPENSSL_free(dataB);
         return(1);
 err:
         BUF_MEM_free(nameB);
         BUF_MEM_free(headerB);
         BUF_MEM_free(dataB);
         return(0);
         }
+
+/* Check pem string and return prefix length.
+ * If for example the pem_str == "RSA PRIVATE KEY" and suffix = "PRIVATE KEY"
+ * the return value is 3 for the string "RSA".
+ */
+
+int pem_check_suffix(const char *pem_str, const char *suffix)
+        {
+        int pem_len = strlen(pem_str);
+        int suffix_len = strlen(suffix);
+        const char *p;
+        if (suffix_len + 1 >= pem_len)
+                return 0;
+        p = pem_str + pem_len - suffix_len;
+        if (strcmp(p, suffix))
+                return 0;
+        p--;
+        if (*p != ' ')
+                return 0;
+        return p - pem_str;
+        }
+