mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2024-12-19 00:42:06 +00:00
Code Issues Releases Activity

fs: add Sha256HashGenerator, LZ4 decompressor

Browse source
This commit is contained in:
Michael Scire 2021-12-14 08:51:27 -08:00 committed by SciresM
parent a2aec363d7
commit 01f7f567b9
11 changed files with 165 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libraries/libstratosphere/include/stratosphere/fssystem.hpp
View file

@ -48,4 +48,5 @@
#include <stratosphere/fssystem/save/fssystem_buffered_storage.hpp>
#include <stratosphere/fssystem/save/fssystem_hierarchical_integrity_verification_storage.hpp>
#include <stratosphere/fssystem/fssystem_integrity_romfs_storage.hpp>
#include <stratosphere/fssystem/fssystem_sha256_hash_generator.hpp>
#include <stratosphere/fssystem/fssystem_file_system_proxy_api.hpp>

2
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_compressed_storage.hpp
View file

@ -66,6 +66,7 @@ namespace ams::fssystem {
public:
virtual Result QueryAppropriateOffset(s64 *out, s64 offset, s64 access_size, s64 alignment_size) override {
AMS_ABORT("TODO");
AMS_UNUSED(out, offset, access_size, alignment_size);
/* return m_core.QueryAppropriateOffsetForAsynchronousAccess(out, offset, access_size, alignment_size); */
}
public:
@ -74,6 +75,7 @@ namespace ams::fssystem {
virtual Result GetSize(s64 *out) override {
AMS_ABORT("TODO");
AMS_UNUSED(out);
/* return m_core.GetSize(out); */
}

2
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_compression_common.hpp
View file

@ -40,7 +40,7 @@ namespace ams::fssystem {
}
constexpr bool IsRandomAccessible(CompressionType type) {
return CompressionType_None;
return type == CompressionType_None;
}
constexpr bool IsUnknownType(CompressionType type) {

71
libraries/libstratosphere/include/stratosphere/fssystem/fssystem_sha256_hash_generator.hpp Normal file
View file

@ -0,0 +1,71 @@
/*
* 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/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/fssystem/fssystem_i_hash_256_generator.hpp>
namespace ams::fssystem {
class Sha256HashGenerator final : public ::ams::fssystem::IHash256Generator, public ::ams::fs::impl::Newable {
NON_COPYABLE(Sha256HashGenerator);
NON_MOVEABLE(Sha256HashGenerator);
private:
crypto::Sha256Generator m_generator;
public:
Sha256HashGenerator() = default;
protected:
virtual void DoInitialize() override {
m_generator.Initialize();
}
virtual void DoUpdate(const void *data, size_t size) override {
m_generator.Update(data, size);
}
virtual void DoGetHash(void *dst, size_t dst_size) override {
m_generator.GetHash(dst, dst_size);
}
};
class Sha256HashGeneratorFactory final : public IHash256GeneratorFactory, public ::ams::fs::impl::Newable {
NON_COPYABLE(Sha256HashGeneratorFactory);
NON_MOVEABLE(Sha256HashGeneratorFactory);
public:
Sha256HashGeneratorFactory() = default;
protected:
virtual std::unique_ptr<IHash256Generator> DoCreate() override {
return std::unique_ptr<IHash256Generator>(new Sha256HashGenerator());
}
virtual void DoGenerateHash(void *dst, size_t dst_size, const void *src, size_t src_size) override {
crypto::GenerateSha256Hash(dst, dst_size, src, src_size);
}
};
class Sha256HashGeneratorFactorySelector final : public IHash256GeneratorFactorySelector, public ::ams::fs::impl::Newable {
NON_COPYABLE(Sha256HashGeneratorFactorySelector);
NON_MOVEABLE(Sha256HashGeneratorFactorySelector);
private:
Sha256HashGeneratorFactory m_factory;
public:
Sha256HashGeneratorFactorySelector() = default;
protected:
virtual IHash256GeneratorFactory *DoGetFactory() override {
return std::addressof(m_factory);
}
};
}

2
libraries/libstratosphere/include/stratosphere/fssystem/save/fssystem_integrity_verification_storage.hpp
View file

@ -82,7 +82,7 @@ namespace ams::fssystem::save {
void CalcBlockHash(BlockHash *out, const void *buffer, size_t block_size, std::unique_ptr<fssystem::IHash256Generator> &generator) const;
void CalcBlockHash(BlockHash *out, const void *buffer, std::unique_ptr<fssystem::IHash256Generator> &generator) const {
return this->CalcBlockHash(out, buffer, static_cast<size_t>(m_verification_block_size));
return this->CalcBlockHash(out, buffer, static_cast<size_t>(m_verification_block_size), generator);
}
Result IsCleared(bool *is_cleared, const BlockHash &hash);

34
libraries/libstratosphere/source/fs/impl/fs_hash_generator_factory_selector.cpp Normal file
View file

@ -0,0 +1,34 @@
/*
* 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>
namespace ams::fs::impl {
namespace {
constinit fssystem::Sha256HashGeneratorFactorySelector g_sha256_hash_generator_factory_selector;
}
fssystem::IHash256GeneratorFactorySelector *GetNcaHashGeneratorFactorySelector() {
return std::addressof(g_sha256_hash_generator_factory_selector);
}
fssystem::IHash256GeneratorFactorySelector *GetSaveDataHashGeneratorFactorySelector() {
return std::addressof(g_sha256_hash_generator_factory_selector);
}
}

47
libraries/libstratosphere/source/fssystem/fssystem_compression_configuration.cpp Normal file
View file

@ -0,0 +1,47 @@
/*
* 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_key_slot_cache.hpp"
namespace ams::fssystem {
namespace {
Result DecompressLz4(void *dst, size_t dst_size, const void *src, size_t src_size) {
R_UNLESS(util::DecompressLZ4(dst, dst_size, src, src_size) == static_cast<int>(dst_size), fs::ResultUnexpectedInCompressedStorageC());
return ResultSuccess();
}
constexpr DecompressorFunction GetNcaDecompressorFunction(CompressionType type) {
switch (type) {
case CompressionType_Lz4:
return DecompressLz4;
default:
return nullptr;
}
}
constexpr NcaCompressionConfiguration g_nca_compression_configuration {
.get_decompressor = GetNcaDecompressorFunction,
};
}
const ::ams::fssystem::NcaCompressionConfiguration *GetNcaCompressionConfiguration() {
return std::addressof(g_nca_compression_configuration);
}
}

2
libraries/libvapours/include/vapours/crypto/impl/crypto_sha1_impl.hpp
View file

@ -39,7 +39,7 @@ namespace ams::crypto::impl {
private:
State m_state;
public:
Sha1Impl() { /* ... */ }
Sha1Impl() { m_state.finalized = false; }
~Sha1Impl() {
static_assert(std::is_trivially_destructible<State>::value);
ClearMemory(std::addressof(m_state), sizeof(m_state));

2
libraries/libvapours/include/vapours/crypto/impl/crypto_sha256_impl.hpp
View file

@ -44,7 +44,7 @@ namespace ams::crypto::impl {
private:
State m_state;
public:
Sha256Impl() { /* ... */ }
Sha256Impl() { m_state.finalized = false; }
~Sha256Impl() {
static_assert(std::is_trivially_destructible<State>::value);
ClearMemory(std::addressof(m_state), sizeof(m_state));

9
libraries/libvapours/include/vapours/results/fs_results.hpp
View file

@ -284,9 +284,12 @@ namespace ams::fs {
R_DEFINE_ERROR_RESULT(GameCardLogoDataCorrupted, 4781);
R_DEFINE_ERROR_RANGE(Unexpected, 5000, 5999);
R_DEFINE_ERROR_RESULT(UnexpectedInAesCtrStorageA, 5315);
R_DEFINE_ERROR_RESULT(UnexpectedInAesXtsStorageA, 5316);
R_DEFINE_ERROR_RESULT(UnexpectedInFindFileSystemA, 5319);
R_DEFINE_ERROR_RESULT(UnexpectedInAesCtrStorageA, 5315);
R_DEFINE_ERROR_RESULT(UnexpectedInAesXtsStorageA, 5316);
R_DEFINE_ERROR_RESULT(UnexpectedInFindFileSystemA, 5319);
R_DEFINE_ERROR_RESULT(UnexpectedInCompressedStorageA, 5324);
R_DEFINE_ERROR_RESULT(UnexpectedInCompressedStorageB, 5325);
R_DEFINE_ERROR_RESULT(UnexpectedInCompressedStorageC, 5326);
R_DEFINE_ERROR_RANGE(PreconditionViolation, 6000, 6499);
R_DEFINE_ERROR_RANGE(InvalidArgument, 6001, 6199);

1
libraries/libvapours/source/crypto/impl/crypto_xts_mode_impl.arch.arm64.cpp
View file

@ -21,7 +21,6 @@
namespace ams::crypto::impl {
/* Variable management macros. */
#define DECLARE_ROUND_KEY_VAR(n) \
const uint8x16_t round_key_##n = vld1q_u8(keys + (BlockSize * n))