mirror of
https://github.com/Atmosphere-NX/Atmosphere
synced 2024-11-10 07:06:34 +00:00
1060 lines
53 KiB
C++
1060 lines
53 KiB
C++
/*
|
|
* Copyright (c) Atmosphère-NX
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <stratosphere.hpp>
|
|
#include "fssystem_read_only_block_cache_storage.hpp"
|
|
#include "fssystem_hierarchical_sha256_storage.hpp"
|
|
|
|
namespace ams::fssystem {
|
|
|
|
namespace {
|
|
|
|
constexpr inline s32 AesCtrExTableCacheBlockSize = AesCtrCounterExtendedStorage::NodeSize;
|
|
constexpr inline s32 AesCtrExTableCacheCount = 8;
|
|
constexpr inline s32 IndirectTableCacheBlockSize = IndirectStorage::NodeSize;
|
|
constexpr inline s32 IndirectTableCacheCount = 8;
|
|
constexpr inline s32 IndirectDataCacheBlockSize = 32_KB;
|
|
constexpr inline s32 IndirectDataCacheCount = 16;
|
|
constexpr inline s32 SparseTableCacheBlockSize = SparseStorage::NodeSize;
|
|
constexpr inline s32 SparseTableCacheCount = 4;
|
|
|
|
class BufferHolder {
|
|
NON_COPYABLE(BufferHolder);
|
|
private:
|
|
MemoryResource *m_allocator;
|
|
char *m_buffer;
|
|
size_t m_buffer_size;
|
|
public:
|
|
BufferHolder() : m_allocator(), m_buffer(), m_buffer_size() { /* ... */ }
|
|
BufferHolder(MemoryResource *a, size_t sz) : m_allocator(a), m_buffer(static_cast<char *>(a->Allocate(sz))), m_buffer_size(sz) { /* ... */ }
|
|
~BufferHolder() {
|
|
if (m_buffer != nullptr) {
|
|
m_allocator->Deallocate(m_buffer, m_buffer_size);
|
|
m_buffer = nullptr;
|
|
}
|
|
}
|
|
|
|
BufferHolder(BufferHolder &&rhs) : m_allocator(rhs.m_allocator), m_buffer(rhs.m_buffer), m_buffer_size(rhs.m_buffer_size) {
|
|
rhs.m_buffer = nullptr;
|
|
}
|
|
|
|
BufferHolder &operator=(BufferHolder &&rhs) {
|
|
if (this != std::addressof(rhs)) {
|
|
AMS_ASSERT(m_buffer == nullptr);
|
|
m_allocator = rhs.m_allocator;
|
|
m_buffer = rhs.m_buffer;
|
|
m_buffer_size = rhs.m_buffer_size;
|
|
|
|
rhs.m_buffer = nullptr;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool IsValid() const { return m_buffer != nullptr; }
|
|
char *Get() const { return m_buffer; }
|
|
size_t GetSize() const { return m_buffer_size; }
|
|
};
|
|
|
|
template<typename Base, typename Sequence>
|
|
class DerivedStorageHolderImpl;
|
|
|
|
template<typename Base, std::size_t... Is>
|
|
class DerivedStorageHolderImpl<Base, std::index_sequence<Is...>> : public Base {
|
|
NON_COPYABLE(DerivedStorageHolderImpl);
|
|
public:
|
|
using StoragePointer = std::unique_ptr<fs::IStorage>;
|
|
|
|
template<size_t N>
|
|
using IndexedStoragePointer = StoragePointer;
|
|
private:
|
|
std::shared_ptr<NcaReader> m_nca_reader;
|
|
std::array<StoragePointer, sizeof...(Is)> m_storages;
|
|
private:
|
|
|
|
template<size_t N>
|
|
void SetImpl(IndexedStoragePointer<N> &&ptr) {
|
|
static_assert(N < sizeof...(Is));
|
|
m_storages[N] = std::move(ptr);
|
|
}
|
|
public:
|
|
DerivedStorageHolderImpl() : Base(), m_nca_reader(), m_storages() { /* ... */ }
|
|
explicit DerivedStorageHolderImpl(std::shared_ptr<NcaReader> nr) : Base(), m_nca_reader(nr), m_storages() { /* ... */ }
|
|
|
|
#define DEFINE_CONSTRUCTORS(n) \
|
|
template<AMS_UTIL_VARIADIC_TEMPLATE_PARAMETERS##n (T)> \
|
|
explicit DerivedStorageHolderImpl(AMS_UTIL_VARIADIC_TEMPLATE_ARGUMENTS##n (T, t)) : Base(AMS_UTIL_VARIADIC_TEMPLATE_FORWARDS##n (T, t)), m_nca_reader(), m_storages() { /* ... */ } \
|
|
template<AMS_UTIL_VARIADIC_TEMPLATE_PARAMETERS##n (T)> \
|
|
explicit DerivedStorageHolderImpl(AMS_UTIL_VARIADIC_TEMPLATE_ARGUMENTS##n (T, t), std::shared_ptr<NcaReader> nr) : Base(AMS_UTIL_VARIADIC_TEMPLATE_FORWARDS##n (T, t)), m_nca_reader(nr), m_storages() { /* ... */ }
|
|
|
|
AMS_UTIL_VARIADIC_INVOKE_MACRO(DEFINE_CONSTRUCTORS)
|
|
|
|
#undef DEFINE_CONSTRUCTORS
|
|
|
|
void Set(IndexedStoragePointer<Is> &&... ptrs) {
|
|
(this->SetImpl<Is>(std::forward<IndexedStoragePointer<Is>>(ptrs)), ...);
|
|
}
|
|
};
|
|
|
|
template<typename Base, size_t N>
|
|
using DerivedStorageHolder = DerivedStorageHolderImpl<Base, std::make_index_sequence<N>>;
|
|
|
|
template<typename Base, size_t N>
|
|
class DerivedStorageHolderWithBuffer : public DerivedStorageHolder<Base, N> {
|
|
NON_COPYABLE(DerivedStorageHolderWithBuffer);
|
|
private:
|
|
using BaseHolder = DerivedStorageHolder<Base, N>;
|
|
private:
|
|
BufferHolder m_buffer;
|
|
public:
|
|
DerivedStorageHolderWithBuffer() : BaseHolder(), m_buffer() { /* ... */ }
|
|
|
|
template<typename... Args>
|
|
DerivedStorageHolderWithBuffer(Args &&... args) : BaseHolder(std::forward<Args>(args)...), m_buffer() { /* ... */ }
|
|
|
|
using BaseHolder::Set;
|
|
|
|
void Set(BufferHolder &&buf) {
|
|
m_buffer = std::move(buf);
|
|
}
|
|
};
|
|
|
|
class AesCtrStorageExternal : public ::ams::fs::IStorage, public ::ams::fs::impl::Newable {
|
|
NON_COPYABLE(AesCtrStorageExternal);
|
|
NON_MOVEABLE(AesCtrStorageExternal);
|
|
public:
|
|
static constexpr size_t BlockSize = crypto::Aes128CtrEncryptor::BlockSize;
|
|
static constexpr size_t KeySize = crypto::Aes128CtrEncryptor::KeySize;
|
|
static constexpr size_t IvSize = crypto::Aes128CtrEncryptor::IvSize;
|
|
private:
|
|
IStorage * const m_base_storage;
|
|
u8 m_iv[IvSize];
|
|
DecryptAesCtrFunction m_decrypt_function;
|
|
s32 m_key_index;
|
|
u8 m_encrypted_key[KeySize];
|
|
public:
|
|
AesCtrStorageExternal(fs::IStorage *bs, const void *enc_key, size_t enc_key_size, const void *iv, size_t iv_size, DecryptAesCtrFunction df, s32 kidx) : m_base_storage(bs), m_decrypt_function(df), m_key_index(kidx) {
|
|
AMS_ASSERT(bs != nullptr);
|
|
AMS_ASSERT(enc_key_size == KeySize);
|
|
AMS_ASSERT(iv != nullptr);
|
|
AMS_ASSERT(iv_size == IvSize);
|
|
AMS_UNUSED(iv_size);
|
|
|
|
std::memcpy(m_iv, iv, IvSize);
|
|
std::memcpy(m_encrypted_key, enc_key, enc_key_size);
|
|
}
|
|
|
|
virtual Result Read(s64 offset, void *buffer, size_t size) override {
|
|
/* Allow zero size. */
|
|
R_SUCCEED_IF(size == 0);
|
|
|
|
/* Validate arguments. */
|
|
/* NOTE: For some reason, Nintendo uses InvalidArgument instead of InvalidOffset/InvalidSize here. */
|
|
R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
|
|
R_UNLESS(util::IsAligned(offset, BlockSize), fs::ResultInvalidArgument());
|
|
R_UNLESS(util::IsAligned(size, BlockSize), fs::ResultInvalidArgument());
|
|
|
|
/* Read the data. */
|
|
R_TRY(m_base_storage->Read(offset, buffer, size));
|
|
|
|
/* Temporarily increase our thread priority. */
|
|
ScopedThreadPriorityChanger cp(+1, ScopedThreadPriorityChanger::Mode::Relative);
|
|
|
|
/* Allocate a pooled buffer for decryption. */
|
|
PooledBuffer pooled_buffer;
|
|
pooled_buffer.AllocateParticularlyLarge(size, BlockSize);
|
|
AMS_ASSERT(pooled_buffer.GetSize() >= BlockSize);
|
|
|
|
/* Setup the counter. */
|
|
u8 ctr[IvSize];
|
|
std::memcpy(ctr, m_iv, IvSize);
|
|
AddCounter(ctr, IvSize, offset / BlockSize);
|
|
|
|
/* Setup tracking. */
|
|
size_t remaining_size = size;
|
|
s64 cur_offset = 0;
|
|
|
|
while (remaining_size > 0) {
|
|
/* Get the current size to process. */
|
|
size_t cur_size = std::min(pooled_buffer.GetSize(), remaining_size);
|
|
char *dst = static_cast<char *>(buffer) + cur_offset;
|
|
|
|
/* Decrypt into the temporary buffer */
|
|
m_decrypt_function(pooled_buffer.GetBuffer(), cur_size, m_key_index, m_encrypted_key, KeySize, ctr, IvSize, dst, cur_size);
|
|
|
|
/* Copy to the destination. */
|
|
std::memcpy(dst, pooled_buffer.GetBuffer(), cur_size);
|
|
|
|
/* Update tracking. */
|
|
cur_offset += cur_size;
|
|
remaining_size -= cur_size;
|
|
|
|
if (remaining_size > 0) {
|
|
AddCounter(ctr, IvSize, cur_size / BlockSize);
|
|
}
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
virtual Result OperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
|
|
switch (op_id) {
|
|
case fs::OperationId::QueryRange:
|
|
{
|
|
/* Validate that we have an output range info. */
|
|
R_UNLESS(dst != nullptr, fs::ResultNullptrArgument());
|
|
R_UNLESS(dst_size == sizeof(fs::QueryRangeInfo), fs::ResultInvalidSize());
|
|
|
|
/* Operate on our base storage. */
|
|
R_TRY(m_base_storage->OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
|
|
|
|
/* Add in new flags. */
|
|
fs::QueryRangeInfo new_info;
|
|
new_info.Clear();
|
|
new_info.aes_ctr_key_type = static_cast<s32>(m_key_index >= 0 ? fs::AesCtrKeyTypeFlag::InternalKeyForHardwareAes : fs::AesCtrKeyTypeFlag::ExternalKeyForHardwareAes);
|
|
|
|
/* Merge the new info in. */
|
|
reinterpret_cast<fs::QueryRangeInfo *>(dst)->Merge(new_info);
|
|
return ResultSuccess();
|
|
}
|
|
default:
|
|
{
|
|
/* Operate on our base storage. */
|
|
R_TRY(m_base_storage->OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
|
|
return ResultSuccess();
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual Result GetSize(s64 *out) override {
|
|
return m_base_storage->GetSize(out);
|
|
}
|
|
|
|
virtual Result Flush() override {
|
|
return ResultSuccess();
|
|
}
|
|
|
|
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
|
|
AMS_UNUSED(offset, buffer, size);
|
|
return fs::ResultUnsupportedOperationInAesCtrStorageExternalA();
|
|
}
|
|
|
|
virtual Result SetSize(s64 size) override {
|
|
AMS_UNUSED(size);
|
|
return fs::ResultUnsupportedOperationInAesCtrStorageExternalB();
|
|
}
|
|
};
|
|
|
|
template<typename F>
|
|
class SwitchStorage : public ::ams::fs::IStorage, public ::ams::fs::impl::Newable {
|
|
NON_COPYABLE(SwitchStorage);
|
|
NON_MOVEABLE(SwitchStorage);
|
|
private:
|
|
std::unique_ptr<fs::IStorage> m_true_storage;
|
|
std::unique_ptr<fs::IStorage> m_false_storage;
|
|
F m_truth_function;
|
|
private:
|
|
ALWAYS_INLINE std::unique_ptr<fs::IStorage> &SelectStorage() {
|
|
return m_truth_function() ? m_true_storage : m_false_storage;
|
|
}
|
|
public:
|
|
SwitchStorage(std::unique_ptr<fs::IStorage> &&t, std::unique_ptr<fs::IStorage> &&f, F func) : m_true_storage(std::move(t)), m_false_storage(std::move(f)), m_truth_function(func) { /* ... */ }
|
|
|
|
virtual Result Read(s64 offset, void *buffer, size_t size) override {
|
|
return this->SelectStorage()->Read(offset, buffer, size);
|
|
}
|
|
|
|
virtual Result OperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
|
|
switch (op_id) {
|
|
case fs::OperationId::Invalidate:
|
|
{
|
|
R_TRY(m_true_storage->OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
|
|
R_TRY(m_false_storage->OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
|
|
return ResultSuccess();
|
|
}
|
|
case fs::OperationId::QueryRange:
|
|
{
|
|
R_TRY(this->SelectStorage()->OperateRange(dst, dst_size, op_id, offset, size, src, src_size));
|
|
return ResultSuccess();
|
|
}
|
|
default:
|
|
return fs::ResultUnsupportedOperationInSwitchStorageA();
|
|
}
|
|
}
|
|
|
|
virtual Result GetSize(s64 *out) override {
|
|
return this->SelectStorage()->GetSize(out);
|
|
}
|
|
|
|
virtual Result Flush() override {
|
|
return this->SelectStorage()->Flush();
|
|
}
|
|
|
|
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
|
|
return this->SelectStorage()->Write(offset, buffer, size);
|
|
}
|
|
|
|
virtual Result SetSize(s64 size) override {
|
|
return this->SelectStorage()->SetSize(size);
|
|
}
|
|
};
|
|
|
|
inline s64 GetFsOffset(const NcaReader &reader, s32 fs_index) {
|
|
return static_cast<s64>(reader.GetFsOffset(fs_index));
|
|
}
|
|
|
|
inline s64 GetFsEndOffset(const NcaReader &reader, s32 fs_index) {
|
|
return static_cast<s64>(reader.GetFsEndOffset(fs_index));
|
|
}
|
|
|
|
inline void MakeAesXtsIv(void *ctr, s64 base_offset) {
|
|
util::StoreBigEndian<s64>(static_cast<s64 *>(ctr) + 1, base_offset / NcaHeader::XtsBlockSize);
|
|
}
|
|
|
|
inline bool IsUsingHardwareAesCtrForSpeedEmulation() {
|
|
auto mode = fssystem::SpeedEmulationConfiguration::GetSpeedEmulationMode();
|
|
return mode == fs::SpeedEmulationMode::None || mode == fs::SpeedEmulationMode::Slower;
|
|
}
|
|
|
|
using Sha256DataRegion = NcaFsHeader::Region;
|
|
using IntegrityLevelInfo = NcaFsHeader::HashData::IntegrityMetaInfo::LevelHashInfo;
|
|
using IntegrityDataInfo = IntegrityLevelInfo::HierarchicalIntegrityVerificationLevelInformation;
|
|
|
|
inline const Sha256DataRegion &GetSha256DataRegion(const NcaFsHeader::HashData &hash_data) {
|
|
return hash_data.hierarchical_sha256_data.hash_layer_region[1];
|
|
}
|
|
|
|
inline const IntegrityDataInfo &GetIntegrityDataInfo(const NcaFsHeader::HashData &hash_data) {
|
|
return hash_data.integrity_meta_info.level_hash_info.info[hash_data.integrity_meta_info.level_hash_info.max_layers - 2];
|
|
}
|
|
|
|
}
|
|
|
|
Result NcaFileSystemDriver::OpenRawStorage(std::shared_ptr<fs::IStorage> *out, s32 fs_index) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(0 <= fs_index && fs_index < NcaHeader::FsCountMax);
|
|
AMS_ASSERT(m_reader != nullptr);
|
|
|
|
/* Get storage extents. */
|
|
const auto storage_offset = GetFsOffset(*m_reader, fs_index);
|
|
const auto storage_size = GetFsEndOffset(*m_reader, fs_index) - storage_offset;
|
|
R_UNLESS(storage_size > 0, fs::ResultInvalidNcaHeader());
|
|
|
|
/* Allocate a substorage. */
|
|
*out = fssystem::AllocateShared<DerivedStorageHolder<fs::SubStorage, 0>>(m_reader->GetBodyStorage(), storage_offset, storage_size, m_reader);
|
|
R_UNLESS(*out != nullptr, fs::ResultAllocationFailureInAllocateShared());
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::OpenStorage(std::shared_ptr<fs::IStorage> *out, NcaFsHeaderReader *out_header_reader, s32 fs_index) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(out_header_reader != nullptr);
|
|
AMS_ASSERT(0 <= fs_index && fs_index < NcaHeader::FsCountMax);
|
|
|
|
/* Open a reader with the appropriate option. */
|
|
StorageOption option(out_header_reader, fs_index);
|
|
R_TRY(this->OpenStorage(out, std::addressof(option)));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::OpenStorage(std::shared_ptr<fs::IStorage> *out, StorageOption *option) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(option != nullptr);
|
|
AMS_ASSERT(m_reader != nullptr);
|
|
|
|
/* Get and validate fs index. */
|
|
const auto fs_index = option->GetFsIndex();
|
|
R_UNLESS(m_reader->HasFsInfo(fs_index), fs::ResultPartitionNotFound());
|
|
|
|
/* Initialize a reader for the fs header. */
|
|
auto &header_reader = option->GetHeaderReader();
|
|
R_TRY(header_reader.Initialize(*m_reader, fs_index));
|
|
|
|
/* Create the storage. */
|
|
std::unique_ptr<fs::IStorage> storage;
|
|
{
|
|
BaseStorage base_storage;
|
|
R_TRY(this->CreateBaseStorage(std::addressof(base_storage), option));
|
|
R_TRY(this->CreateDecryptableStorage(std::addressof(storage), option, std::addressof(base_storage)));
|
|
}
|
|
R_TRY(this->CreateIndirectStorage(std::addressof(storage), option, std::move(storage)));
|
|
R_TRY(this->CreateVerificationStorage(std::addressof(storage), std::move(storage), std::addressof(header_reader)));
|
|
|
|
/* Set the output. */
|
|
*out = std::move(storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::OpenDecryptableStorage(std::shared_ptr<fs::IStorage> *out, StorageOption *option, bool indirect_needed) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(option != nullptr);
|
|
AMS_ASSERT(m_reader != nullptr);
|
|
|
|
/* Get and validate fs index. */
|
|
const auto fs_index = option->GetFsIndex();
|
|
R_UNLESS(m_reader->HasFsInfo(fs_index), fs::ResultPartitionNotFound());
|
|
|
|
/* Initialize a reader for the fs header. */
|
|
auto &header_reader = option->GetHeaderReader();
|
|
if (!header_reader.IsInitialized()) {
|
|
R_TRY(header_reader.Initialize(*m_reader, fs_index));
|
|
}
|
|
|
|
/* Create the storage. */
|
|
std::unique_ptr<fs::IStorage> storage;
|
|
{
|
|
BaseStorage base_storage;
|
|
R_TRY(this->CreateBaseStorage(std::addressof(base_storage), option));
|
|
R_TRY(this->CreateDecryptableStorage(std::addressof(storage), option, std::addressof(base_storage)));
|
|
}
|
|
|
|
/* Set the data storage. */
|
|
{
|
|
const auto &patch_info = header_reader.GetPatchInfo();
|
|
s64 data_storage_size = 0;
|
|
|
|
if (header_reader.GetEncryptionType() == NcaFsHeader::EncryptionType::AesCtrEx) {
|
|
data_storage_size = patch_info.aes_ctr_ex_offset;
|
|
} else {
|
|
switch (header_reader.GetHashType()) {
|
|
case NcaFsHeader::HashType::HierarchicalSha256Hash:
|
|
{
|
|
const auto ®ion = GetSha256DataRegion(header_reader.GetHashData());
|
|
data_storage_size = region.offset + region.size;
|
|
}
|
|
break;
|
|
case NcaFsHeader::HashType::HierarchicalIntegrityHash:
|
|
{
|
|
const auto &info = GetIntegrityDataInfo(header_reader.GetHashData());
|
|
data_storage_size = info.offset + info.size;
|
|
}
|
|
break;
|
|
default:
|
|
return fs::ResultInvalidNcaFsHeaderHashType();
|
|
}
|
|
|
|
data_storage_size = util::AlignUp(data_storage_size, NcaHeader::XtsBlockSize);
|
|
}
|
|
|
|
/* Set the data storage in option. */
|
|
option->SetDataStorage(storage.get(), data_storage_size);
|
|
}
|
|
|
|
/* Create the indirect storage if needed. */
|
|
if (indirect_needed) {
|
|
R_TRY(this->CreateIndirectStorage(std::addressof(storage), option, std::move(storage)));
|
|
}
|
|
|
|
/* Set the output. */
|
|
*out = std::move(storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateBaseStorage(BaseStorage *out, StorageOption *option) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(option != nullptr);
|
|
|
|
/* Get the header reader. */
|
|
const auto fs_index = option->GetFsIndex();
|
|
const auto &header_reader = option->GetHeaderReader();
|
|
|
|
/* Get storage extents. */
|
|
const auto storage_offset = GetFsOffset(*m_reader, fs_index);
|
|
const auto storage_size = GetFsEndOffset(*m_reader, fs_index) - storage_offset;
|
|
R_UNLESS(storage_size > 0, fs::ResultInvalidNcaHeader());
|
|
|
|
/* Set up the sparse storage if we need to, otherwise use body storage directly. */
|
|
if (header_reader.ExistsSparseLayer()) {
|
|
const auto &sparse_info = header_reader.GetSparseInfo();
|
|
|
|
/* Read and verify the bucket tree header. */
|
|
BucketTree::Header header;
|
|
std::memcpy(std::addressof(header), sparse_info.bucket.header, sizeof(header));
|
|
R_TRY(header.Verify());
|
|
|
|
/* Create a new holder for the storages. */
|
|
std::unique_ptr storage = std::make_unique<DerivedStorageHolder<SparseStorage, 2>>(m_reader);
|
|
R_UNLESS(storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* If there are no entries, there's nothing to actually do. */
|
|
if (header.entry_count == 0) {
|
|
storage->Initialize(storage_size);
|
|
} else {
|
|
/* Prepare to create the decryptable storage. */
|
|
const auto raw_storage = m_reader->GetBodyStorage();
|
|
const auto raw_storage_offset = sparse_info.physical_offset;
|
|
const auto raw_storage_size = sparse_info.GetPhysicalSize();
|
|
|
|
/* Validate that we're within range. */
|
|
s64 body_storage_size = 0;
|
|
R_TRY(raw_storage->GetSize(std::addressof(body_storage_size)));
|
|
R_UNLESS(raw_storage_offset + raw_storage_size <= body_storage_size, fs::ResultNcaBaseStorageOutOfRangeB());
|
|
|
|
/* Create the decryptable storage. */
|
|
std::unique_ptr<fs::IStorage> decryptable_storage;
|
|
{
|
|
BaseStorage base_storage(raw_storage, raw_storage_offset, raw_storage_size);
|
|
base_storage.SetStorageOffset(raw_storage_offset);
|
|
base_storage.SetAesCtrUpperIv(sparse_info.MakeAesCtrUpperIv(header_reader.GetAesCtrUpperIv()));
|
|
R_TRY(this->CreateAesCtrStorage(std::addressof(decryptable_storage), std::addressof(base_storage)));
|
|
}
|
|
|
|
/* Create the table storage. */
|
|
std::unique_ptr table_storage = std::make_unique<save::BufferedStorage>();
|
|
R_UNLESS(table_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the table storage. */
|
|
R_TRY(table_storage->Initialize(fs::SubStorage(decryptable_storage.get(), 0, raw_storage_size), m_buffer_manager, SparseTableCacheBlockSize, SparseTableCacheCount));
|
|
|
|
/* Determine storage extents. */
|
|
const auto node_offset = sparse_info.bucket.offset;
|
|
const auto node_size = SparseStorage::QueryNodeStorageSize(header.entry_count);
|
|
const auto entry_offset = node_offset + node_size;
|
|
const auto entry_size = SparseStorage::QueryEntryStorageSize(header.entry_count);
|
|
|
|
/* Initialize the storage. */
|
|
R_TRY(storage->Initialize(m_allocator, fs::SubStorage(table_storage.get(), node_offset, node_size), fs::SubStorage(table_storage.get(), entry_offset, entry_size), header.entry_count));
|
|
|
|
/* Set the data/decryptable storage. */
|
|
storage->SetDataStorage(raw_storage, raw_storage_offset, node_offset);
|
|
storage->Set(std::move(decryptable_storage), std::move(table_storage));
|
|
}
|
|
|
|
/* Set the sparse storage. */
|
|
option->SetSparseStorage(storage.get());
|
|
|
|
/* Set the out storage. */
|
|
out->SetStorage(std::move(storage));
|
|
} else {
|
|
/* Validate that we're within range. */
|
|
s64 body_storage_size;
|
|
R_TRY(m_reader->GetBodyStorage()->GetSize(std::addressof(body_storage_size)));
|
|
R_UNLESS(storage_offset + storage_size <= body_storage_size, fs::ResultNcaBaseStorageOutOfRangeB());
|
|
|
|
/* Set the out storage. */
|
|
out->SetStorage(m_reader->GetBodyStorage(), storage_offset, storage_size);
|
|
}
|
|
|
|
/* Set the crypto variables. */
|
|
out->SetStorageOffset(storage_offset);
|
|
out->SetAesCtrUpperIv(header_reader.GetAesCtrUpperIv());
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateDecryptableStorage(std::unique_ptr<fs::IStorage> *out, StorageOption *option, BaseStorage *base_storage) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(option != nullptr);
|
|
AMS_ASSERT(base_storage != nullptr);
|
|
|
|
/* Get the header reader. */
|
|
const auto &header_reader = option->GetHeaderReader();
|
|
|
|
/* Create the appropriate storage for the encryption type. */
|
|
switch (header_reader.GetEncryptionType()) {
|
|
case NcaFsHeader::EncryptionType::None:
|
|
*out = base_storage->MakeStorage();
|
|
R_UNLESS(*out != nullptr, fs::ResultAllocationFailureInNew());
|
|
break;
|
|
case NcaFsHeader::EncryptionType::AesXts:
|
|
R_TRY(this->CreateAesXtsStorage(out, base_storage));
|
|
break;
|
|
case NcaFsHeader::EncryptionType::AesCtr:
|
|
R_TRY(this->CreateAesCtrStorage(out, base_storage));
|
|
break;
|
|
case NcaFsHeader::EncryptionType::AesCtrEx:
|
|
R_TRY(this->CreateAesCtrExStorage(out, option, base_storage));
|
|
break;
|
|
default:
|
|
return fs::ResultInvalidNcaFsHeaderEncryptionType();
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateAesXtsStorage(std::unique_ptr<fs::IStorage> *out, BaseStorage *base_storage) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(base_storage != nullptr);
|
|
|
|
/* Create the iv. */
|
|
u8 iv[AesXtsStorage::IvSize] = {};
|
|
MakeAesXtsIv(iv, base_storage->GetStorageOffset());
|
|
|
|
/* Allocate a new raw storage. */
|
|
std::unique_ptr<fs::IStorage> raw_storage = base_storage->MakeStorage();
|
|
R_UNLESS(raw_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Make the aes xts storage. */
|
|
const auto *key1 = m_reader->GetDecryptionKey(NcaHeader::DecryptionKey_AesXts1);
|
|
const auto *key2 = m_reader->GetDecryptionKey(NcaHeader::DecryptionKey_AesXts2);
|
|
std::unique_ptr xts_storage = std::make_unique<AesXtsStorage>(raw_storage.get(), key1, key2, AesXtsStorage::KeySize, iv, AesXtsStorage::IvSize, NcaHeader::XtsBlockSize);
|
|
R_UNLESS(xts_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Make the out storage. */
|
|
std::unique_ptr storage = std::make_unique<DerivedStorageHolder<AlignmentMatchingStorage<NcaHeader::XtsBlockSize, 1>, 2>>(xts_storage.get(), m_reader);
|
|
R_UNLESS(storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Set the substorages. */
|
|
storage->Set(std::move(raw_storage), std::move(xts_storage));
|
|
|
|
/* Set the output. */
|
|
*out = std::move(storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateAesCtrStorage(std::unique_ptr<fs::IStorage> *out, BaseStorage *base_storage) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(base_storage != nullptr);
|
|
|
|
/* Create the iv. */
|
|
u8 iv[AesCtrStorage::IvSize] = {};
|
|
AesCtrStorage::MakeIv(iv, sizeof(iv), base_storage->GetAesCtrUpperIv().value, base_storage->GetStorageOffset());
|
|
|
|
/* Create the raw storage. */
|
|
std::unique_ptr raw_storage = base_storage->MakeStorage();
|
|
|
|
/* Create the decrypt storage. */
|
|
const bool has_external_key = m_reader->HasExternalDecryptionKey();
|
|
std::unique_ptr<fs::IStorage> decrypt_storage;
|
|
if (has_external_key) {
|
|
decrypt_storage = std::make_unique<AesCtrStorageExternal>(raw_storage.get(), m_reader->GetExternalDecryptionKey(), AesCtrStorageExternal::KeySize, iv, AesCtrStorageExternal::IvSize, m_reader->GetExternalDecryptAesCtrFunctionForExternalKey(), -1);
|
|
R_UNLESS(decrypt_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
} else {
|
|
/* Check if we have a hardware key. */
|
|
const bool has_hardware_key = m_reader->HasInternalDecryptionKeyForAesHardwareSpeedEmulation();
|
|
|
|
/* Create the software decryption storage. */
|
|
std::unique_ptr<fs::IStorage> aes_ctr_sw_storage = std::make_unique<AesCtrStorage>(raw_storage.get(), m_reader->GetDecryptionKey(NcaHeader::DecryptionKey_AesCtr), AesCtrStorage::KeySize, iv, AesCtrStorage::IvSize);
|
|
R_UNLESS(aes_ctr_sw_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* If we have a hardware key and should use it, make the hardware decryption storage. */
|
|
if (has_hardware_key && !m_reader->IsSoftwareAesPrioritized()) {
|
|
std::unique_ptr<fs::IStorage> aes_ctr_hw_storage = std::make_unique<AesCtrStorageExternal>(raw_storage.get(), m_reader->GetDecryptionKey(NcaHeader::DecryptionKey_AesCtrHw), AesCtrStorageExternal::KeySize, iv, AesCtrStorageExternal::IvSize, m_reader->GetExternalDecryptAesCtrFunction(), GetKeyTypeValue(m_reader->GetKeyIndex(), m_reader->GetKeyGeneration()));
|
|
R_UNLESS(aes_ctr_hw_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Create the selection storage. */
|
|
decrypt_storage = std::make_unique<SwitchStorage<bool (*)()>>(std::move(aes_ctr_hw_storage), std::move(aes_ctr_sw_storage), IsUsingHardwareAesCtrForSpeedEmulation);
|
|
R_UNLESS(decrypt_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
} else {
|
|
/* Otherwise, just use the software decryption storage. */
|
|
decrypt_storage = std::move(aes_ctr_sw_storage);
|
|
}
|
|
}
|
|
|
|
/* Create the storage holder. */
|
|
std::unique_ptr storage = std::make_unique<DerivedStorageHolder<AlignmentMatchingStorage<NcaHeader::CtrBlockSize, 1>, 2>>(decrypt_storage.get(), m_reader);
|
|
R_UNLESS(storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Set the storage holder's storages. */
|
|
storage->Set(std::move(raw_storage), std::move(decrypt_storage));
|
|
|
|
/* Set the out storage. */
|
|
*out = std::move(storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateAesCtrExStorage(std::unique_ptr<fs::IStorage> *out, StorageOption *option, BaseStorage *base_storage) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(option != nullptr);
|
|
AMS_ASSERT(base_storage != nullptr);
|
|
|
|
/* Check if indirection is needed. */
|
|
const auto &header_reader = option->GetHeaderReader();
|
|
const auto &patch_info = header_reader.GetPatchInfo();
|
|
|
|
/* Read the bucket tree header. */
|
|
BucketTree::Header header;
|
|
std::memcpy(std::addressof(header), patch_info.aes_ctr_ex_header, sizeof(header));
|
|
R_TRY(header.Verify());
|
|
|
|
/* Validate patch info extents. */
|
|
R_UNLESS(patch_info.indirect_size > 0, fs::ResultInvalidNcaPatchInfoIndirectSize());
|
|
R_UNLESS(patch_info.aes_ctr_ex_size > 0, fs::ResultInvalidNcaPatchInfoAesCtrExSize());
|
|
|
|
/* Make new base storage. */
|
|
const auto base_storage_offset = base_storage->GetStorageOffset();
|
|
const auto base_storage_size = util::AlignUp(patch_info.aes_ctr_ex_offset + patch_info.aes_ctr_ex_size, NcaHeader::XtsBlockSize);
|
|
fs::SubStorage new_base_storage;
|
|
R_TRY(base_storage->GetSubStorage(std::addressof(new_base_storage), 0, base_storage_size));
|
|
|
|
/* Create the table storage. */
|
|
std::unique_ptr<fs::IStorage> table_storage;
|
|
{
|
|
BaseStorage aes_ctr_base_storage(std::addressof(new_base_storage), patch_info.aes_ctr_ex_offset, patch_info.aes_ctr_ex_size);
|
|
aes_ctr_base_storage.SetStorageOffset(base_storage_offset + patch_info.aes_ctr_ex_offset);
|
|
aes_ctr_base_storage.SetAesCtrUpperIv(header_reader.GetAesCtrUpperIv());
|
|
R_TRY(this->CreateAesCtrStorage(std::addressof(table_storage), std::addressof(aes_ctr_base_storage)));
|
|
}
|
|
|
|
/* Get the table size. */
|
|
s64 table_size = 0;
|
|
R_TRY(table_storage->GetSize(std::addressof(table_size)));
|
|
|
|
/* Create the buffered storage. */
|
|
std::unique_ptr buffered_storage = std::make_unique<save::BufferedStorage>();
|
|
R_UNLESS(buffered_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the buffered storage. */
|
|
R_TRY(buffered_storage->Initialize(fs::SubStorage(table_storage.get(), 0, table_size), m_buffer_manager, AesCtrExTableCacheBlockSize, AesCtrExTableCacheCount));
|
|
|
|
/* Create an aligned storage for the buffered storage. */
|
|
using AlignedStorage = AlignmentMatchingStorage<NcaHeader::CtrBlockSize, 1>;
|
|
std::unique_ptr aligned_storage = std::make_unique<AlignedStorage>(buffered_storage.get());
|
|
R_UNLESS(aligned_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Determine the bucket extents. */
|
|
const auto entry_count = header.entry_count;
|
|
const s64 data_offset = 0;
|
|
const s64 data_size = patch_info.aes_ctr_ex_offset;
|
|
const s64 node_offset = 0;
|
|
const s64 node_size = AesCtrCounterExtendedStorage::QueryNodeStorageSize(entry_count);
|
|
const s64 entry_offset = node_offset + node_size;
|
|
const s64 entry_size = AesCtrCounterExtendedStorage::QueryEntryStorageSize(entry_count);
|
|
|
|
/* Create bucket storages. */
|
|
fs::SubStorage data_storage(std::addressof(new_base_storage), data_offset, data_size);
|
|
fs::SubStorage node_storage(aligned_storage.get(), node_offset, node_size);
|
|
fs::SubStorage entry_storage(aligned_storage.get(), entry_offset, entry_size);
|
|
|
|
/* Get the secure value. */
|
|
const auto secure_value = header_reader.GetAesCtrUpperIv().part.secure_value;
|
|
|
|
/* Create the aes ctr ex storage. */
|
|
std::unique_ptr<fs::IStorage> aes_ctr_ex_storage;
|
|
const bool has_external_key = m_reader->HasExternalDecryptionKey();
|
|
if (has_external_key) {
|
|
/* Create the decryptor. */
|
|
std::unique_ptr<AesCtrCounterExtendedStorage::IDecryptor> decryptor;
|
|
R_TRY(AesCtrCounterExtendedStorage::CreateExternalDecryptor(std::addressof(decryptor), m_reader->GetExternalDecryptAesCtrFunctionForExternalKey(), -1));
|
|
|
|
/* Create the aes ctr ex storage. */
|
|
std::unique_ptr impl_storage = std::make_unique<AesCtrCounterExtendedStorage>();
|
|
R_UNLESS(impl_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the aes ctr ex storage. */
|
|
R_TRY(impl_storage->Initialize(m_allocator, m_reader->GetExternalDecryptionKey(), AesCtrStorage::KeySize, secure_value, base_storage_offset, data_storage, node_storage, entry_storage, entry_count, std::move(decryptor)));
|
|
|
|
/* Set the option's aes ctr ex storage. */
|
|
option->SetAesCtrExStorageRaw(impl_storage.get());
|
|
|
|
aes_ctr_ex_storage = std::move(impl_storage);
|
|
} else {
|
|
/* Check if we have a hardware key. */
|
|
const bool has_hardware_key = m_reader->HasInternalDecryptionKeyForAesHardwareSpeedEmulation();
|
|
|
|
/* Create the software decryptor. */
|
|
std::unique_ptr<AesCtrCounterExtendedStorage::IDecryptor> sw_decryptor;
|
|
R_TRY(AesCtrCounterExtendedStorage::CreateSoftwareDecryptor(std::addressof(sw_decryptor)));
|
|
|
|
/* Make the software storage. */
|
|
std::unique_ptr sw_storage = std::make_unique<AesCtrCounterExtendedStorage>();
|
|
R_UNLESS(sw_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the software storage. */
|
|
R_TRY(sw_storage->Initialize(m_allocator, m_reader->GetDecryptionKey(NcaHeader::DecryptionKey_AesCtr), AesCtrStorage::KeySize, secure_value, base_storage_offset, data_storage, node_storage, entry_storage, entry_count, std::move(sw_decryptor)));
|
|
|
|
/* Set the option's aes ctr ex storage. */
|
|
option->SetAesCtrExStorageRaw(sw_storage.get());
|
|
|
|
/* If we have a hardware key and should use it, make the hardware decryption storage. */
|
|
if (has_hardware_key && !m_reader->IsSoftwareAesPrioritized()) {
|
|
/* Create the hardware decryptor. */
|
|
std::unique_ptr<AesCtrCounterExtendedStorage::IDecryptor> hw_decryptor;
|
|
R_TRY(AesCtrCounterExtendedStorage::CreateExternalDecryptor(std::addressof(hw_decryptor), m_reader->GetExternalDecryptAesCtrFunction(), GetKeyTypeValue(m_reader->GetKeyIndex(), m_reader->GetKeyGeneration())));
|
|
|
|
/* Create the hardware storage. */
|
|
std::unique_ptr hw_storage = std::make_unique<AesCtrCounterExtendedStorage>();
|
|
R_UNLESS(hw_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the hardware storage. */
|
|
R_TRY(hw_storage->Initialize(m_allocator, m_reader->GetDecryptionKey(NcaHeader::DecryptionKey_AesCtrHw), AesCtrStorage::KeySize, secure_value, base_storage_offset, data_storage, node_storage, entry_storage, entry_count, std::move(hw_decryptor)));
|
|
|
|
/* Create the selection storage. */
|
|
std::unique_ptr switch_storage = std::make_unique<SwitchStorage<bool (*)()>>(std::move(hw_storage), std::move(sw_storage), IsUsingHardwareAesCtrForSpeedEmulation);
|
|
R_UNLESS(switch_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Set the aes ctr ex storage. */
|
|
aes_ctr_ex_storage = std::move(switch_storage);
|
|
} else {
|
|
/* Set the aes ctr ex storage. */
|
|
aes_ctr_ex_storage = std::move(sw_storage);
|
|
}
|
|
}
|
|
|
|
/* Create the storage holder. */
|
|
std::unique_ptr storage = std::make_unique<DerivedStorageHolder<AlignedStorage, 5>>(aes_ctr_ex_storage.get(), m_reader);
|
|
R_UNLESS(storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Set the aes ctr ex storages in the option. */
|
|
option->SetAesCtrExTableStorage(table_storage.get());
|
|
option->SetAesCtrExStorage(storage.get());
|
|
|
|
/* Set the storage holder's storages. */
|
|
storage->Set(std::move(base_storage->GetStorage()), std::move(table_storage), std::move(buffered_storage), std::move(aligned_storage), std::move(aes_ctr_ex_storage));
|
|
|
|
/* Set the out storage. */
|
|
*out = std::move(storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateIndirectStorage(std::unique_ptr<fs::IStorage> *out, StorageOption *option, std::unique_ptr<fs::IStorage> base_storage) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(option != nullptr);
|
|
AMS_ASSERT(base_storage != nullptr);
|
|
|
|
/* Check if indirection is needed. */
|
|
const auto &header_reader = option->GetHeaderReader();
|
|
const auto &patch_info = header_reader.GetPatchInfo();
|
|
|
|
if (!patch_info.HasIndirectTable()) {
|
|
*out = std::move(base_storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
/* Read the bucket tree header. */
|
|
BucketTree::Header header;
|
|
std::memcpy(std::addressof(header), patch_info.indirect_header, sizeof(header));
|
|
R_TRY(header.Verify());
|
|
|
|
/* Determine the storage sizes. */
|
|
const auto node_size = IndirectStorage::QueryNodeStorageSize(header.entry_count);
|
|
const auto entry_size = IndirectStorage::QueryEntryStorageSize(header.entry_count);
|
|
R_UNLESS(node_size + entry_size <= patch_info.indirect_size, fs::ResultInvalidIndirectStorageSize());
|
|
|
|
/* Open the original storage. */
|
|
std::unique_ptr<fs::IStorage> original_storage;
|
|
{
|
|
const s32 fs_index = header_reader.GetFsIndex();
|
|
|
|
if (m_original_reader != nullptr && m_original_reader->HasFsInfo(fs_index)) {
|
|
NcaFsHeaderReader original_header_reader;
|
|
R_TRY(original_header_reader.Initialize(*m_original_reader, fs_index));
|
|
|
|
NcaFileSystemDriver original_driver(m_original_reader, m_allocator, m_buffer_manager);
|
|
StorageOption original_option(std::addressof(original_header_reader), fs_index);
|
|
|
|
BaseStorage original_base_storage;
|
|
R_TRY(original_driver.CreateBaseStorage(std::addressof(original_base_storage), std::addressof(original_option)));
|
|
R_TRY(original_driver.CreateDecryptableStorage(std::addressof(original_storage), std::addressof(original_option), std::addressof(original_base_storage)));
|
|
} else {
|
|
original_storage = std::make_unique<fs::MemoryStorage>(nullptr, 0);
|
|
R_UNLESS(original_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
}
|
|
}
|
|
|
|
/* Get the original data size. */
|
|
s64 original_data_size = 0;
|
|
R_TRY(original_storage->GetSize(std::addressof(original_data_size)));
|
|
|
|
/* Get the indirect data size. */
|
|
s64 indirect_data_size = patch_info.indirect_offset;
|
|
AMS_ASSERT(util::IsAligned(indirect_data_size, NcaHeader::XtsBlockSize));
|
|
|
|
/* Create the indirect table storage. */
|
|
std::unique_ptr indirect_table_storage = std::make_unique<save::BufferedStorage>();
|
|
R_UNLESS(indirect_table_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the indirect table storage. */
|
|
R_TRY(indirect_table_storage->Initialize(fs::SubStorage(base_storage.get(), indirect_data_size, node_size + entry_size), m_buffer_manager, IndirectTableCacheBlockSize, IndirectTableCacheCount));
|
|
|
|
/* Create the indirect data storage. */
|
|
std::unique_ptr indirect_data_storage = std::make_unique<save::BufferedStorage>();
|
|
R_UNLESS(indirect_data_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the indirect data storage. */
|
|
R_TRY(indirect_data_storage->Initialize(fs::SubStorage(base_storage.get(), 0, indirect_data_size), m_buffer_manager, IndirectDataCacheBlockSize, IndirectDataCacheCount));
|
|
|
|
/* Create the storage holder. */
|
|
std::unique_ptr storage = std::make_unique<DerivedStorageHolder<IndirectStorage, 4>>(m_reader);
|
|
R_UNLESS(storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the storage holder. */
|
|
R_TRY(storage->Initialize(m_allocator, fs::SubStorage(indirect_table_storage.get(), 0, node_size), fs::SubStorage(indirect_table_storage.get(), node_size, entry_size), header.entry_count));
|
|
|
|
/* Set the storage holder's storages. */
|
|
storage->SetStorage(0, original_storage.get(), 0, original_data_size);
|
|
storage->SetStorage(1, indirect_data_storage.get(), 0, indirect_data_size);
|
|
storage->Set(std::move(base_storage), std::move(original_storage), std::move(indirect_table_storage), std::move(indirect_data_storage));
|
|
|
|
/* Set the indirect storage. */
|
|
option->SetIndirectStorage(storage.get());
|
|
|
|
/* Set the out storage. */
|
|
*out = std::move(storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateVerificationStorage(std::unique_ptr<fs::IStorage> *out, std::unique_ptr<fs::IStorage> base_storage, NcaFsHeaderReader *header_reader) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(base_storage != nullptr);
|
|
AMS_ASSERT(header_reader != nullptr);
|
|
|
|
/* Create the appropriate storage for the encryption type. */
|
|
switch (header_reader->GetHashType()) {
|
|
case NcaFsHeader::HashType::HierarchicalSha256Hash:
|
|
R_TRY(this->CreateSha256Storage(out, std::move(base_storage), header_reader));
|
|
break;
|
|
case NcaFsHeader::HashType::HierarchicalIntegrityHash:
|
|
R_TRY(this->CreateIntegrityVerificationStorage(out, std::move(base_storage), header_reader));
|
|
break;
|
|
default:
|
|
return fs::ResultInvalidNcaFsHeaderHashType();
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateSha256Storage(std::unique_ptr<fs::IStorage> *out, std::unique_ptr<fs::IStorage> base_storage, NcaFsHeaderReader *header_reader) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(base_storage != nullptr);
|
|
AMS_ASSERT(header_reader != nullptr);
|
|
|
|
/* Define storage types. */
|
|
using VerificationStorage = HierarchicalSha256Storage;
|
|
using CacheStorage = ReadOnlyBlockCacheStorage;
|
|
using AlignedStorage = AlignmentMatchingStoragePooledBuffer<1>;
|
|
using StorageHolder = DerivedStorageHolderWithBuffer<AlignedStorage, 4>;
|
|
|
|
/* Get and validate the hash data. */
|
|
auto &hash_data = header_reader->GetHashData().hierarchical_sha256_data;
|
|
R_UNLESS(util::IsPowerOfTwo(hash_data.hash_block_size), fs::ResultInvalidHierarchicalSha256BlockSize());
|
|
R_UNLESS(hash_data.hash_layer_count == HierarchicalSha256Storage::LayerCount - 1, fs::ResultInvalidHierarchicalSha256LayerCount());
|
|
|
|
/* Get the regions. */
|
|
const auto &hash_region = hash_data.hash_layer_region[0];
|
|
const auto &data_region = hash_data.hash_layer_region[1];
|
|
|
|
/* Determine buffer sizes. */
|
|
constexpr s32 CacheBlockCount = 2;
|
|
const auto hash_buffer_size = static_cast<size_t>(hash_region.size);
|
|
const auto cache_buffer_size = CacheBlockCount * hash_data.hash_block_size;
|
|
const auto total_buffer_size = hash_buffer_size + cache_buffer_size;
|
|
|
|
/* Make a buffer holder. */
|
|
BufferHolder buffer_holder(m_allocator, total_buffer_size);
|
|
R_UNLESS(buffer_holder.IsValid(), fs::ResultAllocationFailureInNcaFileSystemDriverI());
|
|
|
|
/* Make the data storage. */
|
|
std::unique_ptr data_storage = std::make_unique<fs::SubStorage>(base_storage.get(), data_region.offset, data_region.size);
|
|
R_UNLESS(data_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Make the verification storage. */
|
|
std::unique_ptr verification_storage = std::make_unique<VerificationStorage>();
|
|
R_UNLESS(verification_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Make layer storages. */
|
|
fs::MemoryStorage master_hash_storage(std::addressof(hash_data.fs_data_master_hash), sizeof(Hash));
|
|
fs::SubStorage layer_hash_storage(base_storage.get(), hash_region.offset, hash_region.size);
|
|
fs::IStorage *storages[VerificationStorage::LayerCount] = {
|
|
std::addressof(master_hash_storage),
|
|
std::addressof(layer_hash_storage),
|
|
data_storage.get()
|
|
};
|
|
|
|
/* Initialize the verification storage. */
|
|
R_TRY(verification_storage->Initialize(storages, VerificationStorage::LayerCount, hash_data.hash_block_size, buffer_holder.Get(), hash_buffer_size));
|
|
|
|
/* Make the cache storage. */
|
|
std::unique_ptr cache_storage = std::make_unique<CacheStorage>(verification_storage.get(), hash_data.hash_block_size, buffer_holder.Get() + hash_buffer_size, cache_buffer_size, CacheBlockCount);
|
|
R_UNLESS(cache_storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Make the storage holder. */
|
|
std::unique_ptr storage = std::make_unique<StorageHolder>(cache_storage.get(), hash_data.hash_block_size, m_reader);
|
|
R_UNLESS(storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Set the storage holder's data. */
|
|
storage->Set(std::move(base_storage), std::move(data_storage), std::move(verification_storage), std::move(cache_storage));
|
|
storage->Set(std::move(buffer_holder));
|
|
|
|
/* Set the output. */
|
|
*out = std::move(storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::CreateIntegrityVerificationStorage(std::unique_ptr<fs::IStorage> *out, std::unique_ptr<fs::IStorage> base_storage, NcaFsHeaderReader *header_reader) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(base_storage != nullptr);
|
|
AMS_ASSERT(header_reader != nullptr);
|
|
|
|
/* Define storage types. */
|
|
using VerificationStorage = save::HierarchicalIntegrityVerificationStorage;
|
|
using StorageInfo = VerificationStorage::HierarchicalStorageInformation;
|
|
using StorageHolder = DerivedStorageHolder<IntegrityRomFsStorage, 1>;
|
|
|
|
/* Get and validate the hash data. */
|
|
auto &hash_data = header_reader->GetHashData().integrity_meta_info;
|
|
save::HierarchicalIntegrityVerificationInformation level_hash_info;
|
|
std::memcpy(std::addressof(level_hash_info), std::addressof(hash_data.level_hash_info), sizeof(level_hash_info));
|
|
|
|
R_UNLESS(save::IntegrityMinLayerCount <= level_hash_info.max_layers, fs::ResultInvalidHierarchicalIntegrityVerificationLayerCount());
|
|
R_UNLESS(level_hash_info.max_layers <= save::IntegrityMaxLayerCount, fs::ResultInvalidHierarchicalIntegrityVerificationLayerCount());
|
|
|
|
/* Create storage info. */
|
|
StorageInfo storage_info;
|
|
for (s32 i = 0; i < static_cast<s32>(level_hash_info.max_layers - 2); ++i) {
|
|
const auto &layer_info = level_hash_info.info[i];
|
|
storage_info[i + 1] = fs::SubStorage(base_storage.get(), layer_info.offset, layer_info.size);
|
|
}
|
|
|
|
/* Set the last layer info. */
|
|
const auto &layer_info = level_hash_info.info[level_hash_info.max_layers - 2];
|
|
storage_info.SetDataStorage(fs::SubStorage(base_storage.get(), layer_info.offset, layer_info.size));
|
|
|
|
/* Make the storage holder. */
|
|
std::unique_ptr storage = std::make_unique<StorageHolder>(m_reader);
|
|
R_UNLESS(storage != nullptr, fs::ResultAllocationFailureInNew());
|
|
|
|
/* Initialize the integrity storage. */
|
|
R_TRY(storage->Initialize(level_hash_info, hash_data.master_hash, storage_info, m_buffer_manager));
|
|
|
|
/* Set the storage holder's data. */
|
|
storage->Set(std::move(base_storage));
|
|
|
|
/* Set the output. */
|
|
*out = std::move(storage);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result NcaFileSystemDriver::SetupFsHeaderReader(NcaFsHeaderReader *out, const NcaReader &reader, s32 fs_index) {
|
|
/* Validate preconditions. */
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(0 <= fs_index && fs_index < NcaHeader::FsCountMax);
|
|
|
|
/* Validate magic. */
|
|
R_UNLESS(reader.GetMagic() == NcaHeader::Magic, fs::ResultUnsupportedVersion());
|
|
|
|
/* Check that the fs header exists. */
|
|
R_UNLESS(reader.HasFsInfo(fs_index), fs::ResultPartitionNotFound());
|
|
|
|
/* Initialize the reader. */
|
|
R_TRY(out->Initialize(reader, fs_index));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
}
|