OmniNX/Atmosphere
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

crypto: add aes (ecb, ctr, xts)

Browse Source
This commit is contained in:
Michael Scire
2020-04-05 23:25:28 -07:00
parent 8d1ada2a1b
commit e04679f05a
19 changed files with 3191 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
libraries/libvapours/include/vapours/crypto/impl/crypto_aes_impl.hpp Normal file
View File

@@ -0,0 +1,47 @@
/*
* Copyright (c) 2018-2020 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/common.hpp>
#include <vapours/assert.hpp>
#include <vapours/util.hpp>
namespace ams::crypto::impl {
template<size_t _KeySize>
class AesImpl {
public:
static constexpr size_t KeySize = _KeySize;
static constexpr size_t BlockSize = 16;
static constexpr s32 RoundCount = (KeySize / 4) + 6;
static constexpr size_t RoundKeySize = BlockSize * (RoundCount + 1);
private:
u32 round_keys[RoundKeySize / sizeof(u32)];
public:
~AesImpl();
void Initialize(const void *key, size_t key_size, bool is_encrypt);
void EncryptBlock(void *dst, size_t dst_size, const void *src, size_t src_size) const;
void DecryptBlock(void *dst, size_t dst_size, const void *src, size_t src_size) const;
const u8 *GetRoundKey() const {
return reinterpret_cast<const u8 *>(this->round_keys);
}
};
/* static_assert(HashFunction<Sha1Impl>); */
}

179
libraries/libvapours/include/vapours/crypto/impl/crypto_ctr_mode_impl.hpp Normal file
View File

@@ -0,0 +1,179 @@
/*
* Copyright (c) 2018-2020 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/common.hpp>
#include <vapours/assert.hpp>
#include <vapours/util.hpp>
#include <vapours/crypto/crypto_memory_clear.hpp>
#include <vapours/crypto/crypto_aes_encryptor.hpp>
namespace ams::crypto::impl {
template<typename BlockCipher>
class CtrModeImpl {
NON_COPYABLE(CtrModeImpl);
NON_MOVEABLE(CtrModeImpl);
public:
static constexpr size_t KeySize = BlockCipher::KeySize;
static constexpr size_t BlockSize = BlockCipher::BlockSize;
static constexpr size_t IvSize = BlockCipher::BlockSize;
private:
enum State {
State_None,
State_Initialized,
};
private:
const BlockCipher *block_cipher;
u8 counter[IvSize];
u8 encrypted_counter[BlockSize];
size_t buffer_offset;
State state;
public:
CtrModeImpl() : state(State_None) { /* ... */ }
~CtrModeImpl() {
ClearMemory(this, sizeof(*this));
}
void Initialize(const BlockCipher *block_cipher, const void *iv, size_t iv_size) {
this->Initialize(block_cipher, iv, iv_size, 0);
}
void Initialize(const BlockCipher *block_cipher, const void *iv, size_t iv_size, s64 offset) {
AMS_ASSERT(iv_size == IvSize);
AMS_ASSERT(offset >= 0);
this->block_cipher = block_cipher;
this->state = State_Initialized;
this->SwitchMessage(iv, iv_size);
if (offset >= 0) {
u64 ctr_offset = offset / BlockSize;
if (ctr_offset > 0) {
this->IncrementCounter(ctr_offset);
}
if (size_t remaining = static_cast<size_t>(offset % BlockSize); remaining != 0) {
this->block_cipher->EncryptBlock(this->encrypted_counter, sizeof(this->encrypted_counter), this->counter, sizeof(this->counter));
this->IncrementCounter();
this->buffer_offset = remaining;
}
}
}
void SwitchMessage(const void *iv, size_t iv_size) {
AMS_ASSERT(this->state == State_Initialized);
AMS_ASSERT(iv_size == IvSize);
std::memcpy(this->counter, iv, iv_size);
this->buffer_offset = 0;
}
void IncrementCounter() {
for (s32 i = IvSize - 1; i >= 0; --i) {
if (++this->counter[i] != 0) {
break;
}
}
}
size_t Update(void *_dst, size_t dst_size, const void *_src, size_t src_size) {
AMS_ASSERT(this->state == State_Initialized);
AMS_ASSERT(dst_size >= src_size);
u8 *dst = static_cast<u8 *>(_dst);
const u8 *src = static_cast<const u8 *>(_src);
size_t remaining = src_size;
if (this->buffer_offset > 0) {
const size_t xor_size = std::min(BlockSize - this->buffer_offset, remaining);
const u8 *ctr = this->encrypted_counter + this->buffer_offset;
for (size_t i = 0; i < xor_size; i++) {
dst[i] = src[i] ^ ctr[i];
}
src += xor_size;
dst += xor_size;
remaining -= xor_size;
this->buffer_offset += xor_size;
if (this->buffer_offset == BlockSize) {
this->buffer_offset = 0;
}
}
if (remaining >= BlockSize) {
const size_t num_blocks = remaining / BlockSize;
this->ProcessBlocks(dst, src, num_blocks);
const size_t processed_size = num_blocks * BlockSize;
dst += processed_size;
src += processed_size;
remaining -= processed_size;
}
if (remaining > 0) {
this->ProcessBlock(dst, src, remaining);
this->buffer_offset = remaining;
}
return src_size;
}
private:
void IncrementCounter(u64 count) {
u64 _block[IvSize / sizeof(u64)] = {};
util::StoreBigEndian(std::addressof(_block[(IvSize / sizeof(u64)) - 1]), count);
u16 acc;
const u8 *block = reinterpret_cast<const u8 *>(_block);
for (s32 i = IvSize - 1; i >= 0; --i) {
acc += (this->counter[i] + block[i]);
this->counter[i] = acc & 0xFF;
acc >>= 8;
}
}
void ProcessBlock(u8 *dst, const u8 *src, size_t src_size) {
this->block_cipher->EncryptBlock(this->encrypted_counter, BlockSize, this->counter, IvSize);
this->IncrementCounter();
for (size_t i = 0; i < src_size; i++) {
dst[i] = src[i] ^ this->encrypted_counter[i];
}
}
void ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks);
};
template<typename BlockCipher>
inline void CtrModeImpl<BlockCipher>::ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks) {
while (num_blocks--) {
this->ProcessBlock(dst, src, BlockSize);
dst += BlockSize;
src += BlockSize;
}
}
template<> void CtrModeImpl<AesEncryptor128>::ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks);
template<> void CtrModeImpl<AesEncryptor192>::ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks);
template<> void CtrModeImpl<AesEncryptor256>::ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks);
}

135
libraries/libvapours/include/vapours/crypto/impl/crypto_xts_mode_impl.hpp Normal file
View File

@@ -0,0 +1,135 @@
/*
* Copyright (c) 2018-2020 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/common.hpp>
#include <vapours/assert.hpp>
#include <vapours/util.hpp>
#include <vapours/crypto/crypto_memory_clear.hpp>
#include <vapours/crypto/crypto_aes_encryptor.hpp>
namespace ams::crypto::impl {
class XtsModeImpl {
NON_COPYABLE(XtsModeImpl);
NON_MOVEABLE(XtsModeImpl);
public:
/* TODO: More generic support. */
static constexpr size_t BlockSize = 16;
static constexpr size_t IvSize = 16;
private:
enum State {
State_None,
State_Initialized,
State_Processing,
State_Done
};
private:
u8 buffer[BlockSize];
u8 tweak[BlockSize];
u8 last_block[BlockSize];
size_t num_buffered;
const void *cipher_ctx;
void (*cipher_func)(void *dst_block, const void *src_block, const void *cipher_ctx);
State state;
public:
XtsModeImpl() : num_buffered(0), state(State_None) { /* ... */ }
~XtsModeImpl() {
ClearMemory(this, sizeof(*this));
}
private:
template<typename BlockCipher>
static void EncryptBlockCallback(void *dst_block, const void *src_block, const void *cipher) {
return static_cast<const BlockCipher *>(cipher)->EncryptBlock(dst_block, BlockCipher::BlockSize, src_block, BlockCipher::BlockSize);
}
template<typename BlockCipher>
static void DecryptBlockCallback(void *dst_block, const void *src_block, const void *cipher) {
return static_cast<const BlockCipher *>(cipher)->DecryptBlock(dst_block, BlockCipher::BlockSize, src_block, BlockCipher::BlockSize);
}
template<typename BlockCipher>
void Initialize(const BlockCipher *cipher, const void *tweak, size_t tweak_size) {
AMS_ASSERT(tweak_size == IvSize);
cipher->EncryptBlock(this->tweak, IvSize, tweak, IvSize);
this->num_buffered = 0;
this->state = State_Initialized;
}
void ProcessBlock(u8 *dst, const u8 *src);
public:
template<typename BlockCipher1, typename BlockCipher2>
void InitializeEncryption(const BlockCipher1 *cipher1, const BlockCipher2 *cipher2, const void *tweak, size_t tweak_size) {
static_assert(BlockCipher1::BlockSize == BlockSize);
static_assert(BlockCipher2::BlockSize == BlockSize);
this->cipher_ctx = cipher1;
this->cipher_func = EncryptBlockCallback<BlockCipher1>;
this->Initialize(cipher2, tweak, tweak_size);
}
template<typename BlockCipher1, typename BlockCipher2>
void InitializeDecryption(const BlockCipher1 *cipher1, const BlockCipher2 *cipher2, const void *tweak, size_t tweak_size) {
static_assert(BlockCipher1::BlockSize == BlockSize);
static_assert(BlockCipher2::BlockSize == BlockSize);
this->cipher_ctx = cipher1;
this->cipher_func = DecryptBlockCallback<BlockCipher1>;
this->Initialize(cipher2, tweak, tweak_size);
}
template<typename BlockCipher>
size_t Update(void *dst, size_t dst_size, const void *src, size_t src_size) {
return this->UpdateGeneric(dst, dst_size, src, src_size);
}
template<typename BlockCipher>
size_t ProcessBlocks(u8 *dst, const u8 *src, size_t num_blocks) {
return this->ProcessBlocksGeneric(dst, src, num_blocks);
}
size_t GetBufferedDataSize() const {
return this->num_buffered;
}
constexpr size_t GetBlockSize() const {
return BlockSize;
}
size_t FinalizeEncryption(void *dst, size_t dst_size);
size_t FinalizeDecryption(void *dst, size_t dst_size);
size_t UpdateGeneric(void *dst, size_t dst_size, const void *src, size_t src_size);
size_t ProcessBlocksGeneric(u8 *dst, const u8 *src, size_t num_blocks);
size_t ProcessPartialData(u8 *dst, const u8 *src, size_t size);
size_t ProcessRemainingData(u8 *dst, const u8 *src, size_t size);
};
template<> size_t XtsModeImpl::Update<AesEncryptor128>(void *dst, size_t dst_size, const void *src, size_t src_size);
template<> size_t XtsModeImpl::Update<AesEncryptor192>(void *dst, size_t dst_size, const void *src, size_t src_size);
template<> size_t XtsModeImpl::Update<AesEncryptor256>(void *dst, size_t dst_size, const void *src, size_t src_size);
template<> size_t XtsModeImpl::Update<AesDecryptor128>(void *dst, size_t dst_size, const void *src, size_t src_size);
template<> size_t XtsModeImpl::Update<AesDecryptor192>(void *dst, size_t dst_size, const void *src, size_t src_size);
template<> size_t XtsModeImpl::Update<AesDecryptor256>(void *dst, size_t dst_size, const void *src, size_t src_size);
}