aes_decryptor.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7
1// Copyright 2013 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 "media/cdm/aes_decryptor.h" 6 7#include <list> 8#include <vector> 9 10#include "base/logging.h" 11#include "base/stl_util.h" 12#include "base/strings/string_number_conversions.h" 13#include "crypto/encryptor.h" 14#include "crypto/symmetric_key.h" 15#include "media/base/audio_decoder_config.h" 16#include "media/base/decoder_buffer.h" 17#include "media/base/decrypt_config.h" 18#include "media/base/video_decoder_config.h" 19#include "media/base/video_frame.h" 20#include "media/cdm/json_web_key.h" 21 22namespace media { 23 24// Keeps track of the session IDs and DecryptionKeys. The keys are ordered by 25// insertion time (last insertion is first). It takes ownership of the 26// DecryptionKeys. 27class AesDecryptor::SessionIdDecryptionKeyMap { 28 // Use a std::list to actually hold the data. Insertion is always done 29 // at the front, so the "latest" decryption key is always the first one 30 // in the list. 31 typedef std::list<std::pair<uint32, DecryptionKey*> > KeyList; 32 33 public: 34 SessionIdDecryptionKeyMap() {} 35 ~SessionIdDecryptionKeyMap() { STLDeleteValues(&key_list_); } 36 37 // Replaces value if |session_id| is already present, or adds it if not. 38 // This |decryption_key| becomes the latest until another insertion or 39 // |session_id| is erased. 40 void Insert(uint32 session_id, scoped_ptr<DecryptionKey> decryption_key); 41 42 // Deletes the entry for |session_id| if present. 43 void Erase(const uint32 session_id); 44 45 // Returns whether the list is empty 46 bool Empty() const { return key_list_.empty(); } 47 48 // Returns the last inserted DecryptionKey. 49 DecryptionKey* LatestDecryptionKey() { 50 DCHECK(!key_list_.empty()); 51 return key_list_.begin()->second; 52 } 53 54 private: 55 // Searches the list for an element with |session_id|. 56 KeyList::iterator Find(const uint32 session_id); 57 58 // Deletes the entry pointed to by |position|. 59 void Erase(KeyList::iterator position); 60 61 KeyList key_list_; 62 63 DISALLOW_COPY_AND_ASSIGN(SessionIdDecryptionKeyMap); 64}; 65 66void AesDecryptor::SessionIdDecryptionKeyMap::Insert( 67 uint32 session_id, 68 scoped_ptr<DecryptionKey> decryption_key) { 69 KeyList::iterator it = Find(session_id); 70 if (it != key_list_.end()) 71 Erase(it); 72 DecryptionKey* raw_ptr = decryption_key.release(); 73 key_list_.push_front(std::make_pair(session_id, raw_ptr)); 74} 75 76void AesDecryptor::SessionIdDecryptionKeyMap::Erase(const uint32 session_id) { 77 KeyList::iterator it = Find(session_id); 78 if (it == key_list_.end()) 79 return; 80 Erase(it); 81} 82 83AesDecryptor::SessionIdDecryptionKeyMap::KeyList::iterator 84AesDecryptor::SessionIdDecryptionKeyMap::Find(const uint32 session_id) { 85 for (KeyList::iterator it = key_list_.begin(); it != key_list_.end(); ++it) { 86 if (it->first == session_id) 87 return it; 88 } 89 return key_list_.end(); 90} 91 92void AesDecryptor::SessionIdDecryptionKeyMap::Erase( 93 KeyList::iterator position) { 94 DCHECK(position->second); 95 delete position->second; 96 key_list_.erase(position); 97} 98 99uint32 AesDecryptor::next_web_session_id_ = 1; 100 101enum ClearBytesBufferSel { 102 kSrcContainsClearBytes, 103 kDstContainsClearBytes 104}; 105 106static void CopySubsamples(const std::vector<SubsampleEntry>& subsamples, 107 const ClearBytesBufferSel sel, 108 const uint8* src, 109 uint8* dst) { 110 for (size_t i = 0; i < subsamples.size(); i++) { 111 const SubsampleEntry& subsample = subsamples[i]; 112 if (sel == kSrcContainsClearBytes) { 113 src += subsample.clear_bytes; 114 } else { 115 dst += subsample.clear_bytes; 116 } 117 memcpy(dst, src, subsample.cypher_bytes); 118 src += subsample.cypher_bytes; 119 dst += subsample.cypher_bytes; 120 } 121} 122 123// Decrypts |input| using |key|. Returns a DecoderBuffer with the decrypted 124// data if decryption succeeded or NULL if decryption failed. 125static scoped_refptr<DecoderBuffer> DecryptData(const DecoderBuffer& input, 126 crypto::SymmetricKey* key) { 127 CHECK(input.data_size()); 128 CHECK(input.decrypt_config()); 129 CHECK(key); 130 131 crypto::Encryptor encryptor; 132 if (!encryptor.Init(key, crypto::Encryptor::CTR, "")) { 133 DVLOG(1) << "Could not initialize decryptor."; 134 return NULL; 135 } 136 137 DCHECK_EQ(input.decrypt_config()->iv().size(), 138 static_cast<size_t>(DecryptConfig::kDecryptionKeySize)); 139 if (!encryptor.SetCounter(input.decrypt_config()->iv())) { 140 DVLOG(1) << "Could not set counter block."; 141 return NULL; 142 } 143 144 const char* sample = reinterpret_cast<const char*>(input.data()); 145 size_t sample_size = static_cast<size_t>(input.data_size()); 146 147 DCHECK_GT(sample_size, 0U) << "No sample data to be decrypted."; 148 if (sample_size == 0) 149 return NULL; 150 151 if (input.decrypt_config()->subsamples().empty()) { 152 std::string decrypted_text; 153 base::StringPiece encrypted_text(sample, sample_size); 154 if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) { 155 DVLOG(1) << "Could not decrypt data."; 156 return NULL; 157 } 158 159 // TODO(xhwang): Find a way to avoid this data copy. 160 return DecoderBuffer::CopyFrom( 161 reinterpret_cast<const uint8*>(decrypted_text.data()), 162 decrypted_text.size()); 163 } 164 165 const std::vector<SubsampleEntry>& subsamples = 166 input.decrypt_config()->subsamples(); 167 168 size_t total_clear_size = 0; 169 size_t total_encrypted_size = 0; 170 for (size_t i = 0; i < subsamples.size(); i++) { 171 total_clear_size += subsamples[i].clear_bytes; 172 total_encrypted_size += subsamples[i].cypher_bytes; 173 // Check for overflow. This check is valid because *_size is unsigned. 174 DCHECK(total_clear_size >= subsamples[i].clear_bytes); 175 if (total_encrypted_size < subsamples[i].cypher_bytes) 176 return NULL; 177 } 178 size_t total_size = total_clear_size + total_encrypted_size; 179 if (total_size < total_clear_size || total_size != sample_size) { 180 DVLOG(1) << "Subsample sizes do not equal input size"; 181 return NULL; 182 } 183 184 // No need to decrypt if there is no encrypted data. 185 if (total_encrypted_size <= 0) { 186 return DecoderBuffer::CopyFrom(reinterpret_cast<const uint8*>(sample), 187 sample_size); 188 } 189 190 // The encrypted portions of all subsamples must form a contiguous block, 191 // such that an encrypted subsample that ends away from a block boundary is 192 // immediately followed by the start of the next encrypted subsample. We 193 // copy all encrypted subsamples to a contiguous buffer, decrypt them, then 194 // copy the decrypted bytes over the encrypted bytes in the output. 195 // TODO(strobe): attempt to reduce number of memory copies 196 scoped_ptr<uint8[]> encrypted_bytes(new uint8[total_encrypted_size]); 197 CopySubsamples(subsamples, kSrcContainsClearBytes, 198 reinterpret_cast<const uint8*>(sample), encrypted_bytes.get()); 199 200 base::StringPiece encrypted_text( 201 reinterpret_cast<const char*>(encrypted_bytes.get()), 202 total_encrypted_size); 203 std::string decrypted_text; 204 if (!encryptor.Decrypt(encrypted_text, &decrypted_text)) { 205 DVLOG(1) << "Could not decrypt data."; 206 return NULL; 207 } 208 DCHECK_EQ(decrypted_text.size(), encrypted_text.size()); 209 210 scoped_refptr<DecoderBuffer> output = DecoderBuffer::CopyFrom( 211 reinterpret_cast<const uint8*>(sample), sample_size); 212 CopySubsamples(subsamples, kDstContainsClearBytes, 213 reinterpret_cast<const uint8*>(decrypted_text.data()), 214 output->writable_data()); 215 return output; 216} 217 218AesDecryptor::AesDecryptor(const SessionCreatedCB& session_created_cb, 219 const SessionMessageCB& session_message_cb, 220 const SessionReadyCB& session_ready_cb, 221 const SessionClosedCB& session_closed_cb, 222 const SessionErrorCB& session_error_cb) 223 : session_created_cb_(session_created_cb), 224 session_message_cb_(session_message_cb), 225 session_ready_cb_(session_ready_cb), 226 session_closed_cb_(session_closed_cb), 227 session_error_cb_(session_error_cb) {} 228 229AesDecryptor::~AesDecryptor() { 230 key_map_.clear(); 231} 232 233bool AesDecryptor::CreateSession(uint32 session_id, 234 const std::string& content_type, 235 const uint8* init_data, 236 int init_data_length) { 237 // Validate that this is a new session. 238 DCHECK(valid_sessions_.find(session_id) == valid_sessions_.end()); 239 valid_sessions_.insert(session_id); 240 241 std::string web_session_id_string(base::UintToString(next_web_session_id_++)); 242 243 // For now, the AesDecryptor does not care about |content_type|; 244 // just fire the event with the |init_data| as the request. 245 std::vector<uint8> message; 246 if (init_data && init_data_length) 247 message.assign(init_data, init_data + init_data_length); 248 249 session_created_cb_.Run(session_id, web_session_id_string); 250 session_message_cb_.Run(session_id, message, std::string()); 251 return true; 252} 253 254void AesDecryptor::LoadSession(uint32 session_id, 255 const std::string& web_session_id) { 256 // TODO(xhwang): Change this to NOTREACHED() when blink checks for key systems 257 // that do not support loadSession. See http://crbug.com/342481 258 session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0); 259} 260 261void AesDecryptor::UpdateSession(uint32 session_id, 262 const uint8* response, 263 int response_length) { 264 CHECK(response); 265 CHECK_GT(response_length, 0); 266 DCHECK(valid_sessions_.find(session_id) != valid_sessions_.end()); 267 268 std::string key_string(reinterpret_cast<const char*>(response), 269 response_length); 270 KeyIdAndKeyPairs keys; 271 if (!ExtractKeysFromJWKSet(key_string, &keys)) { 272 session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0); 273 return; 274 } 275 276 // Make sure that at least one key was extracted. 277 if (keys.empty()) { 278 session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0); 279 return; 280 } 281 282 for (KeyIdAndKeyPairs::iterator it = keys.begin(); it != keys.end(); ++it) { 283 if (it->second.length() != 284 static_cast<size_t>(DecryptConfig::kDecryptionKeySize)) { 285 DVLOG(1) << "Invalid key length: " << key_string.length(); 286 session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0); 287 return; 288 } 289 if (!AddDecryptionKey(session_id, it->first, it->second)) { 290 session_error_cb_.Run(session_id, MediaKeys::kUnknownError, 0); 291 return; 292 } 293 } 294 295 { 296 base::AutoLock auto_lock(new_key_cb_lock_); 297 298 if (!new_audio_key_cb_.is_null()) 299 new_audio_key_cb_.Run(); 300 301 if (!new_video_key_cb_.is_null()) 302 new_video_key_cb_.Run(); 303 } 304 305 session_ready_cb_.Run(session_id); 306} 307 308void AesDecryptor::ReleaseSession(uint32 session_id) { 309 // Validate that this is a reference to an active session and then forget it. 310 std::set<uint32>::iterator it = valid_sessions_.find(session_id); 311 DCHECK(it != valid_sessions_.end()); 312 valid_sessions_.erase(it); 313 314 DeleteKeysForSession(session_id); 315 session_closed_cb_.Run(session_id); 316} 317 318Decryptor* AesDecryptor::GetDecryptor() { 319 return this; 320} 321 322void AesDecryptor::RegisterNewKeyCB(StreamType stream_type, 323 const NewKeyCB& new_key_cb) { 324 base::AutoLock auto_lock(new_key_cb_lock_); 325 326 switch (stream_type) { 327 case kAudio: 328 new_audio_key_cb_ = new_key_cb; 329 break; 330 case kVideo: 331 new_video_key_cb_ = new_key_cb; 332 break; 333 default: 334 NOTREACHED(); 335 } 336} 337 338void AesDecryptor::Decrypt(StreamType stream_type, 339 const scoped_refptr<DecoderBuffer>& encrypted, 340 const DecryptCB& decrypt_cb) { 341 CHECK(encrypted->decrypt_config()); 342 343 scoped_refptr<DecoderBuffer> decrypted; 344 // An empty iv string signals that the frame is unencrypted. 345 if (encrypted->decrypt_config()->iv().empty()) { 346 decrypted = DecoderBuffer::CopyFrom(encrypted->data(), 347 encrypted->data_size()); 348 } else { 349 const std::string& key_id = encrypted->decrypt_config()->key_id(); 350 DecryptionKey* key = GetKey(key_id); 351 if (!key) { 352 DVLOG(1) << "Could not find a matching key for the given key ID."; 353 decrypt_cb.Run(kNoKey, NULL); 354 return; 355 } 356 357 crypto::SymmetricKey* decryption_key = key->decryption_key(); 358 decrypted = DecryptData(*encrypted.get(), decryption_key); 359 if (!decrypted.get()) { 360 DVLOG(1) << "Decryption failed."; 361 decrypt_cb.Run(kError, NULL); 362 return; 363 } 364 } 365 366 decrypted->set_timestamp(encrypted->timestamp()); 367 decrypted->set_duration(encrypted->duration()); 368 decrypt_cb.Run(kSuccess, decrypted); 369} 370 371void AesDecryptor::CancelDecrypt(StreamType stream_type) { 372 // Decrypt() calls the DecryptCB synchronously so there's nothing to cancel. 373} 374 375void AesDecryptor::InitializeAudioDecoder(const AudioDecoderConfig& config, 376 const DecoderInitCB& init_cb) { 377 // AesDecryptor does not support audio decoding. 378 init_cb.Run(false); 379} 380 381void AesDecryptor::InitializeVideoDecoder(const VideoDecoderConfig& config, 382 const DecoderInitCB& init_cb) { 383 // AesDecryptor does not support video decoding. 384 init_cb.Run(false); 385} 386 387void AesDecryptor::DecryptAndDecodeAudio( 388 const scoped_refptr<DecoderBuffer>& encrypted, 389 const AudioDecodeCB& audio_decode_cb) { 390 NOTREACHED() << "AesDecryptor does not support audio decoding"; 391} 392 393void AesDecryptor::DecryptAndDecodeVideo( 394 const scoped_refptr<DecoderBuffer>& encrypted, 395 const VideoDecodeCB& video_decode_cb) { 396 NOTREACHED() << "AesDecryptor does not support video decoding"; 397} 398 399void AesDecryptor::ResetDecoder(StreamType stream_type) { 400 NOTREACHED() << "AesDecryptor does not support audio/video decoding"; 401} 402 403void AesDecryptor::DeinitializeDecoder(StreamType stream_type) { 404 NOTREACHED() << "AesDecryptor does not support audio/video decoding"; 405} 406 407bool AesDecryptor::AddDecryptionKey(const uint32 session_id, 408 const std::string& key_id, 409 const std::string& key_string) { 410 scoped_ptr<DecryptionKey> decryption_key(new DecryptionKey(key_string)); 411 if (!decryption_key) { 412 DVLOG(1) << "Could not create key."; 413 return false; 414 } 415 416 if (!decryption_key->Init()) { 417 DVLOG(1) << "Could not initialize decryption key."; 418 return false; 419 } 420 421 base::AutoLock auto_lock(key_map_lock_); 422 KeyIdToSessionKeysMap::iterator key_id_entry = key_map_.find(key_id); 423 if (key_id_entry != key_map_.end()) { 424 key_id_entry->second->Insert(session_id, decryption_key.Pass()); 425 return true; 426 } 427 428 // |key_id| not found, so need to create new entry. 429 scoped_ptr<SessionIdDecryptionKeyMap> inner_map( 430 new SessionIdDecryptionKeyMap()); 431 inner_map->Insert(session_id, decryption_key.Pass()); 432 key_map_.add(key_id, inner_map.Pass()); 433 return true; 434} 435 436AesDecryptor::DecryptionKey* AesDecryptor::GetKey( 437 const std::string& key_id) const { 438 base::AutoLock auto_lock(key_map_lock_); 439 KeyIdToSessionKeysMap::const_iterator key_id_found = key_map_.find(key_id); 440 if (key_id_found == key_map_.end()) 441 return NULL; 442 443 // Return the key from the "latest" session_id entry. 444 return key_id_found->second->LatestDecryptionKey(); 445} 446 447void AesDecryptor::DeleteKeysForSession(const uint32 session_id) { 448 base::AutoLock auto_lock(key_map_lock_); 449 450 // Remove all keys associated with |session_id|. Since the data is optimized 451 // for access in GetKey(), we need to look at each entry in |key_map_|. 452 KeyIdToSessionKeysMap::iterator it = key_map_.begin(); 453 while (it != key_map_.end()) { 454 it->second->Erase(session_id); 455 if (it->second->Empty()) { 456 // Need to get rid of the entry for this key_id. This will mess up the 457 // iterator, so we need to increment it first. 458 KeyIdToSessionKeysMap::iterator current = it; 459 ++it; 460 key_map_.erase(current); 461 } else { 462 ++it; 463 } 464 } 465} 466 467AesDecryptor::DecryptionKey::DecryptionKey(const std::string& secret) 468 : secret_(secret) { 469} 470 471AesDecryptor::DecryptionKey::~DecryptionKey() {} 472 473bool AesDecryptor::DecryptionKey::Init() { 474 CHECK(!secret_.empty()); 475 decryption_key_.reset(crypto::SymmetricKey::Import( 476 crypto::SymmetricKey::AES, secret_)); 477 if (!decryption_key_) 478 return false; 479 return true; 480} 481 482} // namespace media 483