extensions/browser/verified_contents.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/verified_contents.h"
   6
   7 #include "base/base64.h"
   8 #include "base/files/file_util.h"
   9 #include "base/json/json_reader.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/values.h"
  12 #include "components/crx_file/id_util.h"
  13 #include "crypto/signature_verifier.h"
  14 #include "extensions/common/extension.h"
  15
  16 using base::DictionaryValue;
  17 using base::ListValue;
  18 using base::Value;
  19
  20 namespace {
  21
  22 // Note: this structure is an ASN.1 which encodes the algorithm used with its
  23 // parameters.  The signature algorithm is "RSA256" aka "RSASSA-PKCS-v1_5 using
  24 // SHA-256 hash algorithm". This is defined in PKCS #1 (RFC 3447).
  25 // It is encoding: { OID sha256WithRSAEncryption      PARAMETERS NULL }
  26 const uint8 kSignatureAlgorithm[15] = {0x30, 0x0d, 0x06, 0x09, 0x2a,
  27                                        0x86, 0x48, 0x86, 0xf7, 0x0d,
  28                                        0x01, 0x01, 0x0b, 0x05, 0x00};
  29
  30 const char kBlockSizeKey[] = "block_size";
  31 const char kContentHashesKey[] = "content_hashes";
  32 const char kDescriptionKey[] = "description";
  33 const char kFilesKey[] = "files";
  34 const char kFormatKey[] = "format";
  35 const char kHashBlockSizeKey[] = "hash_block_size";
  36 const char kHeaderKidKey[] = "header.kid";
  37 const char kItemIdKey[] = "item_id";
  38 const char kItemVersionKey[] = "item_version";
  39 const char kPathKey[] = "path";
  40 const char kPayloadKey[] = "payload";
  41 const char kProtectedKey[] = "protected";
  42 const char kRootHashKey[] = "root_hash";
  43 const char kSignatureKey[] = "signature";
  44 const char kSignaturesKey[] = "signatures";
  45 const char kSignedContentKey[] = "signed_content";
  46 const char kTreeHashPerFile[] = "treehash per file";
  47 const char kTreeHash[] = "treehash";
  48 const char kWebstoreKId[] = "webstore";
  49
  50 // Helper function to iterate over a list of dictionaries, returning the
  51 // dictionary that has |key| -> |value| in it, if any, or NULL.
  52 DictionaryValue* FindDictionaryWithValue(const ListValue* list,
  53                                          std::string key,
  54                                          std::string value) {
  55   for (ListValue::const_iterator i = list->begin(); i != list->end(); ++i) {
  56     if (!(*i)->IsType(Value::TYPE_DICTIONARY))
  57       continue;
  58     DictionaryValue* dictionary = static_cast<DictionaryValue*>(*i);
  59     std::string found_value;
  60     if (dictionary->GetString(key, &found_value) && found_value == value)
  61       return dictionary;
  62   }
  63   return NULL;
  64 }
  65
  66 }  // namespace
  67
  68 namespace extensions {
  69
  70 // static
  71 bool VerifiedContents::FixupBase64Encoding(std::string* input) {
  72   for (std::string::iterator i = input->begin(); i != input->end(); ++i) {
  73     if (*i == '-')
  74       *i = '+';
  75     else if (*i == '_')
  76       *i = '/';
  77   }
  78   switch (input->size() % 4) {
  79     case 0:
  80       break;
  81     case 2:
  82       input->append("==");
  83       break;
  84     case 3:
  85       input->append("=");
  86       break;
  87     default:
  88       return false;
  89   }
  90   return true;
  91 }
  92
  93 VerifiedContents::VerifiedContents(const uint8* public_key, int public_key_size)
  94     : public_key_(public_key),
  95       public_key_size_(public_key_size),
  96       valid_signature_(false),  // Guilty until proven innocent.
  97       block_size_(0) {
  98 }
  99
 100 VerifiedContents::~VerifiedContents() {
 101 }
 102
 103 // The format of the payload json is:
 104 // {
 105 //   "item_id": "<extension id>",
 106 //   "item_version": "<extension version>",
 107 //   "content_hashes": [
 108 //     {
 109 //       "block_size": 4096,
 110 //       "hash_block_size": 4096,
 111 //       "format": "treehash",
 112 //       "files": [
 113 //         {
 114 //           "path": "foo/bar",
 115 //           "root_hash": "<base64url encoded bytes>"
 116 //         },
 117 //         ...
 118 //       ]
 119 //     }
 120 //   ]
 121 // }
 122 bool VerifiedContents::InitFrom(const base::FilePath& path,
 123                                 bool ignore_invalid_signature) {
 124   std::string payload;
 125   if (!GetPayload(path, &payload, ignore_invalid_signature))
 126     return false;
 127
 128   scoped_ptr<base::Value> value(base::JSONReader::Read(payload));
 129   if (!value.get() || !value->IsType(Value::TYPE_DICTIONARY))
 130     return false;
 131   DictionaryValue* dictionary = static_cast<DictionaryValue*>(value.get());
 132
 133   std::string item_id;
 134   if (!dictionary->GetString(kItemIdKey, &item_id) ||
 135       !crx_file::id_util::IdIsValid(item_id))
 136     return false;
 137   extension_id_ = item_id;
 138
 139   std::string version_string;
 140   if (!dictionary->GetString(kItemVersionKey, &version_string))
 141     return false;
 142   version_ = base::Version(version_string);
 143   if (!version_.IsValid())
 144     return false;
 145
 146   ListValue* hashes_list = NULL;
 147   if (!dictionary->GetList(kContentHashesKey, &hashes_list))
 148     return false;
 149
 150   for (size_t i = 0; i < hashes_list->GetSize(); i++) {
 151     DictionaryValue* hashes = NULL;
 152     if (!hashes_list->GetDictionary(i, &hashes))
 153       return false;
 154     std::string format;
 155     if (!hashes->GetString(kFormatKey, &format) || format != kTreeHash)
 156       continue;
 157
 158     int block_size = 0;
 159     int hash_block_size = 0;
 160     if (!hashes->GetInteger(kBlockSizeKey, &block_size) ||
 161         !hashes->GetInteger(kHashBlockSizeKey, &hash_block_size))
 162       return false;
 163     block_size_ = block_size;
 164
 165     // We don't support using a different block_size and hash_block_size at
 166     // the moment.
 167     if (block_size_ != hash_block_size)
 168       return false;
 169
 170     ListValue* files = NULL;
 171     if (!hashes->GetList(kFilesKey, &files))
 172       return false;
 173
 174     for (size_t j = 0; j < files->GetSize(); j++) {
 175       DictionaryValue* data = NULL;
 176       if (!files->GetDictionary(j, &data))
 177         return false;
 178       std::string file_path_string;
 179       std::string encoded_root_hash;
 180       std::string root_hash;
 181       if (!data->GetString(kPathKey, &file_path_string) ||
 182           !base::IsStringUTF8(file_path_string) ||
 183           !data->GetString(kRootHashKey, &encoded_root_hash) ||
 184           !FixupBase64Encoding(&encoded_root_hash) ||
 185           !base::Base64Decode(encoded_root_hash, &root_hash))
 186         return false;
 187       base::FilePath file_path =
 188           base::FilePath::FromUTF8Unsafe(file_path_string);
 189       RootHashes::iterator i = root_hashes_.insert(std::make_pair(
 190           base::StringToLowerASCII(file_path.value()), std::string()));
 191       i->second.swap(root_hash);
 192     }
 193
 194     break;
 195   }
 196   return true;
 197 }
 198
 199 bool VerifiedContents::HasTreeHashRoot(
 200     const base::FilePath& relative_path) const {
 201   base::FilePath::StringType path = base::StringToLowerASCII(
 202       relative_path.NormalizePathSeparatorsTo('/').value());
 203   return root_hashes_.find(path) != root_hashes_.end();
 204 }
 205
 206 bool VerifiedContents::TreeHashRootEquals(const base::FilePath& relative_path,
 207                                           const std::string& expected) const {
 208   base::FilePath::StringType path = base::StringToLowerASCII(
 209       relative_path.NormalizePathSeparatorsTo('/').value());
 210   for (RootHashes::const_iterator i = root_hashes_.find(path);
 211        i != root_hashes_.end();
 212        ++i) {
 213     if (expected == i->second)
 214       return true;
 215   }
 216   return false;
 217 }
 218
 219 // We're loosely following the "JSON Web Signature" draft spec for signing
 220 // a JSON payload:
 221 //
 222 //   http://tools.ietf.org/html/draft-ietf-jose-json-web-signature-26
 223 //
 224 // The idea is that you have some JSON that you want to sign, so you
 225 // base64-encode that and put it as the "payload" field in a containing
 226 // dictionary. There might be signatures of it done with multiple
 227 // algorithms/parameters, so the payload is followed by a list of one or more
 228 // signature sections. Each signature section specifies the
 229 // algorithm/parameters in a JSON object which is base64url encoded into one
 230 // string and put into a "protected" field in the signature. Then the encoded
 231 // "payload" and "protected" strings are concatenated with a "." in between
 232 // them and those bytes are signed and the resulting signature is base64url
 233 // encoded and placed in the "signature" field. To allow for extensibility, we
 234 // wrap this, so we can include additional kinds of payloads in the future. E.g.
 235 // [
 236 //   {
 237 //     "description": "treehash per file",
 238 //     "signed_content": {
 239 //       "payload": "<base64url encoded JSON to sign>",
 240 //       "signatures": [
 241 //         {
 242 //           "protected": "<base64url encoded JSON with algorithm/parameters>",
 243 //           "header": {
 244 //             <object with metadata about this signature, eg a key identifier>
 245 //           }
 246 //           "signature":
 247 //              "<base64url encoded signature over payload || . || protected>"
 248 //         },
 249 //         ... <zero or more additional signatures> ...
 250 //       ]
 251 //     }
 252 //   }
 253 // ]
 254 // There might be both a signature generated with a webstore private key and a
 255 // signature generated with the extension's private key - for now we only
 256 // verify the webstore one (since the id is in the payload, so we can trust
 257 // that it is for a given extension), but in the future we may validate using
 258 // the extension's key too (eg for non-webstore hosted extensions such as
 259 // enterprise installs).
 260 bool VerifiedContents::GetPayload(const base::FilePath& path,
 261                                   std::string* payload,
 262                                   bool ignore_invalid_signature) {
 263   std::string contents;
 264   if (!base::ReadFileToString(path, &contents))
 265     return false;
 266   scoped_ptr<base::Value> value(base::JSONReader::Read(contents));
 267   if (!value.get() || !value->IsType(Value::TYPE_LIST))
 268     return false;
 269   ListValue* top_list = static_cast<ListValue*>(value.get());
 270
 271   // Find the "treehash per file" signed content, e.g.
 272   // [
 273   //   {
 274   //     "description": "treehash per file",
 275   //     "signed_content": {
 276   //       "signatures": [ ... ],
 277   //       "payload": "..."
 278   //     }
 279   //   }
 280   // ]
 281   DictionaryValue* dictionary =
 282       FindDictionaryWithValue(top_list, kDescriptionKey, kTreeHashPerFile);
 283   DictionaryValue* signed_content = NULL;
 284   if (!dictionary ||
 285       !dictionary->GetDictionaryWithoutPathExpansion(kSignedContentKey,
 286                                                      &signed_content)) {
 287     return false;
 288   }
 289
 290   ListValue* signatures = NULL;
 291   if (!signed_content->GetList(kSignaturesKey, &signatures))
 292     return false;
 293
 294   DictionaryValue* signature_dict =
 295       FindDictionaryWithValue(signatures, kHeaderKidKey, kWebstoreKId);
 296   if (!signature_dict)
 297     return false;
 298
 299   std::string protected_value;
 300   std::string encoded_signature;
 301   std::string decoded_signature;
 302   if (!signature_dict->GetString(kProtectedKey, &protected_value) ||
 303       !signature_dict->GetString(kSignatureKey, &encoded_signature) ||
 304       !FixupBase64Encoding(&encoded_signature) ||
 305       !base::Base64Decode(encoded_signature, &decoded_signature))
 306     return false;
 307
 308   std::string encoded_payload;
 309   if (!signed_content->GetString(kPayloadKey, &encoded_payload))
 310     return false;
 311
 312   valid_signature_ =
 313       VerifySignature(protected_value, encoded_payload, decoded_signature);
 314   if (!valid_signature_ && !ignore_invalid_signature)
 315     return false;
 316
 317   if (!FixupBase64Encoding(&encoded_payload) ||
 318       !base::Base64Decode(encoded_payload, payload))
 319     return false;
 320
 321   return true;
 322 }
 323
 324 bool VerifiedContents::VerifySignature(const std::string& protected_value,
 325                                        const std::string& payload,
 326                                        const std::string& signature_bytes) {
 327   crypto::SignatureVerifier signature_verifier;
 328   if (!signature_verifier.VerifyInit(
 329           kSignatureAlgorithm,
 330           sizeof(kSignatureAlgorithm),
 331           reinterpret_cast<const uint8*>(signature_bytes.data()),
 332           signature_bytes.size(),
 333           public_key_,
 334           public_key_size_)) {
 335     VLOG(1) << "Could not verify signature - VerifyInit failure";
 336     return false;
 337   }
 338
 339   signature_verifier.VerifyUpdate(
 340       reinterpret_cast<const uint8*>(protected_value.data()),
 341       protected_value.size());
 342
 343   std::string dot(".");
 344   signature_verifier.VerifyUpdate(reinterpret_cast<const uint8*>(dot.data()),
 345                                   dot.size());
 346
 347   signature_verifier.VerifyUpdate(
 348       reinterpret_cast<const uint8*>(payload.data()), payload.size());
 349
 350   if (!signature_verifier.VerifyFinal()) {
 351     VLOG(1) << "Could not verify signature - VerifyFinal failure";
 352     return false;
 353   }
 354   return true;
 355 }
 356
 357 }  // namespace extensions