diff --git a/src/xenia/kernel/xboxkrnl_crypt.cc b/src/xenia/kernel/xboxkrnl_crypt.cc index c41914610..b52053191 100644 --- a/src/xenia/kernel/xboxkrnl_crypt.cc +++ b/src/xenia/kernel/xboxkrnl_crypt.cc @@ -13,27 +13,119 @@ #include "xenia/kernel/xboxkrnl_private.h" #include "xenia/xbox.h" +#include "third_party/crypto/TinySHA1.hpp" + namespace xe { namespace kernel { typedef struct { - xe::be count; - xe::be state[5]; - uint8_t buffer[64]; + xe::be count; // 0x0 + xe::be state[5]; // 0x4 + uint8_t buffer[64]; // 0x18 } XECRYPT_SHA_STATE; +void InitSha1(sha1::SHA1& sha, const XECRYPT_SHA_STATE* state) { + uint32_t digest[5]; + for (int i = 0; i < 5; i++) { + digest[i] = state->state[i]; + } + + sha.init(digest, state->buffer, state->count); +} + +void StoreSha1(sha1::SHA1& sha, XECRYPT_SHA_STATE* state) { + for (int i = 0; i < 5; i++) { + state->state[i] = sha.getDigest()[i]; + } + + state->count = (uint32_t)sha.getByteCount(); + std::memcpy(state->buffer, sha.getBlock(), sha.getBlockByteIndex()); +} + void XeCryptShaInit(pointer_t sha_state) { sha_state.Zero(); + + sha_state->state[0] = 0x67452301; + sha_state->state[1] = 0xEFCDAB89; + sha_state->state[2] = 0x98BADCFE; + sha_state->state[3] = 0x10325476; + sha_state->state[4] = 0xC3D2E1F0; } -DECLARE_XBOXKRNL_EXPORT(XeCryptShaInit, ExportTag::kStub); +DECLARE_XBOXKRNL_EXPORT(XeCryptShaInit, ExportTag::kImplemented); void XeCryptShaUpdate(pointer_t sha_state, lpvoid_t input, - dword_t input_size) {} -DECLARE_XBOXKRNL_EXPORT(XeCryptShaUpdate, ExportTag::kStub); + dword_t input_size) { + sha1::SHA1 sha; + InitSha1(sha, sha_state); -void XeCryptShaFinal(pointer_t sha_state, lpvoid_t out, - dword_t out_size) {} -DECLARE_XBOXKRNL_EXPORT(XeCryptShaFinal, ExportTag::kStub); + sha.processBytes(input, input_size); + + StoreSha1(sha, sha_state); +} +DECLARE_XBOXKRNL_EXPORT(XeCryptShaUpdate, ExportTag::kImplemented); + +void XeCryptShaFinal(pointer_t sha_state, + pointer_t> out, dword_t out_size) { + sha1::SHA1 sha; + InitSha1(sha, sha_state); + + uint32_t digest[5]; + sha.finalize(digest); + + for (int i = 0; i < 5; i++) { + sha_state->state[i] = digest[i]; + } + + for (uint32_t i = 0; i < out_size / 4; i++) { + out[i] = digest[i]; + } +} +DECLARE_XBOXKRNL_EXPORT(XeCryptShaFinal, ExportTag::kImplemented); + +void XeCryptSha(lpvoid_t input_1, dword_t input_1_size, lpvoid_t input_2, + dword_t input_2_size, lpvoid_t input_3, dword_t input_3_size, + pointer_t> output, dword_t output_size) { + sha1::SHA1 sha; + + if (input_1 && input_1_size) { + sha.processBytes(input_1, input_1_size); + } + if (input_2 && input_2_size) { + sha.processBytes(input_2, input_2_size); + } + if (input_3 && input_3_size) { + sha.processBytes(input_3, input_3_size); + } + + uint32_t digest[5]; + sha.finalize(digest); + + for (uint32_t i = 0; i < output_size / 4; i++) { + output[i] = digest[i]; + } +} +DECLARE_XBOXKRNL_EXPORT(XeCryptSha, ExportTag::kImplemented); + +// Byteswap? +dword_result_t XeCryptBnQw_SwapDwQwLeBe(const lpqword_t qw_inp, + lpqword_t qw_out, dword_t size) { + return 0; +} +DECLARE_XBOXKRNL_EXPORT(XeCryptBnQw_SwapDwQwLeBe, ExportTag::kStub); + +dword_result_t XeCryptBnQwNeRsaPubCrypt(const lpqword_t qw_a, lpqword_t qw_b, + const lpvoid_t rsa) { + // 0 indicates failure (but not a BOOL return value) + return 1; +} +DECLARE_XBOXKRNL_EXPORT(XeCryptBnQwNeRsaPubCrypt, ExportTag::kStub); + +dword_result_t XeCryptBnDwLePkcs1Verify(const lpvoid_t hash, const lpvoid_t sig, + const dword_t size) { + // BOOL return value + return 1; +} +DECLARE_XBOXKRNL_EXPORT(XeCryptBnDwLePkcs1Verify, ExportTag::kStub); void xe::kernel::xboxkrnl::RegisterCryptExports( xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {} diff --git a/third_party/crypto/TinySHA1.hpp b/third_party/crypto/TinySHA1.hpp new file mode 100644 index 000000000..2493e88f3 --- /dev/null +++ b/third_party/crypto/TinySHA1.hpp @@ -0,0 +1,223 @@ +/* + * + * TinySHA1 - a header only implementation of the SHA1 algorithm in C++. Based + * on the implementation in boost::uuid::details. + * + * SHA1 Wikipedia Page: http://en.wikipedia.org/wiki/SHA-1 + * + * Copyright (c) 2012-22 SAURAV MOHAPATRA + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Taken from https://github.com/mohaps/TinySHA1 + * Modified for use by Xenia + */ +#ifndef _TINY_SHA1_HPP_ +#define _TINY_SHA1_HPP_ + +#include +#include +#include +#include + +namespace sha1 { +class SHA1 { + public: + typedef uint32_t digest32_t[5]; + typedef uint8_t digest8_t[20]; + inline static uint32_t LeftRotate(uint32_t value, size_t count) { + return (value << count) ^ (value >> (32 - count)); + } + SHA1() { reset(); } + virtual ~SHA1() {} + SHA1(const SHA1& s) { *this = s; } + const SHA1& operator=(const SHA1& s) { + memcpy(m_digest, s.m_digest, 5 * sizeof(uint32_t)); + memcpy(m_block, s.m_block, 64); + m_blockByteIndex = s.m_blockByteIndex; + m_byteCount = s.m_byteCount; + + return *this; + } + + SHA1& init(const uint32_t digest[5], const uint8_t block[64], + uint32_t count) { + std::memcpy(m_digest, digest, 20); + std::memcpy(m_block, block, count % 64); + m_byteCount = count; + m_blockByteIndex = count % 64; + + return *this; + } + + const uint32_t* getDigest() const { return m_digest; } + const uint8_t* getBlock() const { return m_block; } + size_t getBlockByteIndex() const { return m_blockByteIndex; } + size_t getByteCount() const { return m_byteCount; } + + SHA1& reset() { + m_digest[0] = 0x67452301; + m_digest[1] = 0xEFCDAB89; + m_digest[2] = 0x98BADCFE; + m_digest[3] = 0x10325476; + m_digest[4] = 0xC3D2E1F0; + m_blockByteIndex = 0; + m_byteCount = 0; + return *this; + } + + SHA1& processByte(uint8_t octet) { + this->m_block[this->m_blockByteIndex++] = octet; + ++this->m_byteCount; + if (m_blockByteIndex == 64) { + this->m_blockByteIndex = 0; + processBlock(); + } + + return *this; + } + + SHA1& processBlock(const void* const start, const void* const end) { + const uint8_t* begin = static_cast(start); + const uint8_t* finish = static_cast(end); + while (begin != finish) { + processByte(*begin); + begin++; + } + return *this; + } + + SHA1& processBytes(const void* const data, size_t len) { + const uint8_t* block = static_cast(data); + processBlock(block, block + len); + return *this; + } + + const uint32_t* finalize(digest32_t digest) { + size_t bitCount = this->m_byteCount * 8; + processByte(0x80); + if (this->m_blockByteIndex > 56) { + while (m_blockByteIndex != 0) { + processByte(0); + } + while (m_blockByteIndex < 56) { + processByte(0); + } + } else { + while (m_blockByteIndex < 56) { + processByte(0); + } + } + processByte(0); + processByte(0); + processByte(0); + processByte(0); + processByte(static_cast((bitCount >> 24) & 0xFF)); + processByte(static_cast((bitCount >> 16) & 0xFF)); + processByte(static_cast((bitCount >> 8) & 0xFF)); + processByte(static_cast((bitCount)&0xFF)); + + memcpy(digest, m_digest, 5 * sizeof(uint32_t)); + return digest; + } + + const uint8_t* finalize(digest8_t digest) { + digest32_t d32; + finalize(d32); + size_t di = 0; + digest[di++] = ((d32[0] >> 24) & 0xFF); + digest[di++] = ((d32[0] >> 16) & 0xFF); + digest[di++] = ((d32[0] >> 8) & 0xFF); + digest[di++] = ((d32[0]) & 0xFF); + + digest[di++] = ((d32[1] >> 24) & 0xFF); + digest[di++] = ((d32[1] >> 16) & 0xFF); + digest[di++] = ((d32[1] >> 8) & 0xFF); + digest[di++] = ((d32[1]) & 0xFF); + + digest[di++] = ((d32[2] >> 24) & 0xFF); + digest[di++] = ((d32[2] >> 16) & 0xFF); + digest[di++] = ((d32[2] >> 8) & 0xFF); + digest[di++] = ((d32[2]) & 0xFF); + + digest[di++] = ((d32[3] >> 24) & 0xFF); + digest[di++] = ((d32[3] >> 16) & 0xFF); + digest[di++] = ((d32[3] >> 8) & 0xFF); + digest[di++] = ((d32[3]) & 0xFF); + + digest[di++] = ((d32[4] >> 24) & 0xFF); + digest[di++] = ((d32[4] >> 16) & 0xFF); + digest[di++] = ((d32[4] >> 8) & 0xFF); + digest[di++] = ((d32[4]) & 0xFF); + return digest; + } + + protected: + void processBlock() { + uint32_t w[80]; + for (size_t i = 0; i < 16; i++) { + w[i] = (m_block[i * 4 + 0] << 24); + w[i] |= (m_block[i * 4 + 1] << 16); + w[i] |= (m_block[i * 4 + 2] << 8); + w[i] |= (m_block[i * 4 + 3]); + } + for (size_t i = 16; i < 80; i++) { + w[i] = LeftRotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1); + } + + uint32_t a = m_digest[0]; + uint32_t b = m_digest[1]; + uint32_t c = m_digest[2]; + uint32_t d = m_digest[3]; + uint32_t e = m_digest[4]; + + for (std::size_t i = 0; i < 80; ++i) { + uint32_t f = 0; + uint32_t k = 0; + + if (i < 20) { + f = (b & c) | (~b & d); + k = 0x5A827999; + } else if (i < 40) { + f = b ^ c ^ d; + k = 0x6ED9EBA1; + } else if (i < 60) { + f = (b & c) | (b & d) | (c & d); + k = 0x8F1BBCDC; + } else { + f = b ^ c ^ d; + k = 0xCA62C1D6; + } + uint32_t temp = LeftRotate(a, 5) + f + e + k + w[i]; + e = d; + d = c; + c = LeftRotate(b, 30); + b = a; + a = temp; + } + + m_digest[0] += a; + m_digest[1] += b; + m_digest[2] += c; + m_digest[3] += d; + m_digest[4] += e; + } + + private: + digest32_t m_digest; + uint8_t m_block[64]; + size_t m_blockByteIndex; + size_t m_byteCount; +}; +} +#endif