ShuriZma
/
Cxbx-Reloaded
mirror of https://github.com/Cxbx-Reloaded/Cxbx-Reloaded.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SHA1 implementation (SHA1 works, but RSA still doesn't)

This commit is contained in:
ergo720 2018-04-14 23:20:14 +02:00
parent 96dc895916
commit ecbab4fdec
9 changed files with 351 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/Common/Xbe.cpp
View File

@ -377,6 +377,17 @@ Xbe::Xbe(const char *x_szFilename, bool bFromGUI)
printf("OK\n");
}
// read the header to calculate the rsa/sha1 signature against
{
printf("Xbe::Xbe: Reading Signature Header...");
fseek(XbeFile, sizeof(m_Header.dwMagic) + sizeof(m_Header.pbDigitalSignature), SEEK_SET);
m_SignatureHeader = new uint08[m_Header.dwSizeofHeaders - (sizeof(m_Header.dwMagic) + sizeof(m_Header.pbDigitalSignature))];
fread(m_SignatureHeader, m_Header.dwSizeofHeaders - (sizeof(m_Header.dwMagic) + sizeof(m_Header.pbDigitalSignature)), 1, XbeFile);
printf("OK\n");
}
cleanup:
if (HasError())
@ -408,6 +419,7 @@ Xbe::~Xbe()
delete[] m_szSectionName;
delete[] m_SectionHeader;
delete[] m_HeaderEx;
delete[] m_SignatureHeader;
}
// export to Xbe file
@ -810,16 +822,12 @@ const wchar_t *Xbe::GetUnicodeFilenameAddr()
bool Xbe::CheckXbeSignature()
{
DWORD HeaderDigestSize = m_Header.dwSizeofHeaders - (sizeof(m_Header.dwMagic) + sizeof(m_Header.pbDigitalSignature));
SHA_CTX Context;
UCHAR SHADigest[A_SHA_DIGEST_LEN];
unsigned char crypt_buffer[256];
RSA_PUBLIC_KEY key;
memcpy(key.Default, (void*)xboxkrnl::XePublicKeyData, 284);
A_SHAInit(&Context);
A_SHAUpdate(&Context, (PUCHAR)&HeaderDigestSize, sizeof(DWORD));
A_SHAUpdate(&Context, (PUCHAR)&m_Header.dwBaseAddr, HeaderDigestSize);
A_SHAFinal(&Context, SHADigest);
CalcSHA1Hash(SHADigest, m_SignatureHeader, HeaderDigestSize);
RSAdecrypt(m_Header.pbDigitalSignature, crypt_buffer, key);
if (!Verifyhash(SHADigest, crypt_buffer, key)) {

3
src/Common/Xbe.h
View File

@ -241,6 +241,9 @@ class Xbe : public Error
#include "AlignPosfix1.h"
*m_TLS;
// Xbe signature header
uint08* m_SignatureHeader;
// Xbe section names, stored null terminated
char (*m_szSectionName)[10];

66
src/CxbxKrnl/CxbxKrnl.cpp
View File

@ -66,6 +66,7 @@ namespace xboxkrnl
#include "devices\EEPROMDevice.h" // For g_EEPROM
#include "devices\Xbox.h" // For InitXboxHardware()
#include "devices\LED.h" // For LED::Sequence
#include "EmuSha.h" // For the SHA1 functions
/*! thread local storage */
Xbe::TLS *CxbxKrnl_TLS = NULL;
@ -825,6 +826,26 @@ void CxbxKrnlMain(int argc, char* argv[])
EmuWarning("Missing RSA key. Unable to verify xbe signature");
}
// Check the integrity of the xbe sections
for (uint32 sectionIndex = 0; sectionIndex < CxbxKrnl_Xbe->m_Header.dwSections; sectionIndex++) {
uint32 RawSize = CxbxKrnl_Xbe->m_SectionHeader[sectionIndex].dwSizeofRaw;
if (RawSize == 0) {
continue;
}
UCHAR SHADigest[A_SHA_DIGEST_LEN];
CalcSHA1Hash(SHADigest, CxbxKrnl_Xbe->m_bzSection[sectionIndex], RawSize);
// temp
uint08* temp = (CxbxKrnl_Xbe->m_SectionHeader)[sectionIndex].bzSectionDigest;
if (memcmp(SHADigest, (CxbxKrnl_Xbe->m_SectionHeader)[sectionIndex].bzSectionDigest, A_SHA_DIGEST_LEN) != 0) {
EmuWarning("SHA hash of section %s doesn't match, possible section corruption",
(PCHAR)((CxbxKrnl_Xbe->m_SectionHeader)[sectionIndex].dwSectionNameAddr));
}
else {
printf("SHA hash check of section %s successful", (PCHAR)((CxbxKrnl_Xbe->m_SectionHeader)[sectionIndex].dwSectionNameAddr));
}
}
// Detect XBE type :
g_XbeType = GetXbeType(&CxbxKrnl_Xbe->m_Header);
@ -925,13 +946,12 @@ void CxbxKrnlMain(int argc, char* argv[])
void LoadXboxKeys(std::string path)
{
std::string keys_path = path + "\\keys.bin";
std::string RSA_key_path = path + "\\RSAkey.bin";
// Attempt to open Keys.bin
FILE* fp = fopen(keys_path.c_str(), "rb");
if (fp != nullptr) {
// Determine the size of Keys.bin
// Determine size of Keys.bin
xboxkrnl::XBOX_KEY_DATA keys[2];
fseek(fp, 0, SEEK_END);
long size = ftell(fp);
@ -943,49 +963,17 @@ void LoadXboxKeys(std::string path)
memcpy(xboxkrnl::XboxEEPROMKey, &keys[0], xboxkrnl::XBOX_KEY_LENGTH);
memcpy(xboxkrnl::XboxCertificateKey, &keys[1], xboxkrnl::XBOX_KEY_LENGTH);
} else {
}
else {
EmuWarning("Keys.bin has an incorrect filesize. Should be %d bytes", xboxkrnl::XBOX_KEY_LENGTH * 2);
}
fclose(fp);
}
else
{
// keys.bin could not be loaded
EmuWarning("Failed to load Keys.bin. Cxbx-Reloaded will be unable to read Save Data from a real Xbox");
return;
}
// Now load the RSA key data if available
fp = fopen(RSA_key_path.c_str(), "rb");
if (fp != nullptr) {
// Determine the size of RSAkey.bin
fseek(fp, 0, SEEK_END);
long size = ftell(fp);
rewind(fp);
// Ensure that RSAkey.bin is 284 bytes and has a valid magic signature
if (size == 284) {
UCHAR temp[284] = { 0 };
fread(temp, 284, 1, fp);
if (!memcmp(temp, "RSA1", 4)) {
memcpy(xboxkrnl::XePublicKeyData, temp, 284);
}
else {
EmuWarning("RSAkey.bin has an invalid magic signature. Should be \"RSA1\"");
}
}
else {
EmuWarning("RSAkey.bin has an incorrect filesize. Should be 284 bytes");
}
fclose(fp);
}
else
{
// RSAkey.bin could not be loaded
EmuWarning("Failed to load RSAkey.bin. Cxbx-Reloaded will be unable to verify the integrity of the loaded xbe");
}
// If we didn't already exit the function, keys.bin could not be loaded
EmuWarning("Failed to load Keys.bin. Cxbx-Reloaded will be unable to read Save Data from a real Xbox");
}
__declspec(noreturn) void CxbxKrnlInit

35
src/CxbxKrnl/EmuKrnlXc.cpp
View File

@ -41,7 +41,7 @@
// prevent name collisions
namespace xboxkrnl
{
#include <xboxkrnl/xboxkrnl.h> // For XcSHAInit, etc.
#include <xboxkrnl/xboxkrnl.h> // For XcSHAInit, etc.
};
#include "Logging.h" // For LOG_FUNC()
@ -52,7 +52,7 @@ namespace xboxkrnl
// prevent name collisions
namespace NtDll
{
#include "EmuNtDll.h"
#include "EmuNtDll.h"
};
// ******************************************************************
@ -65,7 +65,10 @@ XBSYSAPI EXPORTNUM(335) xboxkrnl::VOID NTAPI xboxkrnl::XcSHAInit
{
LOG_FUNC_ONE_ARG_TYPE(PBYTE, pbSHAContext);
A_SHAInit((SHA_CTX*)pbSHAContext);
// The sha1 context supplied by this function has an extra 24 bytes at the beginning which are unsed by our implementation,
// so we skip them. The same is true for XcSHAUpdate and XcSHAFinal
SHA1Init((SHA1_CTX*)(pbSHAContext + 24));
}
// ******************************************************************
@ -82,9 +85,9 @@ XBSYSAPI EXPORTNUM(336) xboxkrnl::VOID NTAPI xboxkrnl::XcSHAUpdate
LOG_FUNC_ARG_OUT(pbSHAContext)
LOG_FUNC_ARG_OUT(pbInput)
LOG_FUNC_ARG(dwInputLength)
LOG_FUNC_END;
LOG_FUNC_END;
A_SHAUpdate((SHA_CTX*)pbSHAContext, pbInput, dwInputLength);
SHA1Update((SHA1_CTX*)(pbSHAContext + 24), pbInput, dwInputLength);
}
// ******************************************************************
@ -99,9 +102,9 @@ XBSYSAPI EXPORTNUM(337) xboxkrnl::VOID NTAPI xboxkrnl::XcSHAFinal
LOG_FUNC_BEGIN
LOG_FUNC_ARG_TYPE(PBYTE, pbSHAContext)
LOG_FUNC_ARG_TYPE(PBYTE, pbDigest)
LOG_FUNC_END;
LOG_FUNC_END;
A_SHAFinal((SHA_CTX*)pbSHAContext, pbDigest);
SHA1Final(pbDigest, (SHA1_CTX*)(pbSHAContext + 24));
}
// ******************************************************************
@ -183,25 +186,25 @@ XBSYSAPI EXPORTNUM(340) xboxkrnl::VOID NTAPI xboxkrnl::XcHMAC
((DWORD*)Pad2)[dwBlock] ^= ((DWORD)0x5C5C5C5C);
}
SHA_CTX ShaContext;
A_SHAInit(&ShaContext);
A_SHAUpdate(&ShaContext, Pad1, 64);
SHA1_CTX ShaContext;
SHA1Init(&ShaContext);
SHA1Update(&ShaContext, Pad1, 64);
if (cbData != 0) {
A_SHAUpdate(&ShaContext, pbData, cbData);
SHA1Update(&ShaContext, pbData, cbData);
}
if (cbData2 != 0) {
A_SHAUpdate(&ShaContext, pbData2, cbData2);
SHA1Update(&ShaContext, pbData2, cbData2);
}
BYTE Temp[64 + A_SHA_DIGEST_LEN];
A_SHAFinal(&ShaContext, Temp + 64);
SHA1Final(Temp + 64 , &ShaContext);
RtlCopyMemory(Temp, Pad2, 64);
A_SHAInit(&ShaContext);
A_SHAUpdate(&ShaContext, Temp, sizeof(Temp));
A_SHAFinal(&ShaContext, HmacData);
SHA1Init(&ShaContext);
SHA1Update(&ShaContext, Temp, sizeof(Temp));
SHA1Final(HmacData, &ShaContext);
}
// ******************************************************************

17
src/CxbxKrnl/EmuKrnlXe.cpp
View File

@ -49,7 +49,6 @@ namespace xboxkrnl
#include "EmuKrnlLogging.h"
#include "Emu.h" // For EmuWarning()
#include "VMManager.h"
#include "EmuSha.h" // For the SHA1 functions
// ******************************************************************
// * 0x0146 - XeImageFileName
@ -107,22 +106,6 @@ XBSYSAPI EXPORTNUM(327) xboxkrnl::NTSTATUS NTAPI xboxkrnl::XeLoadSection
(*Section->TailReferenceCount)++;
}
// Check the integrity of the loaded section
SHA_CTX Context;
UCHAR SHADigest[A_SHA_DIGEST_LEN];
A_SHAInit(&Context);
A_SHAUpdate(&Context, (PUCHAR)Section->FileSize, sizeof(ULONG));
A_SHAUpdate(&Context, (PUCHAR)Section->VirtualAddress, Section->FileSize);
A_SHAFinal(&Context, SHADigest);
if (memcmp(SHADigest, Section->ShaHash, A_SHA_DIGEST_LEN) != 0) {
EmuWarning("SHA hash of section %s doesn't match, possible section corruption", Section->SectionName);
}
else {
printf("SHA hash check of section %s successful", Section->SectionName);
}
// Increment the reference count
Section->SectionReferenceCount++;
}

7
src/CxbxKrnl/EmuRsa.cpp
View File

@ -33,11 +33,11 @@
// ******************************************************************
// Acknowledgment:
// This barebones rsa implementation is directly borrowed from the xbedump tool of XQEMU (GPLv2 license)
// This rsa implementation is directly borrowed from the xbedump tool of XQEMU (GPLv2 license)
// https://github.com/xqemu/xbedump
#include "CxbxKrnl\EmuRsa.h"
#include "..\CxbxKrnl\Emu.h" // For EmuWarning
#include "EmuRsa.h"
#include "Emu.h" // For EmuWarning
#include <cstring>
@ -164,7 +164,6 @@ void RSAdecrypt(unsigned char* c_number, unsigned char* cryptbuffer, RSA_PUBLIC_
giant e = newgiant(GIANT_INFINITY);
giant sig = newgiant(GIANT_INFINITY);
int count;
gigimport(sig, c_number, 256);
gigimport(n, key.KeyData.Modulus, 256);

4
src/CxbxKrnl/EmuRsa.h
View File

@ -49,10 +49,10 @@ typedef struct _RSA_PUBLIC_KEY
unsigned int ModulusSize; // 255 (bytes in the Modulus)
unsigned char Exponent[4];
unsigned char Modulus[256]; // Bit endian style
unsigned char Padding[8]; // Padding? Only seen as zero
unsigned char Unknown[8]; // ?
}KeyData;
};
}RSA_PUBLIC_KEY;
} RSA_PUBLIC_KEY;
#pragma pack()

282
src/CxbxKrnl/EmuSha.cpp
View File

@ -9,7 +9,7 @@
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuSha.cpp
// * Cxbx->CxbxKrnl->EmuSha.cpp
// *
// * This file is part of the Cxbx project.
// *
@ -29,23 +29,281 @@
// * 59 Temple Place - Suite 330, Bostom, MA 02111-1307, USA.
// *
// * (c) 2002-2003 Aaron Robinson <caustik@caustik.com>
// * (c) 2018 ergo720
// *
// * All rights reserved
// *
// ******************************************************************
#define _XBOXKRNL_DEFEXTRN_
#include <Windows.h>
/*
SHA-1 in C
By Steve Reid <steve@edmweb.com>
100% Public Domain
Test Vectors (from FIPS PUB 180-1)
"abc"
A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
A million repetitions of "a"
34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
*/
/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */
/* #define SHA1HANDSOFF * Copies data before messing with it. */
// Acknowledgment: see above
// https://github.com/clibs/sha1
#define SHA1HANDSOFF
#include <stdio.h>
#include <string.h>
#include "EmuSha.h"
// ******************************************************************
// * Loaded at run-time to avoid linker conflicts
// ******************************************************************
static HMODULE hDll = GetModuleHandle("advapi32.dll");
#define IMPORT(API) \
FPTR_##API API = (FPTR_##API)GetProcAddress(hDll, #API)
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
IMPORT(A_SHAInit);
IMPORT(A_SHAUpdate);
IMPORT(A_SHAFinal);
/* blk0() and blk() perform the initial expand. */
/* I got the idea of expanding during the round function from SSLeay */
#if BYTE_ORDER == LITTLE_ENDIAN
#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
|(rol(block->l[i],8)&0x00FF00FF))
#elif BYTE_ORDER == BIG_ENDIAN
#define blk0(i) block->l[i]
#else
#error "Endianness not defined!"
#endif
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
^block->l[(i+2)&15]^block->l[i&15],1))
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
/* Hash a single 512-bit block. This is the core of the algorithm. */
void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
{
uint32_t a, b, c, d, e;
typedef union
{
unsigned char c[64];
uint32_t l[16];
} CHAR64LONG16;
#ifdef SHA1HANDSOFF
CHAR64LONG16 block[1]; /* use array to appear as a pointer */
memcpy(block, buffer, 64);
#else
/* The following had better never be used because it causes the
* pointer-to-const buffer to be cast into a pointer to non-const.
* And the result is written through. I threw a "const" in, hoping
* this will cause a diagnostic.
*/
CHAR64LONG16 *block = (const CHAR64LONG16 *)buffer;
#endif
/* Copy context->state[] to working vars */
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
/* 4 rounds of 20 operations each. Loop unrolled. */
R0(a, b, c, d, e, 0);
R0(e, a, b, c, d, 1);
R0(d, e, a, b, c, 2);
R0(c, d, e, a, b, 3);
R0(b, c, d, e, a, 4);
R0(a, b, c, d, e, 5);
R0(e, a, b, c, d, 6);
R0(d, e, a, b, c, 7);
R0(c, d, e, a, b, 8);
R0(b, c, d, e, a, 9);
R0(a, b, c, d, e, 10);
R0(e, a, b, c, d, 11);
R0(d, e, a, b, c, 12);
R0(c, d, e, a, b, 13);
R0(b, c, d, e, a, 14);
R0(a, b, c, d, e, 15);
R1(e, a, b, c, d, 16);
R1(d, e, a, b, c, 17);
R1(c, d, e, a, b, 18);
R1(b, c, d, e, a, 19);
R2(a, b, c, d, e, 20);
R2(e, a, b, c, d, 21);
R2(d, e, a, b, c, 22);
R2(c, d, e, a, b, 23);
R2(b, c, d, e, a, 24);
R2(a, b, c, d, e, 25);
R2(e, a, b, c, d, 26);
R2(d, e, a, b, c, 27);
R2(c, d, e, a, b, 28);
R2(b, c, d, e, a, 29);
R2(a, b, c, d, e, 30);
R2(e, a, b, c, d, 31);
R2(d, e, a, b, c, 32);
R2(c, d, e, a, b, 33);
R2(b, c, d, e, a, 34);
R2(a, b, c, d, e, 35);
R2(e, a, b, c, d, 36);
R2(d, e, a, b, c, 37);
R2(c, d, e, a, b, 38);
R2(b, c, d, e, a, 39);
R3(a, b, c, d, e, 40);
R3(e, a, b, c, d, 41);
R3(d, e, a, b, c, 42);
R3(c, d, e, a, b, 43);
R3(b, c, d, e, a, 44);
R3(a, b, c, d, e, 45);
R3(e, a, b, c, d, 46);
R3(d, e, a, b, c, 47);
R3(c, d, e, a, b, 48);
R3(b, c, d, e, a, 49);
R3(a, b, c, d, e, 50);
R3(e, a, b, c, d, 51);
R3(d, e, a, b, c, 52);
R3(c, d, e, a, b, 53);
R3(b, c, d, e, a, 54);
R3(a, b, c, d, e, 55);
R3(e, a, b, c, d, 56);
R3(d, e, a, b, c, 57);
R3(c, d, e, a, b, 58);
R3(b, c, d, e, a, 59);
R4(a, b, c, d, e, 60);
R4(e, a, b, c, d, 61);
R4(d, e, a, b, c, 62);
R4(c, d, e, a, b, 63);
R4(b, c, d, e, a, 64);
R4(a, b, c, d, e, 65);
R4(e, a, b, c, d, 66);
R4(d, e, a, b, c, 67);
R4(c, d, e, a, b, 68);
R4(b, c, d, e, a, 69);
R4(a, b, c, d, e, 70);
R4(e, a, b, c, d, 71);
R4(d, e, a, b, c, 72);
R4(c, d, e, a, b, 73);
R4(b, c, d, e, a, 74);
R4(a, b, c, d, e, 75);
R4(e, a, b, c, d, 76);
R4(d, e, a, b, c, 77);
R4(c, d, e, a, b, 78);
R4(b, c, d, e, a, 79);
/* Add the working vars back into context.state[] */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
/* Wipe variables */
a = b = c = d = e = 0;
#ifdef SHA1HANDSOFF
memset(block, '\0', sizeof(block));
#endif
}
/* SHA1Init - Initialize new context */
void SHA1Init(SHA1_CTX* context)
{
/* SHA1 initialization constants */
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
context->state[4] = 0xC3D2E1F0;
context->count[0] = context->count[1] = 0;
}
/* Run your data through this. */
void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len)
{
uint32_t i;
uint32_t j;
j = context->count[0];
if ((context->count[0] += len << 3) < j)
context->count[1]++;
context->count[1] += (len >> 29);
j = (j >> 3) & 63;
if ((j + len) > 63)
{
memcpy(&context->buffer[j], data, (i = 64 - j));
SHA1Transform(context->state, context->buffer);
for (; i + 63 < len; i += 64)
{
SHA1Transform(context->state, &data[i]);
}
j = 0;
}
else
i = 0;
memcpy(&context->buffer[j], &data[i], len - i);
}
/* Add padding and return the message digest. */
void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
{
unsigned i;
unsigned char finalcount[8];
unsigned char c;
#if 0 /* untested "improvement" by DHR */
/* Convert context->count to a sequence of bytes
* in finalcount. Second element first, but
* big-endian order within element.
* But we do it all backwards.
*/
unsigned char *fcp = &finalcount[8];
for (i = 0; i < 2; i++)
{
uint32_t t = context->count[i];
int j;
for (j = 0; j < 4; t >>= 8, j++)
*--fcp = (unsigned char)t
}
#else
for (i = 0; i < 8; i++)
{
finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
}
#endif
c = 0200;
SHA1Update(context, &c, 1);
while ((context->count[0] & 504) != 448)
{
c = 0000;
SHA1Update(context, &c, 1);
}
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
for (i = 0; i < 20; i++)
{
digest[i] = (unsigned char)
((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
}
/* Wipe variables */
memset(context, '\0', sizeof(*context));
memset(&finalcount, '\0', sizeof(finalcount));
}
void CalcSHA1Hash(unsigned char digest[20], const unsigned char* data, uint32_t len)
{
SHA1_CTX ctx;
SHA1Init(&ctx);
SHA1Update(&ctx, (const unsigned char*)&len, sizeof(uint32_t));
SHA1Update(&ctx, data, len);
SHA1Final(digest, &ctx);
}

58
src/CxbxKrnl/EmuSha.h
View File

@ -7,7 +7,7 @@
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
// *
// * Cxbx->Win32->CxbxKrnl->EmuSha.h
// * Cxbx->CxbxKrnl->EmuSha.h
// *
// * This file is part of the Cxbx project.
// *
@ -27,59 +27,29 @@
// * 59 Temple Place - Suite 330, Bostom, MA 02111-1307, USA.
// *
// * (c) 2002-2003 Aaron Robinson <caustik@caustik.com>
// * (c) 2018 ergo720
// *
// * All rights reserved
// *
// ******************************************************************
#ifndef EMUSHA_H
#define EMUSHA_H
#if defined(__cplusplus)
extern "C"
{
#endif
#include <Windows.h>
#include "stdint.h"
#define A_SHA_DIGEST_LEN 20
typedef struct {
ULONG Unknown[6];
ULONG State[5];
ULONG Count[2];
UCHAR Buffer[64];
} SHA_CTX, *PSHA_CTX;
typedef struct _SHA1_CTX
{
uint32_t state[5];
uint32_t count[2];
unsigned char buffer[64];
} SHA1_CTX;
typedef VOID (WINAPI *FPTR_A_SHAInit)
(
PSHA_CTX
);
typedef VOID(WINAPI *FPTR_A_SHAUpdate)
(
PSHA_CTX,
const unsigned char *,
UINT
);
typedef VOID(WINAPI *FPTR_A_SHAFinal)
(
PSHA_CTX,
PUCHAR
);
// ******************************************************************
// * Exported API
// ******************************************************************
#define EXTERN(API) \
extern FPTR_##API API
EXTERN(A_SHAInit);
EXTERN(A_SHAUpdate);
EXTERN(A_SHAFinal);
#if defined(__cplusplus)
}
#endif
void SHA1Init(SHA1_CTX* context);
void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len);
void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
void CalcSHA1Hash(unsigned char digest[20], const unsigned char* data, uint32_t len);
#endif