Align OpenSSL and NSS ChannelID formats.

crypto/ec_private_key_unittest.cc

Index: crypto/ec_private_key_unittest.cc
diff --git a/crypto/ec_private_key_unittest.cc b/crypto/ec_private_key_unittest.cc
index 0f4479b72f0d8b7c14ead8e919e82358faf9e4a4..6993a20b08f8f872b7f7fda7e2d0f73c4c965057 100644
--- a/crypto/ec_private_key_unittest.cc
+++ b/crypto/ec_private_key_unittest.cc
@@ -6,6 +6,7 @@
 
 #include <vector>
 
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -152,7 +153,6 @@ TEST(ECPrivateKeyUnitTest, LoadNSSKeyTest) {
       0x58, 0x82, 0x14, 0xfb, 0x47, 0x85, 0x3c, 0xc3, 0xdf, 0xdd, 0xcc, 0x79,
       0x9f, 0x41, 0x83, 0x72, 0xf2, 0x0a, 0xe9, 0xe1, 0x2c, 0x12, 0xb0, 0xb0,
       0x0a, 0xb2, 0x1d, 0xca, 0x15, 0xb2, 0xca};
-  unsigned int nss_key_len = 187;
   static const unsigned char nss_pub_key[] = {
       0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
       0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
@@ -162,22 +162,62 @@ TEST(ECPrivateKeyUnitTest, LoadNSSKeyTest) {
       0xd7, 0x5c, 0x5d, 0xc5, 0x53, 0x6e, 0xe5, 0xa9, 0x33, 0xd5, 0xcc, 0xab,
       0x53, 0x78, 0xdd, 0xd6, 0x12, 0x3a, 0x5e, 0xeb, 0xbf, 0xdf, 0x16, 0xd3,
       0x2c, 0x3b, 0xe8, 0xdb, 0x19, 0xfc, 0x5e};
-  unsigned int nss_pub_key_len = 91;
 
   scoped_ptr<crypto::ECPrivateKey> keypair_nss(
       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
           "",
-          std::vector<uint8>(nss_key, nss_key + nss_key_len),
-          std::vector<uint8>(nss_pub_key, nss_pub_key + nss_pub_key_len)));
+          std::vector<uint8>(nss_key, nss_key + arraysize(nss_key)),
+          std::vector<uint8>(nss_pub_key,
+                             nss_pub_key + arraysize(nss_pub_key))));
 
   EXPECT_TRUE(keypair_nss.get());
 }
 
-// The plan is to migrate to OpenSSL everywhere, so making NSS implementation be
-// able to load the OpenSSL generated keys isn't that important.
-#if defined(USE_OPENSSL)
+// Although the plan is to transition from OpenSSL to NSS, ensure NSS can import
+// OpenSSL's format so that it is possible to rollback.
 TEST(ECPrivateKeyUnitTest, LoadOpenSSLKeyTest) {
   static const unsigned char openssl_key[] = {
+      0x30, 0x81, 0xb0, 0x30, 0x1b, 0x06, 0x0a, 0x2a, 0x86, 0x48, 0x86, 0xf7,
+      0x0d, 0x01, 0x0c, 0x01, 0x03, 0x30, 0x0d, 0x04, 0x08, 0xb2, 0xfe, 0x68,
+      0xc2, 0xea, 0x0f, 0x10, 0x9c, 0x02, 0x01, 0x01, 0x04, 0x81, 0x90, 0xe2,
+      0xf6, 0x1c, 0xca, 0xad, 0x64, 0x30, 0xbf, 0x88, 0x04, 0x35, 0xe5, 0x0f,
+      0x11, 0x49, 0x06, 0x01, 0x14, 0x33, 0x80, 0xa2, 0x78, 0x44, 0x5b, 0xaa,
+      0x0d, 0xd7, 0x00, 0x36, 0x9d, 0x91, 0x97, 0x37, 0x20, 0x7b, 0x27, 0xc1,
+      0xa0, 0xa2, 0x73, 0x06, 0x15, 0xdf, 0xc8, 0x13, 0x9b, 0xc9, 0x8c, 0x9c,
+      0xce, 0x00, 0xd0, 0xc8, 0x42, 0xc1, 0xda, 0x2b, 0x07, 0x2b, 0x12, 0xa3,
+      0xce, 0x10, 0x39, 0x7a, 0xf1, 0x55, 0x69, 0x8d, 0xa5, 0xc4, 0x2a, 0x00,
+      0x0d, 0x94, 0xc6, 0xde, 0x6a, 0x3d, 0xb7, 0xe5, 0x6d, 0x59, 0x3e, 0x09,
+      0xb5, 0xe3, 0x3e, 0xfc, 0x50, 0x56, 0xe9, 0x50, 0x42, 0x7c, 0xe7, 0xf0,
+      0x19, 0xbd, 0x31, 0xa7, 0x85, 0x47, 0xb3, 0xe9, 0xb3, 0x50, 0x3c, 0xc9,
+      0x32, 0x37, 0x1a, 0x93, 0x78, 0x48, 0x78, 0x82, 0xde, 0xad, 0x5c, 0xf2,
+      0xcf, 0xf2, 0xbb, 0x2c, 0x44, 0x05, 0x7f, 0x4a, 0xf9, 0xb1, 0x2b, 0xdd,
+      0x49, 0xf6, 0x7e, 0xd0, 0x42, 0xaa, 0x14, 0x3c, 0x24, 0x77, 0xb4};

[davidben, 2014/08/04 17:25:21]

I believe this is slightly larger than the NSS ones because OpenSSL defaults to
a salt length.

[Ryan Sleevi, 2014/08/06 02:24:48]

Not sure I understand?

[davidben, 2014/08/06 18:34:36]

openssl_key is 4 bytes longer than nss_key. Was making a note as to why.

+  static const unsigned char openssl_pub_key[] = {
+      0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
+      0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
+      0x42, 0x00, 0x04, 0xb9, 0xda, 0x0d, 0x71, 0x60, 0xb3, 0x63, 0x28, 0x22,
+      0x67, 0xe7, 0xe0, 0xa3, 0xf8, 0x00, 0x8e, 0x4c, 0x89, 0xed, 0x31, 0x34,
+      0xf6, 0xdb, 0xc4, 0xfe, 0x0b, 0x5d, 0xe1, 0x11, 0x39, 0x49, 0xa6, 0x50,
+      0xa8, 0xe3, 0x4a, 0xc0, 0x40, 0x88, 0xb8, 0x38, 0x3f, 0x56, 0xfb, 0x33,
+      0x8d, 0xd4, 0x64, 0x91, 0xd6, 0x15, 0x77, 0x42, 0x27, 0xc5, 0xaa, 0x44,
+      0xff, 0xab, 0x4d, 0xb5, 0x7e, 0x25, 0x3d};
+
+  scoped_ptr<crypto::ECPrivateKey> keypair_openssl(
+      crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
+          "",
+          std::vector<uint8>(openssl_key, openssl_key + arraysize(openssl_key)),
+          std::vector<uint8>(openssl_pub_key,
+                             openssl_pub_key + arraysize(openssl_pub_key))));
+
+  EXPECT_TRUE(keypair_openssl.get());
+}
+
+// The Android code writes out Channel IDs differently from the NSS
+// implementation; the empty password is converted to "\0\0". The OpenSSL port
+// should support either.
+#if defined(USE_OPENSSL)
+TEST(ECPrivateKeyUnitTest, LoadOldOpenSSLKeyTest) {
+  static const unsigned char openssl_key[] = {

[davidben, 2014/08/04 17:25:21]

The /huge/ difference in size between this and the one I newly generated is
confusing, perhaps something funny happened in dumping these out? Perhaps they
contain the data as a prefix or something? In any case, I've just left it as-is.
The new ones are more consistent when the NSS size.

[Ryan Sleevi, 2014/08/06 02:24:48]

What's the ASN.1 dump say?

[davidben, 2014/08/06 18:34:36]

Interesting. It's actually full-length. The difference appears to be that this
one writes out the curve parameters in full.

$ openssl pkcs8 -in openssl.old.der -inform der -passin 'pass:' | openssl
asn1parse
    0:d=0  hl=4 l= 377 cons: SEQUENCE          
    4:d=1  hl=2 l=   1 prim: INTEGER           :00
    7:d=1  hl=4 l= 259 cons: SEQUENCE          
   11:d=2  hl=2 l=   7 prim: OBJECT            :id-ecPublicKey
   20:d=2  hl=3 l= 247 cons: SEQUENCE          
   23:d=3  hl=2 l=   1 prim: INTEGER           :01
   26:d=3  hl=2 l=  44 cons: SEQUENCE          
   28:d=4  hl=2 l=   7 prim: OBJECT            :prime-field
   37:d=4  hl=2 l=  33 prim: INTEGER          
:FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
   72:d=3  hl=2 l=  91 cons: SEQUENCE          
   74:d=4  hl=2 l=  32 prim: OCTET STRING      [HEX
DUMP]:FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC
  108:d=4  hl=2 l=  32 prim: OCTET STRING      [HEX
DUMP]:5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B
  142:d=4  hl=2 l=  21 prim: BIT STRING        
  165:d=3  hl=2 l=  65 prim: OCTET STRING      [HEX
DUMP]:046B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C2964FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5
  232:d=3  hl=2 l=  33 prim: INTEGER          
:FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551
  267:d=3  hl=2 l=   1 prim: INTEGER           :01
  270:d=1  hl=2 l= 109 prim: OCTET STRING      [HEX
DUMP]:306B02010104204309C0677521479DA8FA16DF15736134686FE38E479195AB794A7214CBE2494FA14403420004DE090807032E8F379AD5ADE5C69DD463C74AE720CB90A01F181872B5218838C0DBBAF699D8A53B83E9E3D561997342C66CE80A9540413B0D10A74A93DB5AE7EC

(Note: this won't work on any of the other keys. As far as I can tell, you can't
actually tell openssl pkcs8 to decrypt one of the PKCS#12 CBE methods without it
first doing an ascii_to_ucs2 + trailing NUL on the password. And so it can't use
the empty byte string.)

       0x30, 0x82, 0x01, 0xa1, 0x30, 0x1b, 0x06, 0x0a, 0x2a, 0x86, 0x48, 0x86,
       0xf7, 0x0d, 0x01, 0x0c, 0x01, 0x03, 0x30, 0x0d, 0x04, 0x08, 0x86, 0xaa,
       0xd7, 0xdf, 0x3b, 0x91, 0x97, 0x60, 0x02, 0x01, 0x01, 0x04, 0x82, 0x01,
@@ -214,7 +254,6 @@ TEST(ECPrivateKeyUnitTest, LoadOpenSSLKeyTest) {
       0xc2, 0xc1, 0x55, 0x22, 0x42, 0x2f, 0x13, 0x7d, 0x93, 0x27, 0xc8, 0x11,
       0x35, 0xc5, 0xe3, 0xc5, 0xaa, 0x15, 0x3c, 0xac, 0x30, 0xbc, 0x45, 0x16,
       0xed};
-  unsigned int openssl_key_len = 421;
   static const unsigned char openssl_pub_key[] = {
       0x30, 0x82, 0x01, 0x4b, 0x30, 0x82, 0x01, 0x03, 0x06, 0x07, 0x2a, 0x86,
       0x48, 0xce, 0x3d, 0x02, 0x01, 0x30, 0x81, 0xf7, 0x02, 0x01, 0x01, 0x30,
@@ -244,14 +283,13 @@ TEST(ECPrivateKeyUnitTest, LoadOpenSSLKeyTest) {
       0x88, 0x38, 0xc0, 0xdb, 0xba, 0xf6, 0x99, 0xd8, 0xa5, 0x3b, 0x83, 0xe9,
       0xe3, 0xd5, 0x61, 0x99, 0x73, 0x42, 0xc6, 0x6c, 0xe8, 0x0a, 0x95, 0x40,
       0x41, 0x3b, 0x0d, 0x10, 0xa7, 0x4a, 0x93, 0xdb, 0x5a, 0xe7, 0xec};
-  unsigned int openssl_pub_key_len = 335;
 
   scoped_ptr<crypto::ECPrivateKey> keypair_openssl(
       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
           "",
-          std::vector<uint8>(openssl_key, openssl_key + openssl_key_len),
+          std::vector<uint8>(openssl_key, openssl_key + arraysize(openssl_key)),
           std::vector<uint8>(openssl_pub_key,
-                             openssl_pub_key + openssl_pub_key_len)));
+                             openssl_pub_key + arraysize(openssl_pub_key))));
 
   EXPECT_TRUE(keypair_openssl.get());
 }