blob: d6c8a3daae2af6144de4cd2e0178fc066848670b [file] [log] [blame]
// Copyright 2018 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "starboard/shared/widevine/widevine_storage.h"
#include "starboard/common/file.h"
#include "starboard/common/log.h"
#include "starboard/shared/widevine/widevine_keybox_hash.h"
#include "starboard/types.h"
namespace starboard {
namespace shared {
namespace widevine {
// Reserved key name for referring to the Widevine Keybox checksum value.
const char WidevineStorage::kCobaltWidevineKeyboxChecksumKey[] =
"cobalt_widevine_keybox_checksum";
namespace {
void ReadFile(const std::string& path_name, std::vector<uint8_t>* content) {
SB_DCHECK(content);
ScopedFile file(path_name.c_str(), kSbFileOpenOnly | kSbFileRead);
if (!file.IsValid()) {
content->clear();
SB_LOG(INFO) << "Failed to open " << path_name
<< ", returning empty content.";
return;
}
auto size = file.GetSize();
if (size < 0) {
content->clear();
SB_LOG(INFO) << "Failed to get size of " << path_name
<< ", returning empty content.";
return;
}
content->resize(size);
if (file.ReadAll(reinterpret_cast<char*>(content->data()), size) != size) {
content->clear();
SB_LOG(INFO) << "Failed to read content of " << path_name
<< ", returning empty content.";
return;
}
}
bool WriteFile(const std::string& path_name,
const std::vector<uint8_t>& content) {
ScopedFile file(path_name.c_str(), kSbFileCreateAlways | kSbFileWrite);
if (!file.IsValid()) {
SB_LOG(INFO) << "Failed to create " << path_name << " for writing.";
return false;
}
if (file.WriteAll(reinterpret_cast<const char*>(content.data()),
static_cast<int>(content.size())) != content.size()) {
SB_LOG(INFO) << "Failed to write content to " << path_name << '.';
return false;
}
file.Flush();
return true;
}
bool ReadString(const std::vector<uint8_t>& data,
size_t* offset,
std::string* str) {
if (*offset + sizeof(int) > data.size()) {
SB_LOG(ERROR) << "Failed to read the size of string from |data|.";
return false;
}
int size = *reinterpret_cast<const int*>(data.data() + *offset);
*offset += sizeof(int);
if (*offset + size > data.size()) {
SB_LOG(ERROR) << "Failed to read " << size << " bytes from |data|.";
return false;
}
str->assign(reinterpret_cast<const char*>(data.data() + *offset),
reinterpret_cast<const char*>(data.data() + *offset + size));
*offset += size;
return true;
}
void WriteString(const std::string& str, std::vector<uint8_t>* content) {
content->reserve(content->size() + sizeof(int) + str.size());
content->resize(content->size() + sizeof(int));
*reinterpret_cast<int*>(content->data() + content->size() - sizeof(int)) =
static_cast<int>(str.size());
content->insert(content->end(), reinterpret_cast<const uint8_t*>(str.c_str()),
reinterpret_cast<const uint8_t*>(str.c_str()) + str.size());
}
} // namespace
WidevineStorage::WidevineStorage(const std::string& path_name)
: path_name_(path_name) {
std::vector<uint8_t> content;
ReadFile(path_name_, &content);
size_t offset = 0;
while (offset != content.size()) {
std::string name, value;
if (!ReadString(content, &offset, &name) ||
!ReadString(content, &offset, &value)) {
cache_.clear();
SB_LOG(WARNING) << path_name_ << " is corrupt, returns empty content.";
return;
}
cache_[name] = value;
}
SB_LOG(INFO) << "Loaded " << cache_.size() << " records from " << path_name_;
// Not a cryptographic hash but is sufficient for this problem space.
std::string keybox_checksum = GetWidevineKeyboxHash();
if (existsInternal(kCobaltWidevineKeyboxChecksumKey)) {
std::string cached_checksum;
readInternal(kCobaltWidevineKeyboxChecksumKey, &cached_checksum);
if (keybox_checksum == cached_checksum) {
return;
}
SB_LOG(INFO) << "Cobalt widevine keybox checksums do not match. Clearing "
"to force re-provisioning.";
cache_.clear();
// Save the new keybox checksum to be used after provisioning completes.
writeInternal(kCobaltWidevineKeyboxChecksumKey, keybox_checksum);
return;
}
SB_LOG(INFO) << "Widevine checksum is not stored on disk. Writing the "
"computed checksum to disk.";
writeInternal(kCobaltWidevineKeyboxChecksumKey, keybox_checksum);
}
bool WidevineStorage::read(const std::string& name, std::string* data) {
SB_DCHECK(name != kCobaltWidevineKeyboxChecksumKey);
return readInternal(name, data);
}
bool WidevineStorage::write(const std::string& name, const std::string& data) {
SB_DCHECK(name != kCobaltWidevineKeyboxChecksumKey);
return writeInternal(name, data);
}
bool WidevineStorage::exists(const std::string& name) {
SB_DCHECK(name != kCobaltWidevineKeyboxChecksumKey);
return existsInternal(name);
}
bool WidevineStorage::remove(const std::string& name) {
SB_DCHECK(name != kCobaltWidevineKeyboxChecksumKey);
return removeInternal(name);
}
int32_t WidevineStorage::size(const std::string& name) {
SB_DCHECK(name != kCobaltWidevineKeyboxChecksumKey);
ScopedLock scoped_lock(lock_);
auto iter = cache_.find(name);
return iter == cache_.end() ? -1 : static_cast<int32_t>(iter->second.size());
}
bool WidevineStorage::list(std::vector<std::string>* records) {
SB_DCHECK(records);
ScopedLock scoped_lock(lock_);
records->clear();
for (auto item : cache_) {
if (item.first == kCobaltWidevineKeyboxChecksumKey) {
continue;
}
records->push_back(item.first);
}
return !records->empty();
}
bool WidevineStorage::readInternal(const std::string& name,
std::string* data) const {
SB_DCHECK(data);
ScopedLock scoped_lock(lock_);
auto iter = cache_.find(name);
if (iter == cache_.end()) {
return false;
}
*data = iter->second;
return true;
}
bool WidevineStorage::writeInternal(const std::string& name,
const std::string& data) {
ScopedLock scoped_lock(lock_);
cache_[name] = data;
std::vector<uint8_t> content;
for (auto iter : cache_) {
WriteString(iter.first, &content);
WriteString(iter.second, &content);
}
return WriteFile(path_name_, content);
}
bool WidevineStorage::existsInternal(const std::string& name) const {
ScopedLock scoped_lock(lock_);
return cache_.find(name) != cache_.end();
}
bool WidevineStorage::removeInternal(const std::string& name) {
ScopedLock scoped_lock(lock_);
auto iter = cache_.find(name);
if (iter == cache_.end()) {
return false;
}
cache_.erase(iter);
return true;
}
} // namespace widevine
} // namespace shared
} // namespace starboard