Enable passing cast channel certificate authority keys.

extensions/browser/api/cast_channel/cast_auth_util_nss.cc

Index: extensions/browser/api/cast_channel/cast_auth_util_nss.cc
diff --git a/extensions/browser/api/cast_channel/cast_auth_util_nss.cc b/extensions/browser/api/cast_channel/cast_auth_util_nss.cc
index bfee716b247a401e8b3514ad11e8aaec4936824a..fb74008cd432c4f934ac678f2d41a04bdeaa5bbd 100644
--- a/extensions/browser/api/cast_channel/cast_auth_util_nss.cc
+++ b/extensions/browser/api/cast_channel/cast_auth_util_nss.cc
@@ -10,10 +10,13 @@
 #include <seccomon.h>
 #include <string>
 
+#include "base/base64.h"
+#include "base/big_endian.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "crypto/nss_util.h"
 #include "crypto/scoped_nss_types.h"
+#include "crypto/signature_verifier.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "net/base/hash_value.h"
@@ -25,12 +28,11 @@ namespace cast_channel {
 
 namespace {
 
-// Fingerprints and public keys of the allowed / trusted ICAs.
-static const net::SHA1HashValue kFingerprintICA1 = { {
+// Fingerprint, public key size, public key data of the allowed / trusted ICAs.
+static const char kDefaultKeysData[] = {

[mark a. foltz, 2014/10/03 20:07:12]

Serializing the keys into a continuous blob without delimiters assumes that all
keys are the same format. We are pretty much SOL if the format of new keys
changes.

[vadimgo, 2014/10/03 20:42:36]

The size of the fingerprint is constant at 20 bytes. There is a size field
before the public key which allows supporting different format keys.

     0x57,0x16,0xE2,0xAD,0x73,0x2E,0xBE,0xDA,0xEB,0x18,
-    0xE8,0x47,0x15,0xA8,0xDE,0x90,0x3B,0x5E,0x2A,0xF4
-} };
-static const unsigned char kPublicKeyICA1[] = {
+    0xE8,0x47,0x15,0xA8,0xDE,0x90,0x3B,0x5E,0x2A,0xF4,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xBC,0x22,0x80,
     0xBD,0x80,0xF6,0x3A,0x21,0x00,0x3B,0xAE,0x76,0x5E,0x35,0x7F,
     0x3D,0xC3,0x64,0x5C,0x55,0x94,0x86,0x34,0x2F,0x05,0x87,0x28,
@@ -53,14 +55,10 @@ static const unsigned char kPublicKeyICA1[] = {
     0x93,0xFA,0x3A,0xA5,0x91,0x5D,0x1C,0xBD,0x66,0xEB,0xCC,0x60,
     0xDC,0x86,0x74,0xCA,0xCF,0xF8,0x92,0x1C,0x98,0x7D,0x57,0xFA,
     0x61,0x47,0x9E,0xAB,0x80,0xB7,0xE4,0x48,0x80,0x2A,0x92,0xC5,
-    0x1B,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA2 = { {
+    0x1B,0x02,0x03,0x01,0x00,0x01,
     0x1B,0xA2,0x9E,0xC9,0x8E,0x4E,0xB3,0x80,0xEE,0x55,
-    0xB2,0x97,0xFD,0x2E,0x2B,0x2C,0xB6,0x8E,0x0B,0x2F
-} };
-static const unsigned char kPublicKeyICA2[] = {
+    0xB2,0x97,0xFD,0x2E,0x2B,0x2C,0xB6,0x8E,0x0B,0x2F,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xBC,0x22,0x80,
     0xBD,0x80,0xF6,0x3A,0x21,0x00,0x3B,0xAE,0x76,0x5E,0x35,0x7F,
     0x3D,0xC3,0x64,0x5C,0x55,0x94,0x86,0x34,0x2F,0x05,0x87,0x28,
@@ -83,14 +81,10 @@ static const unsigned char kPublicKeyICA2[] = {
     0x93,0xFA,0x3A,0xA5,0x91,0x5D,0x1C,0xBD,0x66,0xEB,0xCC,0x60,
     0xDC,0x86,0x74,0xCA,0xCF,0xF8,0x92,0x1C,0x98,0x7D,0x57,0xFA,
     0x61,0x47,0x9E,0xAB,0x80,0xB7,0xE4,0x48,0x80,0x2A,0x92,0xC5,
-    0x1B,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA3 = { {
+    0x1B,0x02,0x03,0x01,0x00,0x01,
     0x97,0x05,0xCE,0xF6,0x3F,0xA9,0x5E,0x0F,0xE7,0x61,
-    0xFB,0x08,0x44,0x31,0xBE,0xDE,0x01,0xB8,0xFB,0xEB
-} };
-static const unsigned char kPublicKeyICA3[] = {
+    0xFB,0x08,0x44,0x31,0xBE,0xDE,0x01,0xB8,0xFB,0xEB,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xB7,0xE8,0xC3,
     0xE4,0x2C,0xDE,0x74,0x53,0xF2,0x49,0x95,0x6D,0xD1,0xDA,0x69,
     0x57,0x0D,0x86,0xE5,0xED,0xB4,0xB9,0xE6,0x73,0x9F,0x6C,0xAD,
@@ -113,14 +107,10 @@ static const unsigned char kPublicKeyICA3[] = {
     0xDC,0xDE,0x09,0x98,0xD2,0x16,0x23,0x04,0x70,0x4D,0x99,0x9F,
     0x4A,0x82,0x28,0xE6,0xBE,0x8F,0x9D,0xBF,0xA1,0x4B,0xA2,0xBA,
     0xF5,0xB2,0x51,0x1E,0x4E,0xE7,0x80,0x9E,0x7A,0x38,0xA1,0xC7,
-    0x09,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA4 = { {
+    0x09,0x02,0x03,0x01,0x00,0x01,
     0x01,0xF5,0x28,0x56,0x33,0x80,0x9B,0x31,0xE7,0xD9,
-    0xF7,0x4E,0xAA,0xDD,0x97,0x37,0xA0,0x28,0xE7,0x24
-} };
-static const unsigned char kPublicKeyICA4[] = {
+    0xF7,0x4E,0xAA,0xDD,0x97,0x37,0xA0,0x28,0xE7,0x24,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xB0,0x0E,0x5E,
     0x07,0x3A,0xDF,0xA4,0x5F,0x68,0xF7,0x21,0xC7,0x64,0xDB,0xB6,
     0x76,0xEF,0xEE,0x8B,0x93,0xF8,0xF6,0x1B,0x88,0xE1,0x93,0xB7,
@@ -143,14 +133,10 @@ static const unsigned char kPublicKeyICA4[] = {
     0x03,0xB7,0x34,0x9E,0x77,0x3F,0xFF,0x78,0x07,0x5B,0x99,0xC1,
     0xB2,0x1F,0x35,0x56,0x6E,0x3A,0x3C,0x0C,0x25,0xE1,0x57,0xF6,
     0x8A,0x7E,0x49,0xC0,0xCC,0x83,0x11,0x35,0xE7,0x91,0x6D,0x2E,
-    0x65,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA5 = { {
+    0x65,0x02,0x03,0x01,0x00,0x01,
     0x59,0xD6,0xA3,0xAB,0xF3,0x2E,0x1D,0x33,0x6C,0xA1,
-    0x08,0xA4,0x8A,0xA4,0x32,0x90,0x5C,0x63,0x2B,0x1E
-} };
-static const unsigned char kPublicKeyICA5[] = {
+    0x08,0xA4,0x8A,0xA4,0x32,0x90,0x5C,0x63,0x2B,0x1E,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xC2,0xF6,0xD5,
     0x91,0xDC,0x37,0xB4,0x9A,0x73,0x4A,0xE7,0x74,0x6D,0x03,0xAE,
     0x27,0x24,0x41,0x99,0x96,0x1B,0x05,0x0E,0xC7,0xCF,0x09,0xCD,
@@ -173,14 +159,10 @@ static const unsigned char kPublicKeyICA5[] = {
     0x91,0xF6,0x96,0x25,0x6C,0xA4,0xE8,0x1F,0xD8,0xB3,0x74,0x20,
     0xEB,0x60,0x9D,0x3D,0xD3,0x3D,0x2E,0x36,0x0F,0xF1,0x94,0x10,
     0xF9,0x7A,0x03,0x52,0x7E,0xA4,0xEF,0xE3,0x40,0x9E,0x74,0x0E,
-    0xDF,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA6 = { {
+    0xDF,0x02,0x03,0x01,0x00,0x01,
     0xE0,0xE1,0x57,0x47,0xFD,0x50,0xA4,0x99,0x80,0x6E,
-    0x52,0x40,0x9F,0x9C,0xE3,0x9F,0x6D,0x81,0x59,0xFE
-} };
-static const unsigned char kPublicKeyICA6[] = {
+    0x52,0x40,0x9F,0x9C,0xE3,0x9F,0x6D,0x81,0x59,0xFE,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xB5,0xC8,0x14,
     0x5B,0x94,0x2E,0x8E,0x40,0xBC,0x8A,0xAB,0x1F,0x48,0xEE,0xA5,
     0x5C,0x5D,0xA9,0x44,0x23,0x33,0xE5,0x09,0xDD,0x84,0xDD,0xA6,
@@ -203,14 +185,10 @@ static const unsigned char kPublicKeyICA6[] = {
     0x01,0x97,0x1E,0xA6,0x94,0x14,0xC0,0xB2,0x55,0x95,0x2E,0x30,
     0x9C,0x7B,0xC6,0x79,0xF8,0x12,0xB3,0xB4,0x11,0x93,0x73,0x9C,
     0xD4,0x3F,0x29,0x6E,0x6A,0xAA,0xA8,0xE9,0xA2,0xF3,0x20,0x4E,
-    0xE9,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA7 = { {
+    0xE9,0x02,0x03,0x01,0x00,0x01,
     0xF9,0xDC,0x51,0x97,0x48,0xB6,0x61,0xBD,0x60,0x78,
-    0x91,0x6B,0x20,0xC1,0x9A,0xA3,0xCA,0xEC,0xF8,0xFC
-} };
-static const unsigned char kPublicKeyICA7[] = {
+    0x91,0x6B,0x20,0xC1,0x9A,0xA3,0xCA,0xEC,0xF8,0xFC,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xCC,0xE2,0xB6,
     0x2F,0x11,0xAB,0xFF,0xD0,0x5D,0x63,0x97,0x59,0xFA,0x5F,0x26,
     0xD7,0x91,0xE9,0x90,0x86,0x31,0x91,0x8E,0x2D,0x29,0x5F,0x7A,
@@ -233,14 +211,10 @@ static const unsigned char kPublicKeyICA7[] = {
     0xD8,0xC4,0xD3,0xB4,0xB5,0xEB,0xDF,0x2D,0x27,0x46,0xA5,0xFF,
     0x35,0xB5,0x5F,0x85,0x72,0xEB,0xCF,0xAD,0x09,0x18,0x05,0x95,
     0x56,0x88,0x95,0x22,0xD7,0x60,0x47,0xC9,0x1F,0xFA,0x2D,0x51,
-    0x3F,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA8 = { {
+    0x3F,0x02,0x03,0x01,0x00,0x01,
     0x51,0xD4,0x70,0x0A,0x03,0x6E,0xA5,0x6A,0xF3,0x99,
-    0xCF,0x3D,0x0F,0x17,0x8D,0x10,0x1A,0x4B,0xD2,0x44
-} };
-static const unsigned char kPublicKeyICA8[] = {
+    0xCF,0x3D,0x0F,0x17,0x8D,0x10,0x1A,0x4B,0xD2,0x44,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xBF,0x3A,0x31,
     0xFC,0xF8,0xE6,0xEE,0xC0,0x48,0x00,0xB4,0x05,0x65,0x36,0x23,
     0x6D,0x34,0xD6,0x00,0xD5,0x43,0x89,0x6A,0x90,0xCB,0x7D,0x1B,
@@ -263,14 +237,10 @@ static const unsigned char kPublicKeyICA8[] = {
     0x45,0x67,0xF0,0x1E,0x46,0xD7,0x83,0x9A,0xE5,0x49,0x76,0x21,
     0x82,0xCB,0x82,0x67,0xA5,0xFF,0x63,0xD8,0x97,0x51,0xB4,0x44,
     0xA0,0x76,0xBA,0x40,0xD8,0xAB,0xA6,0xEB,0x70,0xD5,0xA4,0x38,
-    0xB9,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA9 = { {
+    0xB9,0x02,0x03,0x01,0x00,0x01,
     0x9B,0x2A,0x45,0xBD,0x4F,0x80,0x53,0x94,0xD3,0xA7,
-    0x9D,0xC7,0xFA,0xCD,0x77,0x0B,0x36,0xB2,0x3C,0x18
-} };
-static const unsigned char kPublicKeyICA9[] = {
+    0x9D,0xC7,0xFA,0xCD,0x77,0x0B,0x36,0xB2,0x3C,0x18,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xE5,0x44,0x79,
     0xD4,0x75,0x3A,0xBD,0x25,0x6F,0x89,0xF7,0x94,0xE9,0x23,0xAE,
     0x19,0x38,0x09,0xA7,0x75,0x9C,0x5A,0x08,0x4A,0xC2,0xC6,0xA4,
@@ -293,14 +263,10 @@ static const unsigned char kPublicKeyICA9[] = {
     0x32,0xDF,0x05,0xFA,0x73,0x94,0xB0,0x6B,0x41,0xE7,0x2D,0xF0,
     0x24,0x48,0xA8,0x5B,0x03,0x34,0xE7,0x48,0x92,0x4E,0x99,0x3A,
     0x6B,0x96,0x8E,0x8E,0x48,0x52,0xA5,0xE8,0x13,0x54,0xCF,0x8D,
-    0xA1,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA10 = { {
+    0xA1,0x02,0x03,0x01,0x00,0x01,
     0xDD,0x37,0x71,0xB1,0x84,0x07,0xA5,0x1A,0x8B,0x9C,
-    0x75,0xA3,0x77,0x3B,0xE4,0x67,0x04,0xB8,0x66,0xE5
-} };
-static const unsigned char kPublicKeyICA10[] = {
+    0x75,0xA3,0x77,0x3B,0xE4,0x67,0x04,0xB8,0x66,0xE5,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xAF,0xA1,0x27,
     0x5B,0x18,0x01,0xF9,0x16,0x7C,0xB9,0x1D,0xBB,0x34,0xC4,0x45,
     0xCF,0x7A,0x7B,0x7A,0xB7,0xC9,0x52,0xC6,0xC1,0xBE,0x14,0x57,
@@ -323,14 +289,10 @@ static const unsigned char kPublicKeyICA10[] = {
     0x8D,0x44,0x50,0x1B,0x0B,0x21,0xB2,0x16,0xA2,0x1B,0xF3,0xBD,
     0xC2,0x1D,0xAF,0x4F,0x41,0x43,0xAD,0x3A,0x76,0x45,0x3C,0x2B,
     0xD3,0x71,0x31,0x43,0x37,0xB6,0x68,0xA6,0x5D,0x8C,0x50,0x2B,
-    0x8F,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA11 = { {
+    0x8F,0x02,0x03,0x01,0x00,0x01,
     0x34,0xAB,0x0F,0x01,0x2C,0x4F,0x99,0x70,0xA2,0x44,
-    0x57,0x12,0xFB,0xE3,0x52,0xC4,0x9E,0x0A,0x20,0x6B
-} };
-static const unsigned char kPublicKeyICA11[] = {
+    0x57,0x12,0xFB,0xE3,0x52,0xC4,0x9E,0x0A,0x20,0x6B,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xA8,0xB2,0x65,
     0xFB,0x07,0xB0,0x21,0xBE,0x11,0xD1,0xDA,0x5D,0x89,0xB5,0xAA,
     0xC2,0xFD,0xD3,0x27,0x8D,0x3A,0x29,0x2F,0x3E,0xD4,0x87,0xC1,
@@ -353,14 +315,10 @@ static const unsigned char kPublicKeyICA11[] = {
     0xDE,0x49,0xB9,0x20,0x0D,0x44,0x8F,0x58,0x3C,0xDD,0x52,0x6D,
     0x03,0x7A,0x33,0xB3,0x06,0x7A,0xC7,0x49,0x23,0xC5,0x2A,0x24,
     0xB6,0x96,0x12,0x4C,0x16,0xB3,0x3A,0xFC,0x46,0x03,0xEC,0xBB,
-    0xF9,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA12 = { {
+    0xF9,0x02,0x03,0x01,0x00,0x01,
     0x7C,0x3E,0x64,0x37,0x30,0xA4,0x6D,0xE5,0x16,0x7F,
-    0xAC,0xEA,0xEA,0x2A,0x16,0x3E,0xE7,0x15,0x45,0x3A
-} };
-static const unsigned char kPublicKeyICA12[] = {
+    0xAC,0xEA,0xEA,0x2A,0x16,0x3E,0xE7,0x15,0x45,0x3A,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xD9,0xE3,0x76,
     0x97,0x6A,0xEF,0x2D,0x16,0xD5,0xF9,0xDC,0x9D,0x0E,0x65,0x12,
     0x65,0x72,0xC0,0xE9,0x11,0x12,0x37,0x09,0x5D,0x54,0xF4,0x8F,
@@ -383,14 +341,10 @@ static const unsigned char kPublicKeyICA12[] = {
     0xB6,0x11,0xED,0x18,0x50,0x43,0x2E,0xD7,0xCE,0x18,0x58,0xEB,
     0xCE,0x2E,0xE9,0x9E,0x20,0x86,0xFE,0x97,0xCD,0xB2,0x9C,0xC1,
     0xAF,0x24,0x02,0x38,0x60,0x6B,0xCC,0x66,0xC3,0x04,0x72,0xD3,
-    0xF1,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA13 = { {
+    0xF1,0x02,0x03,0x01,0x00,0x01,
     0x26,0x43,0xE5,0x33,0x9E,0x07,0x14,0x83,0x9A,0xB1,
-    0xCF,0x38,0x1C,0x77,0x74,0xF0,0xE5,0xBF,0x88,0x6F
-} };
-static const unsigned char kPublicKeyICA13[] = {
+    0xCF,0x38,0x1C,0x77,0x74,0xF0,0xE5,0xBF,0x88,0x6F,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xBB,0xE5,0x0F,
     0xD2,0x1C,0x6B,0xBA,0x23,0xA9,0x2F,0x87,0xEC,0xDB,0x92,0x3F,
     0xAF,0xC8,0xD4,0xB2,0x59,0x24,0x2E,0xC8,0xCD,0x00,0xEF,0x09,
@@ -413,14 +367,10 @@ static const unsigned char kPublicKeyICA13[] = {
     0x94,0xF5,0x12,0xF4,0x63,0x38,0x0C,0x51,0xE4,0x03,0x63,0xC4,
     0x76,0x54,0xB7,0x59,0x25,0xCE,0x62,0xDE,0x73,0x3F,0xAB,0x15,
     0x56,0xC5,0xBC,0x99,0x8C,0x3A,0x46,0x3F,0x13,0x0E,0xF4,0x53,
-    0x1D,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA14 = { {
+    0x1D,0x02,0x03,0x01,0x00,0x01,
     0xCF,0x58,0x82,0xEE,0x81,0x71,0x71,0x8E,0x2C,0xBD,
-    0xDB,0x87,0xE0,0x18,0xF5,0xED,0xDA,0x85,0x4A,0x13
-} };
-static const unsigned char kPublicKeyICA14[] = {
+    0xDB,0x87,0xE0,0x18,0xF5,0xED,0xDA,0x85,0x4A,0x13,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xAD,0x16,0x57,
     0x87,0xD7,0x0D,0xA3,0xA2,0x7E,0x8B,0xAE,0x45,0x7A,0x1F,0xCA,
     0xFE,0xB9,0x15,0xB7,0x5B,0x9F,0x7D,0x16,0xA5,0xA5,0x63,0xB1,
@@ -443,14 +393,10 @@ static const unsigned char kPublicKeyICA14[] = {
     0x15,0x54,0x78,0xBA,0x9E,0x4D,0xD8,0x99,0x62,0x9E,0xE8,0x45,
     0x93,0x8C,0x14,0x7E,0x9C,0xE9,0xF7,0x2A,0x7E,0x56,0xE3,0xBD,
     0xF1,0x65,0xC8,0x6B,0xB9,0xE5,0x16,0x1E,0x22,0x29,0xEC,0xCA,
-    0xD9,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA15 = { {
+    0xD9,0x02,0x03,0x01,0x00,0x01,
     0xFD,0x28,0xC3,0x71,0x00,0x27,0x0F,0x36,0x28,0x32,
-    0x7F,0xE6,0xD6,0x8A,0x6F,0x59,0x58,0x4B,0x3E,0x1E
-} };
-static const unsigned char kPublicKeyICA15[] = {
+    0x7F,0xE6,0xD6,0x8A,0x6F,0x59,0x58,0x4B,0x3E,0x1E,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xDD,0xFE,0x56,
     0x5F,0x53,0x05,0x59,0x8F,0x7C,0xF4,0x8B,0x90,0x38,0xED,0x51,
     0xE6,0x8A,0xAC,0x78,0x1F,0x7B,0x33,0x74,0x7F,0x33,0xAA,0x6A,
@@ -473,14 +419,10 @@ static const unsigned char kPublicKeyICA15[] = {
     0xEC,0xE6,0x60,0x7B,0x20,0x7F,0xC3,0x74,0xD9,0xA3,0x67,0x80,
     0x8B,0x4A,0x34,0xDC,0x25,0x6E,0x9B,0xA5,0x67,0x97,0x54,0xAC,
     0x6C,0x8E,0x7A,0x64,0x20,0xDA,0xD6,0xAA,0x59,0x6B,0x27,0x28,
-    0x99,0x02,0x03,0x01,0x00,0x01
-};
-
-static const net::SHA1HashValue kFingerprintICA16 = { {
+    0x99,0x02,0x03,0x01,0x00,0x01,
     0xBC,0x59,0x07,0x13,0xA9,0xCE,0x8B,0xFE,0xE3,0x5B,
-    0xB7,0xC3,0xC3,0xC2,0x48,0x44,0xE8,0x6A,0x77,0xC0
-} };
-static const unsigned char kPublicKeyICA16[] = {
+    0xB7,0xC3,0xC3,0xC2,0x48,0x44,0xE8,0x6A,0x77,0xC0,
+    0x01,0x0E,
     0x30,0x82,0x01,0x0A,0x02,0x82,0x01,0x01,0x00,0xD2,0xB0,0xC9,
     0xB3,0x88,0xCD,0x93,0x23,0x6A,0x46,0xD3,0x69,0x0A,0xD7,0xFF,
     0xE1,0x51,0x7E,0x29,0xA9,0x6B,0x71,0x68,0xC0,0xCF,0x69,0xA3,
@@ -512,87 +454,47 @@ struct ICACertInfo {
   SECItem public_key;
 };
 
-// List of allowed / trusted ICAs.
-static const ICACertInfo kAllowedICAs[] = {
-  { &kFingerprintICA1,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA1),
-      sizeof(kPublicKeyICA1) } },
-  { &kFingerprintICA2,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA2),
-      sizeof(kPublicKeyICA2) } },
-  { &kFingerprintICA3,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA3),
-      sizeof(kPublicKeyICA3) } },
-  { &kFingerprintICA4,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA4),
-      sizeof(kPublicKeyICA4) } },
-  { &kFingerprintICA5,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA5),
-      sizeof(kPublicKeyICA5) } },
-  { &kFingerprintICA6,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA6),
-      sizeof(kPublicKeyICA6) } },
-  { &kFingerprintICA7,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA7),
-      sizeof(kPublicKeyICA7) } },
-  { &kFingerprintICA8,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA8),
-      sizeof(kPublicKeyICA8) } },
-  { &kFingerprintICA9,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA9),
-      sizeof(kPublicKeyICA9) } },
-  { &kFingerprintICA10,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA10),
-      sizeof(kPublicKeyICA10) } },
-  { &kFingerprintICA11,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA11),
-      sizeof(kPublicKeyICA11) } },
-  { &kFingerprintICA12,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA12),
-      sizeof(kPublicKeyICA12) } },
-  { &kFingerprintICA13,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA13),
-      sizeof(kPublicKeyICA13) } },
-  { &kFingerprintICA14,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA14),
-      sizeof(kPublicKeyICA14) } },
-  { &kFingerprintICA15,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA15),
-      sizeof(kPublicKeyICA15) } },
-  { &kFingerprintICA16,
-    { siDERCertBuffer,
-      const_cast<unsigned char*>(kPublicKeyICA16),
-      sizeof(kPublicKeyICA16) } },
-};
+std::string g_DynamicKeysData;
+std::vector<ICACertInfo> g_AllowedICAs;
 
 typedef scoped_ptr<
     CERTCertificate,
     crypto::NSSDestroyer<CERTCertificate, CERT_DestroyCertificate> >
         ScopedCERTCertificate;
 
-// Returns the index of the ICA whose fingerprint matches |fingerprint|.
-// Returns -1, if no such ICA is found.
-static int GetICAWithFingerprint(const net::SHA1HashValue& fingerprint) {
-  for (size_t i = 0; i < arraysize(kAllowedICAs); ++i) {
-    if (kAllowedICAs[i].fingerprint->Equals(fingerprint))
-      return static_cast<int>(i);
+// Initializes allowed ICAs using passed in data in the following format:
+// 20 bytes fingerprint, 2 bytes public key size, public key
+// Returns NULL, if no such ICA is found.
+static void InitializeAllowedICAs(const char* data, unsigned int len) {
+  g_AllowedICAs.clear();
+
+  base::BigEndianReader reader(data, len);
+  while (reader.remaining() > 0) {
+    const char* fingerprint = reader.ptr();
+    reader.Skip(20);
+
+    unsigned short size;
+    reader.ReadU16(&size);
+
+    g_AllowedICAs.push_back(
+        { reinterpret_cast<const net::SHA1HashValue*>(fingerprint),
+          { siDERCertBuffer, (unsigned char*)reader.ptr(), size } });
+
+    reader.Skip(size);
+  }
+}
+
+// Returns the public key of the ICA whose fingerprint matches |fingerprint|.
+// Returns NULL, if no such ICA is found.
+static const SECItem* GetICAWithFingerprint(
+    const net::SHA1HashValue& fingerprint) {
+  for (std::vector<ICACertInfo>::const_iterator iter = g_AllowedICAs.begin();
+       iter != g_AllowedICAs.end();
+       ++iter) {
+    if ((*iter).fingerprint->Equals(fingerprint))
+      return &(*iter).public_key;
   }
-  return -1;
+  return NULL;
 }
 
 // Parses out DeviceAuthMessage from CastMessage
@@ -652,18 +554,21 @@ AuthResult VerifyCredentials(const AuthResponse& response,
 
   VLOG(1) << "Response has " << num_intermediates << " intermediates";
 
+  if (g_AllowedICAs.size() == 0) {
+    InitializeAllowedICAs(kDefaultKeysData, sizeof(kDefaultKeysData));
+  }
+
   if (num_intermediates <= 0) {
-    trusted_ca_key_der = &kAllowedICAs[0].public_key;
+    trusted_ca_key_der = &g_AllowedICAs[0].public_key;
   } else {
     const std::string& ica = response.intermediate_certificate(0);
     scoped_refptr<net::X509Certificate> ica_cert
         = net::X509Certificate::CreateFromBytes(ica.data(), ica.length());
-    int index = GetICAWithFingerprint(ica_cert->fingerprint());
-    if (index == -1) {
+    trusted_ca_key_der = GetICAWithFingerprint(ica_cert->fingerprint());
+    if (trusted_ca_key_der == NULL) {
       return AuthResult::Create(kErrorPrefix + "Disallowed intermediate cert",
                                 AuthResult::ERROR_FINGERPRINT_NOT_FOUND);
     }
-    trusted_ca_key_der = &kAllowedICAs[index].public_key;
   }
 
   crypto::EnsureNSSInit();
@@ -735,6 +640,53 @@ AuthResult VerifyCredentials(const AuthResponse& response,
   return AuthResult();
 }
 
+bool VerifySignature(const std::string& signature, const std::string& data)
+{
+  // This is the algorithm ID for SHA-256 with RSA encryption.
+  const uint8 kSHA256WithRSAAlgorithmID[] = {

[mark a. foltz, 2014/10/03 20:07:12]

Constants should be declared at the top level in the file.

[vadimgo, 2014/10/03 20:42:36]

Done.

+    0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x0B,0x05,0x00
+  };
+
+  // Built in public key for verifying trusted authorities data.
+  const uint8 kPublicKey[294]={
+    0x30,0x82,0x01,0x22,0x30,0x0D,0x06,0x09,0x2A,0x86,0x48,0x86,0xF7,0x0D,0x01,
+    0x01,0x01,0x05,0x00,0x03,0x82,0x01,0x0F,0x00,0x30,0x82,0x01,0x0A,0x02,0x82,
+    0x01,0x01,0x00,0xD7,0x15,0xA7,0x03,0xC1,0xDE,0x7C,0x0E,0x8F,0x3E,0x15,0x7A,
+    0x49,0x34,0x89,0xBC,0x00,0x4C,0x56,0xF3,0x75,0xD2,0x22,0x6D,0x23,0xE7,0x98,
+    0x18,0x45,0xAB,0x24,0x4F,0x1B,0x24,0xAA,0xAD,0x60,0x11,0xDB,0xBF,0x9E,0xD5,
+    0xD2,0x95,0x96,0x23,0x89,0xE3,0x60,0xEB,0xD3,0xF0,0x34,0xC2,0x17,0xFC,0x0E,
+    0x86,0x46,0x74,0x67,0xFA,0x49,0xD9,0x79,0x04,0x3C,0xC4,0x69,0x97,0x5A,0x40,
+    0x5F,0x39,0x3F,0xC3,0x9C,0xAC,0xD0,0xF0,0xD1,0xE1,0x6B,0xB9,0x48,0xEA,0x84,
+    0x92,0x0C,0x4D,0xBE,0x32,0x59,0x47,0x00,0x9E,0x51,0xFD,0xA8,0xF5,0x8B,0x3C,
+    0x85,0xB9,0xED,0x52,0xDA,0xDA,0x40,0x7D,0x8E,0xCE,0x8A,0x77,0x9D,0x0F,0xCA,
+    0x6A,0x8F,0xC7,0xE3,0xFC,0xE2,0x29,0x30,0xE5,0xCE,0xCF,0xCB,0xFA,0x22,0x3F,
+    0xFA,0x32,0x95,0x05,0x47,0xE9,0x1C,0xEE,0x31,0xBE,0xFE,0x35,0xFB,0x58,0xC8,
+    0xF9,0x48,0xB3,0xE5,0xB0,0x1B,0xD6,0x40,0xFC,0xF4,0xB0,0xEC,0x9C,0x7F,0x21,
+    0xDF,0xD7,0x3B,0x99,0xAA,0x07,0x53,0x73,0x50,0x78,0x72,0x31,0x48,0xDF,0x21,
+    0x79,0xE3,0x86,0x19,0x66,0xC9,0x18,0x5F,0x35,0xC8,0x1C,0x10,0xE4,0xA1,0x19,
+    0x4E,0x11,0xBD,0xFE,0xA9,0xFF,0x20,0x84,0xF6,0xC8,0xB7,0x48,0xFA,0xF0,0x74,
+    0x55,0x37,0x0B,0xB1,0x66,0x8D,0xEE,0x3E,0x64,0x39,0xA3,0x90,0x60,0x88,0xAF,
+    0x14,0xE9,0xE0,0x1A,0x22,0x4B,0xA4,0x48,0x42,0x1F,0xCF,0x16,0x9C,0x8F,0x6B,
+    0x29,0xFB,0x80,0xF6,0x3D,0xA5,0x2E,0x51,0x2C,0x05,0x1F,0xD6,0x17,0x51,0x72,
+    0x03,0x4C,0x30,0x37,0x02,0x03,0x01,0x00,0x01,
+  };
+
+  crypto::SignatureVerifier verifier;
+  if (!verifier.VerifyInit(kSHA256WithRSAAlgorithmID,
+                           sizeof(kSHA256WithRSAAlgorithmID),
+                           reinterpret_cast<const uint8*>(signature.data()),
+                           signature.size(),
+                           kPublicKey,
+                           sizeof(kPublicKey))) {
+    return false;
+  }
+
+  verifier.VerifyUpdate(reinterpret_cast<const uint8*>(data.data()),
+                        data.size());
+
+  return verifier.VerifyFinal();
+}
+
 }  // namespace
 
 AuthResult AuthenticateChallengeReply(const CastMessage& challenge_reply,
@@ -765,6 +717,20 @@ AuthResult AuthenticateChallengeReply(const CastMessage& challenge_reply,
   return AuthResult();
 }
 
+bool SetTrustedCertificateAuthorities(const std::string& signature,
+                                      const std::string& keys) {
+  std::string decodedSignature;
+  base::Base64Decode(signature, &decodedSignature);
+  base::Base64Decode(keys, &g_DynamicKeysData);
+  if (!VerifySignature(decodedSignature, g_DynamicKeysData)) {
+    VLOG(1) << "Failed trusted certificate authorities data verification";
+    return false;
+  }
+
+  InitializeAllowedICAs(g_DynamicKeysData.data(), g_DynamicKeysData.size());
+  return true;
+}
+
 }  // namespace cast_channel
 }  // namespace core_api
 }  // namespace extensions