Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(108)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: extensions/browser/api/cast_channel/cast_auth_util.cc

Issue 627573002: Enable passing cast channel certificate authority keys. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Added static to consts. Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« extensions/browser/api/cast_channel/cast_auth_util.h ('K') | « extensions/browser/api/cast_channel/cast_auth_util.h ('k') | extensions/browser/api/cast_channel/cast_auth_util_nss.cc » ('j') | extensions/browser/api/cast_channel/cast_auth_util_nss.cc » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "extensions/browser/api/cast_channel/cast_auth_util.h" 5 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
6 6
7 namespace extensions { 7 namespace extensions {
8 namespace core_api { 8 namespace core_api {
9 namespace cast_channel { 9 namespace cast_channel {
10 10
(...skipping 17 matching lines...) Expand all
28 } 28 }
29 29
30 AuthResult::AuthResult(const std::string& error_message, 30 AuthResult::AuthResult(const std::string& error_message,
31 ErrorType error_type, 31 ErrorType error_type,
32 int nss_error_code) 32 int nss_error_code)
33 : error_message(error_message), 33 : error_message(error_message),
34 error_type(error_type), 34 error_type(error_type),
35 nss_error_code(nss_error_code) { 35 nss_error_code(nss_error_code) {
36 } 36 }
37 37
38 static const net::SHA256HashValue kFingerprintICA1 = { {
39 0x52, 0x9D, 0x9C, 0xD6, 0x7F, 0xE5, 0xEB, 0x69, 0x8E, 0x70, 0xDD, 0x26,
40 0xD7, 0xD8, 0xF1, 0x26, 0x59, 0xF1, 0xE6, 0xE5, 0x23, 0x48, 0xBF, 0x6A,
41 0x5C, 0xF7, 0x16, 0xE1, 0x3F, 0x41, 0x0E, 0x73
42 } };
43
44 static const unsigned char kPublicKeyICA1[] = {
45 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xBC, 0x22, 0x80,
46 0xBD, 0x80, 0xF6, 0x3A, 0x21, 0x00, 0x3B, 0xAE, 0x76, 0x5E, 0x35, 0x7F,
47 0x3D, 0xC3, 0x64, 0x5C, 0x55, 0x94, 0x86, 0x34, 0x2F, 0x05, 0x87, 0x28,
48 0xCD, 0xF7, 0x69, 0x8C, 0x17, 0xB3, 0x50, 0xA7, 0xB8, 0x82, 0xFA, 0xDF,
49 0xC7, 0x43, 0x2D, 0xD6, 0x7E, 0xAB, 0xA0, 0x6F, 0xB7, 0x13, 0x72, 0x80,
50 0xA4, 0x47, 0x15, 0xC1, 0x20, 0x99, 0x50, 0xCD, 0xEC, 0x14, 0x62, 0x09,
51 0x5B, 0xA4, 0x98, 0xCD, 0xD2, 0x41, 0xB6, 0x36, 0x4E, 0xFF, 0xE8, 0x2E,
52 0x32, 0x30, 0x4A, 0x81, 0xA8, 0x42, 0xA3, 0x6C, 0x9B, 0x33, 0x6E, 0xCA,
53 0xB2, 0xF5, 0x53, 0x66, 0xE0, 0x27, 0x53, 0x86, 0x1A, 0x85, 0x1E, 0xA7,
54 0x39, 0x3F, 0x4A, 0x77, 0x8E, 0xFB, 0x54, 0x66, 0x66, 0xFB, 0x58, 0x54,
55 0xC0, 0x5E, 0x39, 0xC7, 0xF5, 0x50, 0x06, 0x0B, 0xE0, 0x8A, 0xD4, 0xCE,
56 0xE1, 0x6A, 0x55, 0x1F, 0x8B, 0x17, 0x00, 0xE6, 0x69, 0xA3, 0x27, 0xE6,
57 0x08, 0x25, 0x69, 0x3C, 0x12, 0x9D, 0x8D, 0x05, 0x2C, 0xD6, 0x2E, 0xA2,
58 0x31, 0xDE, 0xB4, 0x52, 0x50, 0xD6, 0x20, 0x49, 0xDE, 0x71, 0xA0, 0xF9,
59 0xAD, 0x20, 0x40, 0x12, 0xF1, 0xDD, 0x25, 0xEB, 0xD5, 0xE6, 0xB8, 0x36,
60 0xF4, 0xD6, 0x8F, 0x7F, 0xCA, 0x43, 0xDC, 0xD7, 0x10, 0x5B, 0xE6, 0x3F,
61 0x51, 0x8A, 0x85, 0xB3, 0xF3, 0xFF, 0xF6, 0x03, 0x2D, 0xCB, 0x23, 0x4F,
62 0x9C, 0xAD, 0x18, 0xE7, 0x93, 0x05, 0x8C, 0xAC, 0x52, 0x9A, 0xF7, 0x4C,
63 0xE9, 0x99, 0x7A, 0xBE, 0x6E, 0x7E, 0x4D, 0x0A, 0xE3, 0xC6, 0x1C, 0xA9,
64 0x93, 0xFA, 0x3A, 0xA5, 0x91, 0x5D, 0x1C, 0xBD, 0x66, 0xEB, 0xCC, 0x60,
65 0xDC, 0x86, 0x74, 0xCA, 0xCF, 0xF8, 0x92, 0x1C, 0x98, 0x7D, 0x57, 0xFA,
66 0x61, 0x47, 0x9E, 0xAB, 0x80, 0xB7, 0xE4, 0x48, 0x80, 0x2A, 0x92, 0xC5,
67 0x1B, 0x02, 0x03, 0x01, 0x00, 0x01
68 };
69
70 static const net::SHA256HashValue kFingerprintICA2 = { {
71 0x98, 0xD6, 0x6D, 0xE8, 0x1C, 0x56, 0x47, 0x84, 0x4D, 0x96, 0x43, 0x4D,
72 0x37, 0xC4, 0x8D, 0xC2, 0xCE, 0x7F, 0x08, 0x72, 0x50, 0x19, 0xE7, 0xB6,
73 0xE8, 0x92, 0x7F, 0x56, 0xD6, 0x81, 0xAA, 0x18
74 } };
75
76 static const unsigned char kPublicKeyICA2[] = {
77 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xBC, 0x22, 0x80,
78 0xBD, 0x80, 0xF6, 0x3A, 0x21, 0x00, 0x3B, 0xAE, 0x76, 0x5E, 0x35, 0x7F,
79 0x3D, 0xC3, 0x64, 0x5C, 0x55, 0x94, 0x86, 0x34, 0x2F, 0x05, 0x87, 0x28,
80 0xCD, 0xF7, 0x69, 0x8C, 0x17, 0xB3, 0x50, 0xA7, 0xB8, 0x82, 0xFA, 0xDF,
81 0xC7, 0x43, 0x2D, 0xD6, 0x7E, 0xAB, 0xA0, 0x6F, 0xB7, 0x13, 0x72, 0x80,
82 0xA4, 0x47, 0x15, 0xC1, 0x20, 0x99, 0x50, 0xCD, 0xEC, 0x14, 0x62, 0x09,
83 0x5B, 0xA4, 0x98, 0xCD, 0xD2, 0x41, 0xB6, 0x36, 0x4E, 0xFF, 0xE8, 0x2E,
84 0x32, 0x30, 0x4A, 0x81, 0xA8, 0x42, 0xA3, 0x6C, 0x9B, 0x33, 0x6E, 0xCA,
85 0xB2, 0xF5, 0x53, 0x66, 0xE0, 0x27, 0x53, 0x86, 0x1A, 0x85, 0x1E, 0xA7,
86 0x39, 0x3F, 0x4A, 0x77, 0x8E, 0xFB, 0x54, 0x66, 0x66, 0xFB, 0x58, 0x54,
87 0xC0, 0x5E, 0x39, 0xC7, 0xF5, 0x50, 0x06, 0x0B, 0xE0, 0x8A, 0xD4, 0xCE,
88 0xE1, 0x6A, 0x55, 0x1F, 0x8B, 0x17, 0x00, 0xE6, 0x69, 0xA3, 0x27, 0xE6,
89 0x08, 0x25, 0x69, 0x3C, 0x12, 0x9D, 0x8D, 0x05, 0x2C, 0xD6, 0x2E, 0xA2,
90 0x31, 0xDE, 0xB4, 0x52, 0x50, 0xD6, 0x20, 0x49, 0xDE, 0x71, 0xA0, 0xF9,
91 0xAD, 0x20, 0x40, 0x12, 0xF1, 0xDD, 0x25, 0xEB, 0xD5, 0xE6, 0xB8, 0x36,
92 0xF4, 0xD6, 0x8F, 0x7F, 0xCA, 0x43, 0xDC, 0xD7, 0x10, 0x5B, 0xE6, 0x3F,
93 0x51, 0x8A, 0x85, 0xB3, 0xF3, 0xFF, 0xF6, 0x03, 0x2D, 0xCB, 0x23, 0x4F,
94 0x9C, 0xAD, 0x18, 0xE7, 0x93, 0x05, 0x8C, 0xAC, 0x52, 0x9A, 0xF7, 0x4C,
95 0xE9, 0x99, 0x7A, 0xBE, 0x6E, 0x7E, 0x4D, 0x0A, 0xE3, 0xC6, 0x1C, 0xA9,
96 0x93, 0xFA, 0x3A, 0xA5, 0x91, 0x5D, 0x1C, 0xBD, 0x66, 0xEB, 0xCC, 0x60,
97 0xDC, 0x86, 0x74, 0xCA, 0xCF, 0xF8, 0x92, 0x1C, 0x98, 0x7D, 0x57, 0xFA,
98 0x61, 0x47, 0x9E, 0xAB, 0x80, 0xB7, 0xE4, 0x48, 0x80, 0x2A, 0x92, 0xC5,
99 0x1B, 0x02, 0x03, 0x01, 0x00, 0x01
100 };
101
102 static const net::SHA256HashValue kFingerprintICA3 = { {
103 0xA2, 0x48, 0xC2, 0xE8, 0x54, 0xE6, 0x56, 0xA5, 0x6D, 0xE8, 0x23, 0x1F,
104 0x1E, 0xE1, 0x75, 0x6F, 0xDB, 0xE4, 0x07, 0xF9, 0xFE, 0xD4, 0x65, 0x0D,
105 0x60, 0xCC, 0x5A, 0xCB, 0x65, 0x11, 0xC7, 0x20
106 } };
107
108 static const unsigned char kPublicKeyICA3[] = {
109 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xB0, 0x0E, 0x5E,
110 0x07, 0x3A, 0xDF, 0xA4, 0x5F, 0x68, 0xF7, 0x21, 0xC7, 0x64, 0xDB, 0xB6,
111 0x76, 0xEF, 0xEE, 0x8B, 0x93, 0xF8, 0xF6, 0x1B, 0x88, 0xE1, 0x93, 0xB7,
112 0x17, 0xF0, 0x15, 0x1E, 0x7E, 0x52, 0x55, 0x77, 0x3C, 0x02, 0x8D, 0x7B,
113 0x4A, 0x6C, 0xD3, 0xBD, 0xD6, 0xC1, 0x9C, 0x72, 0xC8, 0xB3, 0x15, 0xCF,
114 0x11, 0xC1, 0xF5, 0x46, 0xC4, 0xD5, 0x20, 0x47, 0xFB, 0x30, 0xF4, 0xE4,
115 0x61, 0x0C, 0x68, 0xF0, 0x5E, 0xAB, 0x37, 0x8E, 0x9B, 0xE1, 0xBC, 0x81,
116 0xC3, 0x70, 0x8A, 0x78, 0xD6, 0x83, 0x34, 0x32, 0x9C, 0x19, 0x62, 0xEB,
117 0xE4, 0x9C, 0xED, 0xE3, 0x64, 0x6C, 0x41, 0x1D, 0x9C, 0xD2, 0x8B, 0x48,
118 0x4C, 0x23, 0x90, 0x95, 0xB3, 0xE7, 0x52, 0xEA, 0x05, 0x57, 0xCC, 0x60,
119 0xB3, 0xBA, 0x14, 0xE4, 0xBA, 0x00, 0x39, 0xE4, 0x46, 0x55, 0x74, 0xCE,
120 0x5A, 0x8E, 0x7A, 0x67, 0x23, 0xDA, 0x68, 0x0A, 0xFA, 0xC4, 0x84, 0x1E,
121 0xB4, 0xC5, 0xA1, 0xA2, 0x6A, 0x73, 0x1F, 0x6E, 0xC8, 0x2E, 0x2F, 0x9A,
122 0x9E, 0xA8, 0xB1, 0x0E, 0xFD, 0x87, 0xA6, 0x8F, 0x4D, 0x3D, 0x4B, 0x05,
123 0xD5, 0x35, 0x5A, 0x74, 0x4D, 0xBC, 0x8E, 0x82, 0x44, 0x96, 0xF4, 0xB5,
124 0x95, 0x60, 0x4E, 0xA5, 0xDF, 0x27, 0x3D, 0x41, 0x5C, 0x07, 0xA3, 0xB4,
125 0x35, 0x5A, 0xB3, 0x9E, 0xF2, 0x05, 0x24, 0xCA, 0xCD, 0x31, 0x5A, 0x0D,
126 0x26, 0x4C, 0xD4, 0xD3, 0xFD, 0x50, 0xE1, 0x34, 0xE9, 0x4C, 0x81, 0x58,
127 0x30, 0xB2, 0xC7, 0x7A, 0xDD, 0x81, 0x89, 0xA6, 0xD4, 0x3A, 0x38, 0x84,
128 0x03, 0xB7, 0x34, 0x9E, 0x77, 0x3F, 0xFF, 0x78, 0x07, 0x5B, 0x99, 0xC1,
129 0xB2, 0x1F, 0x35, 0x56, 0x6E, 0x3A, 0x3C, 0x0C, 0x25, 0xE1, 0x57, 0xF6,
130 0x8A, 0x7E, 0x49, 0xC0, 0xCC, 0x83, 0x11, 0x35, 0xE7, 0x91, 0x6D, 0x2E,
131 0x65, 0x02, 0x03, 0x01, 0x00, 0x01
132 };
133
134 static const net::SHA256HashValue kFingerprintICA4 = { {
135 0x2B, 0x9B, 0xC7, 0x92, 0xCD, 0x2A, 0x20, 0xB3, 0x65, 0x5E, 0x57, 0xFB,
136 0x10, 0x1A, 0x95, 0x93, 0x62, 0x53, 0x69, 0x50, 0x52, 0xA2, 0x71, 0x42,
137 0x2B, 0xFE, 0xB5, 0xB4, 0x5D, 0xC5, 0xA5, 0xE9
138 } };
139
140 static const unsigned char kPublicKeyICA4[] = {
141 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xB7, 0xE8, 0xC3,
142 0xE4, 0x2C, 0xDE, 0x74, 0x53, 0xF2, 0x49, 0x95, 0x6D, 0xD1, 0xDA, 0x69,
143 0x57, 0x0D, 0x86, 0xE5, 0xED, 0xB4, 0xB9, 0xE6, 0x73, 0x9F, 0x6C, 0xAD,
144 0x3B, 0x64, 0x85, 0x03, 0x0D, 0x08, 0x44, 0xAF, 0x18, 0x69, 0x82, 0xAD,
145 0xA9, 0x74, 0x64, 0x37, 0x47, 0xE1, 0xE7, 0x26, 0x19, 0x33, 0x3C, 0xE2,
146 0xD0, 0xB5, 0x84, 0x3C, 0xD7, 0xAC, 0x63, 0xAE, 0xC4, 0x32, 0x23, 0xF6,
147 0xDC, 0x14, 0x10, 0x4B, 0x95, 0x7F, 0xE8, 0x98, 0xD7, 0x7A, 0x9E, 0x43,
148 0x3D, 0x68, 0x8B, 0x2A, 0x70, 0xF7, 0x1E, 0x43, 0x70, 0xBA, 0xA5, 0xA5,
149 0x93, 0xAD, 0x8A, 0xD4, 0x9F, 0xAC, 0x83, 0x16, 0xF3, 0x48, 0x5F, 0xC5,
150 0xE0, 0xA5, 0x44, 0xB8, 0x4F, 0xD9, 0xD8, 0x75, 0x90, 0x25, 0x8B, 0xE3,
151 0x1C, 0x6C, 0xDA, 0x88, 0xFF, 0x09, 0x2B, 0xCA, 0x1E, 0x48, 0xDD, 0x76,
152 0x0F, 0x68, 0x56, 0x7B, 0x15, 0x9D, 0xCA, 0x6B, 0x1C, 0xF7, 0x48, 0xC2,
153 0x89, 0xC6, 0x93, 0x0A, 0x31, 0xF2, 0x78, 0x27, 0x45, 0x3D, 0xF1, 0x0D,
154 0x5B, 0x6E, 0x55, 0x32, 0xEF, 0x49, 0xA0, 0xD6, 0xAF, 0xA6, 0x30, 0x91,
155 0xF2, 0x21, 0x2F, 0xDB, 0xA4, 0x29, 0xB9, 0x9B, 0x22, 0xBC, 0xCD, 0x0B,
156 0xA6, 0x8B, 0xA6, 0x22, 0x79, 0xFD, 0xCF, 0x95, 0x93, 0x96, 0xB3, 0x23,
157 0xC9, 0xC6, 0x30, 0x8E, 0xC0, 0xE9, 0x1F, 0xEC, 0xFB, 0xF5, 0x88, 0xDD,
158 0x97, 0x72, 0x16, 0x29, 0x08, 0xFA, 0x42, 0xE7, 0x4F, 0xCA, 0xAE, 0xD7,
159 0x0F, 0x23, 0x48, 0x9B, 0x82, 0xA7, 0x37, 0x4A, 0xDD, 0x60, 0x04, 0x75,
160 0xDC, 0xDE, 0x09, 0x98, 0xD2, 0x16, 0x23, 0x04, 0x70, 0x4D, 0x99, 0x9F,
161 0x4A, 0x82, 0x28, 0xE6, 0xBE, 0x8F, 0x9D, 0xBF, 0xA1, 0x4B, 0xA2, 0xBA,
162 0xF5, 0xB2, 0x51, 0x1E, 0x4E, 0xE7, 0x80, 0x9E, 0x7A, 0x38, 0xA1, 0xC7,
163 0x09, 0x02, 0x03, 0x01, 0x00, 0x01
164 };
165
166 static const net::SHA256HashValue kFingerprintICA5 = { {
167 0xFD, 0xCD, 0x0D, 0x59, 0x29, 0xF8, 0x7A, 0x62, 0xD2, 0xFE, 0x0F, 0xD8,
168 0x94, 0xB8, 0x32, 0xF1, 0xD4, 0x9C, 0x73, 0xF9, 0xD3, 0x51, 0x8B, 0x64,
169 0x67, 0x3E, 0x04, 0x97, 0x0B, 0x0A, 0x4F, 0xAD
170 } };
171
172 static const unsigned char kPublicKeyICA5[] = {
173 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xC2, 0xF6, 0xD5,
174 0x91, 0xDC, 0x37, 0xB4, 0x9A, 0x73, 0x4A, 0xE7, 0x74, 0x6D, 0x03, 0xAE,
175 0x27, 0x24, 0x41, 0x99, 0x96, 0x1B, 0x05, 0x0E, 0xC7, 0xCF, 0x09, 0xCD,
176 0x65, 0x56, 0x02, 0xFC, 0x98, 0x59, 0xB4, 0xBB, 0x95, 0x71, 0xD7, 0x88,
177 0x66, 0xC8, 0x08, 0xCB, 0xBF, 0x5B, 0x85, 0x65, 0x7E, 0xDE, 0xC4, 0xB5,
178 0xE3, 0x71, 0x24, 0xA2, 0xFD, 0x92, 0x2C, 0x77, 0xC5, 0x08, 0xE0, 0xF0,
179 0xB1, 0x8A, 0x8A, 0x54, 0xCA, 0xA6, 0xAF, 0x87, 0xB8, 0xCB, 0x7D, 0x83,
180 0x28, 0x59, 0x9C, 0x01, 0xF5, 0x7B, 0x10, 0xD0, 0xF3, 0x52, 0x09, 0x3F,
181 0xF5, 0x7D, 0xDA, 0x21, 0x63, 0x8F, 0xAC, 0x8B, 0x60, 0x67, 0x22, 0xEF,
182 0x6B, 0x66, 0x91, 0xFC, 0x97, 0x30, 0x8D, 0xCC, 0xFE, 0xDE, 0x5C, 0xF9,
183 0x19, 0xBB, 0x1C, 0x25, 0x29, 0x2C, 0x99, 0x48, 0x41, 0xC2, 0xFC, 0x5B,
184 0x66, 0xD6, 0x79, 0x84, 0x16, 0x8D, 0x0D, 0x4F, 0x75, 0x01, 0x40, 0xC5,
185 0x50, 0x69, 0xFA, 0xA4, 0x88, 0xF1, 0xD2, 0x3B, 0xD1, 0x23, 0xDF, 0xC5,
186 0xBA, 0xE3, 0xE8, 0xBA, 0xCC, 0x1E, 0x93, 0x17, 0xF7, 0x97, 0xE2, 0x71,
187 0x42, 0x75, 0x5B, 0x99, 0x55, 0x98, 0x22, 0x23, 0x98, 0xDC, 0x10, 0x89,
188 0xF4, 0xE8, 0x26, 0xBB, 0x98, 0x66, 0xFD, 0xBB, 0x9A, 0x21, 0x62, 0xA2,
189 0xDF, 0x90, 0xDB, 0x48, 0x6F, 0xDB, 0x2A, 0xEF, 0xDE, 0x53, 0x59, 0x31,
190 0x5D, 0x38, 0xCD, 0x80, 0xA8, 0x0C, 0x6E, 0x4E, 0x37, 0x65, 0xEB, 0x36,
191 0x1C, 0x13, 0xBA, 0x53, 0xD3, 0x8F, 0xCC, 0x43, 0x86, 0x02, 0x70, 0xD2,
192 0x91, 0xF6, 0x96, 0x25, 0x6C, 0xA4, 0xE8, 0x1F, 0xD8, 0xB3, 0x74, 0x20,
193 0xEB, 0x60, 0x9D, 0x3D, 0xD3, 0x3D, 0x2E, 0x36, 0x0F, 0xF1, 0x94, 0x10,
194 0xF9, 0x7A, 0x03, 0x52, 0x7E, 0xA4, 0xEF, 0xE3, 0x40, 0x9E, 0x74, 0x0E,
195 0xDF, 0x02, 0x03, 0x01, 0x00, 0x01
196 };
197
198 static const net::SHA256HashValue kFingerprintICA6 = { {
199 0xD6, 0xA1, 0xC4, 0xBC, 0x74, 0x5B, 0xC8, 0xE9, 0xED, 0xF8, 0x9C, 0x0D,
200 0x55, 0xCC, 0xB2, 0xC9, 0xF3, 0x04, 0xF6, 0x6E, 0x4D, 0x3D, 0x27, 0x4C,
201 0xA3, 0xFC, 0x0F, 0x4B, 0x95, 0x55, 0x10, 0x7E
202 } };
203
204 static const unsigned char kPublicKeyICA6[] = {
205 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xB5, 0xC8, 0x14,
206 0x5B, 0x94, 0x2E, 0x8E, 0x40, 0xBC, 0x8A, 0xAB, 0x1F, 0x48, 0xEE, 0xA5,
207 0x5C, 0x5D, 0xA9, 0x44, 0x23, 0x33, 0xE5, 0x09, 0xDD, 0x84, 0xDD, 0xA6,
208 0x08, 0x95, 0xB0, 0xEA, 0x64, 0xEB, 0xC1, 0xCA, 0x02, 0x60, 0xFF, 0x83,
209 0xF9, 0x17, 0x71, 0x2C, 0xC7, 0xAB, 0x06, 0x0F, 0xE4, 0xAD, 0x39, 0x24,
210 0xFB, 0x1F, 0xED, 0xFA, 0xB2, 0x4D, 0x14, 0x5A, 0x6E, 0x5B, 0x06, 0x10,
211 0x13, 0xE7, 0x77, 0x22, 0xAA, 0xE5, 0xD1, 0x2C, 0x05, 0xC4, 0x06, 0x05,
212 0xB1, 0xCD, 0xBE, 0xCB, 0x4B, 0xAF, 0x11, 0x3E, 0xA0, 0x77, 0xBA, 0x6D,
213 0xE4, 0xA7, 0xBA, 0xC9, 0x9D, 0x3F, 0x47, 0xE0, 0xD6, 0x20, 0x75, 0x1C,
214 0xE9, 0x89, 0xD3, 0x88, 0x56, 0x4F, 0x29, 0xF6, 0x7D, 0x49, 0x96, 0xBE,
215 0xE8, 0x41, 0xAB, 0x35, 0x08, 0xAD, 0x07, 0x22, 0x90, 0xA3, 0x4A, 0x98,
216 0xBA, 0xC3, 0xE2, 0x29, 0xDA, 0x2E, 0xBD, 0x34, 0xF5, 0x41, 0xBC, 0x27,
217 0x7D, 0xE0, 0x02, 0xBF, 0xB7, 0xAE, 0x8B, 0x1E, 0xEE, 0xE9, 0xC1, 0x59,
218 0x92, 0xEA, 0xE3, 0x76, 0x0E, 0xE7, 0x77, 0xEF, 0x10, 0x7E, 0x4F, 0xD8,
219 0xAD, 0xC4, 0x5D, 0xBB, 0xB7, 0x9F, 0x23, 0x0B, 0x34, 0x89, 0xF7, 0x97,
220 0x9A, 0x40, 0x79, 0x00, 0xDD, 0x10, 0x9E, 0x01, 0xA7, 0xF0, 0xD8, 0xC4,
221 0x37, 0xF1, 0x6A, 0xD7, 0xC2, 0xE9, 0x75, 0x94, 0x55, 0xA9, 0x81, 0xA8,
222 0xF8, 0xC6, 0xF9, 0xD2, 0xCF, 0x26, 0xA0, 0x74, 0x58, 0x2E, 0xD0, 0xCB,
223 0x16, 0x58, 0x1B, 0x1E, 0x2B, 0x94, 0x80, 0x26, 0x82, 0x3F, 0x01, 0x36,
224 0x01, 0x97, 0x1E, 0xA6, 0x94, 0x14, 0xC0, 0xB2, 0x55, 0x95, 0x2E, 0x30,
225 0x9C, 0x7B, 0xC6, 0x79, 0xF8, 0x12, 0xB3, 0xB4, 0x11, 0x93, 0x73, 0x9C,
226 0xD4, 0x3F, 0x29, 0x6E, 0x6A, 0xAA, 0xA8, 0xE9, 0xA2, 0xF3, 0x20, 0x4E,
227 0xE9, 0x02, 0x03, 0x01, 0x00, 0x01
228 };
229
230 static const net::SHA256HashValue kFingerprintICA7 = { {
231 0xB6, 0xB3, 0x4F, 0x73, 0x23, 0x9D, 0xA6, 0xDD, 0x9A, 0x26, 0xF7, 0xD5,
232 0x9E, 0x26, 0x3B, 0xF0, 0x0C, 0x01, 0x6B, 0x21, 0x17, 0x41, 0xE5, 0xAD,
233 0x92, 0xA5, 0xA0, 0x0B, 0xD7, 0x31, 0x26, 0x11
234 } };
235
236 static const unsigned char kPublicKeyICA7[] = {
237 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xCC, 0xE2, 0xB6,
238 0x2F, 0x11, 0xAB, 0xFF, 0xD0, 0x5D, 0x63, 0x97, 0x59, 0xFA, 0x5F, 0x26,
239 0xD7, 0x91, 0xE9, 0x90, 0x86, 0x31, 0x91, 0x8E, 0x2D, 0x29, 0x5F, 0x7A,
240 0x2F, 0x12, 0x77, 0x21, 0xD9, 0x0E, 0x99, 0x0F, 0x11, 0x08, 0x69, 0x3C,
241 0x9C, 0x58, 0xD4, 0xCE, 0x44, 0xB3, 0x8E, 0x46, 0x6C, 0xC1, 0x8E, 0x60,
242 0x63, 0x3E, 0x99, 0x24, 0x72, 0x69, 0x07, 0xC2, 0x30, 0x0F, 0xD5, 0x74,
243 0x06, 0xC6, 0x09, 0x94, 0x13, 0xD7, 0x34, 0x34, 0x75, 0x73, 0x4F, 0x4A,
244 0x01, 0xFE, 0x1E, 0x3C, 0x91, 0x86, 0x9C, 0x63, 0xF8, 0xEF, 0x15, 0x79,
245 0xE5, 0x5A, 0xC1, 0xF2, 0x05, 0xDC, 0xE0, 0x76, 0xDE, 0x69, 0x46, 0xDF,
246 0x12, 0x3D, 0xF4, 0xD9, 0x05, 0xE2, 0x9E, 0xAD, 0x07, 0xCC, 0x69, 0x5F,
247 0x1D, 0x42, 0x5E, 0x6C, 0x4A, 0xB4, 0x89, 0x7C, 0xDB, 0xBC, 0x69, 0x4E,
248 0x23, 0x70, 0x9A, 0x67, 0xC5, 0xFA, 0x29, 0x88, 0x7C, 0x30, 0xFA, 0x61,
249 0x98, 0x3C, 0x43, 0x4A, 0x1E, 0xCA, 0xAE, 0xA8, 0x7B, 0x65, 0x68, 0xA3,
250 0xFB, 0x38, 0xB4, 0x4F, 0xCA, 0x49, 0x60, 0x85, 0xA0, 0xC1, 0x55, 0xA1,
251 0xCE, 0x67, 0x78, 0x9F, 0x53, 0x81, 0xD7, 0x92, 0xC9, 0x6D, 0x44, 0xF1,
252 0x97, 0x95, 0xA5, 0x7C, 0x83, 0xEC, 0xD3, 0xEB, 0x7D, 0xD7, 0x0A, 0x06,
253 0xFE, 0xBA, 0xFC, 0x56, 0x5F, 0xF0, 0x70, 0xE4, 0x82, 0xBE, 0x69, 0x6D,
254 0x95, 0x00, 0xDF, 0xB5, 0xE5, 0xBF, 0x9E, 0xF1, 0x12, 0x47, 0x14, 0x9C,
255 0x7D, 0xE5, 0xA0, 0xB8, 0x70, 0x29, 0x6B, 0xC8, 0x8A, 0xF2, 0xBA, 0x35,
256 0xD8, 0xC4, 0xD3, 0xB4, 0xB5, 0xEB, 0xDF, 0x2D, 0x27, 0x46, 0xA5, 0xFF,
257 0x35, 0xB5, 0x5F, 0x85, 0x72, 0xEB, 0xCF, 0xAD, 0x09, 0x18, 0x05, 0x95,
258 0x56, 0x88, 0x95, 0x22, 0xD7, 0x60, 0x47, 0xC9, 0x1F, 0xFA, 0x2D, 0x51,
259 0x3F, 0x02, 0x03, 0x01, 0x00, 0x01
260 };
261
262 static const net::SHA256HashValue kFingerprintICA8 = { {
263 0xE9, 0xD4, 0x83, 0xD3, 0x78, 0x01, 0xB1, 0x1A, 0xB8, 0x8E, 0xE1, 0x87,
264 0xB1, 0x88, 0xD5, 0xE2, 0xF0, 0xFE, 0x18, 0xE7, 0xCE, 0xB8, 0x10, 0x06,
265 0x3E, 0xA5, 0x05, 0x4A, 0x1A, 0x9D, 0x1C, 0x11
266 } };
267
268 static const unsigned char kPublicKeyICA8[] = {
269 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xBF, 0x3A, 0x31,
270 0xFC, 0xF8, 0xE6, 0xEE, 0xC0, 0x48, 0x00, 0xB4, 0x05, 0x65, 0x36, 0x23,
271 0x6D, 0x34, 0xD6, 0x00, 0xD5, 0x43, 0x89, 0x6A, 0x90, 0xCB, 0x7D, 0x1B,
272 0x39, 0xFE, 0x2E, 0x83, 0x84, 0x29, 0xBE, 0x51, 0xEF, 0x98, 0x66, 0x48,
273 0x59, 0x8E, 0x7E, 0x10, 0x14, 0x1D, 0x9F, 0xAA, 0x52, 0xFD, 0x6B, 0xBF,
274 0xC6, 0x13, 0xF2, 0xE9, 0x79, 0x62, 0xE2, 0xA0, 0x3B, 0xC6, 0x44, 0x70,
275 0x94, 0x98, 0xAF, 0x92, 0x9E, 0x66, 0x3F, 0xA4, 0x6C, 0xC1, 0x2F, 0x6D,
276 0xA2, 0x08, 0x8A, 0x47, 0x1B, 0xFA, 0x6D, 0x09, 0xCF, 0x94, 0xDB, 0x20,
277 0xCE, 0xA2, 0xBF, 0xEA, 0x06, 0xF4, 0xD3, 0x4D, 0xF7, 0x62, 0xAE, 0x1A,
278 0x64, 0xEC, 0x1F, 0xA5, 0x40, 0x2D, 0x15, 0xE7, 0xF7, 0x26, 0xFB, 0x08,
279 0xD9, 0x5B, 0xFC, 0x86, 0x7E, 0xC7, 0x94, 0x18, 0x08, 0x2A, 0xF5, 0x83,
280 0x44, 0x06, 0x15, 0x12, 0x5A, 0x1F, 0xBB, 0x47, 0xE3, 0x2C, 0x61, 0x64,
281 0xDF, 0xFE, 0x74, 0x0E, 0x78, 0xA4, 0x65, 0xB8, 0x70, 0xC1, 0xDB, 0x3D,
282 0xCA, 0x26, 0x33, 0xBD, 0x4A, 0x14, 0xDA, 0x0B, 0xEC, 0xEC, 0xB3, 0x34,
283 0x23, 0x59, 0xD2, 0x11, 0xF9, 0xB0, 0x53, 0x1C, 0x75, 0x76, 0xF5, 0x65,
284 0x00, 0x6C, 0xF0, 0x7F, 0xFA, 0x1A, 0x59, 0xFE, 0xF8, 0x9D, 0x1A, 0x4E,
285 0x42, 0x35, 0xEE, 0x2F, 0xE3, 0xA1, 0xE2, 0xDF, 0xDB, 0x7A, 0x6B, 0x5E,
286 0x6B, 0x21, 0xFF, 0xA5, 0xE1, 0x87, 0xDF, 0xB8, 0xE7, 0x52, 0xAD, 0x99,
287 0xCD, 0x47, 0x88, 0xE0, 0xBA, 0xF0, 0x3D, 0x9D, 0x87, 0x93, 0xAD, 0xA7,
288 0x45, 0x67, 0xF0, 0x1E, 0x46, 0xD7, 0x83, 0x9A, 0xE5, 0x49, 0x76, 0x21,
289 0x82, 0xCB, 0x82, 0x67, 0xA5, 0xFF, 0x63, 0xD8, 0x97, 0x51, 0xB4, 0x44,
290 0xA0, 0x76, 0xBA, 0x40, 0xD8, 0xAB, 0xA6, 0xEB, 0x70, 0xD5, 0xA4, 0x38,
291 0xB9, 0x02, 0x03, 0x01, 0x00, 0x01
292 };
293
294 static const net::SHA256HashValue kFingerprintICA9 = { {
295 0x7A, 0x96, 0xE1, 0xA4, 0xDE, 0xEB, 0x04, 0x23, 0xD6, 0xC4, 0xFD, 0x98,
296 0xDF, 0x25, 0x83, 0x25, 0x2C, 0x3E, 0xE0, 0x23, 0x35, 0x9F, 0x4B, 0x92,
297 0x08, 0xAB, 0xE8, 0x7C, 0xB1, 0xD8, 0x4D, 0x85
298 } };
299
300 static const unsigned char kPublicKeyICA9[] = {
301 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xE5, 0x44, 0x79,
302 0xD4, 0x75, 0x3A, 0xBD, 0x25, 0x6F, 0x89, 0xF7, 0x94, 0xE9, 0x23, 0xAE,
303 0x19, 0x38, 0x09, 0xA7, 0x75, 0x9C, 0x5A, 0x08, 0x4A, 0xC2, 0xC6, 0xA4,
304 0x95, 0x13, 0x96, 0x95, 0x4E, 0xFA, 0xF1, 0xC3, 0xD2, 0x7A, 0xBC, 0x4A,
305 0xEE, 0x65, 0x2D, 0xE2, 0xB1, 0x57, 0x49, 0x02, 0x84, 0x7C, 0x35, 0x31,
306 0x8A, 0xBB, 0xCB, 0x75, 0x9C, 0x14, 0x84, 0x52, 0x85, 0x40, 0xD2, 0x1D,
307 0x03, 0xAE, 0x2B, 0x38, 0xA2, 0x7F, 0xEE, 0xE8, 0x3C, 0x51, 0x5B, 0x82,
308 0x11, 0x9E, 0xE2, 0xC9, 0x0B, 0x7B, 0x66, 0xF2, 0xE5, 0x35, 0x64, 0x4B,
309 0xF1, 0x98, 0xD9, 0x60, 0x0A, 0xA2, 0x8B, 0xB2, 0xD3, 0x96, 0x35, 0xBE,
310 0x2D, 0xB4, 0x7E, 0xAC, 0x75, 0x73, 0x5F, 0xC0, 0x78, 0xC1, 0x91, 0x3E,
311 0xB7, 0xB2, 0x53, 0x4F, 0x78, 0x7D, 0x58, 0x93, 0x12, 0x3B, 0xA9, 0xB3,
312 0x8F, 0xA7, 0xF6, 0x7F, 0x4C, 0x2F, 0x7B, 0xFA, 0x41, 0xCA, 0xF5, 0x5A,
313 0xF4, 0x8A, 0x5B, 0xFE, 0x82, 0x18, 0x90, 0xE5, 0x15, 0x01, 0xD3, 0xD8,
314 0x83, 0x6B, 0x02, 0xA3, 0xAE, 0x54, 0x5C, 0xD9, 0x0B, 0x65, 0x00, 0xD6,
315 0x06, 0xF6, 0x4E, 0x52, 0x2C, 0x9C, 0x06, 0x1B, 0x11, 0x53, 0xA5, 0x7E,
316 0xBE, 0xAC, 0x5E, 0x01, 0xF1, 0x50, 0xF2, 0xC0, 0x26, 0xC6, 0xF9, 0xDD,
317 0x89, 0x8C, 0x1D, 0xD4, 0x7A, 0x59, 0xC2, 0xD7, 0xF8, 0x7A, 0x03, 0x6A,
318 0xBD, 0xC5, 0x75, 0x04, 0xED, 0x29, 0x90, 0xD8, 0x24, 0x75, 0x12, 0x38,
319 0x24, 0xF2, 0x56, 0xB4, 0x87, 0xB2, 0x55, 0x0F, 0x26, 0x1D, 0xD0, 0x6B,
320 0x32, 0xDF, 0x05, 0xFA, 0x73, 0x94, 0xB0, 0x6B, 0x41, 0xE7, 0x2D, 0xF0,
321 0x24, 0x48, 0xA8, 0x5B, 0x03, 0x34, 0xE7, 0x48, 0x92, 0x4E, 0x99, 0x3A,
322 0x6B, 0x96, 0x8E, 0x8E, 0x48, 0x52, 0xA5, 0xE8, 0x13, 0x54, 0xCF, 0x8D,
323 0xA1, 0x02, 0x03, 0x01, 0x00, 0x01
324 };
325
326 static const net::SHA256HashValue kFingerprintICA10 = { {
327 0x61, 0x79, 0xBE, 0x64, 0x83, 0xD6, 0x71, 0xCE, 0x4F, 0xEE, 0x95, 0x5B,
328 0xF3, 0x6A, 0x1D, 0xDB, 0xC9, 0x51, 0x2F, 0xF4, 0x0C, 0xF8, 0xA5, 0x1C,
329 0x4F, 0x31, 0x2A, 0x93, 0x9A, 0x94, 0x07, 0xF7
330 } };
331
332 static const unsigned char kPublicKeyICA10[] = {
333 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xAF, 0xA1, 0x27,
334 0x5B, 0x18, 0x01, 0xF9, 0x16, 0x7C, 0xB9, 0x1D, 0xBB, 0x34, 0xC4, 0x45,
335 0xCF, 0x7A, 0x7B, 0x7A, 0xB7, 0xC9, 0x52, 0xC6, 0xC1, 0xBE, 0x14, 0x57,
336 0xF5, 0xDC, 0xF7, 0xA3, 0xB9, 0x1F, 0x63, 0x5B, 0xDE, 0x95, 0x36, 0x23,
337 0x3A, 0xD4, 0xDF, 0x33, 0xA5, 0x75, 0xF6, 0x2B, 0x70, 0x6B, 0xE6, 0x46,
338 0xA9, 0x94, 0x84, 0x22, 0xD0, 0xC7, 0xF4, 0x2C, 0x8D, 0x20, 0xBC, 0x2F,
339 0x8E, 0x08, 0x44, 0xA4, 0x99, 0x30, 0xE2, 0x2B, 0x37, 0x1E, 0x1A, 0xB7,
340 0x0D, 0x98, 0x20, 0x40, 0x18, 0xEC, 0x7E, 0x7C, 0x65, 0xD7, 0xF7, 0x1E,
341 0x7A, 0x50, 0x1C, 0x27, 0xFE, 0x82, 0x5F, 0xFA, 0xDF, 0xAC, 0xA6, 0x4E,
342 0xB4, 0x91, 0x2F, 0x73, 0xFB, 0x20, 0xFC, 0x70, 0x3F, 0x5E, 0x58, 0x7B,
343 0xAC, 0xC6, 0x1C, 0xAD, 0xEF, 0x0A, 0xB1, 0xB3, 0x12, 0x2E, 0xB8, 0xC3,
344 0x60, 0xCB, 0xF7, 0x71, 0x5F, 0x18, 0xDD, 0x85, 0x64, 0x06, 0xA7, 0x17,
345 0x60, 0x81, 0x72, 0x6D, 0xE2, 0x24, 0x57, 0xCA, 0x3D, 0x1D, 0x87, 0x75,
346 0x05, 0x95, 0xDE, 0x38, 0x8A, 0xE0, 0xC2, 0xF7, 0xCB, 0x2F, 0xA6, 0xB9,
347 0x24, 0x50, 0x14, 0x17, 0x12, 0x77, 0xFB, 0x41, 0xA8, 0xA1, 0x79, 0xBC,
348 0xC0, 0x87, 0x06, 0x34, 0xF2, 0xAF, 0x87, 0x12, 0xB6, 0x66, 0x24, 0xDD,
349 0x3E, 0xBA, 0x4E, 0x34, 0x02, 0xF2, 0x1B, 0xAB, 0x1D, 0x79, 0x72, 0x41,
350 0x16, 0x0E, 0x1F, 0x9B, 0x35, 0x40, 0xD0, 0xC6, 0x07, 0xA7, 0x91, 0x53,
351 0x55, 0x19, 0x0C, 0xB1, 0x1B, 0x42, 0x20, 0x41, 0xC5, 0x2A, 0xA8, 0x26,
352 0x8D, 0x44, 0x50, 0x1B, 0x0B, 0x21, 0xB2, 0x16, 0xA2, 0x1B, 0xF3, 0xBD,
353 0xC2, 0x1D, 0xAF, 0x4F, 0x41, 0x43, 0xAD, 0x3A, 0x76, 0x45, 0x3C, 0x2B,
354 0xD3, 0x71, 0x31, 0x43, 0x37, 0xB6, 0x68, 0xA6, 0x5D, 0x8C, 0x50, 0x2B,
355 0x8F, 0x02, 0x03, 0x01, 0x00, 0x01
356 };
357
358 static const net::SHA256HashValue kFingerprintICA11 = { {
359 0x9C, 0x1E, 0xB3, 0xEA, 0x88, 0xAA, 0x1C, 0x1E, 0x0A, 0xE7, 0x9C, 0x2B,
360 0x43, 0xFF, 0x46, 0xD4, 0xC8, 0xF5, 0xF4, 0xFF, 0x43, 0x71, 0xFB, 0x83,
361 0xE4, 0x81, 0x13, 0x8D, 0xAD, 0x82, 0x42, 0xE8
362 } };
363
364 static const unsigned char kPublicKeyICA11[] = {
365 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xA8, 0xB2, 0x65,
366 0xFB, 0x07, 0xB0, 0x21, 0xBE, 0x11, 0xD1, 0xDA, 0x5D, 0x89, 0xB5, 0xAA,
367 0xC2, 0xFD, 0xD3, 0x27, 0x8D, 0x3A, 0x29, 0x2F, 0x3E, 0xD4, 0x87, 0xC1,
368 0x1B, 0x51, 0x39, 0x48, 0x73, 0x4A, 0xD5, 0x52, 0x5D, 0x59, 0x93, 0x8B,
369 0xF3, 0x3D, 0x57, 0x6A, 0x77, 0x7D, 0x43, 0x3A, 0xED, 0xE5, 0xC2, 0x0E,
370 0xFB, 0xE0, 0xFB, 0x0C, 0x65, 0x65, 0x74, 0xA9, 0x1F, 0x3C, 0x56, 0x77,
371 0xC8, 0x5C, 0x8F, 0xA3, 0xCB, 0xB4, 0x68, 0xBC, 0xE9, 0x0F, 0xE4, 0x52,
372 0x46, 0x1B, 0xB2, 0x23, 0x6F, 0x66, 0x9D, 0xB7, 0xCF, 0xD9, 0x48, 0xE2,
373 0x7D, 0x17, 0x26, 0x45, 0x4F, 0xA5, 0x14, 0x10, 0x08, 0xCE, 0xEC, 0x18,
374 0xE0, 0x78, 0x8E, 0x25, 0xB7, 0xAE, 0x23, 0xBD, 0xAE, 0x56, 0x33, 0x1F,
375 0x5B, 0x02, 0x41, 0xE1, 0x22, 0x6D, 0x85, 0x8E, 0xB0, 0x87, 0x73, 0xF8,
376 0xBF, 0x3A, 0x06, 0xF7, 0xDA, 0x70, 0xCB, 0x14, 0x1F, 0x1E, 0xFF, 0x78,
377 0x9D, 0xC4, 0x7A, 0xFF, 0x76, 0x32, 0x35, 0x28, 0x16, 0xD4, 0xBF, 0xBC,
378 0x2B, 0x4E, 0xD2, 0x86, 0x50, 0x14, 0x7A, 0x8D, 0x3F, 0x8F, 0x9E, 0x53,
379 0x0B, 0xB5, 0x83, 0x6E, 0x00, 0x82, 0xB0, 0x08, 0x6F, 0x22, 0xF4, 0x26,
380 0x33, 0x19, 0xCC, 0x82, 0xC7, 0x4C, 0xA0, 0x1B, 0xD2, 0x62, 0x33, 0xF7,
381 0x75, 0x0B, 0x57, 0x4A, 0xDF, 0xDD, 0x68, 0xCB, 0xFD, 0x6F, 0xB8, 0xB3,
382 0x8F, 0x8E, 0x45, 0x8D, 0xEE, 0xF2, 0xA2, 0xFD, 0x71, 0xF5, 0xE0, 0x1B,
383 0x3E, 0x62, 0x00, 0x35, 0x98, 0x19, 0x6B, 0xA3, 0x1B, 0x1A, 0xA3, 0x5D,
384 0xDE, 0x49, 0xB9, 0x20, 0x0D, 0x44, 0x8F, 0x58, 0x3C, 0xDD, 0x52, 0x6D,
385 0x03, 0x7A, 0x33, 0xB3, 0x06, 0x7A, 0xC7, 0x49, 0x23, 0xC5, 0x2A, 0x24,
386 0xB6, 0x96, 0x12, 0x4C, 0x16, 0xB3, 0x3A, 0xFC, 0x46, 0x03, 0xEC, 0xBB,
387 0xF9, 0x02, 0x03, 0x01, 0x00, 0x01
388 };
389
390 static const net::SHA256HashValue kFingerprintICA12 = { {
391 0xFF, 0xFA, 0x45, 0x0D, 0x1D, 0xB6, 0x31, 0x13, 0xA7, 0x43, 0x70, 0x19,
392 0x6E, 0xCB, 0xDB, 0xA4, 0x3F, 0x74, 0xF4, 0xBD, 0x63, 0xAD, 0x8E, 0xFD,
393 0x35, 0x62, 0xB3, 0xF9, 0xE8, 0x69, 0x1F, 0xDB
394 } };
395
396 static const unsigned char kPublicKeyICA12[] = {
397 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xD9, 0xE3, 0x76,
398 0x97, 0x6A, 0xEF, 0x2D, 0x16, 0xD5, 0xF9, 0xDC, 0x9D, 0x0E, 0x65, 0x12,
399 0x65, 0x72, 0xC0, 0xE9, 0x11, 0x12, 0x37, 0x09, 0x5D, 0x54, 0xF4, 0x8F,
400 0x3C, 0xDB, 0xF2, 0xE9, 0x42, 0x9F, 0x4E, 0xF2, 0xD0, 0x4E, 0xC8, 0x10,
401 0x31, 0xE8, 0x1B, 0xFE, 0x5B, 0xFB, 0xC8, 0xD3, 0xFB, 0x77, 0x25, 0xC4,
402 0x69, 0xFA, 0x53, 0x03, 0x16, 0x12, 0x7F, 0x23, 0x9F, 0x4C, 0xFB, 0x35,
403 0x60, 0xAE, 0xFB, 0xA5, 0x94, 0xD3, 0x5A, 0x97, 0x38, 0x91, 0x6E, 0x87,
404 0xE4, 0xB5, 0xA1, 0x6E, 0x23, 0x1C, 0x7A, 0x41, 0x55, 0x27, 0xA3, 0x9E,
405 0x6E, 0xF3, 0xD0, 0xA7, 0x19, 0x52, 0x0C, 0x7C, 0xBC, 0xEC, 0xB6, 0xB8,
406 0x54, 0x40, 0x77, 0x0E, 0x67, 0x14, 0x0D, 0x19, 0x1B, 0x74, 0xD4, 0x2C,
407 0x16, 0x01, 0xE5, 0x57, 0x6C, 0x03, 0x1E, 0xE3, 0x9E, 0xA3, 0x8E, 0x72,
408 0xA6, 0x63, 0x3A, 0xED, 0x25, 0xEC, 0x15, 0x2F, 0xE8, 0xCE, 0x52, 0x1E,
409 0xCB, 0x50, 0x39, 0x36, 0x7E, 0xC2, 0xEC, 0x7C, 0xCA, 0x4A, 0xB8, 0x73,
410 0x91, 0xC8, 0x88, 0x98, 0x31, 0x0F, 0x2E, 0x68, 0x45, 0x53, 0x22, 0x66,
411 0xF1, 0xF5, 0xBF, 0xF9, 0x11, 0x88, 0xB6, 0x36, 0x8E, 0xAA, 0x1A, 0xB8,
412 0xC9, 0x18, 0x90, 0x44, 0xBE, 0xBD, 0xDD, 0xB1, 0x81, 0x98, 0xBE, 0xEB,
413 0x1F, 0xF6, 0x28, 0x85, 0xB3, 0xA4, 0xA1, 0xAE, 0x14, 0xD2, 0x91, 0x9D,
414 0xD3, 0xB1, 0x0B, 0xEC, 0x72, 0x3D, 0x43, 0xEB, 0xD3, 0x79, 0x2A, 0x7D,
415 0xAD, 0x79, 0xA5, 0xB5, 0xA0, 0xDD, 0x88, 0x89, 0x6E, 0xB4, 0xC8, 0x11,
416 0xB6, 0x11, 0xED, 0x18, 0x50, 0x43, 0x2E, 0xD7, 0xCE, 0x18, 0x58, 0xEB,
417 0xCE, 0x2E, 0xE9, 0x9E, 0x20, 0x86, 0xFE, 0x97, 0xCD, 0xB2, 0x9C, 0xC1,
418 0xAF, 0x24, 0x02, 0x38, 0x60, 0x6B, 0xCC, 0x66, 0xC3, 0x04, 0x72, 0xD3,
419 0xF1, 0x02, 0x03, 0x01, 0x00, 0x01
420 };
421
422 static const net::SHA256HashValue kFingerprintICA13 = { {
423 0xE0, 0x2C, 0x66, 0xCD, 0x6F, 0x96, 0xFC, 0x1B, 0x5A, 0x43, 0xC4, 0xA5,
424 0x19, 0xB6, 0x6F, 0x0B, 0xFE, 0xA7, 0x58, 0x0D, 0xC1, 0x02, 0x3E, 0xFE,
425 0xFF, 0x9C, 0xE4, 0x9E, 0xB1, 0x7E, 0x3F, 0x79
426 } };
427
428 static const unsigned char kPublicKeyICA13[] = {
429 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xBB, 0xE5, 0x0F,
430 0xD2, 0x1C, 0x6B, 0xBA, 0x23, 0xA9, 0x2F, 0x87, 0xEC, 0xDB, 0x92, 0x3F,
431 0xAF, 0xC8, 0xD4, 0xB2, 0x59, 0x24, 0x2E, 0xC8, 0xCD, 0x00, 0xEF, 0x09,
432 0xFB, 0xF6, 0x19, 0xE7, 0x6C, 0x8A, 0x1A, 0x3B, 0xB6, 0xCC, 0xEF, 0x3A,
433 0x40, 0x6C, 0x93, 0xF8, 0xE3, 0x1B, 0xB7, 0xE5, 0x1C, 0x92, 0x65, 0xE8,
434 0x5E, 0x64, 0x83, 0x90, 0xF1, 0x24, 0x4A, 0xD1, 0xC5, 0x3D, 0x8C, 0x3B,
435 0x71, 0x66, 0x31, 0x58, 0xD8, 0x55, 0xC2, 0xCC, 0xD3, 0xEA, 0x0E, 0x66,
436 0x88, 0x59, 0x14, 0x77, 0xED, 0x12, 0xC5, 0x96, 0x54, 0x7F, 0x97, 0x28,
437 0x3B, 0x5E, 0xCA, 0xF7, 0x1B, 0xD3, 0x4B, 0x10, 0xC3, 0x45, 0x3A, 0x4D,
438 0xCA, 0x36, 0x5A, 0xFF, 0x4F, 0x86, 0xDD, 0x9E, 0x69, 0xDF, 0xD5, 0x4A,
439 0xD0, 0xB8, 0x9F, 0x8D, 0x31, 0x70, 0x76, 0x63, 0x33, 0xB0, 0xB8, 0xF4,
440 0xB0, 0x45, 0x28, 0xB3, 0x5D, 0xF2, 0x2F, 0xC5, 0xA4, 0xD9, 0x30, 0x6F,
441 0x9F, 0x69, 0x23, 0x42, 0x6D, 0x7D, 0x73, 0x29, 0x56, 0x61, 0xCC, 0x56,
442 0xC9, 0xAE, 0xED, 0x13, 0x33, 0xB4, 0x0E, 0xD0, 0x25, 0xE3, 0x06, 0xC1,
443 0x9A, 0x26, 0xDB, 0x8E, 0x89, 0xA6, 0xA0, 0xF9, 0x30, 0xE6, 0x92, 0xD0,
444 0xEC, 0x77, 0xB9, 0xA8, 0x0C, 0x8E, 0x83, 0x5D, 0x6B, 0xB9, 0x49, 0xF2,
445 0xFB, 0x1C, 0xE4, 0x79, 0xC8, 0xB3, 0x90, 0x88, 0xE9, 0x92, 0x24, 0x8A,
446 0x18, 0x7E, 0xE3, 0x5C, 0xEF, 0xC0, 0x4B, 0xDD, 0xFD, 0x09, 0x14, 0x4C,
447 0x9C, 0x7A, 0xB3, 0x56, 0x84, 0x96, 0xDB, 0x08, 0xA8, 0xE1, 0xCD, 0x40,
448 0x94, 0xF5, 0x12, 0xF4, 0x63, 0x38, 0x0C, 0x51, 0xE4, 0x03, 0x63, 0xC4,
449 0x76, 0x54, 0xB7, 0x59, 0x25, 0xCE, 0x62, 0xDE, 0x73, 0x3F, 0xAB, 0x15,
450 0x56, 0xC5, 0xBC, 0x99, 0x8C, 0x3A, 0x46, 0x3F, 0x13, 0x0E, 0xF4, 0x53,
451 0x1D, 0x02, 0x03, 0x01, 0x00, 0x01
452 };
453
454 static const net::SHA256HashValue kFingerprintICA14 = { {
455 0x3B, 0x60, 0x2E, 0xE9, 0x9F, 0x75, 0x7C, 0x18, 0xE3, 0x08, 0x1E, 0xC0,
456 0x72, 0xE9, 0x20, 0x05, 0x0B, 0x83, 0xD7, 0xB7, 0x5E, 0x25, 0x47, 0xE7,
457 0xE6, 0x44, 0x2C, 0x40, 0xF4, 0xA9, 0xA1, 0xD0
458 } };
459
460 static const unsigned char kPublicKeyICA14[] = {
461 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xAD, 0x16, 0x57,
462 0x87, 0xD7, 0x0D, 0xA3, 0xA2, 0x7E, 0x8B, 0xAE, 0x45, 0x7A, 0x1F, 0xCA,
463 0xFE, 0xB9, 0x15, 0xB7, 0x5B, 0x9F, 0x7D, 0x16, 0xA5, 0xA5, 0x63, 0xB1,
464 0xF5, 0x6E, 0x17, 0x7F, 0x35, 0xD8, 0x4A, 0x8C, 0x97, 0xBF, 0x77, 0x84,
465 0x5E, 0xC6, 0x21, 0x81, 0xAF, 0x72, 0xEF, 0xCF, 0xDE, 0x46, 0xB7, 0xE7,
466 0x49, 0x61, 0x8E, 0xFC, 0x84, 0x12, 0xBC, 0x30, 0xEA, 0xF8, 0x5B, 0x78,
467 0x6C, 0x3E, 0x12, 0x23, 0x33, 0x29, 0x80, 0x34, 0x6A, 0x1E, 0x8D, 0x3C,
468 0x15, 0xE9, 0x47, 0x9E, 0x33, 0x27, 0x90, 0x73, 0x52, 0xD0, 0xBF, 0xCE,
469 0x0D, 0x68, 0xE5, 0x5A, 0x90, 0x71, 0xB2, 0xF2, 0xBD, 0x7E, 0x69, 0xE0,
470 0x92, 0xDC, 0x44, 0x9F, 0x4B, 0xA3, 0xC2, 0x58, 0x16, 0x1A, 0x35, 0x18,
471 0x88, 0x3A, 0x82, 0x15, 0xFC, 0x41, 0x8C, 0x72, 0x11, 0x2E, 0xC4, 0xED,
472 0xD3, 0x7E, 0x68, 0xF2, 0x00, 0x01, 0xE2, 0x71, 0xC3, 0x91, 0x91, 0xFD,
473 0xF3, 0xBE, 0x11, 0xE7, 0x62, 0xB4, 0xAF, 0xC8, 0xF0, 0x12, 0xBC, 0xB2,
474 0x0E, 0x58, 0x5C, 0xFF, 0x08, 0xCB, 0xCB, 0x91, 0xD2, 0xD0, 0x11, 0x87,
475 0x72, 0x04, 0x99, 0x63, 0x12, 0xA6, 0x6F, 0x7D, 0x40, 0x76, 0xB7, 0xE8,
476 0x89, 0xCE, 0xCD, 0x5A, 0x73, 0x18, 0x8A, 0x73, 0xAF, 0xFD, 0x21, 0x68,
477 0xE5, 0x26, 0x74, 0x12, 0x2C, 0xC3, 0xE6, 0x7D, 0x1D, 0x9A, 0xC8, 0x12,
478 0xCD, 0x38, 0xCB, 0x47, 0xA6, 0x54, 0x8F, 0xAD, 0x9F, 0xFA, 0xB1, 0xDF,
479 0xB0, 0xBF, 0xE7, 0x12, 0x32, 0x76, 0xA7, 0xA5, 0xD7, 0x46, 0xF8, 0x62,
480 0x15, 0x54, 0x78, 0xBA, 0x9E, 0x4D, 0xD8, 0x99, 0x62, 0x9E, 0xE8, 0x45,
481 0x93, 0x8C, 0x14, 0x7E, 0x9C, 0xE9, 0xF7, 0x2A, 0x7E, 0x56, 0xE3, 0xBD,
482 0xF1, 0x65, 0xC8, 0x6B, 0xB9, 0xE5, 0x16, 0x1E, 0x22, 0x29, 0xEC, 0xCA,
483 0xD9, 0x02, 0x03, 0x01, 0x00, 0x01
484 };
485
486 static const net::SHA256HashValue kFingerprintICA15 = { {
487 0x09, 0xA7, 0x9F, 0x65, 0xE5, 0x55, 0x72, 0xAA, 0xFD, 0xDB, 0x74, 0xE9,
488 0xF8, 0xFA, 0x01, 0x45, 0x1D, 0x8E, 0xA4, 0x17, 0x48, 0xAB, 0x50, 0x75,
489 0xF9, 0xB1, 0x12, 0xB0, 0x6F, 0xC8, 0x08, 0xAE
490 } };
491
492 static const unsigned char kPublicKeyICA15[] = {
493 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xDD, 0xFE, 0x56,
494 0x5F, 0x53, 0x05, 0x59, 0x8F, 0x7C, 0xF4, 0x8B, 0x90, 0x38, 0xED, 0x51,
495 0xE6, 0x8A, 0xAC, 0x78, 0x1F, 0x7B, 0x33, 0x74, 0x7F, 0x33, 0xAA, 0x6A,
496 0x13, 0x6F, 0x7C, 0xDF, 0x82, 0x8F, 0x7B, 0xC4, 0x11, 0xAE, 0x5C, 0x2B,
497 0x1A, 0xDB, 0x9A, 0x95, 0x13, 0xE8, 0x64, 0x48, 0x37, 0x6C, 0x6B, 0x8C,
498 0xDD, 0x42, 0xE1, 0xCE, 0xE4, 0x0C, 0xDF, 0xA2, 0x41, 0x9E, 0x78, 0x8B,
499 0x26, 0xBF, 0xA1, 0x6E, 0x59, 0x8E, 0x10, 0xF8, 0x31, 0xAD, 0x13, 0xD2,
500 0x1F, 0x84, 0xCC, 0xE0, 0x88, 0x59, 0x5D, 0x0C, 0xD0, 0xAB, 0x24, 0xC8,
501 0x1F, 0xCB, 0xE0, 0x13, 0x72, 0xD3, 0xF3, 0x90, 0xFB, 0xB0, 0x1D, 0x36,
502 0x4E, 0xB6, 0xDC, 0x42, 0xC2, 0x87, 0xD8, 0x38, 0x6D, 0x18, 0x23, 0x3F,
503 0xDF, 0x95, 0x8B, 0xF1, 0x40, 0x89, 0xEE, 0x43, 0xD5, 0x09, 0x1F, 0xBB,
504 0xDA, 0x96, 0x4C, 0xB7, 0x23, 0x33, 0xE9, 0x48, 0xEA, 0x9E, 0x1D, 0x30,
505 0xFD, 0x72, 0x90, 0x81, 0x74, 0x1C, 0xE7, 0x8A, 0xA9, 0x8C, 0xD9, 0x4B,
506 0x30, 0x35, 0x47, 0x60, 0xDC, 0x28, 0x34, 0x92, 0x39, 0xD6, 0xEA, 0x3E,
507 0x1F, 0x70, 0x1B, 0xCA, 0x28, 0x64, 0xA5, 0x2E, 0x90, 0x3E, 0x25, 0x90,
508 0xE7, 0x70, 0x10, 0x55, 0x1E, 0xAE, 0x9B, 0x5C, 0xB3, 0x88, 0xB7, 0x00,
509 0x76, 0x7B, 0xF7, 0xB6, 0x4A, 0xD3, 0x69, 0x1E, 0x00, 0xDF, 0xB1, 0xE6,
510 0x4D, 0xD1, 0x18, 0x3A, 0xAD, 0x7E, 0xB9, 0x6C, 0x6D, 0x51, 0x81, 0x75,
511 0xFE, 0xC4, 0xAA, 0xE6, 0x17, 0x37, 0xBA, 0x2B, 0x3B, 0xD4, 0x4E, 0xFC,
512 0xEC, 0xE6, 0x60, 0x7B, 0x20, 0x7F, 0xC3, 0x74, 0xD9, 0xA3, 0x67, 0x80,
513 0x8B, 0x4A, 0x34, 0xDC, 0x25, 0x6E, 0x9B, 0xA5, 0x67, 0x97, 0x54, 0xAC,
514 0x6C, 0x8E, 0x7A, 0x64, 0x20, 0xDA, 0xD6, 0xAA, 0x59, 0x6B, 0x27, 0x28,
515 0x99, 0x02, 0x03, 0x01, 0x00, 0x01
516 };
517
518 static const net::SHA256HashValue kFingerprintICA16 = { {
519 0x49, 0x0D, 0xC9, 0x48, 0xA1, 0x6B, 0x02, 0xEA, 0xC6, 0xDA, 0x47, 0x99,
520 0x36, 0x4D, 0xD2, 0xAF, 0x04, 0xF7, 0xEA, 0x46, 0x30, 0xCF, 0x33, 0x79,
521 0x73, 0x10, 0xAC, 0x4C, 0x07, 0xB4, 0x67, 0xAD
522 } };
523
524 static const unsigned char kPublicKeyICA16[] = {
525 0x30, 0x82, 0x01, 0x0A, 0x02, 0x82, 0x01, 0x01, 0x00, 0xD2, 0xB0, 0xC9,
526 0xB3, 0x88, 0xCD, 0x93, 0x23, 0x6A, 0x46, 0xD3, 0x69, 0x0A, 0xD7, 0xFF,
527 0xE1, 0x51, 0x7E, 0x29, 0xA9, 0x6B, 0x71, 0x68, 0xC0, 0xCF, 0x69, 0xA3,
528 0xE8, 0xAD, 0xA9, 0x58, 0x22, 0x18, 0x45, 0x9F, 0x04, 0x86, 0x7F, 0xBA,
529 0x1B, 0xC8, 0x1C, 0x3A, 0x99, 0x80, 0xFF, 0x73, 0x8C, 0x65, 0xE7, 0xDA,
530 0x76, 0x5F, 0xCE, 0xD6, 0xB8, 0x28, 0xCA, 0xC9, 0x20, 0x7A, 0x4B, 0xB9,
531 0xC2, 0xCE, 0x89, 0x46, 0x40, 0x68, 0x60, 0x7E, 0x3B, 0xE0, 0x88, 0x1C,
532 0x1B, 0xDC, 0xEE, 0xDC, 0x06, 0x42, 0x5B, 0x28, 0x1A, 0xCD, 0xCB, 0x3E,
533 0x4E, 0xF3, 0x19, 0x0D, 0x83, 0xE2, 0x2A, 0x9D, 0x8C, 0xA3, 0x78, 0xE8,
534 0x1D, 0x6B, 0x79, 0x7C, 0x48, 0xA9, 0xE1, 0x8B, 0x56, 0x8B, 0x66, 0x63,
535 0xCE, 0x54, 0xA7, 0xD2, 0x1F, 0xE6, 0x81, 0x5B, 0x0C, 0x63, 0xB9, 0xF0,
536 0x94, 0xBD, 0xC1, 0xB2, 0x5A, 0x7F, 0xEC, 0x9A, 0x09, 0x4F, 0xB8, 0x02,
537 0x6D, 0x7F, 0x59, 0x64, 0xBE, 0x01, 0xF8, 0x83, 0xD4, 0xF0, 0x0E, 0x96,
538 0x78, 0xDC, 0xF4, 0x9D, 0x4C, 0x91, 0x4C, 0x08, 0xB3, 0xFA, 0x28, 0x55,
539 0xB7, 0xF6, 0x06, 0x1E, 0x34, 0xC3, 0x79, 0x90, 0xAB, 0x2C, 0x4E, 0x2E,
540 0xD9, 0xE4, 0x78, 0x87, 0xCF, 0xF2, 0xAA, 0x83, 0x2D, 0x74, 0x8F, 0xE4,
541 0xDA, 0xEE, 0xD0, 0x24, 0x06, 0xDE, 0x40, 0xE7, 0xC9, 0xC0, 0x02, 0xF5,
542 0x8D, 0x7D, 0xDE, 0x28, 0x03, 0x8A, 0xAE, 0x21, 0xBD, 0xF1, 0x29, 0x36,
543 0xEB, 0xD7, 0xC9, 0x3B, 0x34, 0xE3, 0x08, 0x8C, 0xCA, 0x25, 0xEE, 0x3C,
544 0xE4, 0x07, 0x49, 0xB9, 0xB8, 0xDB, 0x35, 0x90, 0x99, 0x50, 0x99, 0xC2,
545 0x7D, 0x6A, 0x3A, 0x33, 0x31, 0xC7, 0x61, 0x13, 0xB7, 0x71, 0x10, 0x80,
546 0xC1, 0x8C, 0xE0, 0x69, 0xA2, 0xDD, 0xA3, 0xE5, 0x52, 0x8A, 0xF5, 0xEF,
547 0x63, 0x02, 0x03, 0x01, 0x00, 0x01
548 };
549
550 // Fingerprint, public key size, public key data of the allowed / trusted ICAs.
551 // Default list of allowed / trusted ICAs.
552 const AuthorityKeysStore::ICACertInfo AuthorityKeysStore::kAllowedICAs[] = {
553 {&kFingerprintICA1,
554 {siDERCertBuffer,
555 const_cast<unsigned char*>(kPublicKeyICA1),
556 sizeof(kPublicKeyICA1)}},
557 {&kFingerprintICA2,
558 {siDERCertBuffer,
559 const_cast<unsigned char*>(kPublicKeyICA2),
560 sizeof(kPublicKeyICA2)}},
561 {&kFingerprintICA3,
562 {siDERCertBuffer,
563 const_cast<unsigned char*>(kPublicKeyICA3),
564 sizeof(kPublicKeyICA3)}},
565 {&kFingerprintICA4,
566 {siDERCertBuffer,
567 const_cast<unsigned char*>(kPublicKeyICA4),
568 sizeof(kPublicKeyICA4)}},
569 {&kFingerprintICA5,
570 {siDERCertBuffer,
571 const_cast<unsigned char*>(kPublicKeyICA5),
572 sizeof(kPublicKeyICA5)}},
573 {&kFingerprintICA6,
574 {siDERCertBuffer,
575 const_cast<unsigned char*>(kPublicKeyICA6),
576 sizeof(kPublicKeyICA6)}},
577 {&kFingerprintICA7,
578 {siDERCertBuffer,
579 const_cast<unsigned char*>(kPublicKeyICA7),
580 sizeof(kPublicKeyICA7)}},
581 {&kFingerprintICA8,
582 {siDERCertBuffer,
583 const_cast<unsigned char*>(kPublicKeyICA8),
584 sizeof(kPublicKeyICA8)}},
585 {&kFingerprintICA9,
586 {siDERCertBuffer,
587 const_cast<unsigned char*>(kPublicKeyICA9),
588 sizeof(kPublicKeyICA9)}},
589 {&kFingerprintICA10,
590 {siDERCertBuffer,
591 const_cast<unsigned char*>(kPublicKeyICA10),
592 sizeof(kPublicKeyICA10)}},
593 {&kFingerprintICA11,
594 {siDERCertBuffer,
595 const_cast<unsigned char*>(kPublicKeyICA11),
596 sizeof(kPublicKeyICA11)}},
597 {&kFingerprintICA12,
598 {siDERCertBuffer,
599 const_cast<unsigned char*>(kPublicKeyICA12),
600 sizeof(kPublicKeyICA12)}},
601 {&kFingerprintICA13,
602 {siDERCertBuffer,
603 const_cast<unsigned char*>(kPublicKeyICA13),
604 sizeof(kPublicKeyICA13)}},
605 {&kFingerprintICA14,
606 {siDERCertBuffer,
607 const_cast<unsigned char*>(kPublicKeyICA14),
608 sizeof(kPublicKeyICA14)}},
609 {&kFingerprintICA15,
610 {siDERCertBuffer,
611 const_cast<unsigned char*>(kPublicKeyICA15),
612 sizeof(kPublicKeyICA15)}},
613 {&kFingerprintICA16,
614 {siDERCertBuffer,
615 const_cast<unsigned char*>(kPublicKeyICA16),
616 sizeof(kPublicKeyICA16)}},
617 };
618
619 // Initializes trusted certificate authorities store.
620 AuthorityKeysStore::AuthorityKeysStore() {
621 for (size_t i = 0; i < arraysize(kAllowedICAs); i++) {
622 certificate_authorities_.push_back(kAllowedICAs[i]);
623 }
624 }
625
626 AuthorityKeysStore::~AuthorityKeysStore() {
627 }
628
629 // Returns the public key of the ICA whose fingerprint matches |fingerprint|.
630 // Returns NULL, if no such ICA is found.
mark a. foltz 2014/10/14 06:15:04 This documentation belongs in the .h
vadimgo 2014/10/14 19:51:24 Done.
631 const SECItem* AuthorityKeysStore::GetICAPublicKeyFromFingerprint(
632 const net::SHA256HashValue& fingerprint) {
633 for (std::vector<ICACertInfo>::const_iterator iter =
634 certificate_authorities_.begin();
635 iter != certificate_authorities_.end();
636 ++iter) {
637 if ((*iter).fingerprint->Equals(fingerprint))
638 return &(*iter).public_key;
639 }
640 return NULL;
641 }
642
643 // Returns the public key of the first ICA in the list.
mark a. foltz 2014/10/14 06:15:04 Document behavior of returning NULL on empty list;
vadimgo 2014/10/14 19:51:24 Done.
644 const SECItem* AuthorityKeysStore::GetDefaultICAPublicKey() {
645 if (certificate_authorities_.empty())
646 return NULL;
647
648 return &certificate_authorities_[0].public_key;
649 }
650
651 bool AuthorityKeysStore::Load(std::string& keys) {
652 certificate_authorities_.clear();
653 authority_keys_.Clear();
654
655 if (!authority_keys_.ParseFromString(keys))
656 return false;
657
658 for (int i = 0; i < authority_keys_.keys_size(); i++) {
659 const std::string& fingerprint = authority_keys_.keys(i).fingerprint();
660
661 // Ensure it's the size of SHA-256 fingerprint.
662 if (fingerprint.size() != 32) {
663 return false;
664 }
665
666 const std::string& public_key = authority_keys_.keys(i).public_key();
667 ICACertInfo cert_info = {
668 reinterpret_cast<const net::SHA256HashValue*>(fingerprint.data()),
669 {siDERCertBuffer,
670 (unsigned char*)public_key.data(),
671 public_key.size()}};
672 certificate_authorities_.push_back(cert_info);
mark a. foltz 2014/10/14 06:15:04 Is there any way to validate that public_key is, i
dougsteed 2014/10/14 18:09:51 We don't have the certificates here, only the fing
673 }
674
675 return true;
676 }
677
38 } // namespace cast_channel 678 } // namespace cast_channel
39 } // namespace core_api 679 } // namespace core_api
40 } // namespace extensions 680 } // namespace extensions
OLDNEW
« extensions/browser/api/cast_channel/cast_auth_util.h ('K') | « extensions/browser/api/cast_channel/cast_auth_util.h ('k') | extensions/browser/api/cast_channel/cast_auth_util_nss.cc » ('j') | extensions/browser/api/cast_channel/cast_auth_util_nss.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698