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

openssl/crypto/seed/seed.c

 /*
  * Copyright (c) 2007 KISA(Korea Information Security Agency). All rights reserved.  
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Neither the name of author nor the names of its contributors may
  *    be used to endorse or promote products derived from this software
@@ skipping 17 matching lines @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifdef WIN32
 #include <memory.h>
 #endif
 
 #include <openssl/seed.h>
 #include "seed_locl.h"
 
-static seed_word SS[4][256] = { {
+static const seed_word SS[4][256] = {   {
         0x2989a1a8, 0x05858184, 0x16c6d2d4, 0x13c3d3d0, 0x14445054, 0x1d0d111c, 0x2c8ca0ac, 0x25052124,
         0x1d4d515c, 0x03434340, 0x18081018, 0x1e0e121c, 0x11415150, 0x3cccf0fc, 0x0acac2c8, 0x23436360,
         0x28082028, 0x04444044, 0x20002020, 0x1d8d919c, 0x20c0e0e0, 0x22c2e2e0, 0x08c8c0c8, 0x17071314,
         0x2585a1a4, 0x0f8f838c, 0x03030300, 0x3b4b7378, 0x3b8bb3b8, 0x13031310, 0x12c2d2d0, 0x2ecee2ec,
         0x30407070, 0x0c8c808c, 0x3f0f333c, 0x2888a0a8, 0x32023230, 0x1dcdd1dc, 0x36c6f2f4, 0x34447074,
         0x2ccce0ec, 0x15859194, 0x0b0b0308, 0x17475354, 0x1c4c505c, 0x1b4b5358, 0x3d8db1bc, 0x01010100,
         0x24042024, 0x1c0c101c, 0x33437370, 0x18889098, 0x10001010, 0x0cccc0cc, 0x32c2f2f0, 0x19c9d1d8,
         0x2c0c202c, 0x27c7e3e4, 0x32427270, 0x03838380, 0x1b8b9398, 0x11c1d1d0, 0x06868284, 0x09c9c1c8,
         0x20406060, 0x10405050, 0x2383a3a0, 0x2bcbe3e8, 0x0d0d010c, 0x3686b2b4, 0x1e8e929c, 0x0f4f434c,
         0x3787b3b4, 0x1a4a5258, 0x06c6c2c4, 0x38487078, 0x2686a2a4, 0x12021210, 0x2f8fa3ac, 0x15c5d1d4,
@@ skipping 131 matching lines @@
 #define KC7     0x1bbcdccf
 #define KC8     0x3779b99e
 #define KC9     0x6ef3733c
 #define KC10    0xdde6e678
 #define KC11    0xbbcdccf1
 #define KC12    0x779b99e3
 #define KC13    0xef3733c6
 #define KC14    0xde6e678d
 #define KC15    0xbcdccf1b
 
+#if defined(OPENSSL_SMALL_FOOTPRINT)
+static const seed_word KC[] = {
+        KC0,    KC1,    KC2,    KC3,    KC4,    KC5,    KC6,    KC7,
+        KC8,    KC9,    KC10,   KC11,   KC12,   KC13,   KC14,   KC15    };
+#endif
 
 void SEED_set_key(const unsigned char rawkey[SEED_KEY_LENGTH], SEED_KEY_SCHEDULE *ks)
 {
         seed_word x1, x2, x3, x4;
         seed_word t0, t1;
 
         char2word(rawkey   , x1);
         char2word(rawkey+4 , x2);
         char2word(rawkey+8 , x3);
         char2word(rawkey+12, x4);
 
         t0 = (x1 + x3 - KC0) & 0xffffffff;
         t1 = (x2 - x4 + KC0) & 0xffffffff;                     KEYUPDATE_TEMP(t0, t1, &ks->data[0]);
         KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC1);      KEYUPDATE_TEMP(t0, t1, &ks->data[2]);
+
+#if !defined(OPENSSL_SMALL_FOOTPRINT)
         KEYSCHEDULE_UPDATE0(t0, t1, x1, x2, x3, x4, KC2);      KEYUPDATE_TEMP(t0, t1, &ks->data[4]);
         KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC3);      KEYUPDATE_TEMP(t0, t1, &ks->data[6]);
         KEYSCHEDULE_UPDATE0(t0, t1, x1, x2, x3, x4, KC4);      KEYUPDATE_TEMP(t0, t1, &ks->data[8]);
         KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC5);      KEYUPDATE_TEMP(t0, t1, &ks->data[10]);
         KEYSCHEDULE_UPDATE0(t0, t1, x1, x2, x3, x4, KC6);      KEYUPDATE_TEMP(t0, t1, &ks->data[12]);
         KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC7);      KEYUPDATE_TEMP(t0, t1, &ks->data[14]);
         KEYSCHEDULE_UPDATE0(t0, t1, x1, x2, x3, x4, KC8);      KEYUPDATE_TEMP(t0, t1, &ks->data[16]);
         KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC9);      KEYUPDATE_TEMP(t0, t1, &ks->data[18]);
         KEYSCHEDULE_UPDATE0(t0, t1, x1, x2, x3, x4, KC10);     KEYUPDATE_TEMP(t0, t1, &ks->data[20]);
         KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC11);     KEYUPDATE_TEMP(t0, t1, &ks->data[22]);
         KEYSCHEDULE_UPDATE0(t0, t1, x1, x2, x3, x4, KC12);     KEYUPDATE_TEMP(t0, t1, &ks->data[24]);
         KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC13);     KEYUPDATE_TEMP(t0, t1, &ks->data[26]);
         KEYSCHEDULE_UPDATE0(t0, t1, x1, x2, x3, x4, KC14);     KEYUPDATE_TEMP(t0, t1, &ks->data[28]);
         KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC15);     KEYUPDATE_TEMP(t0, t1, &ks->data[30]);
+#else
+        {
+            int i;
+            for (i=2; i<16; i+=2) {
+                KEYSCHEDULE_UPDATE0(t0, t1, x1, x2, x3, x4, KC[i]);
+                KEYUPDATE_TEMP(t0, t1, &ks->data[i*2]);
+                KEYSCHEDULE_UPDATE1(t0, t1, x1, x2, x3, x4, KC[i+1]);
+                KEYUPDATE_TEMP(t0, t1, &ks->data[i*2+2]);
+            }
+        }
+#endif
 }
 
 void SEED_encrypt(const unsigned char s[SEED_BLOCK_SIZE], unsigned char d[SEED_BLOCK_SIZE], const SEED_KEY_SCHEDULE *ks)
 {
         seed_word x1, x2, x3, x4;
         seed_word t0, t1;
 
         char2word(s,    x1);
         char2word(s+4,  x2);
         char2word(s+8,  x3);
         char2word(s+12, x4);
-        
+
+#if !defined(OPENSSL_SMALL_FOOTPRINT)   
         E_SEED(t0, t1, x1, x2, x3, x4, 0);
         E_SEED(t0, t1, x3, x4, x1, x2, 2);
         E_SEED(t0, t1, x1, x2, x3, x4, 4);
         E_SEED(t0, t1, x3, x4, x1, x2, 6);
         E_SEED(t0, t1, x1, x2, x3, x4, 8);
         E_SEED(t0, t1, x3, x4, x1, x2, 10);
         E_SEED(t0, t1, x1, x2, x3, x4, 12);
         E_SEED(t0, t1, x3, x4, x1, x2, 14);
         E_SEED(t0, t1, x1, x2, x3, x4, 16);
         E_SEED(t0, t1, x3, x4, x1, x2, 18);
         E_SEED(t0, t1, x1, x2, x3, x4, 20);
         E_SEED(t0, t1, x3, x4, x1, x2, 22);
         E_SEED(t0, t1, x1, x2, x3, x4, 24);
         E_SEED(t0, t1, x3, x4, x1, x2, 26);
         E_SEED(t0, t1, x1, x2, x3, x4, 28);
         E_SEED(t0, t1, x3, x4, x1, x2, 30);
+#else
+        {
+            int i;
+            for (i=0;i<30;i+=4) {
+                E_SEED(t0,t1,x1,x2,x3,x4,i);
+                E_SEED(t0,t1,x3,x4,x1,x2,i+2);
+            }
+        }
+#endif
 
         word2char(x3, d);
         word2char(x4, d+4);
         word2char(x1, d+8);
         word2char(x2, d+12);
 }
 
 void SEED_decrypt(const unsigned char s[SEED_BLOCK_SIZE], unsigned char d[SEED_BLOCK_SIZE], const SEED_KEY_SCHEDULE *ks)
 {
         seed_word x1, x2, x3, x4;
         seed_word t0, t1;
 
         char2word(s,    x1);
         char2word(s+4,  x2);
         char2word(s+8,  x3);
         char2word(s+12, x4);
-        
+
+#if !defined(OPENSSL_SMALL_FOOTPRINT)
         E_SEED(t0, t1, x1, x2, x3, x4, 30);
         E_SEED(t0, t1, x3, x4, x1, x2, 28);
         E_SEED(t0, t1, x1, x2, x3, x4, 26);
         E_SEED(t0, t1, x3, x4, x1, x2, 24);
         E_SEED(t0, t1, x1, x2, x3, x4, 22);
         E_SEED(t0, t1, x3, x4, x1, x2, 20);
         E_SEED(t0, t1, x1, x2, x3, x4, 18);
         E_SEED(t0, t1, x3, x4, x1, x2, 16);
         E_SEED(t0, t1, x1, x2, x3, x4, 14);
         E_SEED(t0, t1, x3, x4, x1, x2, 12);
         E_SEED(t0, t1, x1, x2, x3, x4, 10);
         E_SEED(t0, t1, x3, x4, x1, x2, 8);
         E_SEED(t0, t1, x1, x2, x3, x4, 6);
         E_SEED(t0, t1, x3, x4, x1, x2, 4);
         E_SEED(t0, t1, x1, x2, x3, x4, 2);
         E_SEED(t0, t1, x3, x4, x1, x2, 0);
+#else
+        {
+            int i;
+            for (i=30; i>0; i-=4) {
+                E_SEED(t0, t1, x1, x2, x3, x4, i);
+                E_SEED(t0, t1, x3, x4, x1, x2, i-2);
+
+            }
+        }
+#endif
 
         word2char(x3, d);
         word2char(x4, d+4);
         word2char(x1, d+8);
         word2char(x2, d+12);
 }
 
 #endif /* OPENSSL_NO_SEED */