You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
115 lines
3.6 KiB
115 lines
3.6 KiB
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cstring>
|
|
#include "core/crypto/ctr_encryption_layer.h"
|
|
|
|
namespace Core::Crypto {
|
|
|
|
CTREncryptionLayer::CTREncryptionLayer(FileSys::VirtualFile base_, Key128 key_,
|
|
std::size_t base_offset_)
|
|
: EncryptionLayer(std::move(base_)), base_offset(base_offset_), cipher(key_, Mode::CTR) {}
|
|
|
|
std::size_t CTREncryptionLayer::Read(u8* data, std::size_t length, std::size_t offset) const {
|
|
if (length == 0)
|
|
return 0;
|
|
|
|
constexpr std::size_t BlockSize = 0x10;
|
|
constexpr std::size_t MaxChunkSize = 0x10000;
|
|
|
|
std::size_t total_read = 0;
|
|
auto* out = data;
|
|
std::size_t remaining = length;
|
|
std::size_t current_offset = offset;
|
|
|
|
const auto read_exact = [this](u8* dst, std::size_t bytes, std::size_t src_offset) {
|
|
std::size_t filled = 0;
|
|
while (filled < bytes) {
|
|
const std::size_t got = base->Read(dst + filled, bytes - filled, src_offset + filled);
|
|
if (got == 0)
|
|
break;
|
|
filled += got;
|
|
}
|
|
return filled;
|
|
};
|
|
|
|
if (const std::size_t intra_block = current_offset & (BlockSize - 1); intra_block != 0) {
|
|
std::array<u8, BlockSize> block{};
|
|
const std::size_t aligned_offset = current_offset - intra_block;
|
|
const std::size_t got = read_exact(block.data(), BlockSize, aligned_offset);
|
|
if (got <= intra_block)
|
|
return total_read;
|
|
|
|
UpdateIV(base_offset + aligned_offset);
|
|
cipher.Transcode(block.data(), got, block.data(), Op::Decrypt);
|
|
|
|
const std::size_t available = got - intra_block;
|
|
const std::size_t to_copy = std::min<std::size_t>(remaining, available);
|
|
std::memcpy(out, block.data() + intra_block, to_copy);
|
|
|
|
out += to_copy;
|
|
current_offset += to_copy;
|
|
remaining -= to_copy;
|
|
total_read += to_copy;
|
|
|
|
if (to_copy != available)
|
|
return total_read;
|
|
}
|
|
|
|
while (remaining >= BlockSize) {
|
|
const std::size_t chunk_request = std::min<std::size_t>(remaining, MaxChunkSize);
|
|
const std::size_t aligned_request = chunk_request - (chunk_request % BlockSize);
|
|
if (aligned_request == 0)
|
|
break;
|
|
|
|
const std::size_t got = read_exact(out, aligned_request, current_offset);
|
|
if (got == 0)
|
|
break;
|
|
|
|
UpdateIV(base_offset + current_offset);
|
|
cipher.Transcode(out, got, out, Op::Decrypt);
|
|
|
|
out += got;
|
|
current_offset += got;
|
|
remaining -= got;
|
|
total_read += got;
|
|
|
|
if (got < aligned_request)
|
|
return total_read;
|
|
}
|
|
|
|
if (remaining > 0) {
|
|
std::array<u8, BlockSize> block{};
|
|
const std::size_t got = read_exact(block.data(), BlockSize, current_offset);
|
|
if (got == 0)
|
|
return total_read;
|
|
|
|
UpdateIV(base_offset + current_offset);
|
|
cipher.Transcode(block.data(), got, block.data(), Op::Decrypt);
|
|
|
|
const std::size_t to_copy = std::min<std::size_t>(remaining, got);
|
|
std::memcpy(out, block.data(), to_copy);
|
|
total_read += to_copy;
|
|
}
|
|
|
|
return total_read;
|
|
}
|
|
|
|
void CTREncryptionLayer::SetIV(const IVData& iv_) {
|
|
iv = iv_;
|
|
}
|
|
|
|
void CTREncryptionLayer::UpdateIV(std::size_t offset) const {
|
|
offset >>= 4;
|
|
for (std::size_t i = 0; i < 8; ++i) {
|
|
iv[16 - i - 1] = offset & 0xFF;
|
|
offset >>= 8;
|
|
}
|
|
cipher.SetIV(iv);
|
|
}
|
|
} // namespace Core::Crypto
|