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

openssl/engines/e_ubsec.c

 /* crypto/engine/hw_ubsec.c */
 /* Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL
  * project 2000.
  *
  * Cloned shamelessly by Joe Tardo. 
  */
 /* ====================================================================
  * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ skipping 77 matching lines @@
 #include "e_ubsec_err.c"
 
 #define FAIL_TO_SOFTWARE -15
 
 static int ubsec_destroy(ENGINE *e);
 static int ubsec_init(ENGINE *e);
 static int ubsec_finish(ENGINE *e);
 static int ubsec_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void));
 static int ubsec_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                 const BIGNUM *m, BN_CTX *ctx);
+#ifndef OPENSSL_NO_RSA
 static int ubsec_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                         const BIGNUM *q, const BIGNUM *dp,
                         const BIGNUM *dq, const BIGNUM *qinv, BN_CTX *ctx);
-#ifndef OPENSSL_NO_RSA
 static int ubsec_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx);
-#endif
 static int ubsec_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
+#endif
 #ifndef OPENSSL_NO_DSA
 #ifdef NOT_USED
 static int ubsec_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
                 BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
                 BN_CTX *ctx, BN_MONT_CTX *in_mont);
 static int ubsec_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
                 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
                 BN_MONT_CTX *m_ctx);
 #endif
 static DSA_SIG *ubsec_dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa);
@@ skipping 179 matching lines @@
 
 static t_UBSEC_ubsec_bytes_to_bits *p_UBSEC_ubsec_bytes_to_bits = NULL;
 static t_UBSEC_ubsec_bits_to_bytes *p_UBSEC_ubsec_bits_to_bytes = NULL;
 static t_UBSEC_ubsec_open *p_UBSEC_ubsec_open = NULL;
 static t_UBSEC_ubsec_close *p_UBSEC_ubsec_close = NULL;
 #ifndef OPENSSL_NO_DH
 static t_UBSEC_diffie_hellman_generate_ioctl 
         *p_UBSEC_diffie_hellman_generate_ioctl = NULL;
 static t_UBSEC_diffie_hellman_agree_ioctl *p_UBSEC_diffie_hellman_agree_ioctl = NULL;
 #endif
-/* #ifndef OPENSSL_NO_RSA */
+#ifndef OPENSSL_NO_RSA
 static t_UBSEC_rsa_mod_exp_ioctl *p_UBSEC_rsa_mod_exp_ioctl = NULL;
 static t_UBSEC_rsa_mod_exp_crt_ioctl *p_UBSEC_rsa_mod_exp_crt_ioctl = NULL;
-/* #endif */
+#endif
 #ifndef OPENSSL_NO_DSA
 static t_UBSEC_dsa_sign_ioctl *p_UBSEC_dsa_sign_ioctl = NULL;
 static t_UBSEC_dsa_verify_ioctl *p_UBSEC_dsa_verify_ioctl = NULL;
 #endif
 static t_UBSEC_math_accelerate_ioctl *p_UBSEC_math_accelerate_ioctl = NULL;
 static t_UBSEC_rng_ioctl *p_UBSEC_rng_ioctl = NULL;
 static t_UBSEC_max_key_len_ioctl *p_UBSEC_max_key_len_ioctl = NULL;
 
 static int max_key_len = 1024;  /* ??? */
 
@@ skipping 298 matching lines @@
         {
           /*
            * Do in software as hardware failed.
            */
            const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
            to_return = (*meth->rsa_mod_exp)(r0, I, rsa, ctx);
         }
 err:
         return to_return;
         }
-#endif
 
 static int ubsec_mod_exp_crt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                         const BIGNUM *q, const BIGNUM *dp,
                         const BIGNUM *dq, const BIGNUM *qinv, BN_CTX *ctx)
         {
         int     y_len,
-                m_len,
                 fd;
 
-        m_len = BN_num_bytes(p) + BN_num_bytes(q) + 1;
         y_len = BN_num_bits(p) + BN_num_bits(q);
 
         /* Check if hardware can't handle this argument. */
         if (y_len > max_key_len) {
                 UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_SIZE_TOO_LARGE_OR_TOO_SMALL);
                 return FAIL_TO_SOFTWARE;
         } 
 
         if (!bn_wexpand(r, p->top + q->top + 1)) {
                 UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_BN_EXPAND_FAIL);
@@ skipping 17 matching lines @@
                 UBSECerr(UBSEC_F_UBSEC_MOD_EXP_CRT, UBSEC_R_REQUEST_FAILED);
                 p_UBSEC_ubsec_close(fd);
                 return FAIL_TO_SOFTWARE;
         }
 
         p_UBSEC_ubsec_close(fd);
 
         r->top = (BN_num_bits(p) + BN_num_bits(q) + BN_BITS2 - 1)/BN_BITS2;
         return 1;
 }
+#endif
 
 #ifndef OPENSSL_NO_DSA
 #ifdef NOT_USED
 static int ubsec_dsa_mod_exp(DSA *dsa, BIGNUM *rr, BIGNUM *a1,
                 BIGNUM *p1, BIGNUM *a2, BIGNUM *p2, BIGNUM *m,
                 BN_CTX *ctx, BN_MONT_CTX *in_mont)
         {
         BIGNUM t;
         int to_return = 0;
  
@@ skipping 12 matching lines @@
 
 static int ubsec_mod_exp_dsa(DSA *dsa, BIGNUM *r, BIGNUM *a,
                 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
                 BN_MONT_CTX *m_ctx)
         {
         return ubsec_mod_exp(r, a, p, m, ctx);
         }
 #endif
 #endif
 
+#ifndef OPENSSL_NO_RSA
+
 /*
  * This function is aliased to mod_exp (with the mont stuff dropped).
  */
 static int ubsec_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
         {
         int ret = 0;
 
-#ifndef OPENSSL_NO_RSA
         /* Do in software if the key is too large for the hardware. */
         if (BN_num_bits(m) > max_key_len)
                 {
                 const RSA_METHOD *meth = RSA_PKCS1_SSLeay();
                 ret = (*meth->bn_mod_exp)(r, a, p, m, ctx, m_ctx);
                 }
         else
-#endif
                 {
                 ret = ubsec_mod_exp(r, a, p, m, ctx);
                 }
         
         return ret;
         }
+#endif
 
 #ifndef OPENSSL_NO_DH
 /* This function is aliased to mod_exp (with the dh and mont dropped). */
 static int ubsec_mod_exp_dh(const DH *dh, BIGNUM *r, const BIGNUM *a,
                 const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx,
                 BN_MONT_CTX *m_ctx)
         {
         return ubsec_mod_exp(r, a, p, m, ctx);
         }
 #endif
@@ skipping 321 matching lines @@
         if(!bind_helper(e))
                 return 0;
         return 1;
         }
 IMPLEMENT_DYNAMIC_CHECK_FN()
 IMPLEMENT_DYNAMIC_BIND_FN(bind_fn)
 #endif /* OPENSSL_NO_DYNAMIC_ENGINE */
 
 #endif /* !OPENSSL_NO_HW_UBSEC */
 #endif /* !OPENSSL_NO_HW */