Bottersnike/micetools
Bottersnike
/
micetools
4
4
Fork 0
Code Issues 5 Pull Requests Projects Releases Wiki Activity

Large amount of stuff leading up to fully networking maimai

This commit is contained in:
Bottersnike 2023-05-19 15:16:07 +01:00
parent d3ff2e7c24
commit 50737e6011
Signed by: Bottersnike
SSH Key Fingerprint: SHA256:3g0ghwd4dNX1k1RX8qazbiT+3RIYn/daeBevHZVCiU0
69 changed files with 3423 additions and 445 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/micetools/dll/comdevice.c
View File

@ -81,10 +81,10 @@ short comdev_read_blocking(com_device_t* com, unsigned char* buffer, short bytes
}
return ringbuf_read(&com->in, buffer, bytes);
}
short comdev_read(com_device_t* com, unsigned char* buffer, short bytes) {
short comdev_read(com_device_t* com, LPVOID buffer, short bytes) {
return ringbuf_read(&com->in, buffer, bytes);
}
bool comdev_write(com_device_t* com, const unsigned char* buffer, short bytes) {
bool comdev_write(com_device_t* com, LPCVOID buffer, short bytes) {
bool ret = ringbuf_write(&com->out, buffer, bytes);
SetEvent(com->dataOutReady);
return ret;
@ -93,7 +93,7 @@ short comdev_available(com_device_t* com) { return ringbuf_available(&com->in);
BYTE comdev_peek(com_device_t* com) { return com->in.buffer[com->in.read]; }
// Read data from a com device, unescaping as we go
void comio_read(com_device_t* com, BYTE* data, BYTE len) {
void comio_read(com_device_t* com, LPVOID data, BYTE len) {
BYTE one_byte;
for (; len; len--) {
comdev_read_blocking(com, &one_byte, 1);
@ -101,14 +101,14 @@ void comio_read(com_device_t* com, BYTE* data, BYTE len) {
comdev_read_blocking(com, &one_byte, 1);
one_byte++;
}
*(data++) = one_byte;
*(((LPBYTE)data)++) = one_byte;
}
}
// Write data to a com device, escaping as we go
void comio_write(com_device_t* com, BYTE* data, BYTE len) {
void comio_write(com_device_t* com, LPCVOID data, BYTE len) {
BYTE one_byte;
for (; len; len--) {
one_byte = *(data++);
one_byte = *(((LPBYTE)data)++);
if (one_byte == COMIO_MARK || one_byte == COMIO_SYNC) {
BYTE mark = COMIO_MARK;
comdev_write(com, &mark, 1);
@ -117,7 +117,7 @@ void comio_write(com_device_t* com, BYTE* data, BYTE len) {
comdev_write(com, &one_byte, 1);
}
}
unsigned char comio_next_req(com_device_t* com, comio_recv_head_t* head, BYTE* data) {
unsigned char comio_next_req(com_device_t* com, comio_recv_head_t* head, LPVOID data) {
BYTE one_byte;
do {
if (comdev_available(com) < (sizeof *head + 1)) {
@ -140,7 +140,7 @@ unsigned char comio_next_req(com_device_t* com, comio_recv_head_t* head, BYTE* d
comio_read(com, &sum, 1);
return sum;
}
void comio_reply(com_device_t* com, comio_recv_head_t* req, BYTE status, BYTE len, BYTE* data) {
void comio_reply(com_device_t* com, comio_recv_head_t* req, BYTE status, BYTE len, LPCVOID data) {
BYTE one_byte;
one_byte = COMIO_SYNC;
comdev_write(com, &one_byte, 1);
@ -161,7 +161,7 @@ void comio_reply(com_device_t* com, comio_recv_head_t* req, BYTE status, BYTE le
// Checksum
one_byte = 0;
for (BYTE i = 0; i < sizeof resp; i++) one_byte += ((LPBYTE)&resp)[i];
for (BYTE i = 0; i < len; i++) one_byte += data[i];
for (BYTE i = 0; i < len; i++) one_byte += ((LPBYTE)data)[i];
comio_write(com, &one_byte, 1);
}

16
src/micetools/dll/comdevice.h
View File

@ -22,6 +22,7 @@ struct com_device {
};
com_device_t* com_devices[NUM_COM_PORTS];
#pragma pack(push, 1)
typedef struct {
BYTE frame_length;
BYTE dst;
@ -38,6 +39,7 @@ typedef struct {
BYTE status;
BYTE length;
} comio_resp_head_t;
#pragma pack(pop)
#define COMIO_SYNC 0xE0
#define COMIO_MARK 0xD0
@ -45,17 +47,17 @@ typedef struct {
#define COMIO_STATUS_OK 0
#define COMIO_STATUS_NG 1
short comdev_read_blocking(com_device_t* com, unsigned char* buffer, short bytes);
short comdev_read(com_device_t* com, unsigned char* buffer, short bytes);
bool comdev_write(com_device_t* com, const unsigned char* buffer, short bytes);
short comdev_read_blocking(com_device_t* com, LPVOID buffer, short bytes);
short comdev_read(com_device_t* com, LPVOID buffer, short bytes);
bool comdev_write(com_device_t* com, LPCVOID buffer, short bytes);
short comdev_available(com_device_t* com);
BYTE comdev_peek(com_device_t* com);
void comio_read(com_device_t* com, BYTE* data, BYTE len);
void comio_write(com_device_t* com, BYTE* data, BYTE len);
void comio_read(com_device_t* com, LPVOID data, BYTE len);
void comio_write(com_device_t* com, LPCVOID data, BYTE len);
unsigned char comio_next_req(com_device_t* com, comio_recv_head_t* head, BYTE* data);
void comio_reply(com_device_t* com, comio_recv_head_t* req, BYTE status, BYTE len, BYTE* data);
unsigned char comio_next_req(com_device_t* com, comio_recv_head_t* head, LPVOID data);
void comio_reply(com_device_t* com, comio_recv_head_t* req, BYTE status, BYTE len, LPCVOID data);
com_device_t* new_com_device(BYTE port);
BOOL attach_com_device(BYTE port, FnComDeviceThread* thread);

2
src/micetools/dll/devices/meson.build
View File

@ -1,6 +1,8 @@
devices_files = files(
'_ds_sha.c',
'_devices.c',
'nfc/felica.c',
'nfc/bng.c',
# Serial devices
'ser_led_bd.c',
'ser_maitouch.c',

127
src/micetools/dll/devices/nfc/bng.c Normal file
View File

@ -0,0 +1,127 @@
#include "bng.h"
#include <stdlib.h>
#include "../../../lib/mice/blowfish.h"
#include "../../../lib/mice/des.h"
// Are these SEGA-specific or used for all FeliCa cards?
// Commentary: The MAC validation code in bnacard can take a key as an argument
// and uses the below key if NULL is passed (which it is).
// The NbgiAccessCode library names this `ucFK` which doesn't feel
// like a name someone would pick out of the blue.
DWORD64 CK_GEN_KEY[3] = { 0x1223491caf37206d, 0x5f3f1d16badd58a2, 0xc2f2ea946a755ee7 };
#pragma pack(push, 1)
typedef struct BNG_SIGNED_BLOCK {
WORD m_BNAVersion;
BYTE m_Name[6];
DWORD m_BFLeft;
DWORD m_BFRight;
} BNG_SIGNED_BLOCK, *PBNG_SIGNED_BLOCK;
#pragma pack(pop)
typedef struct {
char m_Name[8];
BYTE m_Key[56];
BYTE Unk40[72];
} BLOWFISH_KEY;
static BLOWFISH_KEY DataKeyNBGIC[3] = {
{
.m_Name = { 'N', 'B', 'G', 'I', 'C', '0', '\0', '\0' },
.m_Key = { 0x6b, 0xf9, 0xe0, 0x22, 0x4b, 0x14, 0xa9, 0x51, 0xd4, 0x3d, 0xb6, 0x2d,
0x2a, 0x99, 0x47, 0xd8, 0xb2, 0x78, 0x80, 0x35, 0x8e, 0x71, 0x16, 0xeb,
0xa0, 0x00, 0x01, 0x3e, 0x8c, 0xfe, 0xf6, 0x09, 0x02, 0xa9, 0x59, 0x5d,
0x4c, 0x25, 0xfe, 0xff, 0x74, 0x3f, 0xc8, 0xd8, 0xe0, 0x75, 0x6a, 0xe6,
0x18, 0xef, 0x8b, 0x72, 0x12, 0xde, 0x5a, 0x4b },
.Unk40 = { 0x97, 0xba, 0xa5, 0x1b, 0x46, 0x04, 0x87, 0x43, 0x9f, 0x21, 0x5b, 0xe9,
0xe1, 0xd0, 0x98, 0x72, 0x27, 0x91, 0x31, 0xba, 0x8a, 0x82, 0x8f, 0xab,
0x50, 0x7f, 0x44, 0x7f, 0x8b, 0xc5, 0xe3, 0x4a, 0xc3, 0x32, 0xb7, 0xcb,
0xd8, 0x4f, 0xb1, 0x4c, 0x45, 0x21, 0x20, 0xe2, 0xa0, 0x71, 0x38, 0x4d,
0xe6, 0x95, 0x89, 0xc1, 0x5b, 0x04, 0x14, 0xc6, 0x9d, 0xcd, 0x03, 0x1c,
0xd0, 0xa8, 0x15, 0x3a, 0xf4, 0x6d, 0x3d, 0xea, 0x84, 0xec, 0xcd, 0x40 },
},
{
.m_Name = { 'N', 'B', 'G', 'I', 'C', '1', '\0', '\0' },
.m_Key = { 0x5e, 0x6b, 0xb1, 0x92, 0xc0, 0x52, 0x2f, 0x4c, 0xa0, 0x29, 0x6a, 0x1c,
0x98, 0x62, 0xfb, 0xeb, 0xac, 0xf5, 0xe1, 0xd7, 0x66, 0xe6, 0x34, 0x69,
0x40, 0x47, 0x5b, 0x96, 0xfe, 0x17, 0x89, 0x3d, 0x18, 0xae, 0x98, 0xf8,
0xbd, 0x6d, 0xfa, 0x12, 0xd6, 0xcd, 0xf5, 0x81, 0x7b, 0x78, 0xd6, 0x60,
0x71, 0x8f, 0x7a, 0x28, 0xca, 0x3c, 0xfd, 0x2f },
.Unk40 = { 0xa6, 0x29, 0x78, 0x80, 0x63, 0xae, 0xa3, 0xa7, 0x84, 0xdd, 0x24, 0x60,
0x62, 0x86, 0x10, 0x97, 0x80, 0x75, 0xb4, 0x3d, 0x44, 0x81, 0xc9, 0x9f,
0xf4, 0x4a, 0xf7, 0xfd, 0xe4, 0xc8, 0x96, 0xcb, 0x9c, 0x2f, 0x3b, 0x6d,
0x95, 0xfe, 0x49, 0x54, 0x9d, 0x36, 0xea, 0x58, 0xcb, 0xf4, 0x0e, 0x06,
0x42, 0xfa, 0x6f, 0xb5, 0x1b, 0xc7, 0x88, 0x50, 0xea, 0x7b, 0x5f, 0x60,
0x56, 0xdb, 0x6f, 0x03, 0xd7, 0x84, 0x75, 0x4e, 0x07, 0x9d, 0xbc, 0x05 },
},
{
.m_Name = { 'N', 'B', 'G', 'I', 'C', '2', '\0', '\0' },
.m_Key = { 0xde, 0x15, 0x00, 0x6f, 0x45, 0xe2, 0x73, 0x66, 0xaa, 0x74, 0x8f, 0x98,
0x14, 0x6e, 0x05, 0x7b, 0x52, 0x18, 0x29, 0xd5, 0x0a, 0x65, 0xa9, 0x0c,
0xfe, 0xca, 0xd3, 0x8e, 0x04, 0xcf, 0x3e, 0x72, 0x31, 0xfb, 0x76, 0x50,
0xfb, 0x8c, 0x67, 0x09, 0x95, 0x08, 0xff, 0xf0, 0xc2, 0x97, 0x31, 0x5f,
0xde, 0x6c, 0x54, 0x32, 0xec, 0x8e, 0x2c, 0x6c },
.Unk40 = { 0xc0, 0x6c, 0xa9, 0x7d, 0xd1, 0x10, 0x35, 0xc2, 0xa8, 0x6d, 0x52, 0xfc,
0x0a, 0x8c, 0x1a, 0xf7, 0xd1, 0x61, 0xea, 0x40, 0x49, 0x86, 0x7f, 0x37,
0x3f, 0xd1, 0x84, 0x2e, 0x98, 0xd9, 0x6d, 0x2c, 0x5e, 0x80, 0xe0, 0xe1,
0x92, 0x7c, 0xf2, 0x09, 0xef, 0x11, 0x44, 0x29, 0xe9, 0x4b, 0xb9, 0x3a,
0x87, 0x27, 0x5c, 0xa8, 0x05, 0xca, 0xfc, 0xcd, 0x3f, 0x21, 0x91, 0x17,
0xf5, 0x05, 0x6b, 0x82, 0x6b, 0x47, 0xdc, 0x06, 0x75, 0x1f, 0x04, 0x30 },
},
};
void NbgiWriteBNESignedBlock(PNFC_CARD lpCard, BYTE block, BYTE nKey, LPBYTE lpData) {
if (nKey > 2) return;
PBNG_SIGNED_BLOCK lpBlock = (PBNG_SIGNED_BLOCK)&lpCard->m_FeliCaData.m_UserBlocks[block].bytes;
lpBlock->m_BNAVersion = 0x200;
memcpy(lpBlock->m_Name, DataKeyNBGIC[nKey].m_Name, 6);
lpData[7] = lpData[0] ^ lpData[1] ^ lpData[2] ^ lpData[3] ^ lpData[4] ^ lpData[5] ^ lpData[6];
DWORD dataLeft = ((LPDWORD)lpData)[0];
DWORD dataRight = ((LPDWORD)lpData)[1];
BlowfishSetKey(DataKeyNBGIC[nKey].m_Key, _countof(DataKeyNBGIC[nKey].m_Key));
BlowfishEncrypt(&dataLeft, &dataRight);
lpBlock->m_BFLeft = dataLeft;
lpBlock->m_BFRight = dataRight;
}
static inline DWORD64 _FelicaMacCKNested(DWORD64 data, DWORD64 key) {
data = Mice3Des_3K(data, CK_GEN_KEY);
data ^= key;
data = Mice3Des_3K(data, CK_GEN_KEY);
return data;
}
void FelicaMacGenerateCK(DWORD64* ID, KEY_PAIR lpKeys) {
DWORD64 data = Mice3Des_3K(0x0, CK_GEN_KEY);
BOOL will_overflow = ((LPBYTE)&data)[0] & 0x80;
// Binary rotate left 1. While `<<= 1` would be lovely here, the carries
// are expected to be performed (incorrectly) to the right.
for (BYTE i = 0; i < 8; i++) {
if (i != 0 && ((LPBYTE)&data)[i] & 0x80) ((LPBYTE)&data)[i - 1] |= 1;
((LPBYTE)&data)[i] <<= 1;
}
if (will_overflow) ((LPBYTE)&data)[7] ^= 0x1b;
DWORD64 idKey = data ^ ID[1];
lpKeys[0] = _byteswap_uint64(_FelicaMacCKNested(ID[0], idKey));
((LPBYTE)&ID[0])[0] ^= 0x80;
lpKeys[1] = _byteswap_uint64(_FelicaMacCKNested(ID[0], idKey));
((LPBYTE)&ID[0])[0] ^= 0x80; // Undo our modification above
}
void FelicaMacGenerateSK(DWORD64* random, KEY_PAIR ck, KEY_PAIR lpSk) {
lpSk[0] = Mice3Des_2K(_byteswap_uint64(random[0]), ck);
lpSk[1] = lpSk[0] ^ _byteswap_uint64(random[1]);
lpSk[1] = Mice3Des_2K(lpSk[1], ck);
}
DWORD64 FelicaMacGenerateMAC(DWORD64* data, KEY_PAIR sk, DWORD64* random) {
DWORD64 mac = data[0] ^ random[0];
mac = Mice3Des_2K(_byteswap_uint64(mac), sk);
mac = mac ^ _byteswap_uint64(data[1]);
return Mice3Des_2K(mac, sk);
}

12
src/micetools/dll/devices/nfc/bng.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <Windows.h>
#include "nfc.h"
typedef DWORD64 KEY_PAIR[2];
void NbgiWriteBNESignedBlock(PNFC_CARD lpCard, BYTE block, BYTE nKey, LPBYTE lpData);
void FelicaMacGenerateCK(DWORD64* ID, KEY_PAIR lpKeys);
void FelicaMacGenerateSK(DWORD64* random, KEY_PAIR ck, KEY_PAIR lpSk);
DWORD64 FelicaMacGenerateMAC(DWORD64* data, KEY_PAIR sk, DWORD64* random);

423
src/micetools/dll/devices/nfc/felica.c Normal file
View File

@ -0,0 +1,423 @@
#include "../../../lib/mice/spad.h"
#include "../_devices.h"
#include "../ser_tn32msec.h"
#include "bng.h"
#include "nfc.h"
static const BYTE PMmTiming[6] = { 0x00, 0x00, 0x00, 0x01, 0x43, 0x00 };
#define DFC_BNG_EDY_0 0x8C
#define DFC_BNG_EDY_1 0xA2
#define DFC_BNG_LITE_0 0x00
#define DFC_BNG_LITE_1 0x3A
#define DFC_KNM_LITES_0 0x00
#define DFC_KNM_LITES_1 0x68
#define DFC_BNE_LITES_0 0x00
#define DFC_BNE_LITES_1 0x2A
#define DFC_SEGA_LITES_0 0x00
#define DFC_SEGA_LITES_1 0x78
#define DFC_TEST_0 0x00
#define DFC_TEST_1 0x00
static const BYTE ID_Arbitrary[6] = { 0x05, 0x73, 0x02, 0x01, 0x02, 0x00 };
inline static void _FelicaDumpChars(LPBYTE lpBytes, BYTE nBytes) {
printf("|");
for (int i = 0; i < nBytes; i++) {
BYTE chr = lpBytes[i];
if (' ' < chr && chr <= '~')
printf("%c", chr);
else
printf(".");
}
printf("|");
}
static void _FelicaDumpBlock(PNFC_CARD lpCard, BYTE block, BYTE nBytes, LPCSTR lpName) {
PFelicaBlock_t lpBlock;
if (block < 0xf)
lpBlock = &lpCard->m_FeliCaData.m_UserBlocks[block];
else
lpBlock = &lpCard->m_FeliCaData.m_SystemBlocks[block - 0x80];
printf("[%02X] ", block);
for (int i = 0; i < 8; i++) {
if (i < nBytes)
printf("%02X ", lpBlock->bytes[i]);
else
printf("-- ");
}
if (lpName)
printf("(%s)", lpName);
else
_FelicaDumpChars(lpBlock->bytes, 8);
printf("\n ");
for (int i = 8; i < 16; i++) {
if (i < nBytes)
printf("%02X ", lpBlock->bytes[i]);
else
printf("-- ");
}
if (!lpName) _FelicaDumpChars(&(lpBlock->bytes[8]), 8);
printf("\n");
}
void FelicaDumpCard(PNFC_CARD lpCard) {
for (BYTE block = 0; block < 15; block++) {
_FelicaDumpBlock(lpCard, block, 16, NULL);
}
_FelicaDumpBlock(lpCard, 0x80, 16, "RC");
_FelicaDumpBlock(lpCard, 0x81, 8, "MAC");
_FelicaDumpBlock(lpCard, 0x82, 16, "ID");
_FelicaDumpBlock(lpCard, 0x83, 16, "D_ID");
_FelicaDumpBlock(lpCard, 0x84, 2, "SER_C");
_FelicaDumpBlock(lpCard, 0x85, 2, "SYS_C");
_FelicaDumpBlock(lpCard, 0x86, 2, "CKV");
_FelicaDumpBlock(lpCard, 0x87, 16, "CK");
_FelicaDumpBlock(lpCard, 0x88, 13, "MC");
}
void FelicaPopulate(PNFC_CARD lpCard, PFELICA_ID lpFelicaId, PACCESS_CODE lpAccessCode) {
ZeroMemory(&lpCard->m_FeliCaData, sizeof lpCard->m_FeliCaData);
lpCard->m_Header.m_Type = CardType_FeliCa;
lpCard->m_Header.m_IdLen = sizeof(lpCard->m_FeliCa);
memcpy(&lpCard->m_FeliCa.m_IDm, lpFelicaId, sizeof *lpFelicaId);
// TODO: Toggle between suica and AIC mode.
lpCard->m_FeliCaData.m_EmuMode = FelicaEmulationMode_AIC;
lpCard->m_FeliCaData.m_AICVendor = FelicaAICVendor_Konami;
lpCard->m_FeliCa.m_PMm[0] = 0x00;
switch (lpCard->m_FeliCaData.m_EmuMode) {
case FelicaEmulationMode_Suica:
lpCard->m_FeliCa.m_PMm[1] = FelicaChipType_Mobile_Ver10;
lpCard->m_FeliCaData.m_SystemBlock_SYS_C.m_SYS_C = _byteswap_ushort(FelicaSystem_Suica);
// DFC shouldn't matter for Suica
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[0] = DFC_TEST_0;
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[1] = DFC_TEST_1;
break;
case FelicaEmulationMode_AIC:
lpCard->m_FeliCaData.m_SystemBlock_SYS_C.m_SYS_C =
_byteswap_ushort(FelicaSystem_FelicaLite);
/**
* The DFC code is used to identify the card manufacturer. Each
* manufacturer uses a different derivation algorithm for FeliCa ID
* to Access Code conversion, which AiMeDB is able to validate
* based on this information.
*
* This validation is performed as part of
* AiMe_DB_com_get_AiMeAccountS, added in AiMeDB version 4.0.0
*
* To the best of my knowledge this was added long after RingEdge
* was a dead platform, so isn't something we will need to concern
* ourselves with here.
*
* Maimai itself only does a check for if this is
* FelicaAICVendor_BandaiNamco_LiteS, in which case special
* handling is required.
*
* TODO: Right now things seem to test bad if it's _not_ a BNE card??
*/
switch (lpCard->m_FeliCaData.m_AICVendor) {
case FelicaAICVendor_BandaiNamcoGames:
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[0] = DFC_BNG_LITE_0;
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[1] = DFC_BNG_LITE_1;
break;
case FelicaAICVendor_BandaiNamcoEntertainment: {
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[0] = DFC_BNE_LITES_0;
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[1] = DFC_BNE_LITES_1;
BYTE block0D[8] = {
// TODO: Work backwards and figure out where the key is coming from
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, /*sum*/ 0x00,
};
NbgiWriteBNESignedBlock(lpCard, 0x0D, 0, block0D);
break;
}
case FelicaAICVendor_SEGA:
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[0] = DFC_SEGA_LITES_0;
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[1] = DFC_SEGA_LITES_1;
break;
case FelicaAICVendor_Konami:
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[0] = DFC_KNM_LITES_0;
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[1] = DFC_KNM_LITES_1;
break;
default:
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[0] = DFC_TEST_0;
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[1] = DFC_TEST_1;
break;
}
// Write the card IC type into the PMm
switch (lpCard->m_FeliCaData.m_AICVendor) {
case FelicaAICVendor_BandaiNamcoGames:
lpCard->m_FeliCa.m_PMm[1] = FelicaChipType_Lite;
break;
case FelicaAICVendor_BandaiNamcoEntertainment:
case FelicaAICVendor_SEGA:
case FelicaAICVendor_Konami:
default:
lpCard->m_FeliCa.m_PMm[1] = FelicaChipType_LiteS;
break;
}
break;
case FelicaEmulationMode_BNG:
default:
lpCard->m_FeliCa.m_PMm[1] = FelicaChipType_STD_RC_S915;
lpCard->m_FeliCaData.m_SystemBlock_SYS_C.m_SYS_C = _byteswap_ushort(FelicaSystem_NDEF);
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[0] = DFC_BNG_EDY_0;
lpCard->m_FeliCaData.m_SystemBlock_ID.m_DFC[1] = DFC_BNG_EDY_1;
break;
}
memcpy(&(lpCard->m_FeliCa.m_PMm[2]), PMmTiming, sizeof PMmTiming);
if (lpAccessCode) {
BYTE block0[16];
memcpy(&(block0[6]), lpAccessCode->m_AC, 10);
Spad0Encrypt(block0, block0);
memcpy(lpCard->m_FeliCaData.m_UserBlocks[0].bytes, block0, 16);
}
memset(lpCard->m_FeliCaData.m_UserBlocks[0x0e].bytes, 0xFF, 16);
memcpy(&lpCard->m_FeliCaData.m_SystemBlock_ID.m_FelicaId, lpFelicaId, sizeof *lpFelicaId);
memcpy(lpCard->m_FeliCaData.m_SystemBlock_ID.m_Arbitrary, ID_Arbitrary, sizeof ID_Arbitrary);
memcpy(&lpCard->m_FeliCaData.m_SystemBlock_D_ID.m_FelicaId, lpFelicaId, sizeof *lpFelicaId);
memcpy(lpCard->m_FeliCaData.m_SystemBlock_D_ID.m_PMm, lpCard->m_FeliCa.m_PMm,
sizeof lpCard->m_FeliCa.m_PMm);
#if 0
FelicaDumpCard(lpCard);
#endif
}
void FelicaPoll(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse, PNFC_CARD lpCard) {
FelicaPollRequest request = lpReq->m_Poll.m_Request;
lpResponse->m_FelicaLen = FelicaRespSize(lpResponse->m_Poll);
lpResponse->m_FelicaCommand = FelicaCommand_Poll_Response;
memcpy(&lpResponse->m_IDm, &lpReq->m_IDm, sizeof lpReq->m_IDm);
memcpy(lpResponse->m_Poll.m_PMm, lpCard->m_FeliCa.m_PMm, sizeof lpCard->m_FeliCa.m_PMm);
switch (request) {
case FelicaPollRequest_SystemCode:
lpResponse->m_Poll.m_Value = lpCard->m_FeliCaData.m_SystemBlock_SYS_C.m_SYS_C;
break;
default:
log_error(plfAime, "Unhnaldled poll request: %02x", request);
lpResponse->m_FelicaLen -= 2;
break;
}
}
void FelicaReadNoEnc(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse, PNFC_CARD lpCard) {
BYTE readIndex = 0;
BYTE serviceN = lpReq->m_ReadNoEnc.m_Rest[readIndex++];
for (BYTE i = 0; i < serviceN; i++) {
WORD service = *(LPWORD)(&lpReq->m_ReadNoEnc.m_Rest[readIndex++]);
readIndex++;
}
BYTE blockCount = lpReq->m_ReadNoEnc.m_Rest[readIndex++];
lpResponse->m_FelicaLen = FelicaRespSize(lpResponse->m_ReadNoEnc) + 16 * blockCount;
lpResponse->m_FelicaCommand = FelicaCommand_ReadNoEnc_Response;
memcpy(&lpResponse->m_IDm, &lpReq->m_ReadNoEnc.m_IDm, sizeof lpReq->m_ReadNoEnc.m_IDm);
lpResponse->m_ReadNoEnc.m_Status1 = FelicaStatus1_Success;
lpResponse->m_ReadNoEnc.m_Status2 = FelicaStatus2_Success;
lpResponse->m_ReadNoEnc.m_BlockCount = blockCount;
BYTE writeIndex = 0;
for (BYTE i = 0; i < blockCount; i++) {
BYTE blHeader = lpReq->m_ReadNoEnc.m_Rest[readIndex++];
BOOL isExtended = !(blHeader & 0x80);
BYTE serviceCodeOrder = blHeader & 0x0f;
BYTE accessMode = (blHeader & 0x70) >> 4;
WORD blockNumber;
if (isExtended) {
blockNumber = *(LPWORD)(&lpReq->m_ReadNoEnc.m_Rest[readIndex++]);
readIndex++;
} else {
blockNumber = lpReq->m_ReadNoEnc.m_Rest[readIndex++];
}
if (blockNumber < 0xf) {
memcpy(&lpResponse->m_ReadNoEnc.m_BlockData[writeIndex],
lpCard->m_FeliCaData.m_UserBlocks[blockNumber].bytes, 16);
log_warning(plfAime, "Felica read: s:%x block:%04x", serviceCodeOrder, blockNumber);
writeIndex += 16;
} else if (blockNumber >= 0x80 && blockNumber < 0x89) {
if (blockNumber - 0x80 == FelicaSystemBlock_MAC) {
log_info(plfAime, "MAC challenge requested");
DWORD64 ID[2] = { 0 };
memcpy(ID, &lpCard->m_FeliCaData.m_SystemBlock_ID, 16);
KEY_PAIR CK, SK;
DWORD64* RC = (DWORD64*)&lpCard->m_FeliCaData.m_SystemBlock_RC.m_RC;
FelicaMacGenerateCK(ID, CK);
FelicaMacGenerateSK(RC, CK, SK);
DWORD64 mac = FelicaMacGenerateMAC(ID, SK, RC);
mac = _byteswap_uint64(mac);
memcpy(&lpResponse->m_ReadNoEnc.m_BlockData[writeIndex], &mac, 8);
memset(&lpResponse->m_ReadNoEnc.m_BlockData[writeIndex + 8], 0, 8);
log_warning(plfAime, "Felica read: s:%x block:%04x", serviceCodeOrder, blockNumber);
writeIndex += 16;
} else {
memcpy(&lpResponse->m_ReadNoEnc.m_BlockData[writeIndex],
lpCard->m_FeliCaData.m_SystemBlocks[blockNumber - 0x80].bytes, 16);
log_warning(plfAime, "Felica read: s:%x block:%04x", serviceCodeOrder, blockNumber);
writeIndex += 16;
}
} else {
// Invalid block, but we're already committed to the success state because I'm lazy,
// so just write a bunch of nulls.
memset(&lpResponse->m_ReadNoEnc.m_BlockData[writeIndex], 0, 16);
log_warning(plfAime, "Felica read: s:%x block:%04x", serviceCodeOrder, blockNumber);
writeIndex += 16;
}
}
}
void FelicaWriteNoEnc(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse,
PNFC_CARD lpCard) {
BYTE readIndex = 0;
BYTE serviceN = lpReq->m_WriteNoEnc.m_Rest[readIndex++];
for (BYTE i = 0; i < serviceN; i++) {
WORD service = *(LPWORD)(&lpReq->m_WriteNoEnc.m_Rest[readIndex++]);
readIndex++;
}
BYTE blockCount = lpReq->m_WriteNoEnc.m_Rest[readIndex++];
for (BYTE i = 0; i < blockCount; i++) {
BYTE blHeader = lpReq->m_WriteNoEnc.m_Rest[readIndex++];
BOOL isExtended = !(blHeader & 0x80);
BYTE serviceCodeOrder = blHeader & 0x0f;
BYTE accessMode = (blHeader & 0x70) >> 4;
WORD blockNumber;
if (isExtended) {
blockNumber = *(LPWORD)(&lpReq->m_WriteNoEnc.m_Rest[readIndex++]);
readIndex++;
} else {
blockNumber = lpReq->m_WriteNoEnc.m_Rest[readIndex++];
}
log_warning(plfAime, "Felica write: s:%x block:%04x", serviceCodeOrder, blockNumber);
// TODO: Access controls!
if (blockNumber < 0xf) {
memcpy(lpCard->m_FeliCaData.m_UserBlocks[blockNumber].bytes,
&lpReq->m_WriteNoEnc.m_Rest[readIndex], 16);
readIndex += 16;
} else if (blockNumber >= 0x80 && blockNumber < 0x89) {
memcpy(lpCard->m_FeliCaData.m_SystemBlocks[blockNumber - 0x80].bytes,
&lpReq->m_WriteNoEnc.m_Rest[readIndex], 16);
readIndex += 16;
} else {
// Invalid block, but I'd rather just steamroll through it for the sake of
// compatability, so don't error.
readIndex += 16;
}
}
lpResponse->m_FelicaLen = FelicaRespSize(lpResponse->m_WriteNoEnc);
lpResponse->m_FelicaCommand = FelicaCommand_WriteNoEnc_Response;
memcpy(&lpResponse->m_IDm, &lpReq->m_WriteNoEnc.m_IDm, sizeof lpReq->m_WriteNoEnc.m_IDm);
lpResponse->m_WriteNoEnc.m_Status1 = FelicaStatus1_Success;
lpResponse->m_WriteNoEnc.m_Status2 = FelicaStatus2_Success;
}
void FelicaSystemCode(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse,
PNFC_CARD lpCard) {
lpResponse->m_FelicaLen = FelicaRespSize(lpResponse->m_SystemCode);
lpResponse->m_FelicaCommand = FelicaCommand_RequestSystemCode_Response;
memcpy(&lpResponse->m_IDm, &lpReq->m_SystemCode.m_IDm, sizeof lpReq->m_SystemCode.m_IDm);
lpResponse->m_SystemCode.m_SystemsCount = 1;
lpResponse->m_SystemCode.m_SystemCode = lpCard->m_FeliCaData.m_SystemBlock_SYS_C.m_SYS_C;
}
void FelicaMobileActive2(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse,
PNFC_CARD lpCard) {
lpResponse->m_FelicaLen = FelicaRespSize(lpResponse->m_Active2);
lpResponse->m_FelicaCommand = FelicaCommand_MobileActive2_Response;
switch (lpReq->m_Active2.m_Val) {
case 0: // Alive check
lpResponse->m_Active2.m_Data = 0;
break;
case 1: // OS Version
switch (lpCard->m_FeliCa.m_PMm[1]) {
case FelicaChipType_Mobile_Ver10:
lpResponse->m_Active2.m_Data = 1;
break;
case FelicaChipType_Mobile_Ver20:
lpResponse->m_Active2.m_Data = 0;
break;
default:
// I have no idea what other chips return
lpResponse->m_Active2.m_Data = 0;
break;
}
break;
case 2:
lpResponse->m_Active2.m_Data = 0xff;
break;
}
}
void FelicaEncap(com_device_t* dev, comio_recv_head_t* req, LPBYTE lpPacket, PNFC_CARD lpCard) {
if (lpCard->m_Header.m_Type != CardType_FeliCa) {
log_error(plfAime, "Reader %02x requested a FeliCa encap on a non-FeliCa card!", req->dst);
comio_reply(dev, req, TN32Error_CardError, 0, NULL);
return;
}
PFelicaEncapRequest lpReq = (PFelicaEncapRequest)lpPacket;
FelicaEncapResponse fResponse;
FelicaCommand felicaCmd = lpReq->m_FelicaCommand;
fResponse.m_FelicaCommand = felicaCmd + 1;
fResponse.m_FelicaLen = 0;
/**
* Suica devices will:
* - FelicaCommand_Poll
* - FelicaCommand_RequestSystemCode
* - FelicaCommand_MobileActive2
*
* Others (maimai does not appear to disambiguate?) will:
* - FelicaCommand_Poll
* - FelicaCommand_ReadNoEnc (block 82)
* - FelicaCommand_WriteNoEnc (block 80)
* - FelicaCommand_ReadNoEnc (block 82,21)
* - FelicaCommand_ReadNoEnc (block 0D)
*/
log_game(plfAime, "FeliCa command: %02x", felicaCmd);
switch (felicaCmd) {
case FelicaCommand_Poll:
FelicaPoll(lpReq, &fResponse, lpCard);
break;
case FelicaCommand_ReadNoEnc:
FelicaReadNoEnc(lpReq, &fResponse, lpCard);
break;
case FelicaCommand_WriteNoEnc:
FelicaWriteNoEnc(lpReq, &fResponse, lpCard);
break;
case FelicaCommand_RequestSystemCode:
FelicaSystemCode(lpReq, &fResponse, lpCard);
break;
case FelicaCommand_MobileActive2:
FelicaMobileActive2(lpReq, &fResponse, lpCard);
break;
default:
log_error(plfAime, "Unknown FeliCa command: %02x", felicaCmd);
break;
}
comio_reply(dev, req, TN32Error_OK, fResponse.m_FelicaLen, &fResponse);
}

365
src/micetools/dll/devices/nfc/felica.h Normal file
View File

@ -0,0 +1,365 @@
#include <Windows.h>
#include "../_devices.h"
typedef struct FELICA_ID {
BYTE m_ID[8];
} FELICA_ID, *PFELICA_ID;
enum FelicaCommand {
FelicaCommand_Poll = 0x00,
FelicaCommand_Poll_Response = 0x01,
FelicaCommand_RequestService = 0x02,
FelicaCommand_RequestService_Response = 0x03,
FelicaCommand_RequestResponse = 0x04,
FelicaCommand_RequestResponse_Response = 0x05,
FelicaCommand_ReadNoEnc = 0x06,
FelicaCommand_ReadNoEnc_Response = 0x07,
FelicaCommand_WriteNoEnc = 0x08,
FelicaCommand_WriteNoEnc_Response = 0x09,
FelicaCommand_Search = 0x0a,
FelicaCommand_Search_Response = 0x0b,
FelicaCommand_RequestSystemCode = 0x0c,
FelicaCommand_RequestSystemCode_Response = 0x0d,
FelicaCommand_Authentication1 = 0x10,
FelicaCommand_Authentication1_Response = 0x11,
FelicaCommand_Authentication2 = 0x12,
FelicaCommand_Authentication2_Response = 0x13,
FelicaCommand_Read = 0x14,
FelicaCommand_Read_Response = 0x15,
FelicaCommand_Write = 0x16,
FelicaCommand_Write_Response = 0x17,
FelicaCommand_GetNodeProperty = 0x28,
FelicaCommand_GetNodeProperty_Response = 0x29,
FelicaCommand_RequestServiceV2 = 0x32,
FelicaCommand_RequestServiceV2_Response = 0x33,
FelicaCommand_InternalAuthAndRead = 0x34,
FelicaCommand_InternalAuthAndRead_Response = 0x35,
FelicaCommand_ExternalAuthAndRead = 0x36,
FelicaCommand_ExternalAuthAndRead_Response = 0x37,
FelicaCommand_GetSystemStatus = 0x38,
FelicaCommand_GetSystemStatus_Response = 0x39,
FelicaCommand_RequestSpecVersion = 0x3c,
FelicaCommand_RequestSpecVersion_Response = 0x3d,
FelicaCommand_ResetMode = 0x3e,
FelicaCommand_ResetMode_Response = 0x3f,
FelicaCommand_Authentication1V2 = 0x40,
FelicaCommand_Authentication1V2_Response = 0x41,
FelicaCommand_Authentication2V2 = 0x42,
FelicaCommand_Authentication2V2_Response = 0x43,
FelicaCommand_ReadV2 = 0x44,
FelicaCommand_ReadV2_Response = 0x45,
FelicaCommand_WriteV2 = 0x46,
FelicaCommand_WriteV2_Response = 0x47,
FelicaCommand_UpdateRandomID = 0x4C,
FelicaCommand_UpdateRandomID_Response = 0x4D,
FelicaCommand_SetNodeProperty = 0x78,
FelicaCommand_SetNodeProperty_Response = 0x79,
FelicaCommand_MobileActive2 = 0xa4,
FelicaCommand_MobileActive2_Response = 0xa5,
};
typedef BYTE FelicaCommand;
enum FelicaSystem {
FelicaSystem_Any = 0xffff,
FelicaSystem_NDEF = 0x12fc,
FelicaSystem_Emulator = 0x4000,
FelicaSystem_FelicaLite = 0x88b4,
FelicaSystem_FelicaSecureID = 0x957a,
FelicaSystem_JISX_Start = 0xaaa0,
FelicaSystem_JISX_End = 0xaafe,
FelicaSystem_CommonArea = 0xfe00,
FelicaSystem_FelicaPlug = 0xfee1,
FelicaSystem_Edy = 0xfe00,
FelicaSystem_Cyberne = 0x0003,
FelicaSystem_Suica = 0x0003,
FelicaSystem_Pasmo = 0x0003,
};
typedef WORD FelicaSystem;
enum FelicaService {
FelicaService_SuicaInOut = 0x108f,
FelicaService_SuicaHistory = 0x090f,
FelicaService_FelicaLiteRO = 0x0b00,
FelicaService_FelicaLiteEW = 0x0900,
};
typedef WORD FelicaService;
enum FelicaPollRequest {
FelicaPollRequest_NoRequest = 0x00,
FelicaPollRequest_SystemCode = 0x01,
FelicaPollRequest_CommPerformance = 0x02,
};
typedef BYTE FelicaPollRequest;
enum FelicaStatus1 {
FelicaStatus1_Success = 0x00,
// Everything between here is dynamically generated, and I cba
FelicaStatus1_Fatal = 0xFF,
};
typedef BYTE FelicaStatus1;
enum FelicaStatus2 {
// Generic
FelicaStatus2_Success = 0x00,
FelicaStatus2_Overflow = 0x01,
FelicaStatus2_CashbackExceeded = 0x02,
FelicaStatus2_PurseOutOfRange = 0x03,
FelicaStatus2_MemoryError = 0x70,
FelicaStatus2_RewritesExceeded = 0x71,
// Card specific
FelicaStatus2_IllegalServiceNumber = 0xA1,
FelicaStatus2_IllegalCommandPacket = 0xA2,
FelicaStatus2_IllegalBlockList = 0xA3,
FelicaStatus2_IllegalService = 0xA4,
FelicaStatus2_AccessDenied = 0xA5,
FelicaStatus2_IllegalServiceCode = 0xA6,
FelicaStatus2_IllegalBlockListAccess = 0xA7,
FelicaStatus2_IllegalBlockNumber = 0xA8,
FelicaStatus2_DataWriteFailure = 0xA9,
FelicaStatus2_KeyChangeFailure = 0xAA,
FelicaStatus2_IllegalParity = 0xAB,
FelicaStatus2_IllegalParameter = 0xAC,
FelicaStatus2_ServiceExists = 0xAD,
FelicaStatus2_IllegalSystemCode = 0xAE,
FelicaStatus2_TooManyWrites = 0xAF,
FelicaStatus2_IllegalPackage = 0xC0,
FelicaStatus2_PackageDiscrepancy = 0xC1,
FelicaStatus2_CommandDisabled = 0xC2,
FelicaStatus2_IllegalNodeProperty = 0xC3,
};
typedef BYTE FelicaStatus2;
// https://www.sony.net/Products/felica/business/tech-support/list.html
enum FelicaChipType {
FelicaChipType_STD_RC_S915 = 0x01,
FelicaChipType_STD_RC_S952 = 0x08,
FelicaChipType_STD_RC_S953 = 0x09,
FelicaChipType_STD_RC_S960 = 0x0D,
FelicaChipType_STD_RC_S962 = 0x20,
FelicaChipType_STD_RC_SA00_1 = 0x32,
FelicaChipType_STD_RC_SA20_1 = 0x44,
FelicaChipType_STD_RC_SA20_2 = 0x45,
FelicaChipType_Mobile_Ver10 = 0x06, // And 07h
FelicaChipType_Mobile_Ver20 = 0x10, // Up to 13h
FelicaChipType_Mobile_Ver30 = 0x14, // And 15h
FelicaChipType_Mobile_Ver40 = 0x17,
FelicaChipType_Mobile_Ver41 = 0x18, // Up to 1Fh
FelicaChipType_Lite = 0xf0, // RC-S965
FelicaChipType_LiteS = 0xf1, // RC-S966
FelicaChipType_Link_LiteS = 0xf2, // RC-S967
FelicaChipType_Link_Plug = 0xe1, // RC-S967
FelicaChipType_Link_NFC_DEP = 0xff, // RC-S967
FelicaChipType_Plug = 0xe0, // RC-S926
};
typedef BYTE FelicaChipType;
/**
* Multiple vendors make use of FeliCa cards for their amusement cards, but we
* can disamiguate them based on the specific FeliCa chip they use.
*
* Mobile phones will be using the Mobile chip versions. The specific OS
* version only matters for when the game is requesting to send mail or open a
* URL in the browser.
*
* The now-common Amusement IC cards all use FeliCa Lite or FeliCa LiteS. We
* choose to emulate our AIC cards as LiteS (RC-S966).
*
* Banapasses (BNG) also use FeliCa, however use FeliCa standard. We're going
* to keep things simple and just emulate RC-S915.
*/
typedef enum FelicaEmulationMode {
// Emulate a Suica mobile phone (FelicaChipType_Mobile_Ver**)
FelicaEmulationMode_Suica, // TODO: Which OS version do we want to emulate?
// Emulate an AmusementIC card (FelicaChipType_LiteS)
FelicaEmulationMode_AIC,
// Emulate a Banapass card (FelicaChipType_STD_RC_S915)
FelicaEmulationMode_BNG,
} FelicaEmulationMode;
typedef enum FelicaAICVendor {
FelicaAICVendor_BandaiNamcoGames, // FeliCa Lite, never used afaik
FelicaAICVendor_BandaiNamcoEntertainment, // FeliCa LiteS
FelicaAICVendor_SEGA, // FeliCa LiteS
FelicaAICVendor_Konami, // FeliCa LiteS
} FelicaAICVendor;
#define FelicaSystemBlock_RC 0x00
#define FelicaSystemBlock_MAC 0x01
#define FelicaSystemBlock_ID 0x02
#define FelicaSystemBlock_D_ID 0x03
#define FelicaSystemBlock_SER_C 0x04
#define FelicaSystemBlock_SYS_C 0x05
#define FelicaSystemBlock_CKV 0x06
#define FelicaSystemBlock_CK 0x07
#define FelicaSystemBlock_MC 0x08
#pragma pack(push, 1)
typedef struct FelicaBlock {
BYTE bytes[16];
} FelicaBlock_t, *PFelicaBlock_t;
typedef struct FelicaBlock_RC {
union {
struct {
DWORD64 m_RC1;
DWORD64 m_RC2;
};
DWORD64 m_RC[2];
};
} FelicaBlock_RC;
typedef struct FelicaBlock_MAC {
BYTE m_MAC[8];
BYTE Rsv08[8];
} FelicaBlock_MAC;
typedef struct FelicaBlock_ID {
FELICA_ID m_FelicaId;
BYTE m_DFC[2];
BYTE m_Arbitrary[6];
} FelicaBlock_ID;
typedef struct FelicaBlock_D_ID {
FELICA_ID m_FelicaId;
BYTE m_PMm[8];
} FelicaBlock_D_ID;
typedef struct FelicaBlock_SER_C {
BYTE m_SER_C[2];
BYTE Rsv02[14];
} FelicaBlock_SER_C;
typedef struct FelicaBlock_SYS_C {
WORD m_SYS_C;
BYTE Rsv02[14];
} FelicaBlock_SYS_C;
typedef struct FelicaBlock_CKV {
BYTE m_CKV[2];
BYTE Rsv02[14];
} FelicaBlock_CKV;
typedef struct FelicaBlock_CK {
BYTE m_CK1[8];
BYTE m_CK2[8];
} FelicaBlock_CK;
typedef struct FelicaBlock_MC {
// I really don't want to map this all out, and don't think I need to.
// So I'm not going to.
// Page 30 on the below URL if ever actually needed.
// https://www.sony.net/Products/felica/business/tech-support/data/fls_usmnl_1.31.pdf
BYTE Rsv00[16];
} FelicaBlock_MC;
typedef struct FelicaMemory {
FelicaEmulationMode m_EmuMode;
FelicaAICVendor m_AICVendor;
FelicaBlock_t m_UserBlocks[15];
union {
FelicaBlock_t m_SystemBlocks[9];
struct {
FelicaBlock_RC m_SystemBlock_RC;
FelicaBlock_MAC m_SystemBlock_MAC;
FelicaBlock_ID m_SystemBlock_ID;
FelicaBlock_D_ID m_SystemBlock_D_ID;
FelicaBlock_SER_C m_SystemBlock_SER_C;
FelicaBlock_SYS_C m_SystemBlock_SYS_C;
FelicaBlock_CKV m_SystemBlock_CKV;
FelicaBlock_CK m_SystemBlock_CK;
FelicaBlock_MC m_SystemBlock_MC;
};
};
} FelicaMemory_t;
typedef struct FelicaRequest_Poll {
FelicaSystem m_SystemCode;
FelicaPollRequest m_Request;
BYTE m_TimeSlot;
} FelicaRequest_Poll, *PFelicaRequest_Poll;
typedef struct FelicaResponse_Poll {
BYTE m_PMm[8];
WORD m_Value;
} FelicaResponse_Poll, *PFelicaResponse_Poll;
typedef struct FelicaRequest_ReadNoEnc {
FELICA_ID m_IDm;
BYTE m_Rest[];
} FelicaRequest_ReadNoEnc, *PFelicaRequest_ReadNoEnc;
typedef struct FelicaResponse_ReadNoEnc {
BYTE m_Status1;
BYTE m_Status2;
BYTE m_BlockCount;
BYTE m_BlockData[];
} FelicaResponse_ReadNoEnc, *PFelicaResponse_ReadNoEnc;
typedef struct FelicaRequest_WriteNoEnc {
FELICA_ID m_IDm;
BYTE m_Rest[];
} FelicaRequest_WriteNoEnc, *PFelicaRequest_WriteNoEnc;
typedef struct FelicaResponse_WriteNoEnc {
BYTE m_Status1;
BYTE m_Status2;
} FelicaResponse_WriteNoEnc, *PFelicaResponse_WriteNoEnc;
typedef struct FelicaRequest_SystemCode {
FELICA_ID m_IDm;
} FelicaRequest_SystemCode, *PFelicaRequest_SystemCode;
typedef struct FelicaResponse_SystemCode {
BYTE m_SystemsCount;
WORD m_SystemCode;
} FelicaResponse_SystemCode, *PFelicaResponse_SystemCode;
typedef struct FelicaRequest_Active2 {
FELICA_ID m_IDm;
BYTE m_Val;
} FelicaRequest_Active2, *PFelicaRequest_Active2;
typedef struct FelicaResponse_Active2 {
BYTE m_Data;
} FelicaResponse_Active2, *PFelicaResponse_Active2;
typedef struct FelicaEncapRequest {
FELICA_ID m_IDm;
BYTE m_FelicaLen;
BYTE m_FelicaCommand;
union {
FelicaRequest_Poll m_Poll;
FelicaRequest_ReadNoEnc m_ReadNoEnc;
FelicaRequest_WriteNoEnc m_WriteNoEnc;
FelicaRequest_SystemCode m_SystemCode;
FelicaRequest_Active2 m_Active2;
BYTE m_Body[238];
};
} FelicaEncapRequest, *PFelicaEncapRequest;
typedef struct FelicaEncapResponse {
BYTE m_FelicaLen;
BYTE m_FelicaCommand;
FELICA_ID m_IDm;
union {
FelicaResponse_Poll m_Poll;
FelicaResponse_ReadNoEnc m_ReadNoEnc;
FelicaResponse_WriteNoEnc m_WriteNoEnc;
FelicaResponse_SystemCode m_SystemCode;
FelicaResponse_Active2 m_Active2;
BYTE m_Body[246];
};
} FelicaEncapResponse, *PFelicaEncapResponse;
#pragma pack(pop)
#define FelicaRespSize(x) (10 + sizeof x)
#ifndef _NFC_H
typedef struct NFC_CARD NFC_CARD, *PNFC_CARD;
typedef struct ACCESS_CODE ACCESS_CODE, *PACCESS_CODE;
#define _NFC_H
#endif
void FelicaPoll(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse, PNFC_CARD lpCard);
void FelicaReadNoEnc(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse, PNFC_CARD lpCard);
void FelicaWriteNoEnc(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse, PNFC_CARD lpCard);
void FelicaSystemCode(PFelicaEncapRequest lpReq, PFelicaEncapResponse lpResponse, PNFC_CARD lpCard);
void FelicaEncap(com_device_t* dev, comio_recv_head_t* req, LPBYTE lpPacket, PNFC_CARD lpCard);
void FelicaPopulate(PNFC_CARD lpCard, PFELICA_ID lpFelicaId, PACCESS_CODE lpAccessCode);

15
src/micetools/dll/devices/nfc/mifare.h Normal file
View File

@ -0,0 +1,15 @@
#include <Windows.h>
#pragma pack(push, 1)
typedef struct MifareBlock {
BYTE bytes[16];
} MifareBlock_t;
typedef struct MifareSector {
MifareBlock_t blocks[4];
} MifareSector_t;
typedef struct MifareMemory_t {
MifareSector_t sectors[16];
} MifareMemory_t;
#pragma pack(pop)

65
src/micetools/dll/devices/nfc/nfc.h Normal file
View File

@ -0,0 +1,65 @@
#pragma once
#include <Windows.h>
#include "felica.h"
#include "mifare.h"
enum CardType {
CardType_Unknown = 0x00,
CardType_Mifare = 0x10,
CardType_FeliCa = 0x20,
};
typedef BYTE CardType;
struct ACCESS_CODE {
BYTE m_AC[10];
};
#ifndef _NFC_H
typedef struct NFC_CARD NFC_CARD, *PNFC_CARD;
typedef struct ACCESS_CODE ACCESS_CODE, *PACCESS_CODE;
#define _NFC_H
#endif
#pragma pack(push, 1)
struct NFC_CARD {
struct {
BYTE m_Type;
BYTE m_IdLen;
} m_Header;
union {
struct {
union {
FELICA_ID m_IDm;
struct {
WORD m_Code; // Manufacturer code
WORD m_Machine; // Manufacturer machine
INT16 m_Date; // Days since 2000-01-01
WORD m_Serial; // Daily serial
};
};
union {
BYTE m_PMm[8];
struct {
BYTE m_RomType;
FelicaChipType m_ICType;
BYTE m_Response[6]; // Response time information
};
};
} m_FeliCa;
struct {
DWORD m_Uid;
} m_Mifare;
struct {
BYTE Unk00[7];
} m_Amiibo;
};
union {
MifareMemory_t m_MifareData;
FelicaMemory_t m_FeliCaData;
};
};
#pragma pack(pop)
#define NFC_FeliCaSize (sizeof((PNFC_CARD)0)->m_Header + sizeof((PNFC_CARD)0)->m_FeliCa)
#define NFC_MifareSize (sizeof((PNFC_CARD)0)->m_Header + sizeof((PNFC_CARD)0)->m_Mifare)

717
src/micetools/dll/devices/ser_tn32msec.c
View File

@ -1,218 +1,290 @@
/*
FeliCa Lite:
AIC cards starting with 300x, 302x, and 303x contain their AIC number in block 0D
*/
#include "ser_tn32msec.h"
#include "../../lib/mice/solitaire.h"
#include "_devices.h"
#include "nfc/nfc.h"
static BYTE read_one(com_device_t* dev) {
while (!comdev_available(dev)) Sleep(50);
BYTE data;
comdev_read(dev, &data, 1);
return data;
static BYTE extra[0xff];
BYTE cardLED_RGB_P1[3];
BYTE cardLED_RGB_P2[3];
static char* OpcodeNames[256];
typedef enum TN32_FwVer {
TN32_FwVer_10 = 0x10, // 1.0
TN32_FwVer_12 = 0x12, // 1.2
} TN32_FwVer;
TN32_FwVer FIRMWARE_VERSION = TN32_FwVer_10;
static const char FWVer00[] = "TN32MSEC003S F/W Ver0.0"; // Not a real firmware version
static const char FWVer10[] = "TN32MSEC003S F/W Ver1.0";
static const char FWVer12[] = "TN32MSEC003S F/W Ver1.2";
static const char HWVer[] = "TN32MSEC003S H/W Ver3.0";
NFC_CARD nfcCardReaderP1;
NFC_CARD nfcCardReaderP2;
#define READER_P1_ADDR 0x00
#define READER_P2_ADDR 0x01
#define READER_P1_LED_ADDR 0x08
#define READER_P2_LED_ADDR 0x09
CHAR cardIdentifier1P[32];
CHAR cardIdentifier2P[32];
static LPCSTR GetCardIdentifier(DWORD player) {
LPCSTR card = player == 0 ? MiceConfig.aime.player1_card : MiceConfig.aime.player2_card;
LPCSTR cardFile =
player == 0 ? MiceConfig.aime.player1_cardfile : MiceConfig.aime.player2_cardfile;
LPSTR cardIdentifier = player == 0 ? cardIdentifier1P : cardIdentifier2P;
if (_PathFileExistsA(cardFile)) {
log_info(plfAime, "Reading P%d card from %s", player + 1, cardFile);
HANDLE hFile =
_CreateFileA(cardFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (hFile == INVALID_HANDLE_VALUE) {
log_warning(plfAime, "Failed to open %s for reading", cardFile);
} else {
DWORD nRead;
if (!_ReadFile(hFile, cardIdentifier, 32, &nRead, NULL)) {
log_error(plfAime, "Failed to read from %s", cardFile);
} else {
card = cardIdentifier;
}
_CloseHandle(hFile);
}
} else if (card == NULL || strlen(card) == 0) {
log_error(plfAime,
"No card specified for Player %d. Either specify a card in settings, or place a "
"card ID into %s",
player + 1, cardFile);
}
return card == NULL ? "" : card;
}
BYTE extra[0xff];
/**
* 51 and 55 are guesses based on the code. Makes sense given their opcodes
* too.
* TODO: Validate against a real board
* @brief Convert a card identification string to either an access code or felica ID
*
* Supported card formats:
* Access codes (AiMe Mifare cards):
* "1234-1234-1234-1234-1234"
* "1234 1234 1234 1234 1234"
* "12341234123412341234"
* FeliCa IDm (AIC cards):
* "0134567890123456"
* "01 34 56 78 90 12 34 56"
*/
enum TN32_Opcode {
TN32Op_GetFWVersion = 0x30,
TN32Op_GetHWVersion = 0x32,
static CardType TN32GetCardInfo(LPCSTR lpIdentifier, PACCESS_CODE lpAccessCode,
PFELICA_ID lpFelicaId) {
DWORD nChars;
DWORD len = strlen(lpIdentifier);
TN32Op_RadioOn = 0x40,
TN32Op_RadioOff = 0x41,
TN32Op_Poll = 0x42,
TN32Op_MifareSelectTag = 0x43,
TN32Op_CardHalt = 0x44,
TN32Op_SetKeyBana = 0x50,
TN32Op_GetKeyBana = 0x51,
TN32Op_ReadBlock = 0x52,
TN32Op_WriteBlock = 0x53,
TN32Op_SetKeyAime = 0x54,
TN32Op_GetKeyAime = 0x55,
// Firmware update
TN32Op_EnterUpdaterMode = 0x60,
TN32Op_SendHex = 0x61,
TN32Op_Reset = 0x62,
TN32Op_SendBindata = 0x63,
TN32Op_BindataExec = 0x64,
// Felica
TN32Op_FelicaPush = 0x70,
TN32Op_FelicaEncap = 0x71,
// No responses to either
Led_SetColour = 0x80,
Led_SetColourRGB = 0x81,
Led_GetInfo = 0xf0,
Led_FirmwareSum = 0xf2,
Led_SendHex = 0xf3,
Led_EnterBootMode = 0xf4,
Led_Reset = 0xf5,
};
char* OpcodeNames[256];
const char FWVer[] = "TN32MSEC003S F/W Ver1.2";
const char HWVer[] = "TN32MSEC003S H/W Ver3.0";
#define CardType_Mifare 0x10
#define CardType_FeliCa 0x20
#pragma pack(push, 1)
typedef struct NFCMifare {
BYTE type;
BYTE id_len;
DWORD uid;
} NFCMifare_t;
typedef struct NFCFelica {
BYTE type;
BYTE id_len;
uint64_t IDm;
uint64_t PMm;
} NFCFelica_t;
typedef struct MifareBlock {
BYTE bytes[16];
} MifareBlock_t;
typedef struct MifareSector {
MifareBlock_t blocks[4];
} MifareSector_t;
typedef struct MifareMemory_t {
MifareSector_t sectors[16];
} MifareMemory_t;
typedef struct FelicaBlock {
BYTE bytes[16];
} FelicaBlock_t;
typedef struct FelicaMemory {
FelicaBlock_t dataBlocks[15];
FelicaBlock_t systemBlocks[9];
} FelicaMemory_t;
#pragma pack(pop)
MifareMemory_t mifareMemory;
FelicaMemory_t felicaMemory;
BYTE luid[10] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89 };
#define PMm_VALUE 0x00F1000000014300ULL
#define FelicaSystemBlock_RC 0x00
#define FelicaSystemBlock_MAC 0x01
#define FelicaSystemBlock_ID 0x02
#define FelicaSystemBlock_D_ID 0x03
#define FelicaSystemBlock_SER_C 0x04
#define FelicaSystemBlock_SYS_C 0x05
#define FelicaSystemBlock_CKV 0x06
#define FelicaSystemBlock_CK 0x07
#define FelicaSystemBlock_MC 0x08
void populate_felica(NFCFelica_t* card) {
card->type = CardType_FeliCa;
card->id_len = sizeof(card->IDm) + sizeof(card->PMm);
card->IDm = _byteswap_uint64(0x012E4CD8A30A39B3ULL);
card->PMm = _byteswap_uint64(PMm_VALUE);
// Key name
felicaMemory.dataBlocks[0x0D].bytes[0] = 0x00;
felicaMemory.dataBlocks[0x0D].bytes[1] = 0x02;
felicaMemory.dataBlocks[0x0D].bytes[2] = 'N';
felicaMemory.dataBlocks[0x0D].bytes[3] = 'B';
felicaMemory.dataBlocks[0x0D].bytes[4] = 'G';
felicaMemory.dataBlocks[0x0D].bytes[5] = 'I';
felicaMemory.dataBlocks[0x0D].bytes[6] = 'C';
felicaMemory.dataBlocks[0x0D].bytes[7] = '0';
// Setup the fake blowfish data
felicaMemory.dataBlocks[0x0D].bytes[8] = 0x89;
felicaMemory.dataBlocks[0x0D].bytes[9] = 0x00;
felicaMemory.dataBlocks[0x0D].bytes[10] = 0x00;
felicaMemory.dataBlocks[0x0D].bytes[11] = 0x00;
felicaMemory.dataBlocks[0x0D].bytes[12] = 0x00;
felicaMemory.dataBlocks[0x0D].bytes[13] = 0x00;
felicaMemory.dataBlocks[0x0D].bytes[14] = 0x00;
felicaMemory.dataBlocks[0x0D].bytes[15] = 0x00;
BYTE block0[16] = {
0xC2, 0x1C, 0xCB, 0xC7, 0x58, 0xCA, 0x81, 0xB7,
0xC0, 0x0B, 0x8E, 0x3A, 0x45, 0x43, 0xFE, 0xFC,
};
memcpy(felicaMemory.dataBlocks[0].bytes, block0, 16);
memset(felicaMemory.dataBlocks[0x0e].bytes, 0xFF, 16);
BYTE blockID[16] = {
// IDd (=IDm)
0x01, 0x2E, 0x4C, 0xD8, 0xA3, 0x0A, 0x39, 0xB3,
// ID
0x00, 0x2a, 0x05, 0x73, 0x02, 0x01, 0x03, 0x00,
// ^DFC^ ^~~~~~ arbitary value
};
memcpy(felicaMemory.systemBlocks[FelicaSystemBlock_ID].bytes, blockID, 16);
BYTE blockDID[16] = {
// IDd (=IDm)
0x01,
0x2E,
0x4C,
0xD8,
0xA3,
0x0A,
0x39,
0xB3,
// PMm
0x00,
0xF1,
0x00,
0x00,
0x00,
0x01,
0x43,
0x00,
};
memcpy(felicaMemory.systemBlocks[FelicaSystemBlock_D_ID].bytes, blockDID, 16);
if (len == 24) {
if (sscanf_s(lpIdentifier,
"%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%n",
&lpAccessCode->m_AC[0], &lpAccessCode->m_AC[1], &lpAccessCode->m_AC[2],
&lpAccessCode->m_AC[3], &lpAccessCode->m_AC[4], &lpAccessCode->m_AC[5],
&lpAccessCode->m_AC[6], &lpAccessCode->m_AC[7], &lpAccessCode->m_AC[8],
&lpAccessCode->m_AC[9], &nChars) == 10 &&
nChars == 24) {
return CardType_Mifare;
}
if (sscanf_s(lpIdentifier,
"%02hhx%02hhx %02hhx%02hhx %02hhx%02hhx %02hhx%02hhx %02hhx%02hhx%n",
&lpAccessCode->m_AC[0], &lpAccessCode->m_AC[1], &lpAccessCode->m_AC[2],
&lpAccessCode->m_AC[3], &lpAccessCode->m_AC[4], &lpAccessCode->m_AC[5],
&lpAccessCode->m_AC[6], &lpAccessCode->m_AC[7], &lpAccessCode->m_AC[8],
&lpAccessCode->m_AC[9], &nChars) == 10 &&
nChars == 24) {
return CardType_Mifare;
}
} else if (len == 20) {
if (sscanf_s(lpIdentifier, "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%n",
&lpAccessCode->m_AC[0], &lpAccessCode->m_AC[1], &lpAccessCode->m_AC[2],
&lpAccessCode->m_AC[3], &lpAccessCode->m_AC[4], &lpAccessCode->m_AC[5],
&lpAccessCode->m_AC[6], &lpAccessCode->m_AC[7], &lpAccessCode->m_AC[8],
&lpAccessCode->m_AC[9], &nChars) == 10 &&
nChars == 20)
return CardType_Mifare;
} else if (len == 16) {
if (sscanf_s(lpIdentifier, "%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%n",
&lpFelicaId->m_ID[0], &lpFelicaId->m_ID[1], &lpFelicaId->m_ID[2],
&lpFelicaId->m_ID[3], &lpFelicaId->m_ID[4], &lpFelicaId->m_ID[5],
&lpFelicaId->m_ID[6], &lpFelicaId->m_ID[7], &nChars) == 8 &&
nChars == 16)
return CardType_FeliCa;
} else if (len == 23) {
if (sscanf_s(lpIdentifier, "%02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx%n",
&lpFelicaId->m_ID[0], &lpFelicaId->m_ID[1], &lpFelicaId->m_ID[2],
&lpFelicaId->m_ID[3], &lpFelicaId->m_ID[4], &lpFelicaId->m_ID[5],
&lpFelicaId->m_ID[6], &lpFelicaId->m_ID[7], &nChars) == 8 &&
nChars == 23)
return CardType_FeliCa;
}
return CardType_Unknown;
}
void populate_mifare(NFCMifare_t* card) {
card->type = CardType_Mifare;
card->id_len = sizeof(card->uid);
card->uid = _byteswap_ulong(0x01020304);
// TODO: Better state haha
// Flash the card memory
#define ACKEY_ACCESSCODE_LEN 20
#define ACKEY_ACCESSHEADER_ID_LEN 5
#define ACKEY_SERIAL_LEN 8
static DWORD AccessCodeToSerial(PACCESS_CODE lpAccessCode) {
char accessCode[ACKEY_ACCESSCODE_LEN + 1];
sprintf_s(accessCode, sizeof accessCode, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
lpAccessCode->m_AC[0], lpAccessCode->m_AC[1], lpAccessCode->m_AC[2],
lpAccessCode->m_AC[3], lpAccessCode->m_AC[4], lpAccessCode->m_AC[5],
lpAccessCode->m_AC[6], lpAccessCode->m_AC[7], lpAccessCode->m_AC[8],
lpAccessCode->m_AC[9]);
char hashed_id_wrk[ACKEY_SERIAL_LEN + 1];
char id_wrk[ACKEY_SERIAL_LEN + 1];
memcpy_s(hashed_id_wrk, sizeof(hashed_id_wrk), &accessCode[ACKEY_ACCESSHEADER_ID_LEN],
ACKEY_SERIAL_LEN);
hashed_id_wrk[ACKEY_SERIAL_LEN] = '\0';
SolitaireCipherDecode(&accessCode[ACKEY_ACCESSHEADER_ID_LEN + ACKEY_SERIAL_LEN], hashed_id_wrk,
id_wrk);
return atoi(id_wrk);
}
static void MifarePopulate(PNFC_CARD lpCard, PACCESS_CODE lpAccessCode) {
lpCard->m_Header.m_IdLen = sizeof(lpCard->m_Mifare);
DWORD nSerial = AccessCodeToSerial(lpAccessCode);
lpCard->m_Mifare.m_Uid = nSerial;
printf("Serial: %d\n", nSerial);
// Block 0: Manufacture data (only used by BNG)
// Block 1: Game ID information (kCARD_DETECT_KEY_B_READ_1)
const char GAME_ID[4] = { 'S', 'B', 'S', 'D' };
memcpy_s(&lpCard->m_MifareData.sectors[0].blocks[1].bytes[0],
sizeof lpCard->m_MifareData.sectors[0].blocks[1].bytes, GAME_ID, 4);
lpCard->m_MifareData.sectors[0].blocks[1].bytes[12] = (nSerial >> 24) & 0xff;
lpCard->m_MifareData.sectors[0].blocks[1].bytes[13] = (nSerial >> 16) & 0xff;
lpCard->m_MifareData.sectors[0].blocks[1].bytes[14] = (nSerial >> 8) & 0xff;
lpCard->m_MifareData.sectors[0].blocks[1].bytes[15] = nSerial & 0xff;
// Block 2: Access code (kCARD_DETECT_KEY_B_READ_2)
memcpy_s(&lpCard->m_MifareData.sectors[0].blocks[2].bytes[6],
sizeof lpCard->m_MifareData.sectors[0].blocks[2].bytes - 6, lpAccessCode->m_AC,
sizeof lpAccessCode->m_AC);
}
void AmiiboPopulate(PNFC_CARD lpCard) {
// What _is_ the ID though?
lpCard->m_Header.m_IdLen = sizeof(lpCard->m_Mifare);
// Write the card
for (BYTE i = 0; i < 10; i++) {
BYTE b = luid[i];
mifareMemory.sectors[0].blocks[2].bytes[i + 6] = b;
mifareMemory.sectors[0].blocks[1].bytes[i + 6] = b;
lpCard->m_MifareData.sectors[0].blocks[21].bytes[i] = 0;
}
}
void nfc_poll(com_device_t* dev, comio_recv_head_t* req) {
BYTE TN32PopulateCard(PNFC_CARD lpCard, LPCSTR lpIdentifier) {
ACCESS_CODE accessCode;
FELICA_ID felicaId;
CardType type = TN32GetCardInfo(lpIdentifier, &accessCode, &felicaId);
if (type == CardType_Unknown) {
log_error(plfAime, "Unable to parse card: %s", lpIdentifier);
return 0;
}
lpCard->m_Header.m_Type = type;
if (type == CardType_Mifare) {
log_info(plfAime,
"Inserting card: %02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx",
accessCode.m_AC[0], accessCode.m_AC[1], accessCode.m_AC[2], accessCode.m_AC[3],
accessCode.m_AC[4], accessCode.m_AC[5], accessCode.m_AC[6], accessCode.m_AC[7],
accessCode.m_AC[8], accessCode.m_AC[9]);
MifarePopulate(lpCard, &accessCode);
return NFC_MifareSize;
} else if (type == CardType_FeliCa) {
log_info(plfAime, "Inserting card: %02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",
felicaId.m_ID[0], felicaId.m_ID[1], felicaId.m_ID[2], felicaId.m_ID[3],
felicaId.m_ID[4], felicaId.m_ID[5], felicaId.m_ID[6], felicaId.m_ID[7]);
// TODO: FeliCa AIC cards can take an access code in their first block,
// and we support this. Figure out a nice way to allow this to be
// specified by users. That said, I'm not sure if anything in the Ring
// series actually uses this.
FelicaPopulate(lpCard, &felicaId, NULL);
return NFC_FeliCaSize;
}
return 0;
}
static void nfc_poll(com_device_t* dev, comio_recv_head_t* req) {
BYTE data[256];
data[0] = 0;
BYTE nbytes = 1;
// felica present
if (GetAsyncKeyState('L') < 0) {
NFCFelica_t card;
populate_felica(&card);
memcpy(data + nbytes, &card, sizeof card);
nbytes += sizeof card;
data[0]++;
}
// mifare (aime, bana) present
if (GetAsyncKeyState('P') < 0) {
NFCMifare_t card;
populate_mifare(&card);
memcpy(data + nbytes, &card, sizeof card);
nbytes += sizeof card;
data[0]++;
}
BOOL p1 = req->dst == READER_P1_ADDR;
comio_reply(dev, req, COMIO_STATUS_OK, nbytes, data);
PNFC_CARD lpCard = p1 ? &nfcCardReaderP1 : &nfcCardReaderP2;
SHORT key = GetAsyncKeyState(p1 ? 'P' : 'L');
if (key < 0) {
LPCSTR cardId = GetCardIdentifier(p1 ? 0 : 1);
BYTE nCardBytes = TN32PopulateCard(lpCard, cardId);
if (nCardBytes) {
memcpy(data + nbytes, lpCard, nCardBytes);
nbytes += nCardBytes;
data[0]++;
}
}
comio_reply(dev, req, TN32Error_OK, nbytes, data);
}
BYTE AIME_KEY[6];
BYTE BANA_KEY[6];
// Games don't expect this to be preloaded, but we might as well
BYTE AIME_KEY[6] = { 0x57, 0x43, 0x43, 0x46, 0x76, 0x32 };
BYTE BANA_KEY[6] = { 0x60, 0x90, 0xd0, 0x06, 0x32, 0xf5 };
void MifareBlockRead(com_device_t* dev, comio_recv_head_t* req, LPBYTE lpPacket, PNFC_CARD lpCard) {
// langth = 4 bytes uid + 1 byte block
if (req->length != 5) {
log_warning(plfAime, "Mifare read packet bad: %d", req->length);
comio_reply(dev, req, TN32Error_InvalidData, 0, NULL);
return;
}
if (lpCard->m_Header.m_Type != CardType_Mifare) {
log_error(plfAime, "Reader %02x requested a Mifare read on a non-Mifare card!", req->dst);
comio_reply(dev, req, TN32Error_CardError, 0, NULL);
return;
}
DWORD uid = *((LPDWORD)(&lpPacket[0]));
BYTE blockNo = lpPacket[4];
if (blockNo > 3) {
log_warning(plfAime, "Mifare block out of range: %d", blockNo);
comio_reply(dev, req, TN32Error_CardError, 0, NULL);
return;
}
if (lpCard->m_Mifare.m_Uid != uid) {
log_error(plfAime,
"Reader %02x requested to read card %08x. Currently present card is %08x.", uid,
lpCard->m_Mifare.m_Uid);
comio_reply(dev, req, TN32Error_CardError, 0, NULL);
return;
}
log_misc(plfAime, "Read mifare block: %d", blockNo);
MifareBlock_t* block = &(lpCard->m_MifareData.sectors[0].blocks[blockNo]);
comio_reply(dev, req, TN32Error_OK, sizeof *block, block->bytes);
}
DWORD WINAPI aime_bd_thread(com_device_t* dev) {
static int fwNumBytes = 0;
@ -224,80 +296,167 @@ DWORD WINAPI aime_bd_thread(com_device_t* dev) {
comio_recv_head_t req;
unsigned char sum = comio_next_req(dev, &req, extra);
log_info(plfAime, "(%d) %02x(%d) = %s", req.dst, req.op, req.length, OpcodeNames[req.op]);
log_trace(plfAime, "(%d) %02x(%d) = %s", req.dst, req.op, req.length, OpcodeNames[req.op]);
// Proxy 1P reader to hardware COM1. Used for debugging; preserved because it might end up
// useful again in the future. Allowing proxying to hardware a first-party feature could be
// cool down the line, but would need much much nicer code than this :D
/*
if (req.dst == READER_P1_ADDR) {
HANDLE hCom = _CreateFileA("\\\\.\\COM1", GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, 0, NULL);
DWORD nWrote;
BYTE data = 0xE0;
BYTE mark = 0xD0;
_WriteFile(hCom, &data, 1, &nWrote, NULL);
for (int i = 0; i < sizeof req; i++) {
data = ((LPBYTE)&req)[i];
if (data == 0xE0 || data == 0xD0) {
_WriteFile(hCom, &mark, 1, &nWrote, NULL);
data--;
}
_WriteFile(hCom, &data, 1, &nWrote, NULL);
}
for (int i = 0; i < req.length; i++) {
data = extra[i];
if (data == 0xE0 || data == 0xD0) {
_WriteFile(hCom, &mark, 1, &nWrote, NULL);
data--;
}
_WriteFile(hCom, &data, 1, &nWrote, NULL);
}
data = sum;
if (data == 0xE0 || data == 0xD0) {
_WriteFile(hCom, &mark, 1, &nWrote, NULL);
data--;
}
_WriteFile(hCom, &data, 1, &nWrote, NULL);
Sleep(250);
BYTE readBuf[4096];
DWORD nRead;
_ReadFile(hCom, readBuf, 4096, &nRead, NULL);
log_game(plfAime, "Transact read: %d", nRead);
for (DWORD i = 0; i < nRead; i++) printf("%02x ", readBuf[i]);
puts("");
comdev_write(dev, readBuf, nRead);
_CloseHandle(hCom);
continue;
}
*/
if (req.dst == READER_P1_ADDR || req.dst == READER_P2_ADDR) {
PNFC_CARD lpCard = req.dst == READER_P1_ADDR ? &nfcCardReaderP1 : &nfcCardReaderP2;
if (req.dst == 0x00 || req.dst == 0x01) {
// Aime readers
switch (req.op) {
case TN32Op_Reset:
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
break;
// Core
case TN32Op_GetFWVersion:
// BYTE fver = 0x10;
// comio_reply(dev, &req, COMIO_STATUS_OK, 1, &fver);
comio_reply(dev, &req, COMIO_STATUS_OK, sizeof FWVer - 1, (LPBYTE)FWVer);
if (FIRMWARE_VERSION == TN32_FwVer_10)
comio_reply(dev, &req, TN32Error_OK, sizeof FWVer10 - 1, (LPBYTE)FWVer10);
else if (FIRMWARE_VERSION == TN32_FwVer_12)
comio_reply(dev, &req, TN32Error_OK, sizeof FWVer12 - 1, (LPBYTE)FWVer12);
else
comio_reply(dev, &req, TN32Error_OK, sizeof FWVer00 - 1, (LPBYTE)FWVer00);
break;
case TN32Op_GetHWVersion:
// BYTE hver = 0x10;
// comio_reply(dev, &req, COMIO_STATUS_OK, 1, &hver);
comio_reply(dev, &req, COMIO_STATUS_OK, sizeof HWVer - 1, (LPBYTE)HWVer);
comio_reply(dev, &req, TN32Error_OK, sizeof HWVer - 1, (LPBYTE)HWVer);
break;
case TN32Op_SetKeyAime:
if (req.length != sizeof AIME_KEY) {
comio_reply(dev, &req, COMIO_STATUS_NG, 0, NULL);
} else {
memcpy(AIME_KEY, extra, sizeof AIME_KEY);
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
log_info(plfAime, "Aime key: %02x %02x %02x %02x %02x %02x", AIME_KEY[0],
AIME_KEY[1], AIME_KEY[2], AIME_KEY[3], AIME_KEY[4], AIME_KEY[5]);
}
break;
case TN32Op_SetKeyBana:
if (req.length != sizeof BANA_KEY) {
comio_reply(dev, &req, COMIO_STATUS_NG, 0, NULL);
} else {
memcpy(BANA_KEY, extra, sizeof BANA_KEY);
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
log_info(plfAime, "Bana key: %02x %02x %02x %02x %02x %02x", BANA_KEY[0],
BANA_KEY[1], BANA_KEY[2], BANA_KEY[3], BANA_KEY[4], BANA_KEY[5]);
}
break;
// Radio
case TN32Op_RadioOn:
radio = true;
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
case TN32Op_RadioOff:
radio = false;
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
case TN32Op_Poll:
case TN32Op_CardDetect:
nfc_poll(dev, &req);
break;
case TN32Op_GetKeyBana:
case TN32Op_GetKeyAime:
if (req.length != 5) {
//
}
case TN32Op_CardHalt:
case TN32Op_MifareSelectTag:
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
// TODO: What's this?
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
case TN32Op_CardSelect:
// TODO: Card stacks, for games that need those
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
// Mifare
case TN32Op_MifareKeySetA:
if (req.length != sizeof BANA_KEY) {
comio_reply(dev, &req, TN32Error_InvalidData, 0, NULL);
} else {
memcpy(BANA_KEY, extra, sizeof BANA_KEY);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
log_misc(plfAime, "Bana key: %02x %02x %02x %02x %02x %02x", BANA_KEY[0],
BANA_KEY[1], BANA_KEY[2], BANA_KEY[3], BANA_KEY[4], BANA_KEY[5]);
}
break;
case TN32Op_MifareKeySetB:
if (req.length != sizeof AIME_KEY) {
comio_reply(dev, &req, TN32Error_InvalidData, 0, NULL);
} else {
memcpy(AIME_KEY, extra, sizeof AIME_KEY);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
log_misc(plfAime, "Aime key: %02x %02x %02x %02x %02x %02x", AIME_KEY[0],
AIME_KEY[1], AIME_KEY[2], AIME_KEY[3], AIME_KEY[4], AIME_KEY[5]);
}
break;
case TN32Op_MifareRead:
/**
* All Mifare reads AiMeLib can perform:
*
* kCARD_DETECT_KEY_B_READ_0: [0]
* kCARD_DETECT_KEY_B_READ_1: [1]
* kCARD_DETECT_KEY_B_READ_2: [2]
* kCARD_DETECT_KEY_A_READ_0: [0]
* kCARD_DETECT_KEY_A_READ_1: [1]
* kCARD_DETECT_KEY_A_READ_2: [2]
*
* kCARD_DETECT_NAUTH_READ: [21] Amiibo things
* https://www.reddit.com/r/amiibo/comments/38rdll/my_research_on_amiibo_id_this_time_about/
* > Pages 21 and 22 are character IDs
* https://www.reddit.com/r/amiibo/comments/38p4a0/my_research_on_amiibo_id_including_variants_types/
*
* Supporting Amiibos is probably not worth doing until we find a game that
* actually uses them!
*/
MifareBlockRead(dev, &req, extra, lpCard);
break;
case TN32Op_MifareWrite:
// TODO: Do we want to support writing?
comio_reply(dev, &req, TN32Error_InvalidCommand, 0, NULL);
break;
case TN32Op_MifareAuthorizeA:
case TN32Op_MifareAuthorizeB:
// TODO: We probably should?
if (req.length != 5) {
}
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
// Firmware control
case TN32Op_EnterUpdaterMode:
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
case TN32Op_SendHex:
// null-terminated line of the firmware hex!
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
log_info(plfAime, "Recv firmware: %s", extra);
break;
case TN32Op_Reset:
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
case TN32Op_SendBindata:
fwNumBytes = 0;
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
case TN32Op_BindataExec:
// Raw binary firmware data
@ -319,35 +478,61 @@ DWORD WINAPI aime_bd_thread(com_device_t* dev) {
if (fwNumBytes >= 0x3000)
;
else
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
// TODO: These
case TN32Op_ReadBlock:
comio_reply(dev, &req, COMIO_STATUS_NG, 0, NULL);
// Felica
case TN32Op_FelicaPush:
// TODO: Implement mail and url opening?
comio_reply(dev, &req, TN32Error_InvalidCommand, 0, NULL);
break;
case TN32Op_FelicaEncap:
comio_reply(dev, &req, COMIO_STATUS_NG, 0, NULL);
if (FIRMWARE_VERSION == TN32_FwVer_12) {
FelicaEncap(dev, &req, extra, lpCard);
} else {
/**
* Firmware version 1.0 has no support for FeliCa
* proxying, and just returns Invalid Command for 70h
* and 71h. maimai is absolutely happy with this, and
* will just use the IDm from the Poll request without
* querying the card further.
*
* In fact, maimai _cannot_ function with newer
* firmware, due to an outdated restriction within
* AiMeLib that only allows BNG cards.
*/
comio_reply(dev, &req, TN32Error_InvalidCommand, 0, NULL);
}
break;
}
} else if (req.dst == 0x08 || req.dst == 0x09) {
} else if (req.dst == READER_P1_LED_ADDR || req.dst == READER_P2_LED_ADDR) {
// LED sub-boards
switch (req.op) {
case Led_Reset:
comio_reply(dev, &req, COMIO_STATUS_OK, 0, NULL);
comio_reply(dev, &req, TN32Error_OK, 0, NULL);
break;
case Led_GetInfo:
// TODO: I'm not sure what this actually means.
// 838-15084 is probably a part number
comio_reply(dev, &req, COMIO_STATUS_OK, 9, (BYTE*)"15084\xff\x10\x00\x12");
// Format:
// 0xff-delimited board info string
// 1 byte, board version
comio_reply(dev, &req, TN32Error_OK, 9, (BYTE*)"15084\xff\x10");
break;
case Led_SetColour:
log_misc(plfAime, "Set LED: %02x @ %02x intensity", extra[0], extra[1]);
break;
case Led_SetColourRGB:
log_misc(plfAime, "Set LED: #%02x%02x%02x", extra[0], extra[1], extra[2]);
printf(
"\033[48;2;%d;%d;%dm "
" \033[0m",
extra[0], extra[1], extra[2]);
// No response expected here!
// TODO: Bring this back, in a nicer way
if (req.dst == READER_P1_LED_ADDR) {
cardLED_RGB_P1[0] = extra[0];
cardLED_RGB_P1[1] = extra[1];
cardLED_RGB_P1[2] = extra[2];
} else {
cardLED_RGB_P2[0] = extra[0];
cardLED_RGB_P2[1] = extra[1];
cardLED_RGB_P2[2] = extra[2];
}
break;
}
}
@ -362,15 +547,15 @@ void install_aime_bd() {
OpcodeNames[TN32Op_GetHWVersion] = "GetHWVersion";
OpcodeNames[TN32Op_RadioOn] = "RadioOn";
OpcodeNames[TN32Op_RadioOff] = "RadioOff";
OpcodeNames[TN32Op_Poll] = "Poll";
OpcodeNames[TN32Op_MifareSelectTag] = "MifareSelectTag";
OpcodeNames[TN32Op_CardDetect] = "CardDetect";
OpcodeNames[TN32Op_CardSelect] = "CardSelect";
OpcodeNames[TN32Op_CardHalt] = "CardHalt";
OpcodeNames[TN32Op_SetKeyBana] = "SetKeyBana";
OpcodeNames[TN32Op_GetKeyBana] = "GetKeyBana";
OpcodeNames[TN32Op_ReadBlock] = "ReadBlock";
OpcodeNames[TN32Op_WriteBlock] = "WriteBlock";
OpcodeNames[TN32Op_SetKeyAime] = "SetKeyAime";
OpcodeNames[TN32Op_GetKeyAime] = "GetKeyAime";
OpcodeNames[TN32Op_MifareKeySetA] = "MifareKeySetA";
OpcodeNames[TN32Op_MifareAuthorizeA] = "MifareAuthorizeA";
OpcodeNames[TN32Op_MifareRead] = "MifareRead";
OpcodeNames[TN32Op_MifareWrite] = "MifareWrite";
OpcodeNames[TN32Op_MifareKeySetB] = "MifareKeySetB";
OpcodeNames[TN32Op_MifareAuthorizeB] = "MifareAuthorizeB";
OpcodeNames[TN32Op_EnterUpdaterMode] = "EnterUpdaterMode";
OpcodeNames[TN32Op_SendHex] = "SendHex";
OpcodeNames[TN32Op_Reset] = "Reset";

72
src/micetools/dll/devices/ser_tn32msec.h Normal file
View File

@ -0,0 +1,72 @@
#pragma once
#include <Windows.h>
#include <stdint.h>
#include "nfc/nfc.h"
enum TN32Error {
TN32Error_OK,
TN32Error_CardError,
TN32Error_NoAccept,
TN32Error_InvalidCommand,
TN32Error_InvalidData,
TN32Error_SumError,
TN32Error_HexError,
};
typedef BYTE TN32Error;
enum TN32ErrorLED {
TN32ErrorLED_OK,
TN32ErrorLED_CommandUnknown,
TN32ErrorLED_OverflowErr,
TN32ErrorLED_ParityErr,
TN32ErrorLED_OverrunErr,
TN32ErrorLED_FramingErr,
TN32ErrorLED_SumErr,
TN32ErrorLED_ParameterErr,
TN32ErrorLED_HexErr,
};
typedef BYTE TN32ErrorLED;
/**
* 51 and 55 are guesses based on the code. Makes sense given their opcodes
* too.
* TODO: Validate against a real board
*/
enum TN32_Opcode {
TN32Op_GetFWVersion = 0x30,
TN32Op_GetHWVersion = 0x32,
TN32Op_RadioOn = 0x40,
TN32Op_RadioOff = 0x41,
TN32Op_CardDetect = 0x42,
TN32Op_CardSelect = 0x43,
TN32Op_CardHalt = 0x44,
TN32Op_MifareKeySetA = 0x50, // BNG key
TN32Op_MifareAuthorizeA = 0x51,
TN32Op_MifareRead = 0x52,
TN32Op_MifareWrite = 0x53,
TN32Op_MifareKeySetB = 0x54, // AiMe key
TN32Op_MifareAuthorizeB = 0x55,
// Firmware update
TN32Op_EnterUpdaterMode = 0x60,
TN32Op_SendHex = 0x61,
TN32Op_Reset = 0x62,
TN32Op_SendBindata = 0x63,
TN32Op_BindataExec = 0x64,
// Felica
TN32Op_FelicaPush = 0x70,
TN32Op_FelicaEncap = 0x71,
// No responses to either
Led_SetColour = 0x80,
Led_SetColourRGB = 0x81,
Led_GetInfo = 0xf0,
Led_FirmwareSum = 0xf2,
Led_SendHex = 0xf3,
Led_EnterBootMode = 0xf4,
Led_Reset = 0xf5,
};

15
src/micetools/dll/devices/smb_at24c64an.c
View File

@ -42,13 +42,16 @@ void set_eeprom_static_config() {
.m_Region = MiceConfig.sysconf.region & (1 | 2 | 4 | 8),
.m_Rental = MiceConfig.sysconf.rental,
};
strcpy_s(Static.m_strSerialId, sizeof Static.m_strSerialId, MiceConfig.sysconf.serial);
ZeroMemory(Static.m_strSerialId, sizeof Static.m_strSerialId);
DWORD len = strlen(MiceConfig.sysconf.serial);
if (len > sizeof Static.m_strSerialId - 1) len = sizeof Static.m_strSerialId - 1;
memcpy(Static.m_strSerialId, MiceConfig.sysconf.serial, len);
fix_crc(Static);
memcpy(&EEPROM_DATA[AM_SYSDATAwH_STATIC_REG], &Static, sizeof Static);
memcpy(&EEPROM_DATA[AM_SYSDATAwH_STATIC_DUP], &Static, sizeof Static);
}
void build_eeprom() { // return;
void build_eeprom() { // return;
log_info(plfEeprom, "Building default EEPROM file");
memset(EEPROM_DATA, 0xff, EEPROM_SIZE);
@ -97,10 +100,10 @@ void eeprom_fixup() {
set_eeprom_static_config();
set_eeprom_network_config();
AmHistory.m_Region = MiceConfig.sysconf.region & (1 | 2 | 4 | 8);
fix_crc(AmHistory);
memcpy(&EEPROM_DATA[AM_SYSDATAwH_HISTORY_REG], &AmHistory, sizeof AmHistory);
memcpy(&EEPROM_DATA[AM_SYSDATAwH_HISTORY_DUP], &AmHistory, sizeof AmHistory);
// AmHistory.m_Region = MiceConfig.sysconf.region & (1 | 2 | 4 | 8);
// fix_crc(AmHistory);
// memcpy(&EEPROM_DATA[AM_SYSDATAwH_HISTORY_REG], &AmHistory, sizeof AmHistory);
// memcpy(&EEPROM_DATA[AM_SYSDATAwH_HISTORY_DUP], &AmHistory, sizeof AmHistory);
}
void ensure_valid_eeprom() {

8
src/micetools/dll/dllmain.c
View File

@ -143,7 +143,7 @@ void init_injection(HMODULE hModule) {
if (success) success &= MiceFSAddDevLayers();
MiceFSSetCwd(RING_MOUNT_GAME);
MiceFSSetCwd(RING_MOUNT_GAME "\\");
// Setup default COM devices
init_com_devices();
@ -187,8 +187,10 @@ void init_injection(HMODULE hModule) {
// OPENSSL_add_all_algorithms_noconf (old exe)
// ((void (*)(void))(0x00459770 + imageOffset))();
// OPENSSL_add_all_algorithms_noconf (new exe)
((void (*)(void))(0x00463480 + imageOffset))();
// OPENSSL_add_all_algorithms_noconf (pink exe)
// ((void (*)(void))(0x00463480 + imageOffset))();
// TODO: Find finale offset
}
setup_hooks();

58
src/micetools/dll/gui/gui.c
View File

@ -76,6 +76,7 @@ static bool showFps = false;
static bool showEeprom = false;
static bool showSram = false;
static bool showControl = false;
static bool showCardP1 = false;
void InitImGui(unsigned int hookType, IDirect3DDevice9* pDevice) {
if (hookType == UI_HOOK_DX9) {
@ -117,6 +118,34 @@ void InitImGui(unsigned int hookType, IDirect3DDevice9* pDevice) {
}
}
extern BYTE cardLED_RGB_P1[3];
extern BYTE cardLED_RGB_P2[3];
void hud_card(ImGuiKey open_key) {
if (igIsKeyPressed_Bool(open_key, false)) showCardP1 = !showCardP1;
if (!showCardP1) return;
igBegin("Card Reader", NULL, 0);
ImVec4 col;
col.w = 1.0f;
col.x = cardLED_RGB_P1[0] / 511.0f;
col.y = cardLED_RGB_P1[1] / 511.0f;
col.z = cardLED_RGB_P1[2] / 511.0f;
igPushStyleColor_Vec4(ImGuiCol_Button, col);
igButton("Insert card P1", vec0);
igPopStyleColor(1);
col.x = cardLED_RGB_P2[0] / 511.0f;
col.y = cardLED_RGB_P2[1] / 511.0f;
col.z = cardLED_RGB_P2[2] / 511.0f;
igPushStyleColor_Vec4(ImGuiCol_Button, col);
igButton("Insert card P2", vec0);
igPopStyleColor(1);
igEnd();
}
void hud_fps() {
if (igBegin("FPS", NULL,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse |
@ -898,6 +927,26 @@ void tab_main_keybinds() {
}
}
void tab_main_aime_cards() {
igText(
"Specify the cards to be inserted when using the TN32MSEC AiMe reader module.\nCards can be "
"specified as either an NFC ID or an access code.\nIf a card file is present, it will be "
"used preferentially.");
igColumns(2, "AimeWindow", true);
igSeparator();
bool changed = false;
changed |= AddSettingString("Player 1 Card ID", NULL, &MiceConfig.aime.player1_card);
changed |= AddSettingString("Player 2 Card ID", NULL, &MiceConfig.aime.player2_card);
changed |= AddSettingString("Player 1 Card File", NULL, &MiceConfig.aime.player1_cardfile);
changed |= AddSettingString("Player 2 Card File", NULL, &MiceConfig.aime.player2_cardfile);
igEndColumns();
if (changed) save_current_config();
}
void hud_control(ImGuiKey open_key) {
if (igIsKeyPressed_Bool(open_key, false)) showControl = !showControl;
if (!showControl) return;
@ -919,6 +968,12 @@ void hud_control(ImGuiKey open_key) {
igEndChild();
igEndTabItem();
}
if (igBeginTabItem("AiMe Cards", NULL, 0)) {
igBeginChild_Str("AiMe Cards", vec0, FALSE, 0);
tab_main_aime_cards();
igEndChild();
igEndTabItem();
}
if (igBeginTabItem("Settings", NULL, 0)) {
igBeginChild_Str("Settings", vec0, FALSE, 0);
tab_main_settings();
@ -935,7 +990,7 @@ void hud_control(ImGuiKey open_key) {
void __stdcall hud_gui(unsigned int hookType, IDirect3DDevice9* dev) {
static bool lastAnyOpen = false;
bool anyOpen = showControl || showEeprom || showSram;
bool anyOpen = showControl || showEeprom || showSram || showCardP1;
if (anyOpen != lastAnyOpen) {
changeCursorState = anyOpen ? 1 : 0;
lastAnyOpen = anyOpen;
@ -964,6 +1019,7 @@ void __stdcall hud_gui(unsigned int hookType, IDirect3DDevice9* dev) {
hud_eeprom(ImGuiKey_F11);
hud_sram(ImGuiKey_F10);
hud_control(ImGuiKey_F4);
hud_card(ImGuiKey_F5);
if (hookType == UI_HOOK_DX9) {
igEndFrame();

46
src/micetools/dll/hooks/drive/disks.c
View File

@ -62,6 +62,26 @@ physical_disk_t UPDATE_USB = {
},
.m_Extended = {{ 0 }},
};
physical_disk_t DOWNLOAD_USB = {
.m_BusType = BusTypeUsb,
.m_VID = "13FE",
.m_PID = "4200",
.m_BlockSize = BLOCK_SIZE_FLASH,
.m_TotalSize = 64 * 1024 * ((1024 * 1024) / BLOCK_SIZE_FLASH),
.m_IsFormatted = true,
.m_DiskType = DiskType_Flash,
.m_Partitions = {
// 59050 MB update partitions
{
.m_Size = 0xe6b410,
.m_Filesystem = MBR_FS_NTFS,
.m_Volume = {
.m_Name = "SEGA_DL",
},
},
},
.m_Extended = {{ 0 }},
};
physical_disk_t LOG_USB = {
.m_BusType = BusTypeUsb,
.m_VID = "13FE",
@ -83,6 +103,27 @@ physical_disk_t LOG_USB = {
},
.m_Extended = {{ 0 }},
};
physical_disk_t MAI_USB_DONGLE = {
.m_BusType = BusTypeUsb,
.m_VID = "13FE",
.m_PID = "4200",
.m_BlockSize = BLOCK_SIZE_FLASH,
.m_TotalSize = 16 * 1024 * ((1024 * 1024) / BLOCK_SIZE_FLASH),
.m_IsFormatted = true,
.m_DiskType = DiskType_Flash,
.m_Partitions = {
// 4 GB partition
{
.m_Size = 0x100000,
.m_Filesystem = MBR_FS_NTFS,
.m_Volume = {
.m_Name = "USBDONGLE",
.m_MountPoint = 'U',
},
},
},
.m_Extended = {{ 0 }},
};
physical_disk_t ALPHA_DVD = {
.m_BusType = BusTypeScsi,
.m_DeviceType = DeviceTypeCdRom,
@ -124,9 +165,12 @@ physical_disk_t APM_HDD = {
physical_disk_t* PHYSICAL_DISKS[] = {
&SSD,
&UPDATE_USB,
// &UPDATE_USB,
// &DOWNLOAD_USB,
// &APM_HDD,
// &MAI_USB_DONGLE,
// &LOG_USB,
// &ALPHA_DVD,
};

2
src/micetools/dll/hooks/drive/drive.c
View File

@ -366,6 +366,8 @@ inline static BOOL matchVolume(disk_volume_t* volume, LPCSTR lpRootPathName, DWO
if (match & VOL_MATCH_DOS_DEVICE && volume->m_MountPoint) {
if (char_lower(volume->m_MountPoint) == char_lower(lpRootPathName[0])) {
if (lpRootPathName[1] == ':' && lpRootPathName[2] == '\0') return TRUE;
if (lpRootPathName[1] == ':' && lpRootPathName[2] == '\\' && lpRootPathName[3] == '\0')
return TRUE;
}
}
return FALSE;

26
src/micetools/dll/hooks/drive/drive.h
View File

@ -113,20 +113,24 @@ void hook_drives();
#define MBR_FS_NTFS 0x07
#define MBR_FS_EXT_LBA 0x0F
#define MBR_BOOTSTRAP_SIZE 446
#pragma pack(push, 1)
typedef struct mbr {
BYTE bootstrap_code[446];
struct {
BYTE status;
BYTE start_chs[3];
BYTE type;
BYTE end_chs[3];
DWORD lba;
DWORD sectors;
} partitions[4];
typedef struct MBR_PARTITION {
BYTE status;
BYTE start_chs[3];
BYTE type;
BYTE end_chs[3];
DWORD lba;
DWORD sectors;
} MBR_PARTITION, *PMBR_PARTITION;
typedef struct MBR_HEADER {
BYTE bootstrap_code[MBR_BOOTSTRAP_SIZE];
MBR_PARTITION partitions[4];
BYTE sig[2];
} mbr_t;
} MBR_HEADER, *PMBR_HEADER;
#pragma pack(pop)
typedef MBR_HEADER mbr_t;
#define IOCTL_CDROM_GET_DRIVE_GEOMETRY 0x2404c // #include <Ntddcdrm.h> causes errors

6
src/micetools/dll/hooks/drive/hooks.c
View File

@ -89,6 +89,7 @@ BOOL WINAPI FakeGetVolumeInformationA(LPCSTR lpRootPathName, LPSTR lpVolumeNameB
LPDWORD lpMaximumComponentLength, LPDWORD lpFileSystemFlags,
LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize) {
disk_volume_t* volume = getVolumeByPath(lpRootPathName, VOL_MATCH_ALL);
log_game(plfDrive, "GetVolumeInformationA(%s) = %p", lpRootPathName, volume);
if (volume == NULL) return FALSE;
if (lpVolumeSerialNumber) *lpVolumeSerialNumber = volume->m_pDrive->m_SerialNumber;
@ -130,7 +131,8 @@ BOOL WINAPI FakeGetVolumeNameForVolumeMountPointA(LPCSTR lpszVolumeMountPoint, L
DWORD cchBufferLength) {
log_trace(plfDrive, "GetVolumeNameForVolumeMountPointA(%s)", lpszVolumeMountPoint);
disk_volume_t* volume = getVolumeByPath(lpszVolumeMountPoint, VOL_MATCH_PATH);
disk_volume_t* volume =
getVolumeByPath(lpszVolumeMountPoint, VOL_MATCH_PATH | VOL_MATCH_DOS_DEVICE);
if (volume == NULL) {
SetLastError(ERROR_FILE_NOT_FOUND);
return FALSE;
@ -141,7 +143,7 @@ BOOL WINAPI FakeGetVolumeNameForVolumeMountPointA(LPCSTR lpszVolumeMountPoint, L
}
BOOL WINAPI FakeGetVolumePathNamesForVolumeNameA(LPCSTR lpszVolumeName, LPCH lpszVolumePathNames,
DWORD cchBufferLength, PDWORD lpcchReturnLength) {
log_trace(plfDrive, "GetVolumeNameForVolumeMountPointA(%s)", lpszVolumeName);
log_trace(plfDrive, "FakeGetVolumePathNamesForVolumeNameA(%s)", lpszVolumeName);
disk_volume_t* volume = getVolumeByPath(lpszVolumeName, VOL_MATCH_GUID);
if (volume == NULL) {

74
src/micetools/dll/hooks/files.c
View File

@ -128,7 +128,10 @@ HANDLE WINAPI FakeCreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD d
MiceFSRedirectPathW(lpFileName, &lpFileName);
handle = TrueCreateFileW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
log_misc(plfHooks, "CreateFileW(%ls) -> 0x%p", lpFileName, handle);
if (handle == INVALID_HANDLE_VALUE)
log_warning(plfHooks, "CreateFileW(%ls) failed", lpFileName);
else
log_misc(plfHooks, "CreateFileW(%ls) -> 0x%p", lpFileName, handle);
return handle;
}
@ -149,7 +152,10 @@ HANDLE WINAPI FakeCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
MiceFSRedirectPathA(lpFileName, &lpFileName);
HANDLE handle = TrueCreateFileA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
log_misc(plfHooks, "CreateFileA(%s) -> 0x%p", lpFileName, handle);
if (handle == INVALID_HANDLE_VALUE)
log_warning(plfHooks, "CreateFileA(%s) failed", lpFileName);
else
log_misc(plfHooks, "CreateFileA(%s) -> 0x%p", lpFileName, handle);
return handle;
}
@ -320,17 +326,33 @@ BOOL WINAPI FakeCloseHandle(HANDLE hObject) {
return TrueCloseHandle(hObject);
}
int WINAPIV Fake_stat64i32(const char* path, struct _stat64i32* buffer) {
MiceFSRedirectPathA((char*)path, &path);
return True_stat64i32(path, buffer);
};
void FileTimeToTimet(__time64_t* t, LPFILETIME pft) {
ULARGE_INTEGER time_value;
time_value.HighPart = pft->dwHighDateTime;
time_value.LowPart = pft->dwLowDateTime;
*t = (time_value.QuadPart - 116444736000000000LL) / 10000000LL;
}
int WINAPIV Fake_stat64i32(const char* path, _stat64i32_t* buffer) {
MiceFSRedirectPathA(path, &path);
// NOTE: We can't use True_stat64i32 because it has issues with another other than dir-relative
// child paths
WIN32_FILE_ATTRIBUTE_DATA fileInformation;
if (!GetFileAttributesEx(path, GetFileExInfoStandard, &fileInformation)) return -1;
// TODO: Populate other values. ALLNetProc and OpenSSL only need st_size. atime/ctime are free
// so were added too.
buffer->st_size = fileInformation.nFileSizeLow;
FileTimeToTimet(&buffer->st_atime, &fileInformation.ftLastAccessTime);
FileTimeToTimet(&buffer->st_ctime, &fileInformation.ftCreationTime);
return 0x800;
}
DWORD WINAPI FakeGetFileAttributesA(LPCSTR lpFileName) {
// The game quits out if MiniDump is present!
if (PathEqual(lpFileName, "Y:\\MiniDump\\")) {
return 0;
}
MiceFSRedirectPathA(lpFileName, &lpFileName);
return TrueGetFileAttributesA(lpFileName);
}
@ -338,18 +360,36 @@ DWORD WINAPI FakeGetFileAttributesW(LPCWSTR lpFileName) {
MiceFSRedirectPathW(lpFileName, &lpFileName);
return TrueGetFileAttributesW(lpFileName);
}
BOOL WINAPI FakeCreateDirectoryA(LPCSTR lpFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes) {
MiceFSRedirectPathA(lpFileName, &lpFileName);
return TrueCreateDirectoryA(lpFileName, lpSecurityAttributes);
}
BOOL WINAPI FakeCreateDirectoryW(LPCWSTR lpFileName, LPSECURITY_ATTRIBUTES lpSecurityAttributes) {
MiceFSRedirectPathW(lpFileName, &lpFileName);
return TrueCreateDirectoryW(lpFileName, lpSecurityAttributes);
}
HANDLE WINAPI FakeFindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData) {
MiceFSRedirectPathA(lpFileName, &lpFileName);
return TrueFindFirstFileA(lpFileName, lpFindFileData);
}
DWORD WINAPI FakeGetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer) {
strcpy_s(lpBuffer, nBufferLength, MiceFSGetCwd());
return strnlen_s(lpBuffer, nBufferLength);
LPCSTR cwd = MiceFSGetCwd();
DWORD length = strlen(cwd);
if (nBufferLength < length + 1) {
return length + 1;
}
strcpy_s(lpBuffer, nBufferLength, cwd);
return length;
}
DWORD WINAPI FakeGetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer) {
MultiByteToWideChar(CP_ACP, 0, MiceFSGetCwd(), -1, lpBuffer, nBufferLength);
return wcsnlen_s(lpBuffer, nBufferLength);
LPCSTR cwd = MiceFSGetCwd();
DWORD length = strlen(cwd);
if (nBufferLength < (length + 1) * 2) {
return (length + 1) * 2;
}
MultiByteToWideChar(CP_ACP, 0, cwd, -1, lpBuffer, nBufferLength);
return length;
}
void hook_io() {
@ -380,6 +420,10 @@ void hook_io() {
(void**)&TrueGetFileAttributesA);
hook("Kernel32.dll", "GetFileAttributesW", FakeGetFileAttributesW,
(void**)&TrueGetFileAttributesW);
hook("Kernel32.dll", "CreateDirectoryA", FakeCreateDirectoryA,
(void**)&TrueCreateDirectoryA);
hook("Kernel32.dll", "CreateDirectoryW", FakeCreateDirectoryW,
(void**)&TrueCreateDirectoryW);
hook("MSVCR90.DLL", "_stat64i32", Fake_stat64i32, (void**)&True_stat64i32);
}

20
src/micetools/dll/hooks/files.h
View File

@ -5,6 +5,20 @@
#define _MICE_FILES extern
#endif
typedef struct {
unsigned int st_dev;
unsigned short st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
unsigned int st_rdev;
long st_size;
__time64_t st_atime;
__time64_t st_mtime;
__time64_t st_ctime;
} _stat64i32_t;
_MICE_FILES HANDLE(WINAPI* TrueCreateFileA)(LPCSTR lpFileName, DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
@ -40,6 +54,11 @@ _MICE_FILES BOOL(WINAPI* TrueDeleteFileW)(LPCWSTR lpFileName);
_MICE_FILES HANDLE(WINAPI* TrueFindFirstFileA)(LPCSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData);
_MICE_FILES DWORD(WINAPI* TrueGetFileAttributesA)(LPCSTR lpFileName);
_MICE_FILES DWORD(WINAPI* TrueGetFileAttributesW)(LPCWSTR lpFileName);
_MICE_FILES BOOL(WINAPI* TrueCreateDirectoryA)(LPCSTR lpFileName,
LPSECURITY_ATTRIBUTES lpSecurityAttributes);
_MICE_FILES BOOL(WINAPI* TrueCreateDirectoryW)(LPCWSTR lpFileName,
LPSECURITY_ATTRIBUTES lpSecurityAttributes);
_MICE_FILES DWORD(WINAPI* TrueGetCurrentDirectoryA)(DWORD nBufferLength, LPSTR lpBuffer);
_MICE_FILES DWORD(WINAPI* TrueGetCurrentDirectoryW)(DWORD nBufferLength, LPWSTR lpBuffer);
@ -65,7 +84,6 @@ typedef BOOL(FnReadFile)(file_context_t* ctx, LPVOID lpBuffer, DWORD nNumberOfBy
typedef BOOL(FnGetFileSizeEx)(file_context_t* ctx, PLARGE_INTEGER lpFileSize);
typedef struct _stat64i32 _stat64i32_t;
static int(WINAPIV* True_stat64i32)(const char* path, _stat64i32_t* buffer);
#define _WriteFile (TrueWriteFile ? TrueWriteFile : WriteFile)

63
src/micetools/dll/hooks/network.c
View File

@ -75,7 +75,7 @@ DWORD WINAPI FakeGetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
typedef struct {
char* name;
unsigned int* address;
const unsigned int* address;
} dns;
dns INTERCEPT_DNS[] = {
@ -114,7 +114,7 @@ DNS_STATUS WINAPI FakeDnsQuery_A(PCSTR pszName, WORD wType, DWORD Options, PVOID
}
}
}
log_warning(plfNetwork, "DNS passthrough for %s", pszName);
log_info(plfNetwork, "DNS passthrough for %s", pszName);
return TrueDnsQuery_A(pszName, wType, Options, pExtra, ppQueryResults, pReserved);
};
@ -129,17 +129,41 @@ INT WSAAPI FakeWSAStringToAddressA(LPSTR AddressString, INT AddressFamily,
lpAddress->sa_family = AF_INET;
PULONG addr = &(((SOCKADDR_IN*)lpAddress)->sin_addr.S_un.S_addr);
*addr = _byteswap_ulong(
*INTERCEPT_DNS[i]
.address); //(192UL) | (168UL << 8) | (103UL << 16) | (200UL << 24);
*addr = _byteswap_ulong(*INTERCEPT_DNS[i].address);
return ERROR_SUCCESS;
}
}
log_warning(plfNetwork, "WSA DNS passthrough for %s", AddressString);
log_info(plfNetwork, "WSA DNS passthrough for %s", AddressString);
return TrueWSAStringToAddressA(AddressString, AddressFamily, lpProtocolInfo, lpAddress,
lpAddressLength);
}
INT WINAPI Fake_getaddrinfo(PCSTR pNodeName, PCSTR pServiceName, const ADDRINFOA* pHints,
PADDRINFOA* ppResult) {
if (!pNodeName) return True_getaddrinfo(pNodeName, pServiceName, pHints, ppResult);
for (size_t i = 0; i < sizeof INTERCEPT_DNS / sizeof INTERCEPT_DNS[0]; i++) {
if (strcmp(pNodeName, INTERCEPT_DNS[i].name) == 0) {
char szNewAddress[16];
sprintf_s(szNewAddress, sizeof szNewAddress, "%d.%d.%d.%d",
(*INTERCEPT_DNS[i].address >> 24) & 0xff,
(*INTERCEPT_DNS[i].address >> 16) & 0xff,
(*INTERCEPT_DNS[i].address >> 8) & 0xff, *INTERCEPT_DNS[i].address & 0xff);
szNewAddress[sizeof szNewAddress - 1] = '\0';
log_info(plfNetwork, "GAI DNS Replacing %s with %s:%s", pNodeName, szNewAddress,
pServiceName);
return True_getaddrinfo(szNewAddress, pServiceName, pHints, ppResult);
}
}
// Exclude a few known services
if (strcmp(pNodeName, "0.0.0.0") != 0 && strcmp(pNodeName, "127.0.0.0") != 0 &&
strcmp(pNodeName, "240.0.0.0") != 0)
log_info(plfNetwork, "GAI DNS passthrough for %s:%s", pNodeName, pServiceName);
return True_getaddrinfo(pNodeName, pServiceName, pHints, ppResult);
}
int __stdcall Fake_socket(int domain, int type, int protocol) {
int sock = True_socket(domain, type, protocol);
log_trace(plfNetwork, "Creating new socket: %d/%s/%d -> %d", domain,
@ -179,9 +203,9 @@ int __stdcall Fake_sendto(SOCKET s, const char* buf, int len, int flags, const P
memcpy(&toLocalhost, to, sizeof toLocalhost);
toLocalhost.sin_addr.S_un.S_addr = 0x0100007f; // 127.0.0.1
log_warning(plfNetwork, "(probable) Ping to: %d.%d.%d.%d (%d). Redirecting to localhost",
addr & 0xff, (addr >> 8) & 0xff, (addr >> 16) & 0xff, addr >> 24,
((PSOCKADDR_IN)to)->sin_port, seq);
log_info(plfNetwork, "(probable) Ping to: %d.%d.%d.%d (%d). Redirecting to localhost",
addr & 0xff, (addr >> 8) & 0xff, (addr >> 16) & 0xff, addr >> 24,
((PSOCKADDR_IN)to)->sin_port, seq);
return True_sendto(s, buf, len, flags, (PSOCKADDR)&toLocalhost, tolen);
}
@ -189,13 +213,32 @@ int __stdcall Fake_sendto(SOCKET s, const char* buf, int len, int flags, const P
return True_sendto(s, buf, len, flags, to, tolen);
}
ULONG WINAPI FakeGetAdaptersAddresses(ULONG Family, ULONG Flags, PVOID Reserved,
PIP_ADAPTER_ADDRESSES AdapterAddresses, PULONG SizePointer) {
if (SizePointer == NULL || *SizePointer < sizeof *AdapterAddresses) {
if (SizePointer != NULL) *SizePointer = sizeof *AdapterAddresses;
return ERROR_BUFFER_OVERFLOW;
}
AdapterAddresses->PhysicalAddressLength = 6;
AdapterAddresses->PhysicalAddress[0] = MAC_PREFIX_0;
AdapterAddresses->PhysicalAddress[1] = MAC_PREFIX_1;
AdapterAddresses->PhysicalAddress[2] = MAC_PREFIX_2;
AdapterAddresses->PhysicalAddress[3] = (MiceConfig.network.mac >> 16) & 0xff;
AdapterAddresses->PhysicalAddress[4] = (MiceConfig.network.mac >> 8) & 0xff;
AdapterAddresses->PhysicalAddress[5] = MiceConfig.network.mac & 0xff;
return ERROR_SUCCESS;
};
void hook_network() {
hook("Ws2_32.dll", "connect", Fake_connect, (void**)&True_connect);
hook("Ws2_32.dll", "socket", Fake_socket, (void**)&True_socket);
hook("Ws2_32.dll", "bind", Fake_bind, (void**)&True_bind);
hook("Ws2_32.dll", "sendto", Fake_sendto, (void**)&True_sendto);
hook("Ws2_32.dll", "getaddrinfo", Fake_getaddrinfo, (void**)&True_getaddrinfo);
// hook("Ws2_32.dll", "sendto", Fake_sendto, (void**)&True_sendto);
hook("Ws2_32.dll", "WSAStringToAddressA", FakeWSAStringToAddressA,
(void**)&TrueWSAStringToAddressA);
hook("Iphlpapi.dll", "GetIfTable", FakeGetIfTable, (void**)&TrueGetIfTable);
hook("Dnsapi.dll", "DnsQuery_A", FakeDnsQuery_A, (void**)&TrueDnsQuery_A);
hook("Iphlpapi.dll", "GetAdaptersAddresses", FakeGetAdaptersAddresses, NULL);
}

2
src/micetools/dll/hooks/network.h
View File

@ -6,6 +6,8 @@ static int(WINAPI* True_connect)(SOCKET s, const SOCKADDR* name, int namelen);
static int(WINAPI* True_bind)(SOCKET s, const SOCKADDR* addr, int namelen);
static int(WINAPI* True_sendto)(SOCKET s, const char* buf, int len, int flags,
const struct sockaddr* to, int tolen);
static INT(WINAPI* True_getaddrinfo)(PCSTR pNodeName, PCSTR pServiceName, const ADDRINFOA* pHints,
PADDRINFOA* ppResult);
static DWORD(WINAPI* TrueGetIfTable)(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder);

11
src/micetools/dll/hooks/processes.c
View File

@ -15,8 +15,9 @@ BOOL WINAPI FakeCreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine,
lpProcessInformation);
}
if (strcmp(lpCommandLine, "s:\\mxkeychip.exe") == 0 ||
strcmp(lpCommandLine, "C:\\WINDOWS\\system32\\regini.exe S:\\default_regset.txt") == 0) {
if (lpCommandLine &&
(strcmp(lpCommandLine, "s:\\mxkeychip.exe") == 0 ||
strcmp(lpCommandLine, "C:\\WINDOWS\\system32\\regini.exe S:\\default_regset.txt") == 0)) {
if (lpProcessInformation) {
lpProcessInformation->hProcess = CreateEventA(NULL, FALSE, TRUE, NULL);
lpProcessInformation->hThread = CreateEventA(NULL, FALSE, TRUE, NULL);
@ -51,7 +52,11 @@ BOOL WINAPI FakeCreateProcessW(LPCWSTR lpApplicationName, LPWSTR lpCommandLine,
LPPROCESS_INFORMATION lpProcessInformation) {
log_info(plfProcesses, "CreateProcessW %ls %ls", lpApplicationName, lpCommandLine);
if (wcsncmp(lpCommandLine, L"chkdsk.exe", wcslen(L"chkdsk.exe")) == 0) {
// if (lpCommandLine && (wcscmp(lpCommandLine, L"chkdsk.exe") == 0 ||
// wcscmp(lpCommandLine, L"ALLNetProc_Win.exe") == 0 ||
// wcscmp(lpCommandLine, L"ALLNetProc_Ring.exe") == 0 ||
// wcscmp(lpCommandLine, L"ALLNetProc.exe") == 0)) {
if (lpCommandLine && (wcscmp(lpCommandLine, L"chkdsk.exe") == 0)) {
if (lpProcessInformation) {
lpProcessInformation->hProcess = CreateEventA(NULL, FALSE, TRUE, NULL);
lpProcessInformation->hThread = CreateEventA(NULL, FALSE, TRUE, NULL);

38
src/micetools/launcher/main.c
View File

@ -24,7 +24,7 @@ static void print_help(char* exe) {
static bool parse_cmdline(int argc, char* argv[]) {
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "-h") == 0) {
if (strcmp(argv[i], "--mice-h") == 0) {
print_help(argv[0]);
} else if (strcmp(argv[i], "-b") == 0) {
if (i + 1 == argc) print_help(argv[0]);
@ -92,7 +92,7 @@ static DWORD WINAPI MiceMailslotWatcher(HANDLE* pSlot) {
HANDLE hLogFile = INVALID_HANDLE_VALUE;
if (MiceConfig.mice.log_to_file) {
hLogFile = CreateFileA(MiceConfig.mice.log_file, GENERIC_WRITE, FILE_SHARE_READ, NULL,
hLogFile = CreateFileA(MiceConfig.mice.log_file, GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
CREATE_ALWAYS, 0, NULL);
if (hLogFile == INVALID_HANDLE_VALUE) {
fprintf(stderr, "Failed to initialise logging: open %s failed: %d",
@ -174,7 +174,41 @@ BOOL WINAPI MiceHandlerRoutine(DWORD CtrlType) {
ExitProcess(terminate(0));
}
#include "../lib/mice/spad.h"
int main(int argc, char* argv[]) {
// unsigned char spad_new_bytes[16] = {
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x06,
// 0x94, 0x87, 0x82, 0x60, 0x37, 0x73, 0x12, 0x13,
// };
// unsigned char spn[16];
// Spad0Encrypt(spn, spad_new_bytes);
// for (int i = 0; i < 8; i++) printf("%02x", spn[i]);
// puts("");
// for (int i = 8; i < 16; i++) printf("%02x", spn[i]);
// puts("");
// puts("--");
// unsigned char back_out[16];
// Spad0Decrypt(back_out, spn);
// for (int i = 0; i < 8; i++) printf("%02x", back_out[i]);
// puts("");
// for (int i = 8; i < 16; i++) printf("%02x", back_out[i]);
// puts("");
// unsigned char bng[16] = {
// 0xE6, 0xBC, 0x6D, 0x56, 0x83, 0xF6, 0xB6, 0x48,
// 0x4C, 0x24, 0xE4, 0x83, 0xD5, 0xE8, 0x93, 0x7F,
// };
// Spad0Decrypt(back_out, bng);
// for (int i = 0; i < 8; i++) printf("%02x", back_out[i]);
// puts("");
// for (int i = 8; i < 16; i++) printf("%02x", back_out[i]);
// puts("");
// return -1;
load_mice_config();
if (!setup_mailslot()) return 1;
setup_logging();

4
src/micetools/lib/_am.h
View File

@ -2,9 +2,9 @@
#define AM_LIB_C_HEADER(name, storage_type) \
int name##DebugLevel = 0; \
struct _##storage_type name; \
struct storage_type name; \
char* name##Version = #name " Ver.mice" MICE_VERSION " Build:" __DATE__ " " __TIME__;
#define AM_LIB_H_HEADER(name, storage_type) \
extern int name##DebugLevel; \
extern struct _##storage_type name; \
extern struct storage_type name; \
extern char* name##Version;

71
src/micetools/lib/am/amCmos.c Normal file
View File

@ -0,0 +1,71 @@
#include "amCmos.h"
AM_LIB_C_HEADER(amCmos, AM_CMOS)
AM_CMOS_STATUS amCmosInit(AM_CMOS_CONFIG *lpConfig) {
if (amCmos.m_bInit != 0) return AM_CMOS_STATUS_ERR_ALREADY_INIT;
if (lpConfig == NULL) return AM_CMOS_STATUS_ERR_INVALID_PARAM;
HANDLE hMutex = CreateMutexA(NULL, 0, "AM_CMOS_MUTEX");
if (hMutex == NULL) return AM_CMOS_STATUS_ERR_SYS;
HANDLE hCmos = CreateFileA("\\\\.\\mxcmos", 0xc0000000, 3, NULL, 3, 0, NULL);
if (hCmos == INVALID_HANDLE_VALUE) {
CloseHandle(hMutex);
return AM_CMOS_STATUS_ERR_OPEN_FAILED;
}
amCmos.m_bInit = TRUE;
amCmos.m_hMutex = hMutex;
amCmos.m_hCmos = hCmos;
memcpy(&amCmos.m_Config, lpConfig, sizeof *lpConfig);
return AM_CMOS_STATUS_OK;
}
AM_CMOS_STATUS amCmosExit(void) {
if (amCmos.m_bInit == 0) return AM_CMOS_STATUS_ERR_NO_INIT;
if (amCmos.m_hMutex != NULL) {
CloseHandle(amCmos.m_hMutex);
amCmos.m_hMutex = NULL;
}
if (amCmos.m_hCmos != INVALID_HANDLE_VALUE) {
CloseHandle(amCmos.m_hCmos);
amCmos.m_hCmos = INVALID_HANDLE_VALUE;
}
amCmos.m_bInit = FALSE;
return AM_CMOS_STATUS_OK;
}
AM_CMOS_STATUS amCmosReadByteInRearpart(BYTE nIndex, LPBYTE lpData) {
if (amCmos.m_bInit == 0) return AM_CMOS_STATUS_ERR_NO_INIT;
if (lpData == NULL || nIndex > 0x7f) return AM_CMOS_STATUS_ERR_INVALID_PARAM;
if (WaitForSingleObject(amCmos.m_hMutex, 0) != WAIT_OBJECT_0) return AM_CMOS_STATUS_ERR_LOCK;
BYTE request[2];
request[0] = nIndex;
request[1] = 0;
DWORD nBytesReturned;
BOOL bErr = DeviceIoControl(amCmos.m_hCmos, IOCTL_MXCMOS_READ, request, sizeof request, lpData,
1, &nBytesReturned, NULL);
int iRet = 0;
if (!bErr) {
iRet = AM_CMOS_STATUS_ERR_SYS;
} else {
iRet = nBytesReturned == 1 ? AM_CMOS_STATUS_OK : AM_CMOS_STATUS_ERR_SYS;
}
if (!ReleaseMutex(amCmos.m_hMutex)) {
if (amCmosDebugLevel > 0)
amiDebugLog("ReleaseMutex Error!! Error Code is %ld!!", GetLastError());
return AM_CMOS_STATUS_ERR_SYS;
}
return iRet;
}

40
src/micetools/lib/am/amCmos.h
View File

@ -1,3 +1,39 @@
void amCmosReadByteInRearpart(void);
void amCmosSetPartition(void);
#pragma once
#include <Windows.h>
#include "../../dll/smbus.h"
#include "../_am.h"
AM_LIB_H_HEADER(amCmos, AM_CMOS)
typedef enum {
AM_CMOS_STATUS_OK = 0,
AM_CMOS_STATUS_NG = -1,
AM_CMOS_STATUS_ERR_INVALID_PARAM = -2,
AM_CMOS_STATUS_ERR_NO_INIT = -3,
AM_CMOS_STATUS_ERR_ALREADY_INIT = -4,
AM_CMOS_STATUS_ERR_SYS = -5,
AM_CMOS_STATUS_ERR_OPEN_FAILED = -6,
AM_CMOS_STATUS_ERR_LOCK = -7,
} AM_CMOS_STATUS;
typedef struct AM_CMOS_CONFIG {
BYTE index[4];
BYTE m_MbrCount;
} AM_CMOS_CONFIG;
typedef struct AM_CMOS {
BOOL m_bInit;
HANDLE m_hMutex;
HANDLE m_hCmos;
AM_CMOS_CONFIG m_Config;
} AM_CMOS;
AM_CMOS_STATUS amCmosInit(AM_CMOS_CONFIG* lpConfig);
AM_CMOS_STATUS amCmosExit(void);
AM_CMOS_STATUS amCmosReadByteInRearpart(BYTE param_1, LPBYTE param_2);
void amCmosWriteByteInRearpart(void);
void amCmosSetPartition(void);

118
src/micetools/lib/am/amDipsw.c Normal file
View File

@ -0,0 +1,118 @@
#include "amDipsw.h"
#include <setupapi.h>
AM_LIB_C_HEADER(amDipsw, AM_DIPSW)
int amDipswCreateMutex(AM_DIPSW *this) {
SECURITY_ATTRIBUTES securityAttributes;
SECURITY_DESCRIPTOR securityDescriptor;
SID_IDENTIFIER_AUTHORITY sid;
PSID *ppSid = &this->m_Sid;
sid.Value[0] = '\0';
sid.Value[1] = '\0';
sid.Value[2] = '\0';
sid.Value[3] = '\0';
sid.Value[4] = '\0';
sid.Value[5] = '\x01';
if (!AllocateAndInitializeSid(&sid, '\x01', 0, 0, 0, 0, 0, 0, 0, 0, ppSid)) {
if (amDipswDebugLevel > 0) amiDebugLog("AllocateAndInitializeSid Error in amDipswInit.");
*ppSid = NULL;
goto fail_cleanup;
}
if (!InitializeSecurityDescriptor(&securityDescriptor, 1)) {
if (amDipswDebugLevel > 0)
amiDebugLog("InitializeSecurityDescriptor Error in amDipswInit.");
goto fail_cleanup;
}
if (!SetSecurityDescriptorDacl(&securityDescriptor, 1, NULL, 0)) {
if (amDipswDebugLevel > 0) amiDebugLog("SetSecurityDescriptorDacl Error in amDipswInit.");
goto fail_cleanup;
}
securityAttributes.lpSecurityDescriptor = &securityDescriptor;
securityAttributes.nLength = 0xc;
securityAttributes.bInheritHandle = 0;
HANDLE mutex = CreateMutexA(&securityAttributes, 0, "Global\\AM_PCA9535_MUTEX");
this->m_Mutex = mutex;
if (mutex != NULL) return 0;
if (amDipswDebugLevel > 0) amiDebugLog("CreateMutexA Error(%ld).", GetLastError());
fail_cleanup:
if (this->m_Mutex != NULL) {
CloseHandle(this->m_Mutex);
this->m_Mutex = NULL;
}
if (*ppSid != NULL) {
FreeSid(*ppSid);
*ppSid = NULL;
}
return -5;
}
HANDLE amDipswCreateDeviceFile(GUID *guid, DWORD memberIndex, char *name) {
HDEVINFO deviceInfoSet;
BOOL BVar3;
SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
SP_DEVICE_INTERFACE_DETAIL_DATA_A deviceInterfaceDetailData[204];
if (guid == NULL) {
if (amDipswDebugLevel > 0) amiDebugLog("PARAM Error.");
return INVALID_HANDLE_VALUE;
}
deviceInfoSet = SetupDiGetClassDevsA(guid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
if (deviceInfoSet == INVALID_HANDLE_VALUE) {
if (amDipswDebugLevel > 0) amiDebugLog("SetupDiGetClassDevs Error(%ld).", GetLastError());
return INVALID_HANDLE_VALUE;
}
char szFilename[260];
ZeroMemory(szFilename, 4);
deviceInterfaceData.cbSize = 0x1c;
if (!SetupDiEnumDeviceInterfaces(deviceInfoSet, NULL, guid, memberIndex, &deviceInterfaceData)) {
if (amDipswDebugLevel > 0)
amiDebugLog("SetupDiEnumDeviceInterfaces Error(%ld).", GetLastError());
} else {
deviceInterfaceDetailData[0].cbSize = 5;
if (SetupDiGetDeviceInterfaceDetailA(deviceInfoSet, &deviceInterfaceData,
deviceInterfaceDetailData, 0x400, NULL, NULL)) {
strcpy_s(szFilename, 4, deviceInterfaceDetailData[0].DevicePath);
if (name != NULL) {
strcat_s(szFilename, 4, "\\");
strcat_s(szFilename, 4, name);
}
SetupDiDestroyDeviceInfoList(deviceInfoSet);
return CreateFileA(szFilename, GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
FILE_SUPPORTS_GHOSTING, NULL);
}
if (amDipswDebugLevel > 0) amiDebugLog("SetupDiGetClassDevs Error(%ld).", GetLastError());
}
SetupDiDestroyDeviceInfoList(deviceInfoSet);
return INVALID_HANDLE_VALUE;
}
void amDipswExit(void);
void amDipswGetDriverVerision(void);
void amDipswInit(void);
void amDipswModifyByte(void);
void amDipswModifyByteEx(void);
void amDipswModifyByteInternal(void);
void amDipswModifyByteInternalEx(void);
void amDipswMxsmbusStatusCheck(void);
void amDipswReadByte(void);
void amDipswReadByteInternal(void);
void amDipswReadByteInternalEx(void);
void amDipswRequestGetDipsw(void);
void amDipswRequestGetPushsw(void);
void amDipswRequestReadByte(void);
void amDipswRequestSetJvsIoctl(void);
void amDipswRequestSetLed(void);
void amDipswResponse(void);
void amDipswResponseInternalEx(void);
void amDipswWriteByte(void);
void amDipswWriteByteInternal(void);
void amDipswWriteByteInternalEx(void);

23
src/micetools/lib/am/amDipsw.h
View File

@ -1,5 +1,24 @@
void amDipswCreateDeviceFile(void);
void amDipswCreateMutex(void);
#pragma once
#include <Windows.h>
#include "../_am.h"
AM_LIB_H_HEADER(amDipsw, AM_DIPSW)
typedef struct AM_DIPSW {
BOOL m_Init;
HANDLE m_Mutex;
HANDLE m_Handle;
BYTE m_Addr;
//
OVERLAPPED m_Overlapped;
PSID m_Sid;
} AM_DIPSW;
int amDipswCreateMutex(AM_DIPSW *this);
HANDLE amDipswCreateDeviceFile(GUID *guid, DWORD memberIndex, char *name);
void amDipswExit(void);
void amDipswGetDriverVerision(void);
void amDipswInit(void);

6
src/micetools/lib/am/amDongle.h
View File

@ -5,12 +5,12 @@
#include "../_am.h"
#include "../libpcp/pcpa.h"
typedef struct _AM_DONGLE_DS_CHALLENGE {
typedef struct AM_DONGLE_DS_CHALLENGE {
byte challenge[7];
byte pages[4][20];
} AM_DONGLE_DS_CHALLENGE;
typedef struct _AM_DONGLE_SSD_CHALLENGE {
typedef struct AM_DONGLE_SSD_CHALLENGE {
byte challenge[16];
byte response[16];
} AM_DONGLE_SSD_CHALLENGE;
@ -25,7 +25,7 @@ typedef enum {
AM_DONGLE_SEQ_DONE = 8,
} AM_DONGLE_SEQ;
typedef struct _AM_DONGLE {
typedef struct AM_DONGLE {
BOOL m_init;
BOOL done_init;
BOOL available;

2
src/micetools/lib/am/amEeprom.h
View File

@ -26,7 +26,7 @@ typedef struct {
int WriteTimeout;
} AM_EEPROM_TIMEOUT;
typedef struct _AM_EEPROM {
typedef struct AM_EEPROM {
BOOL m_init;
AM_EEPROM_TIMEOUT m_timeout;
HANDLE m_mutex;

2
src/micetools/lib/am/amInstall.h
View File

@ -144,7 +144,7 @@ typedef enum {
AM_INSTALL_REQUEST_18 = 18,
} AM_INSTALL_REQUEST;
typedef struct _AM_INSTALL {
typedef struct AM_INSTALL {
BOOL m_init;
AM_INSTALL_SEQ m_nextSeq;
AM_INSTALL_REQUEST m_requestCode;

1
src/micetools/lib/am/amNetwork.h
View File

@ -13,3 +13,4 @@ void amNetworkResponseCheck(void);
void amNetworkSendAndRecvEx(void);
void amNetworkSendRequest(void);
void amNetworkSetCommandModifyProperty(void);
void amNetworkPcpAddCommandInterface(void);

2
src/micetools/lib/am/amOemstring.h
View File

@ -14,7 +14,7 @@ typedef struct {
DWORD m_elementCount;
} AM_COLUMBA_REQUEST;
typedef struct _AM_OEMSTRING {
typedef struct AM_OEMSTRING {
BOOL m_loaded;
CHAR m_biosVersion[32];
CHAR m_biosDate[11];

12
src/micetools/lib/am/amPlatform.c
View File

@ -158,12 +158,12 @@ AM_PLATFORM_STATUS amPlatformGetPlatformId(AM_PLATFORM_PLATFORM_ID *platformId)
strncpy_s(amPlatform.m_platformId.strPlatformId,
sizeof amPlatform.m_platformId.strPlatformId, oemstringPlatform, 0xffffffff);
} else if (amOemstringGetManufacturer(oemstringManufacturer) == AM_OEMSTRING_STATUS_OK) {
if (strcmp(oemstringManufacturer, "NEC") == 0) {
if (strcmp(oemstringManufacturer, MANUFACTURER_RE) == 0) {
strncpy_s(amPlatform.m_platformId.strPlatformId,
sizeof amPlatform.m_platformId.strPlatformId, PLATFORM_RINGEDGE,
0xffffffff);
} else if (strcmp(oemstringManufacturer, "Supermicro") == 0 ||
strcmp(oemstringManufacturer, "Advantech") == 0) {
} else if (strcmp(oemstringManufacturer, MANUFACTURER_RW_1) == 0 ||
strcmp(oemstringManufacturer, MANUFACTURER_RW_2) == 0) {
strncpy_s(amPlatform.m_platformId.strPlatformId,
sizeof amPlatform.m_platformId.strPlatformId, PLATFORM_RINGWIDE,
0xffffffff);
@ -198,9 +198,9 @@ AM_PLATFORM_STATUS amPlatformGetBoardType(AM_PLATFORM_BOARD_TYPE *boardType) {
}
if (strcmp(platformId.strPlatformId, PLATFORM_RINGWIDE) == 0) {
if (strcmp(oemstringManufacturer, "Supermicro") == 0) {
if (strcmp(oemstringManufacturer, MANUFACTURER_RW_1) == 0) {
*boardType = amPlatform.m_boardType = AM_PLATFORM_BOARD_TYPE_RW_SPEC_1;
} else if (strcmp(oemstringManufacturer, "Advantech") == 0) {
} else if (strcmp(oemstringManufacturer, MANUFACTURER_RW_2) == 0) {
*boardType = amPlatform.m_boardType = AM_PLATFORM_BOARD_TYPE_RW_SPEC_2;
} else {
*boardType = amPlatform.m_boardType = AM_PLATFORM_BOARD_TYPE_UNKNOWN;
@ -211,7 +211,7 @@ AM_PLATFORM_STATUS amPlatformGetBoardType(AM_PLATFORM_BOARD_TYPE *boardType) {
}
if (strcmp(platformId.strPlatformId, PLATFORM_RINGEDGE) == 0) {
if (strcmp(oemstringManufacturer, "NEC") == 0) {
if (strcmp(oemstringManufacturer, MANUFACTURER_RE) == 0) {
ZeroMemory(oemstring4, sizeof oemstring4);
if (amOemstringGetOemstring(oemstring4, 4) != AM_OEMSTRING_STATUS_OK) {

6
src/micetools/lib/am/amPlatform.h
View File

@ -10,6 +10,10 @@ AM_LIB_H_HEADER(amPlatform, AM_PLATFORM)
#define PLATFORM_RINGEDGE "AAL"
#define PLATFORM_RINGEDGE2 "AAL2" // Also AAS in places
#define MANUFACTURER_RE "NEC"
#define MANUFACTURER_RW_1 "Supermicro"
#define MANUFACTURER_RW_2 "Advantech"
typedef struct {
char strPlatformId[4];
} AM_PLATFORM_PLATFORM_ID;
@ -22,7 +26,7 @@ typedef enum {
AM_PLATFORM_BOARD_TYPE_UNKNOWN = 4,
} AM_PLATFORM_BOARD_TYPE;
typedef struct _AM_PLATFORM {
typedef struct AM_PLATFORM {
BOOL m_boardTypeCached;
AM_PLATFORM_BOARD_TYPE m_boardType;
BOOL m_platformIdCached;

2
src/micetools/lib/am/amSerialId.h
View File

@ -6,7 +6,7 @@
AM_LIB_H_HEADER(amSerialId, AM_SERIAL_ID)
typedef struct _AM_SERIAL_ID {
typedef struct AM_SERIAL_ID {
unsigned char Rsv00;
} AM_SERIAL_ID;

2
src/micetools/lib/am/amSram.h
View File

@ -6,7 +6,7 @@
AM_LIB_H_HEADER(amSram, AM_SRAM)
typedef struct _AM_SRAM {
typedef struct AM_SRAM {
DWORD m_init;
HANDLE m_handle;
LARGE_INTEGER m_size;

10
src/micetools/lib/am/meson.build
View File

@ -68,3 +68,13 @@ amInstall = static_library(
libpcp,
],
)
amCmos = static_library(
'amCmos',
sources: [
'amCmos.c',
],
link_with: [
amiDebug,
],
)

2
src/micetools/lib/ami/amiCrc.h
View File

@ -6,7 +6,7 @@
AM_LIB_H_HEADER(amiCrc, AMI_CRC)
typedef struct _AMI_CRC {
typedef struct AMI_CRC {
uint32_t m_init;
uint32_t m_table[256];
} AMI_CRC;

2
src/micetools/lib/ami/amiDebug.h
View File

@ -6,7 +6,7 @@
#include "../_am.h"
typedef struct _AM_DEBUG {
typedef struct AM_DEBUG {
unsigned char Rsv00;
} AM_DEBUG;
AM_LIB_H_HEADER(amiDebug, AM_DEBUG)

2
src/micetools/lib/ami/amiTimer.h
View File

@ -6,7 +6,7 @@
AM_LIB_H_HEADER(amiTimer, AMI_TIMER)
typedef struct _AMI_TIMER {
typedef struct AMI_TIMER {
unsigned char Rsv00;
} AMI_TIMER;

233
src/micetools/lib/mice/blowfish.c Normal file
View File

@ -0,0 +1,233 @@
#include "blowfish.h"
static DWORD INIT_BLOWFISH_P[18] = {
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0,
0x082EFA98, 0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B,
};
static DWORD INIT_BLOWFISH_S[4][256] = {
{
0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7, 0xB8E1AFED, 0x6A267E96, 0xBA7C9045,
0xF12C7F99, 0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16, 0x636920D8, 0x71574E69,
0xA458FEA3, 0xF4933D7E, 0x0D95748F, 0x728EB658, 0x718BCD58, 0x82154AEE, 0x7B54A41D,
0xC25A59B5, 0x9C30D539, 0x2AF26013, 0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF,
0x8E79DCB0, 0x603A180E, 0x6C9E0E8B, 0xB01E8A3E, 0xD71577C1, 0xBD314B27, 0x78AF2FDA,
0x55605C60, 0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440, 0x55CA396A, 0x2AAB10B6,
0xB4CC5C34, 0x1141E8CE, 0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A, 0x2BA9C55D,
0x741831F6, 0xCE5C3E16, 0x9B87931E, 0xAFD6BA33, 0x6C24CF5C, 0x7A325381, 0x28958677,
0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193, 0x61D809CC, 0xFB21A991, 0x487CAC60,
0x5DEC8032, 0xEF845D5D, 0xE98575B1, 0xDC262302, 0xEB651B88, 0x23893E81, 0xD396ACC5,
0x0F6D6FF3, 0x83F44239, 0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E, 0x21C66842,
0xF6E96C9A, 0x670C9C61, 0xABD388F0, 0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3,
0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98, 0xA1F1651D, 0x39AF0176, 0x66CA593E,
0x82430E88, 0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE, 0xE06F75D8, 0x85C12073,
0x401A449F, 0x56C16AA6, 0x4ED3AA62, 0x363F7706, 0x1BFEDF72, 0x429B023D, 0x37D0D724,
0xD00A1248, 0xDB0FEAD3, 0x49F1C09B, 0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7,
0xE3FE501A, 0xB6794C3B, 0x976CE0BD, 0x04C006BA, 0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2,
0x196A2463, 0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F, 0x6DFC511F, 0x9B30952C,
0xCC814544, 0xAF5EBD09, 0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3, 0xC0CBA857,
0x45C8740F, 0xD20B5F39, 0xB9D3FBDB, 0x5579C0BD, 0x1A60320A, 0xD6A100C6, 0x402C7279,
0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8, 0x3C7516DF, 0xFD616B15, 0x2F501EC8,
0xAD0552AB, 0x323DB5FA, 0xFD238760, 0x53317B48, 0x3E00DF82, 0x9E5C57BB, 0xCA6F8CA0,
0x1A87562E, 0xDF1769DB, 0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573, 0x695B27B0,
0xBBCA58C8, 0xE1FFA35D, 0xB8F011A0, 0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B,
0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790, 0xE1DDF2DA, 0xA4CB7E33, 0x62FB1341,
0xCEE4C6E8, 0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4, 0x95DBDA4D, 0xAE909198,
0xEAAD8E71, 0x6B93D5A0, 0xD08ED1D0, 0xAFC725E0, 0x8E3C5B2F, 0x8E7594B7, 0x8FF6E2FB,
0xF2122B64, 0x8888B812, 0x900DF01C, 0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD,
0x2F2F2218, 0xBE0E1777, 0xEA752DFE, 0x8B021FA1, 0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6,
0xCE89E299, 0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9, 0x165FA266, 0x80957705,
0x93CC7314, 0x211A1477, 0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF, 0xEBCDAF0C,
0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49, 0x00250E2D, 0x2071B35E, 0x226800BB, 0x57B8E0AF,
0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA, 0x78C14389, 0xD95A537F, 0x207D5BA2,
0x02E5B9C5, 0x83260376, 0x6295CFA9, 0x11C81968, 0x4E734A41, 0xB3472DCA, 0x7B14A94A,
0x1B510052, 0x9A532915, 0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400, 0x08BA6FB5,
0x571BE91F, 0xF296EC6B, 0x2A0DD915, 0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664,
0x53B02D5D, 0xA99F8FA1, 0x8BA4799, 0x6E85076A,
},
{
0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, 0xAD6EA6B0, 0x49A7DF7D, 0x9CEE60B8,
0x8FEDB266, 0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1, 0x193602A5, 0x75094C29,
0xA0591340, 0xE4183A3E, 0x3F54989A, 0x5B429D65, 0x6B8FE4D6, 0x99F73FD6, 0xA1D29C07,
0xEFE830F5, 0x4D2D38E6, 0xF0255DC1, 0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E,
0x09686B3F, 0x3EBAEFC9, 0x3C971814, 0x6B6A70A1, 0x687F3584, 0x52A0E286, 0xB79C5305,
0xAA500737, 0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8, 0xB03ADA37, 0xF0500C0D,
0xF01C1F04, 0x0200B3FF, 0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD, 0xD19113F9,
0x7CA92FF6, 0x94324773, 0x22F54701, 0x3AE5E581, 0x37C2DADC, 0xC8B57634, 0x9AF3DDA7,
0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41, 0xE238CD99, 0x3BEA0E2F, 0x3280BBA1,
0x183EB331, 0x4E548B38, 0x4F6DB908, 0x6F420D03, 0xF60A04BF, 0x2CB81290, 0x24977C79,
0x5679B072, 0xBCAF89AF, 0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E, 0x5512721F,
0x2E6B7124, 0x501ADDE6, 0x9F84CD87, 0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C,
0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2, 0xEF1C1847, 0x3215D908, 0xDD433B37,
0x24C2BA16, 0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD, 0x71DFF89E, 0x10314E55,
0x81AC77D6, 0x5F11199B, 0x043556F1, 0xD7A3C76B, 0x3C11183B, 0x5924A509, 0xF28FE6ED,
0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E, 0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3,
0x771FE71C, 0x4E3D06FA, 0x2965DCB9, 0x99E71D0F, 0x803E89D6, 0x5266C825, 0x2E4CC978,
0x9C10B36A, 0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4, 0xF2F74EA7, 0x361D2B3D,
0x1939260F, 0x19C27960, 0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66, 0xE3BC4595,
0xA67BC883, 0xB17F37D1, 0x018CFF28, 0xC332DDEF, 0xBE6C5AA5, 0x65582185, 0x68AB9802,
0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84, 0x1521B628, 0x29076170, 0xECDD4775,
0x619F1510, 0x13CCA830, 0xEB61BD96, 0x0334FE1E, 0xAA0363CF, 0xB5735C90, 0x4C70A239,
0xD59E9E0B, 0xCBAADE14, 0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E, 0x648B1EAF,
0x19BDF0CA, 0xA02369B9, 0x655ABB50, 0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7,
0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8, 0xF837889A, 0x97E32D77, 0x11ED935F,
0x16681281, 0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99, 0x57F584A5, 0x1B227263,
0x9B83C3FF, 0x1AC24696, 0xCDB30AEB, 0x532E3054, 0x8FD948E4, 0x6DBC3128, 0x58EBF2EF,
0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73, 0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0,
0x45EEE2B6, 0xA3AAABEA, 0xDB6C4F15, 0xFACB4FD0, 0xC742F442, 0xEF6ABBB5, 0x654F3B1D,
0x41CD2105, 0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250, 0xCF62A1F2, 0x5B8D2646,
0xFC8883A0, 0xC1C7B6A3, 0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285, 0x095BBF00,
0xAD19489D, 0x1462B174, 0x23820E00, 0x58428D2A, 0x0C55F5EA, 0x1DADF43E, 0x233F7061,
0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB, 0x7CDE3759, 0xCBEE7460, 0x4085F2A7,
0xCE77326E, 0xA6078084, 0x19F8509E, 0xE8EFD855, 0x61D99735, 0xA969A7AA, 0xC50C06C2,
0x5A04ABFC, 0x800BCADC, 0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9, 0xDB73DBD3,
0x105588CD, 0x675FDA79, 0xE3674340, 0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20,
0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7,
},
{
0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934, 0x411520F7, 0x7602D4F7, 0xBCF46B2E,
0xD4A20068, 0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF, 0x1E39F62E, 0x97244546,
0x14214F74, 0xBF8B8840, 0x4D95FC1D, 0x96B591AF, 0x70F4DDD3, 0x66A02F45, 0xBFBC09EC,
0x03BD9785, 0x7FAC6DD0, 0x31CB8504, 0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A,
0x28507825, 0x530429F4, 0x0A2C86DA, 0xE9B66DFB, 0x68DC1462, 0xD7486900, 0x680EC0A4,
0x27A18DEE, 0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6, 0xAACE1E7C, 0xD3375FEC,
0xCE78A399, 0x406B2A42, 0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B, 0x1DC9FAF7,
0x4B6D1856, 0x26A36631, 0xEAE397B2, 0x3A6EFA74, 0xDD5B4332, 0x6841E7F7, 0xCA7820FB,
0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527, 0x55533A3A, 0x20838D87, 0xFE6BA9B7,
0xD096954B, 0x55A867BC, 0xA1159A58, 0xCCA92963, 0x99E1DB33, 0xA62A4A56, 0x3F3125F9,
0x5EF47E1C, 0x9029317C, 0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3, 0x95C11548,
0xE4C66D22, 0x48C1133F, 0xC70F86DC, 0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17,
0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564, 0x257B7834, 0x602A9C60, 0xDFF8E8A3,
0x1F636C1B, 0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115, 0x6B2395E0, 0x333E92E1,
0x3B240B62, 0xEEBEB922, 0x85B2A20E, 0xE6BA0D99, 0xDE720C8C, 0x2DA2F728, 0xD0127845,
0x95B794FD, 0x647D0862, 0xE7CCF5F0, 0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E,
0x0A476341, 0x992EFF74, 0x3A6F6EAB, 0xF4F8FD37, 0xA812DC60, 0xA1EBDDF8, 0x991BE14C,
0xDB6E6B0D, 0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804, 0xF1290DC7, 0xCC00FFA3,
0xB5390F92, 0x690FED0B, 0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3, 0xBB132F88,
0x515BAD24, 0x7B9479BF, 0x763BD6EB, 0x37392EB3, 0xCC115979, 0x8026E297, 0xF42E312D,
0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C, 0x6A124237, 0xB79251E7, 0x06A1BBE6,
0x4BFB6350, 0x1A6B1018, 0x11CAEDFA, 0x3D25BDD8, 0xE2E1C3C9, 0x44421659, 0x0A121386,
0xD90CEC6E, 0xD5ABEA2A, 0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE, 0x9DBC8057,
0xF0F7C086, 0x60787BF8, 0x6003604D, 0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC,
0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F, 0x77A057BE, 0xBDE8AE24, 0x55464299,
0xBF582E61, 0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2, 0x5366F9C3, 0xC8B38E74,
0xB475F255, 0x46FCD9B9, 0x7AEB2661, 0x8B1DDF84, 0x846A0E79, 0x915F95E2, 0x466E598E,
0x20B45770, 0x8CD55591, 0xC902DE4C, 0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E,
0xB77F19B6, 0xE0A9DC09, 0x662D09A1, 0xC4324633, 0xE85A1F02, 0x09F0BE8C, 0x4A99A025,
0x1D6EFE10, 0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169, 0xDCB7DA83, 0x573906FE,
0xA1E2CE9B, 0x4FCD7F52, 0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027, 0x9AF88C27,
0x773F8641, 0xC3604C06, 0x61A806B5, 0xF0177A28, 0xC0F586E0, 0x006058AA, 0x30DC7D62,
0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634, 0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1,
0xCE591D76, 0x6F05E409, 0x4B7C0188, 0x39720A3D, 0x7C927C24, 0x86E3725F, 0x724D9DB9,
0x1AC15BB4, 0xD39EB8FC, 0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4, 0x1E50EF5E,
0xB161E6F8, 0xA28514D9, 0x6C51133C, 0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837,
0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0,
},
{
0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B, 0x5CB0679E, 0x4FA33742, 0xD3822740,
0x99BC9BBE, 0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B, 0xB78C1B6B, 0x21A19045,
0xB26EB1BE, 0x6A366EB4, 0x5748AB2F, 0xBC946E79, 0xC6A376D2, 0x6549C2C8, 0x530FF8EE,
0x468DDE7D, 0xD5730A1D, 0x4CD04DC6, 0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304,
0xA1FAD5F0, 0x6A2D519A, 0x63EF8CE2, 0x9A86EE22, 0xC089C2B8, 0x43242EF6, 0xA51E03AA,
0x9CF2D0A4, 0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6, 0x2826A2F9, 0xA73A3AE1,
0x4BA99586, 0xEF5562E9, 0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59, 0x80E4A915,
0x87B08601, 0x9B09E6AD, 0x3B3EE593, 0xE990FD5A, 0x9E34D797, 0x2CF0B7D9, 0x022B8B51,
0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28, 0x1F9F25CF, 0xADF2B89B, 0x5AD6B472,
0x5A88F54C, 0xE029AC71, 0xE019A5E6, 0x47B0ACFD, 0xED93FA9B, 0xE8D3C48D, 0x283B57CC,
0xF8D56629, 0x79132E28, 0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C, 0x15056DD4,
0x88F46DBA, 0x03A16125, 0x0564F0BD, 0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A,
0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319, 0x7533D928, 0xB155FDF5, 0x03563482,
0x8ABA3CBB, 0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F, 0x4DE81751, 0x3830DC8E,
0x379D5862, 0x9320F991, 0xEA7A90C2, 0xFB3E7BCE, 0x5121CE64, 0x774FBE32, 0xA8B6E37E,
0xC3293D46, 0x48DE5369, 0x6413E680, 0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166,
0xB39A460A, 0x6445C0DD, 0x586CDECF, 0x1C20C8AE, 0x5BBEF7DD, 0x1B588D40, 0xCCD2017F,
0x6BB4E3BB, 0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5, 0x72EACEA8, 0xFA6484BB,
0x8D6612AE, 0xBF3C6F47, 0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370, 0x740E0D8D,
0xE75B1357, 0xF8721671, 0xAF537D5D, 0x4040CB08, 0x4EB4E2CC, 0x34D2466A, 0x0115AF84,
0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048, 0x6F3F3B82, 0x3520AB82, 0x011A1D4B,
0x277227F8, 0x611560B1, 0xE7933FDC, 0xBB3A792B, 0x344525BD, 0xA08839E1, 0x51CE794B,
0x2F32C9B7, 0xA01FBAC9, 0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7, 0x1A908749,
0xD44FBD9A, 0xD0DADECB, 0xD50ADA38, 0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F,
0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C, 0xBF97222C, 0x15E6FC2A, 0x0F91FC71,
0x9B941525, 0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1, 0xB6C1075E, 0xE3056A0C,
0x10D25065, 0xCB03A442, 0xE0EC6E0E, 0x1698DB3B, 0x4C98A0BE, 0x3278E964, 0x9F1F9532,
0xE0D392DF, 0xD3A0342B, 0x8971F21E, 0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8,
0xDF359F8D, 0x9B992F2E, 0xE60B6F47, 0x0FE3F11D, 0xE54CDA54, 0x1EDAD891, 0xCE6279CF,
0xCD3E7E6F, 0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299, 0xF523F357, 0xA6327623,
0x93A83531, 0x56CCCD02, 0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC, 0xDE966292,
0x81B949D0, 0x4C50901B, 0x71C65614, 0xE6C6C7BD, 0x327A140A, 0x45E1D006, 0xC3F27B9A,
0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6, 0x71126905, 0xB2040222, 0xB6CBCF7C,
0xCD769C2B, 0x53113EC0, 0x1640E3D3, 0x38ABBD60, 0x2547ADF0, 0xBA38209C, 0xF746CE76,
0x77AFA1C5, 0x20756060, 0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E, 0x1948C25C,
0x02FB8A8C, 0x01C36AE4, 0xD6EBE1F9, 0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F,
0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6,
}
};
static DWORD BLOWFISH_P[18];
static DWORD BLOWFISH_S[4][256];
static inline DWORD _BlowfishF(DWORD x) {
DWORD h = BLOWFISH_S[0][x >> 24] + BLOWFISH_S[1][x >> 16 & 0xff];
return (h ^ BLOWFISH_S[2][x >> 8 & 0xff]) + BLOWFISH_S[3][x & 0xff];
}
static inline void swap(LPDWORD x, LPDWORD y) {
DWORD tmp = *x;
*x = *y;
*y = tmp;
}
void BlowfishEncrypt(LPDWORD lpLeft, LPDWORD lpRight) {
for (short r = 0; r < 16; r++) {
*lpLeft ^= BLOWFISH_P[r];
*lpRight ^= _BlowfishF(*lpLeft);
swap(lpLeft, lpRight);
}
swap(lpLeft, lpRight);
*lpRight ^= BLOWFISH_P[16];
*lpLeft ^= BLOWFISH_P[17];
}
void BlowfishDecrypt(LPDWORD lpLeft, LPDWORD lpRight) {
for (short r = 17; r > 1; r--) {
*lpLeft ^= BLOWFISH_P[r];
*lpRight ^= _BlowfishF(*lpLeft);
swap(lpLeft, lpRight);
}
swap(lpLeft, lpRight);
*lpRight ^= BLOWFISH_P[1];
*lpLeft ^= BLOWFISH_P[0];
}
void BlowfishSetKey(LPBYTE lpKey, DWORD nKeyLen) {
memcpy(BLOWFISH_P, INIT_BLOWFISH_P, sizeof BLOWFISH_P);
memcpy(BLOWFISH_S, INIT_BLOWFISH_S, sizeof BLOWFISH_S);
// Initialise P-box
DWORD k;
for (short i = 0, p = 0; i < 18; i++) {
k = 0;
for (short j = 0; j < 4; j++) {
k = (k << 8) | lpKey[p];
p = (p + 1) % nKeyLen;
}
BLOWFISH_P[i] ^= k;
}
// Key expansion
DWORD l = 0, r = 0;
for (short i = 0; i < 18; i += 2) {
BlowfishEncrypt(&l, &r);
BLOWFISH_P[i] = l;
BLOWFISH_P[i + 1] = r;
}
for (short i = 0; i < 4; i++) {
for (short j = 0; j < 256; j += 2) {
BlowfishEncrypt(&l, &r);
BLOWFISH_S[i][j] = l;
BLOWFISH_S[i][j + 1] = r;
}
}
}

5
src/micetools/lib/mice/blowfish.h Normal file
View File

@ -0,0 +1,5 @@
#include <Windows.h>
void BlowfishEncrypt(LPDWORD lpLeft, LPDWORD lpRight);
void BlowfishDecrypt(LPDWORD lpLeft, LPDWORD lpRight);
void BlowfishSetKey(LPBYTE lpKey, DWORD nKeyLen);

7
src/micetools/lib/mice/config.def
View File

@ -114,6 +114,13 @@ CFG_str(devices, com7, "", "")
CFG_str(devices, com8, "", "")
ENDSECTION(devices)
SECTION(aime, "Aime cards used when a TN32MSEC reader is attached\nSpecify either an access code or FeliCa ID")
CFG_str(aime, player1_card, "", "")
CFG_str(aime, player1_cardfile, "aime1.txt", "")
CFG_str(aime, player2_card, "", "")
CFG_str(aime, player2_cardfile, "aime2.txt", "")
ENDSECTION(aime)
#undef CFG_str
#undef CFG_int
#undef CFG_bool

179
src/micetools/lib/mice/des.c Normal file
View File

@ -0,0 +1,179 @@
#include <Windows.h>
#include <stdlib.h>
#include "des.h"
static BYTE IP[] = {
58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 62, 54, 46, 38, 30, 22,
14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35,
27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7,
};
static BYTE PI[] = {
40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, 38, 6, 46, 14, 54, 22,
62, 30, 37, 5, 45, 13, 53, 21, 61, 29, 36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11,
51, 19, 59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25,
};
static BYTE E[] = {
32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25, 24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1,
};
static BYTE P[] = {
16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25,
};
static BYTE SBOX[8][64] = {
{
14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7, 0, 15, 7, 4, 14, 2,
13, 1, 10, 6, 12, 11, 9, 5, 3, 8, 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7,
3, 10, 5, 0, 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
},
{
15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10, 3, 13, 4, 7, 15, 2,
8, 14, 12, 0, 1, 10, 6, 9, 11, 5, 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6,
9, 3, 2, 15, 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
},
{
10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8, 13, 7, 0, 9, 3, 4,
6, 10, 2, 8, 5, 14, 12, 11, 15, 1, 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12,
5, 10, 14, 7, 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
},
{
7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15, 13, 8, 11, 5, 6, 15,
0, 3, 4, 7, 2, 12, 1, 10, 14, 9, 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14,
5, 2, 8, 4, 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
},
{
2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9, 14, 11, 2, 12, 4, 7,
13, 1, 5, 0, 15, 10, 3, 9, 8, 6, 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5,
6, 3, 0, 14, 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
},
{
12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11, 10, 15, 4, 2, 7, 12,
9, 5, 6, 1, 13, 14, 0, 11, 3, 8, 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10,
1, 13, 11, 6, 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
},
{
4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1, 13, 0, 11, 7, 4, 9,
1, 10, 14, 3, 5, 12, 2, 15, 8, 6, 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8,
0, 5, 9, 2, 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
},
{
13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7, 1, 15, 13, 8, 10, 3,
7, 4, 12, 5, 6, 11, 0, 14, 9, 2, 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13,
15, 3, 5, 8, 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11,
},
};
static BYTE PC1[] = {
57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4,
};
static BYTE PC2[] = {
14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32,
};
static BYTE ITERATION_SHIFT[] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
#define DesModeDecrypt 0
#define DesModeEncrypt 1
DWORD64 MiceDesCrypt(DWORD64 nData, DWORD64 nKey, BYTE mode) {
nData = _byteswap_uint64(nData);
nKey = _byteswap_uint64(nKey);
DWORD64 init_perm_res = 0;
for (int i = 0; i < 64; i++) {
init_perm_res <<= 1;
init_perm_res |= (nData >> (64 - IP[i])) & 1;
}
DWORD L = (DWORD)(init_perm_res >> 32) & 0xffffffff;
DWORD R = (DWORD)init_perm_res & 0xffffffff;
DWORD64 permuted_choice_1 = 0;
for (int i = 0; i < 56; i++) {
permuted_choice_1 <<= 1;
permuted_choice_1 |= (nKey >> (64 - PC1[i])) & 1;
}
DWORD C = (DWORD)((permuted_choice_1 >> 28) & 0x0fffffff);
DWORD D = (DWORD)(permuted_choice_1 & 0x0fffffff);
DWORD64 sub_key[16] = { 0 };
for (int i = 0; i < 16; i++) {
for (int j = 0; j < ITERATION_SHIFT[i]; j++) {
C = 0x0fffffff & (C << 1) | 1 & (C >> 27);
D = 0x0fffffff & (D << 1) | 1 & (D >> 27);
}
DWORD64 permuted_choice_2 = (((DWORD64)C) << 28) | (DWORD64)D;
sub_key[i] = 0;
for (int j = 0; j < 48; j++) {
sub_key[i] <<= 1;
sub_key[i] |= (permuted_choice_2 >> (56 - PC2[j])) & 1;
}
}
for (int i = 0; i < 16; i++) {
DWORD64 s_input = 0;
for (int j = 0; j < 48; j++) {
s_input <<= 1;
s_input |= (DWORD64)((R >> (32 - E[j])) & 1);
}
s_input ^= sub_key[mode == DesModeDecrypt ? 15 - i : i];
DWORD s_output = 0;
for (int j = 0; j < 8; j++) {
BYTE row = (BYTE)((s_input & (0x0000840000000000 >> (6 * j))) >> (42 - 6 * j));
row = (row >> 4) | row & 0x01;
BYTE column = (BYTE)((s_input & (0x0000780000000000 >> (6 * j))) >> (43 - 6 * j));
s_output <<= 4;
s_output |= (DWORD)(SBOX[j][16 * row + column] & 0x0f);
}
DWORD f_function_res = 0;
for (int j = 0; j < 32; j++) {
f_function_res <<= 1;
f_function_res |= (s_output >> (32 - P[j])) & 1;
}
DWORD temp = R;
R = L ^ f_function_res;
L = temp;
}
DWORD64 pre = (((DWORD64)R) << 32) | (DWORD64)L;
DWORD64 result = 0;
for (int i = 0; i < 64; i++) {
result <<= 1;
result |= (pre >> (64 - PI[i])) & 1;
}
return _byteswap_uint64(result);
}
DWORD64 MiceDesEncrypt(DWORD64 nData, DWORD64 nKey) {
return MiceDesCrypt(nData, nKey, DesModeEncrypt);
}
DWORD64 MiceDesDecrypt(DWORD64 nData, DWORD64 nKey) {
return MiceDesCrypt(nData, nKey, DesModeDecrypt);
}
DWORD64 Mice3Des_3K(DWORD64 nData, DWORD64 lpKeys[3]) {
nData = MiceDesEncrypt(nData, lpKeys[0]);
nData = MiceDesDecrypt(nData, lpKeys[1]);
return MiceDesEncrypt(nData, lpKeys[2]);
}
DWORD64 Mice3Des_2K(DWORD64 nData, DWORD64 lpKeys[2]) {
nData = MiceDesEncrypt(nData, lpKeys[0]);
nData = MiceDesDecrypt(nData, lpKeys[1]);
return MiceDesEncrypt(nData, lpKeys[0]);
}
DWORD64 Mice3Des_1K(DWORD64 nData, DWORD64 nKey) {
nData = MiceDesEncrypt(nData, nKey);
nData = MiceDesDecrypt(nData, nKey);
return MiceDesEncrypt(nData, nKey);
}

7
src/micetools/lib/mice/des.h Normal file
View File

@ -0,0 +1,7 @@
#include <Windows.h>
DWORD64 MiceDesEncrypt(DWORD64 nData, DWORD64 nKey);
DWORD64 MiceDesDecrypt(DWORD64 nData, DWORD64 nKey);
DWORD64 Mice3Des_3K(DWORD64 nData, DWORD64 lpKeys[3]);
DWORD64 Mice3Des_2K(DWORD64 nData, DWORD64 lpKeys[2]);
DWORD64 Mice3Des_1K(DWORD64 nData, DWORD64 nKey);

32
src/micetools/lib/mice/exe.c
View File

@ -11,7 +11,7 @@ bool inject_debug_wait(HANDLE process) {
do {
Sleep(1000);
if (FAILED(CheckRemoteDebuggerPresent(process, &present))) {
log_error(plfBoot, "Fatal: CheckRemoteDebuggerPresent failed: %d", GetLastError());
log_error(plfBoot, "CheckRemoteDebuggerPresent failed: %d", GetLastError());
return false;
}
} while (!present);
@ -24,33 +24,33 @@ bool remote_call(HANDLE process, LPVOID function, LPCSTR argument, DWORD* result
LPVOID arg_addr =
VirtualAllocEx(process, NULL, nchars + 1, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
if (arg_addr == NULL) {
log_error(plfProcesses, "Fatal: VirtualAllocEx failed: %d", GetLastError());
log_error(plfProcesses, "VirtualAllocEx failed: %d", GetLastError());
return false;
}
if (FAILED(WriteProcessMemory(process, arg_addr, argument, nchars + 1, NULL))) {
log_error(plfProcesses, "Fatal: WriteProcessMemory failed: %d", GetLastError());
log_error(plfProcesses, "WriteProcessMemory failed: %d", GetLastError());
return false;
}
HANDLE remote_thread =
CreateRemoteThread(process, NULL, 0, (LPTHREAD_START_ROUTINE)function, arg_addr, 0, NULL);
if (remote_thread == INVALID_HANDLE_VALUE) {
log_error(plfProcesses, "Fatal: CreateRemoteThread failed: %d", GetLastError());
log_error(plfProcesses, "CreateRemoteThread failed: %d", GetLastError());
return false;
}
if (WaitForSingleObject(remote_thread, INFINITE) != WAIT_OBJECT_0) {
log_error(plfProcesses, "Fatal: WaitForSingleObject failed: %d", GetLastError());
log_error(plfProcesses, "WaitForSingleObject failed: %d", GetLastError());
return false;
}
if (FAILED(GetExitCodeThread(remote_thread, result))) {
log_error(plfProcesses, "Fatal: GetExitCodeThread failed: %d", GetLastError());
log_error(plfProcesses, "GetExitCodeThread failed: %d", GetLastError());
return false;
}
if (*result == 0) {
log_error(plfProcesses, "Fatal: GetExitCodeThread failed: result == 0");
log_error(plfProcesses, "GetExitCodeThread failed: result == 0");
return false;
}
@ -59,13 +59,13 @@ bool remote_call(HANDLE process, LPVOID function, LPCSTR argument, DWORD* result
bool inject_dll(HANDLE process, LPCSTR inject) {
HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
if (kernel32 == NULL) {
log_error(plfProcesses, "Fatal: GetModuleHandleA failed: %d", GetLastError());
log_error(plfProcesses, "GetModuleHandleA failed: %d", GetLastError());
return false;
}
LPVOID addr_LoadLibraryA = (LPVOID)GetProcAddress(kernel32, "LoadLibraryA");
if (addr_LoadLibraryA == NULL) {
log_error(plfProcesses, "Fatal: GetProcAddress failed: %d", GetLastError());
log_error(plfProcesses, "GetProcAddress failed: %d", GetLastError());
return false;
}
@ -90,14 +90,14 @@ BOOL start_and_inject(HANDLE hJob, LPCSTR path, LPSTR cmdline, LPCSTR inject, BO
// Does the exe we're starting exist?
found = SearchPathA(NULL, path, NULL, 0, NULL, NULL);
if (found == 0) {
log_error(plfProcesses, "Fatal: Cannot start %s: not found", path);
log_error(plfProcesses, "Cannot start %s: not found", path);
goto abort;
}
if (inject != NULL) {
// Does the DLL we want to inject exist?
found = SearchPathA(NULL, inject, NULL, 0, NULL, NULL);
if (found == 0) {
log_error(plfProcesses, "Fatal: Cannot inject %s: not found", inject);
log_error(plfProcesses, "Cannot inject %s: not found", inject);
goto abort;
}
}
@ -106,7 +106,7 @@ BOOL start_and_inject(HANDLE hJob, LPCSTR path, LPSTR cmdline, LPCSTR inject, BO
flags |= CREATE_SUSPENDED;
if (!CreateProcessA(path, cmdline, NULL, NULL, FALSE, flags, NULL, NULL, &startupInfo,
&processInformation)) {
log_error(plfProcesses, "Fatal: CreateProcessA(%s, %s) failed: %d", path, cmdline,
log_error(plfProcesses, "CreateProcessA(%s, %s) failed: %d", path, cmdline,
GetLastError());
goto abort;
}
@ -140,7 +140,7 @@ BOOL start_and_inject(HANDLE hJob, LPCSTR path, LPSTR cmdline, LPCSTR inject, BO
// Injection completed, let the program continue execution
if (FAILED(ResumeThread(processInformation.hThread))) {
log_error(plfProcesses, "Fatal: ResumeThread failed: %d", GetLastError());
log_error(plfProcesses, "ResumeThread failed: %d", GetLastError());
goto abort;
}
@ -153,14 +153,14 @@ BOOL start_and_inject(HANDLE hJob, LPCSTR path, LPSTR cmdline, LPCSTR inject, BO
abort:
if (processInformation.hProcess && processInformation.hProcess != INVALID_HANDLE_VALUE) {
if (!CloseHandle(processInformation.hThread) && GetLastError() != ERROR_INVALID_HANDLE)
log_error(plfProcesses, "Fatal: CloseHandle(hProcess) failed: %d", GetLastError());
log_error(plfProcesses, "CloseHandle(hProcess) failed: %d", GetLastError());
if (!TerminateProcess(processInformation.hProcess, 1))
log_error(plfProcesses, "Fatal: TerminateProcess failed: %d", GetLastError());
log_error(plfProcesses, "TerminateProcess failed: %d", GetLastError());
}
if (processInformation.hThread && processInformation.hThread != INVALID_HANDLE_VALUE) {
if (!CloseHandle(processInformation.hThread) && GetLastError() != ERROR_INVALID_HANDLE)
log_error(plfProcesses, "Fatal: CloseHandle(hThread) failed: %d", GetLastError());
log_error(plfProcesses, "CloseHandle(hThread) failed: %d", GetLastError());
}
return FALSE;

7
src/micetools/lib/mice/ioctl.h
View File

@ -85,6 +85,13 @@
#define IOCTL_MXPARALLEL_READ_FLAGS \
(DWORD) CTL_CODE(FILE_DEVICE_SEGA, 0x807, METHOD_BUFFERED, FILE_READ_ACCESS)
// amCmosReadByteInRearpart
#define IOCTL_MXCMOS_READ \
(DWORD) CTL_CODE(FILE_DEVICE_SEGA, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
// amCmosWriteByteInRearpart
#define IOCTL_MXCMOS_WRITE \
(DWORD) CTL_CODE(FILE_DEVICE_SEGA, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)
// CrackProof
#define IOCTL_CRACKPROOF_10 CTL_CODE(FILE_DEVICE_HTSYS, 0x810, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_CRACKPROOF_11 CTL_CODE(FILE_DEVICE_HTSYS, 0x811, METHOD_BUFFERED, FILE_ANY_ACCESS)

2
src/micetools/lib/mice/kcf.h
View File

@ -5,7 +5,7 @@
#include "../../segastructs.h"
#pragma pack(push, 1)
typedef struct _AM_KCF {
typedef struct AM_KCF {
AM_APPBOOT m_Header;
BYTE m_AppData[216];
BYTE m_Seed[16];

4
src/micetools/lib/mice/meson.build
View File

@ -8,6 +8,10 @@ mice_lib = static_library(
'config.c',
'kcf.c',
'micefs.c',
'des.c',
'blowfish.c',
'solitaire.c',
'spad.c',
],
link_with: [
inih.get_variable('lib_inih'),

8
src/micetools/lib/mice/micefs.c
View File

@ -118,6 +118,8 @@ BOOL MiceFSAddDevLayers(VOID) {
BOOL success = TRUE;
for (int i = 0; i < 26; i++) {
if (i == 2) continue; // TODO: DON'T SKIP C
szMountPoint[0] = 'A' + (char)i;
szMountPoint[1] = ':';
szMountPoint[2] = '\\';
@ -134,7 +136,7 @@ BOOL MiceFSAddRingedgeLayers(BOOL bIsOsupdate) {
// Windows file systems
success &= MiceFSAddLayer(RING_MOUNT_OS, "mount/os");
success &= MiceFSAddLayer(RING_MOUNT_EXTEND, "mount/extend");
// success &= MiceFSAddLayer(RING_MOUNT_EXTEND, "mount/extend");
success &= MiceFSAddLayer(RING_MOUNT_RECOVERY, "mount/os_recovery");
// TrueCrypt Volumes
@ -145,8 +147,8 @@ BOOL MiceFSAddRingedgeLayers(BOOL bIsOsupdate) {
success &= MiceFSAddLayer(RING_MOUNT_OS_UPDATE, "mount/os_update");
success &= MiceFSAddLayer(RING_MOUNT_OS_DEFAULT_DRVIERS, "mount/os_default_drivers");
} else {
success &= MiceFSAddLayer(RING_MOUNT_EXTEND_VOL, "mount/extend/extend");
success &= MiceFSAddLayer(RING_MOUNT_EXTEND2_VOL, "mount/extend/extend2");
// success &= MiceFSAddLayer(RING_MOUNT_EXTEND_VOL, "mount/extend/extend");
// success &= MiceFSAddLayer(RING_MOUNT_EXTEND2_VOL, "mount/extend/extend2");
}
// geminifs

143
src/micetools/lib/mice/solitaire.c Normal file
View File

@ -0,0 +1,143 @@
#include "solitaire.h"
#include <memory.h>
#define DECK_SIZE 22
#define JOKER_A 21
#define JOKER_B 22
typedef struct {
char m_Deck[DECK_SIZE];
} DECK, *PDECK;
static DECK SOL_INIT_DECK = {
.m_Deck = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 },
};
#define char2num(c) ((c) - '0' + 1)
static inline char num2char(char num) {
while (num < 1) num = num + 10;
return (num - 1) % 10 + '0';
}
static void SolMoveCard(PDECK lpDeck, char card) {
int p = 0;
for (int i = 0; i < DECK_SIZE; i++) {
if (lpDeck->m_Deck[i] == card) {
p = i;
break;
}
}
if (p < DECK_SIZE - 1) {
lpDeck->m_Deck[p] = lpDeck->m_Deck[p + 1];
lpDeck->m_Deck[p + 1] = card;
} else {
for (int i = DECK_SIZE - 1; i > 1; i--) lpDeck->m_Deck[i] = lpDeck->m_Deck[i - 1];
lpDeck->m_Deck[1] = card;
}
}
static void SolCutDeck(PDECK lpDeck, char point) {
DECK tmp;
memcpy(tmp.m_Deck, &lpDeck->m_Deck[point], DECK_SIZE - point - 1);
memcpy(&tmp.m_Deck[DECK_SIZE - point - 1], lpDeck->m_Deck, point);
memcpy(lpDeck->m_Deck, tmp.m_Deck, DECK_SIZE - 1);
}
static void SolSwapOutsideJoker(PDECK lpDeck) {
int j1 = -1;
int j2 = -1;
DECK tmp;
for (int i = 0; i < DECK_SIZE; i++) {
if (lpDeck->m_Deck[i] == JOKER_A || lpDeck->m_Deck[i] == JOKER_B) {
if (j1 == -1) {
j1 = i;
} else {
j2 = i;
}
}
}
if (0 < DECK_SIZE - j2 - 1) memcpy(tmp.m_Deck, &lpDeck->m_Deck[j2 + 1], DECK_SIZE - j2 - 1);
tmp.m_Deck[DECK_SIZE - j2 - 1] = lpDeck->m_Deck[j1];
if (0 < j2 - j1 - 1) memcpy(&tmp.m_Deck[DECK_SIZE - j2], &lpDeck->m_Deck[j1 + 1], j2 - j1 - 1);
tmp.m_Deck[DECK_SIZE - j1 - 1] = lpDeck->m_Deck[j2];
if (0 < j1) memcpy(&tmp.m_Deck[DECK_SIZE - j1], lpDeck->m_Deck, j1);
memcpy(lpDeck->m_Deck, tmp.m_Deck, DECK_SIZE);
}
static void SolCutByBottomCard(PDECK lpDeck) {
char p = lpDeck->m_Deck[DECK_SIZE - 1];
if (p == JOKER_B) p = JOKER_A;
SolCutDeck(lpDeck, p);
}
static char SolGetTopCardNum(PDECK lpDeck) {
char p = lpDeck->m_Deck[0];
if (p == JOKER_B) p = JOKER_A;
return lpDeck->m_Deck[p];
}
static void SolDeckHash(PDECK lpDeck) {
char p;
do {
SolMoveCard(lpDeck, JOKER_A);
SolMoveCard(lpDeck, JOKER_B);
SolMoveCard(lpDeck, JOKER_B);
SolSwapOutsideJoker(lpDeck);
SolCutByBottomCard(lpDeck);
p = SolGetTopCardNum(lpDeck);
} while (p == JOKER_A || p == JOKER_B);
}
static void SolCreateDeck(PDECK lpDeck, const char *key) {
memcpy_s(lpDeck, sizeof *lpDeck, &SOL_INIT_DECK, sizeof SOL_INIT_DECK);
int p = 0;
while (key[p] != '\0') {
SolDeckHash(lpDeck);
char c = char2num(key[p]);
SolCutDeck(lpDeck, c);
p++;
}
}
void SolitaireCipherEncode(const char *szKey, const char *szSrc, char *szDst) {
DECK deck;
SolCreateDeck(&deck, szKey);
int i = 0;
while (szSrc[i] != '\0') {
SolDeckHash(&deck);
char p = SolGetTopCardNum(&deck);
szDst[i] = num2char(char2num(szSrc[i]) + p);
i++;
}
szDst[i] = '\0';
}
void SolitaireCipherDecode(const char *szKey, const char *szSrc, char *szDst) {
DECK deck;
SolCreateDeck(&deck, szKey);
int i = 0;
while (szSrc[i] != '\0') {
SolDeckHash(&deck);
char p = SolGetTopCardNum(&deck);
szDst[i] = num2char(char2num(szSrc[i]) - p);
i++;
}
szDst[i] = '\0';
}
void SolitaireCipher(int nMode, const char *szKey, const char *szSrc, char *szDst) {
if (nMode == 0)
SolitaireCipherEncode(szKey, szSrc, szDst);
else if (nMode == 1)
SolitaireCipherDecode(szKey, szSrc, szDst);
}

3
src/micetools/lib/mice/solitaire.h Normal file
View File

@ -0,0 +1,3 @@
void SolitaireCipherDecode(const char *szKey, const char *szSrc, char *szDst);
void SolitaireCipherEncode(const char *szKey, const char *szSrc, char *szDst);
void SolitaireCipher(int mode, const char *key, const char *src_str, char *dest_str);

224
src/micetools/lib/mice/spad.c Normal file
View File

@ -0,0 +1,224 @@
#include "spad.h"
#include <memory.h>
#define HASH_ADD 5
BYTE SPAD0_SPN_TABLE[9][256] = {
{
175, 168, 99, 169, 36, 192, 241, 190, 231, 179, 172, 22, 133, 185, 17, 111, 16, 49,
50, 174, 177, 120, 35, 210, 162, 202, 249, 43, 69, 184, 60, 98, 26, 109, 130, 140,
0, 217, 226, 122, 70, 25, 42, 204, 19, 167, 228, 183, 132, 155, 142, 255, 251, 139,
3, 137, 48, 41, 211, 135, 1, 191, 53, 218, 89, 92, 205, 9, 127, 112, 65, 129,
108, 95, 83, 194, 114, 212, 121, 72, 149, 180, 91, 57, 68, 157, 253, 81, 113, 246,
215, 213, 45, 159, 237, 51, 234, 170, 90, 23, 106, 186, 189, 233, 156, 206, 77, 124,
24, 59, 13, 238, 12, 128, 161, 10, 143, 181, 107, 247, 63, 209, 71, 37, 198, 54,
232, 125, 123, 62, 243, 153, 117, 5, 28, 224, 207, 52, 187, 158, 235, 145, 173, 38,
141, 199, 102, 8, 230, 88, 64, 20, 166, 197, 250, 18, 236, 196, 240, 33, 138, 134,
214, 225, 6, 182, 96, 116, 46, 227, 254, 39, 47, 94, 244, 178, 104, 40, 86, 239,
154, 97, 34, 163, 201, 11, 2, 150, 79, 219, 229, 144, 74, 76, 146, 203, 152, 105,
208, 87, 100, 14, 55, 80, 171, 188, 222, 118, 7, 200, 61, 73, 252, 119, 148, 248,
193, 151, 101, 58, 75, 131, 110, 115, 136, 30, 93, 4, 84, 103, 223, 21, 176, 195,
147, 44, 56, 221, 245, 164, 85, 15, 78, 29, 160, 31, 32, 165, 220, 67, 242, 216,
126, 82, 27, 66,
},
{
3, 75, 184, 151, 183, 143, 13, 113, 220, 73, 167, 144, 255, 160, 157, 248, 35, 95,
32, 108, 17, 249, 105, 142, 239, 203, 240, 20, 223, 27, 122, 198, 54, 91, 197, 147,
182, 40, 53, 178, 59, 209, 236, 243, 159, 128, 100, 37, 5, 207, 84, 175, 70, 63,
150, 6, 229, 16, 251, 170, 222, 98, 65, 81, 89, 231, 41, 181, 77, 61, 242, 55,
106, 232, 22, 139, 92, 168, 30, 87, 226, 9, 235, 50, 201, 46, 180, 241, 164, 118,
211, 193, 165, 112, 96, 18, 177, 234, 102, 225, 74, 146, 161, 109, 58, 244, 213, 111,
218, 216, 10, 88, 24, 99, 43, 163, 93, 103, 119, 107, 57, 195, 219, 76, 2, 186,
206, 187, 85, 1, 23, 133, 39, 228, 48, 114, 200, 141, 252, 120, 25, 185, 67, 45,
8, 155, 26, 217, 205, 38, 250, 130, 204, 127, 117, 121, 158, 101, 254, 237, 145, 199,
49, 208, 82, 42, 72, 132, 116, 221, 125, 233, 174, 110, 51, 71, 214, 80, 12, 83,
166, 189, 34, 172, 138, 4, 137, 66, 64, 179, 69, 90, 68, 230, 169, 29, 196, 129,
227, 21, 31, 86, 135, 212, 62, 15, 149, 215, 224, 148, 171, 36, 104, 7, 162, 152,
123, 238, 245, 176, 136, 192, 56, 156, 153, 94, 173, 210, 60, 44, 33, 202, 140, 126,
28, 97, 194, 52, 124, 47, 11, 131, 154, 79, 190, 78, 188, 115, 19, 0, 246, 14,
134, 191, 253, 247,
},
{
65, 7, 147, 138, 64, 255, 14, 47, 84, 252, 172, 212, 30, 176, 200, 137, 223, 0,
100, 79, 243, 203, 44, 192, 143, 110, 23, 191, 149, 153, 42, 13, 81, 173, 75, 202,
247, 105, 85, 56, 76, 198, 104, 195, 163, 31, 131, 62, 11, 112, 199, 178, 78, 207,
254, 77, 253, 139, 180, 150, 206, 249, 241, 211, 67, 96, 174, 213, 179, 219, 74, 185,
229, 234, 106, 72, 93, 167, 135, 218, 184, 6, 45, 148, 193, 102, 36, 38, 177, 154,
37, 8, 92, 89, 166, 175, 39, 146, 136, 242, 237, 27, 28, 17, 210, 34, 22, 118,
86, 103, 20, 159, 238, 95, 220, 91, 164, 70, 221, 16, 51, 41, 127, 90, 201, 151,
132, 133, 66, 188, 171, 119, 60, 161, 194, 170, 55, 73, 97, 53, 156, 134, 25, 87,
94, 230, 226, 160, 4, 109, 209, 168, 157, 236, 2, 189, 216, 71, 98, 26, 5, 125,
1, 63, 24, 111, 117, 68, 228, 122, 246, 169, 232, 114, 244, 107, 251, 126, 235, 54,
82, 222, 121, 35, 141, 231, 113, 99, 152, 108, 217, 233, 59, 19, 144, 3, 120, 116,
32, 129, 186, 52, 50, 250, 123, 49, 214, 61, 48, 10, 227, 18, 142, 15, 29, 187,
165, 115, 83, 130, 128, 181, 215, 225, 58, 43, 208, 224, 33, 190, 205, 21, 101, 182,
239, 204, 145, 245, 12, 196, 46, 158, 88, 240, 197, 155, 57, 9, 162, 124, 69, 183,
40, 140, 248, 80,
},
{
118, 205, 22, 127, 233, 107, 149, 58, 78, 187, 110, 204, 210, 179, 105, 169, 114, 175,
199, 130, 56, 111, 188, 55, 166, 40, 54, 189, 195, 207, 133, 70, 10, 153, 99, 151,
131, 86, 136, 161, 2, 100, 172, 121, 85, 101, 255, 194, 239, 122, 89, 43, 28, 224,
140, 143, 90, 228, 180, 159, 252, 247, 69, 71, 74, 234, 192, 13, 235, 200, 120, 201,
103, 3, 5, 49, 20, 222, 211, 115, 250, 31, 182, 80, 19, 4, 183, 123, 73, 26,
249, 23, 77, 79, 134, 32, 193, 253, 160, 165, 72, 225, 60, 96, 242, 11, 48, 15,
76, 238, 141, 109, 190, 142, 198, 246, 216, 8, 148, 27, 42, 181, 158, 162, 147, 245,
34, 168, 52, 38, 167, 124, 236, 63, 14, 59, 178, 244, 41, 206, 46, 66, 129, 50,
37, 95, 102, 219, 125, 215, 231, 45, 67, 106, 91, 25, 173, 62, 155, 197, 171, 132,
196, 108, 51, 218, 251, 138, 17, 84, 254, 87, 75, 61, 126, 9, 163, 145, 64, 191,
104, 229, 185, 243, 150, 248, 81, 202, 154, 176, 152, 174, 30, 156, 94, 232, 0, 57,
18, 220, 12, 16, 139, 93, 214, 44, 39, 213, 97, 135, 83, 186, 35, 113, 47, 29,
116, 137, 157, 221, 53, 21, 208, 68, 177, 203, 240, 98, 88, 164, 119, 227, 24, 212,
230, 128, 209, 170, 144, 112, 1, 36, 241, 33, 217, 6, 117, 184, 65, 92, 146, 223,
237, 7, 226, 82,
},
{
170, 148, 153, 116, 146, 214, 28, 70, 71, 121, 47, 86, 122, 247, 181, 10, 201, 6,
215, 250, 64, 17, 165, 255, 31, 232, 0, 140, 221, 183, 66, 110, 53, 240, 190, 194,
29, 202, 182, 142, 226, 68, 78, 159, 81, 129, 139, 76, 93, 89, 56, 211, 143, 37,
179, 9, 49, 173, 11, 107, 14, 80, 187, 216, 150, 136, 222, 73, 234, 180, 74, 154,
48, 109, 44, 15, 205, 246, 126, 79, 82, 217, 251, 40, 7, 99, 25, 164, 238, 1,
248, 235, 210, 245, 61, 13, 145, 91, 103, 184, 87, 243, 43, 230, 104, 22, 123, 111,
101, 195, 118, 227, 60, 46, 65, 62, 207, 84, 225, 23, 167, 69, 45, 90, 252, 198,
130, 239, 203, 120, 172, 52, 186, 113, 39, 34, 242, 18, 63, 26, 36, 168, 193, 158,
199, 24, 228, 95, 254, 108, 175, 200, 55, 197, 119, 189, 2, 41, 125, 253, 94, 131,
233, 191, 42, 92, 115, 229, 218, 231, 236, 128, 106, 3, 88, 59, 33, 19, 209, 83,
112, 147, 188, 161, 16, 244, 100, 133, 135, 176, 97, 177, 241, 67, 98, 196, 249, 162,
174, 212, 4, 134, 223, 38, 208, 171, 54, 30, 75, 224, 96, 144, 204, 152, 149, 58,
156, 155, 21, 27, 51, 141, 77, 35, 157, 132, 206, 178, 5, 166, 12, 185, 20, 72,
213, 163, 117, 8, 124, 237, 127, 220, 137, 102, 169, 192, 57, 114, 32, 151, 138, 160,
85, 105, 219, 50,
},
{
222, 90, 27, 105, 60, 66, 163, 81, 64, 56, 241, 23, 40, 28, 184, 172, 232, 153,
69, 160, 18, 104, 206, 21, 201, 71, 109, 200, 70, 78, 30, 166, 17, 248, 62, 49,
250, 230, 45, 253, 50, 20, 156, 1, 177, 237, 87, 113, 227, 48, 207, 14, 231, 204,
55, 74, 120, 171, 29, 150, 234, 37, 133, 32, 73, 77, 117, 82, 238, 239, 175, 84,
51, 249, 9, 158, 129, 225, 115, 42, 242, 61, 34, 19, 146, 139, 240, 192, 132, 13,
168, 4, 220, 141, 187, 44, 148, 3, 245, 209, 208, 46, 93, 235, 94, 98, 111, 33,
176, 145, 254, 203, 10, 236, 183, 47, 52, 36, 214, 233, 102, 130, 198, 25, 31, 217,
193, 167, 246, 136, 2, 135, 7, 221, 216, 103, 197, 185, 41, 164, 194, 101, 211, 83,
170, 59, 121, 224, 114, 215, 6, 26, 88, 147, 126, 12, 144, 110, 116, 15, 76, 11,
228, 108, 67, 210, 65, 54, 189, 219, 53, 89, 95, 169, 159, 85, 128, 57, 142, 243,
213, 229, 99, 195, 119, 162, 91, 123, 127, 174, 186, 161, 16, 223, 75, 43, 155, 22,
188, 0, 199, 24, 251, 100, 255, 244, 247, 190, 5, 86, 205, 8, 79, 106, 154, 118,
122, 181, 149, 202, 80, 125, 124, 107, 165, 196, 58, 138, 39, 218, 182, 97, 35, 134,
112, 72, 151, 157, 252, 143, 92, 68, 178, 173, 131, 191, 38, 212, 179, 96, 152, 226,
63, 140, 180, 137,
},
{
25, 46, 93, 122, 91, 124, 126, 57, 239, 139, 47, 204, 134, 27, 194, 140, 32, 251,
89, 95, 33, 205, 159, 148, 167, 11, 186, 14, 71, 123, 165, 6, 183, 216, 201, 38,
240, 157, 104, 242, 94, 18, 58, 101, 176, 92, 226, 34, 153, 130, 16, 245, 68, 80,
116, 161, 249, 66, 168, 37, 77, 234, 8, 62, 150, 146, 196, 45, 162, 35, 52, 169,
69, 107, 121, 127, 200, 76, 67, 103, 41, 4, 250, 181, 30, 5, 198, 180, 175, 29,
187, 247, 48, 237, 236, 171, 64, 224, 152, 233, 75, 17, 135, 21, 24, 190, 238, 120,
177, 2, 87, 144, 50, 142, 97, 203, 60, 230, 215, 117, 49, 185, 84, 54, 225, 221,
108, 151, 98, 172, 65, 137, 156, 96, 246, 99, 188, 20, 125, 119, 213, 9, 149, 223,
23, 74, 12, 43, 82, 56, 254, 182, 51, 164, 81, 115, 109, 79, 179, 191, 113, 235,
105, 63, 19, 0, 28, 111, 155, 53, 202, 163, 42, 118, 141, 128, 1, 22, 3, 61,
229, 131, 112, 143, 90, 88, 136, 243, 227, 15, 195, 7, 70, 255, 73, 253, 232, 206,
133, 209, 220, 241, 184, 211, 110, 212, 160, 173, 114, 218, 231, 59, 132, 248, 210, 40,
222, 193, 26, 100, 145, 10, 228, 197, 36, 106, 214, 83, 199, 129, 44, 192, 147, 217,
13, 166, 219, 174, 207, 244, 85, 102, 31, 55, 252, 189, 72, 170, 78, 86, 39, 158,
208, 138, 178, 154,
},
{
84, 217, 66, 80, 184, 116, 171, 50, 166, 36, 72, 111, 240, 126, 215, 48, 180, 109,
6, 162, 136, 214, 89, 57, 76, 44, 175, 110, 168, 43, 102, 92, 185, 28, 231, 83,
25, 86, 138, 17, 216, 97, 95, 7, 3, 218, 181, 176, 8, 208, 39, 69, 0, 195,
245, 177, 121, 107, 196, 91, 33, 226, 85, 61, 160, 254, 49, 154, 54, 15, 236, 203,
187, 114, 41, 26, 249, 118, 135, 106, 174, 201, 82, 183, 235, 123, 243, 5, 148, 4,
1, 198, 161, 244, 55, 227, 251, 193, 79, 186, 158, 128, 40, 47, 90, 246, 145, 62,
207, 65, 173, 190, 182, 51, 155, 252, 206, 192, 104, 238, 63, 81, 191, 78, 210, 73,
169, 247, 143, 134, 200, 42, 103, 56, 228, 77, 199, 46, 99, 127, 239, 223, 151, 170,
93, 98, 11, 112, 209, 230, 19, 153, 146, 248, 211, 18, 60, 100, 132, 167, 10, 178,
156, 234, 27, 204, 94, 67, 30, 205, 141, 147, 225, 113, 59, 242, 163, 35, 233, 194,
221, 152, 139, 115, 150, 87, 34, 53, 14, 165, 172, 12, 212, 159, 9, 219, 58, 22,
96, 229, 137, 133, 45, 119, 29, 129, 32, 197, 122, 237, 202, 20, 131, 250, 31, 38,
24, 71, 157, 2, 224, 88, 16, 253, 37, 117, 188, 70, 222, 164, 21, 64, 120, 52,
74, 23, 213, 13, 105, 101, 220, 75, 124, 149, 232, 142, 255, 125, 144, 140, 130, 108,
179, 189, 68, 241,
},
{
195, 11, 184, 21, 0, 164, 61, 217, 253, 22, 233, 8, 32, 230, 141, 196, 71, 56,
37, 147, 94, 170, 236, 42, 16, 110, 88, 149, 38, 83, 4, 30, 146, 158, 47, 139,
189, 10, 105, 169, 59, 65, 240, 208, 218, 106, 161, 113, 19, 99, 239, 144, 148, 176,
235, 231, 220, 115, 185, 120, 122, 228, 199, 109, 127, 163, 172, 133, 80, 243, 145, 234,
54, 250, 155, 142, 247, 174, 193, 67, 28, 192, 202, 143, 78, 162, 49, 18, 116, 44,
157, 241, 173, 63, 104, 187, 53, 154, 124, 3, 251, 9, 35, 39, 212, 77, 23, 222,
76, 238, 118, 156, 160, 225, 117, 219, 91, 17, 167, 33, 175, 2, 66, 75, 131, 211,
206, 159, 205, 204, 48, 43, 82, 34, 203, 89, 125, 20, 249, 177, 112, 84, 224, 129,
90, 29, 14, 74, 244, 132, 237, 150, 26, 215, 201, 130, 137, 45, 135, 51, 226, 92,
81, 58, 27, 246, 229, 216, 50, 13, 95, 114, 136, 214, 183, 198, 221, 31, 128, 55,
100, 181, 123, 223, 255, 210, 64, 252, 96, 5, 182, 102, 97, 200, 40, 153, 188, 165,
52, 25, 248, 254, 36, 72, 209, 12, 85, 98, 107, 134, 179, 186, 138, 46, 111, 166,
103, 101, 1, 232, 24, 62, 126, 119, 41, 140, 242, 7, 108, 168, 121, 79, 68, 70,
6, 194, 171, 15, 180, 178, 190, 152, 213, 73, 227, 245, 207, 151, 93, 191, 87, 60,
57, 197, 69, 86,
}
};
BYTE SPAD0_SPN_INV_TABLE[9][256];
BOOL _SPAD0_SPN_INV_TABLE_INIT = FALSE;
void Spad0Encrypt(LPBYTE spad0_encrypted, const BYTE* spad0) {
if (spad0_encrypted != spad0)
memcpy(spad0_encrypted, spad0, 16);
int hashLoopCount = (spad0[15] >> 4) + 7;
int hashTableNo = spad0[15] & 0x7;
// Primary encryption loop
for (int i = 0; i < hashLoopCount; i++) {
for (int j = 0; j < 15; j++)
spad0_encrypted[j] = SPAD0_SPN_TABLE[hashTableNo][spad0_encrypted[j]];
// Rotate the first 15 bytes left by 5 bits
BYTE prior = spad0_encrypted[0];
for (int j = 14; j >= 0; j--) {
BYTE new = ((spad0_encrypted[j] & 0x7) << 5) | (prior >> 3);
prior = spad0_encrypted[j];
spad0_encrypted[j] = new;
}
hashTableNo = (hashTableNo + HASH_ADD) & 0x7;
}
// Apply the outer encryption layer to mask the parameters
for (int i = 0; i < 16; i++) spad0_encrypted[i] = SPAD0_SPN_TABLE[8][spad0_encrypted[i]];
}
void Spad0Decrypt(LPBYTE spad0, const BYTE* spad0_encrypted) {
// Build the inversed table
if (!_SPAD0_SPN_INV_TABLE_INIT) {
for (int i = 0; i < 9; i++)
for (int j = 0; j < 256; j++) SPAD0_SPN_INV_TABLE[i][SPAD0_SPN_TABLE[i][j]] = (BYTE)j;
_SPAD0_SPN_INV_TABLE_INIT = TRUE;
}
for (int i = 0; i < 16; i++) spad0[i] = SPAD0_SPN_INV_TABLE[8][spad0_encrypted[i]];
// Removing the outer layer gives us access to the cipher parameters
int hashLoopCount = ((spad0[15] >> 4) & 0xf) + 7;
int hashTableNo = spad0[15] & 0x7;
// We're doing this in reverse, so start from the final value
for (int i = 0; i < hashLoopCount - 1; i++) hashTableNo += HASH_ADD;
hashTableNo &= 0x7;
// Primary decryption loop
for (int i = 0; i < hashLoopCount; i++) {
// Rotate the first 15 bytes right by 5 bits
BYTE prior = spad0[14];
for (int j = 0; j < 15; j++) {
BYTE new = (spad0[j] >> 5) | ((prior & 0x1f) << 3);
prior = spad0[j];
spad0[j] = new;
}
for (int j = 0; j < 15; j++) spad0[j] = SPAD0_SPN_INV_TABLE[hashTableNo][spad0[j]];
hashTableNo = ((hashTableNo | 8) - HASH_ADD) & 0x7;
}
}

4
src/micetools/lib/mice/spad.h Normal file
View File

@ -0,0 +1,4 @@
#include <Windows.h>
void Spad0Encrypt(LPBYTE spad0_encrypted, const BYTE* spad0);
void Spad0Decrypt(LPBYTE spad0, const BYTE* spad0_encrypted);

39
src/micetools/micekeychip/callbacks/billing.c
View File

@ -78,28 +78,33 @@ byte CA_CERTIFICATION[CA_CERT_BUF_MAX];
int CA_CERT_LEN = 0;
void mxkPcpPbCaCertification(pcpa_t* stream, void* data) {
if (CA_CERT_LEN == 0) {
FILE* fCert;
fopen_s(&fCert, Config.billing_cacert, "r");
if (fCert == NULL)
CA_CERT_LEN = -1;
else {
fseek(fCert, 0, SEEK_END);
CA_CERT_LEN = ftell(fCert);
HANDLE hFile = CreateFileA(Config.billing_cacert, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile == INVALID_HANDLE_VALUE) {
CA_CERT_LEN = 0;
} else {
CA_CERT_LEN = GetFileSize(hFile, NULL);
if (CA_CERT_LEN > CA_CERT_BUF_MAX) CA_CERT_LEN = CA_CERT_BUF_MAX;
rewind(fCert);
fread(CA_CERTIFICATION, CA_CERT_LEN, 1, fCert);
fclose(fCert);
DWORD numberOfBytesRead;
int read_remaining = CA_CERT_LEN;
int read_offset = 0;
while (read_remaining) {
printf("Remaining: %d, offset: %d\n", read_remaining, read_offset);
if (!ReadFile(hFile, CA_CERTIFICATION, CA_CERT_BUF_MAX, &numberOfBytesRead, NULL)) {
printf("Read failed: %d", GetLastError());
}
// int nread = fread(&CA_CERTIFICATION[read_offset], 1, read_remaining, fCert);
read_remaining -= numberOfBytesRead;
read_offset += numberOfBytesRead;
}
printf("Read done %d\n", CA_CERT_LEN);
CloseHandle(hFile);
}
}
if (CA_CERT_LEN == -1) {
// TODO: Fix this maybe?
pcpaSetBinaryMode(stream, binary_mode_none);
pcpaSetSendPacket(stream, BIL_CACERT, "-1");
return;
}
pcpaSetBinaryMode(stream, binary_mode_send);
pcpaSetBeforeBinaryModeCallBackFunc(stream, mxkBinaryCallback, NULL);

15
src/micetools/micekeychip/callbacks/tracedata.c
View File

@ -24,8 +24,19 @@ void mxkPcpTdPut(pcpa_t* stream, void* data) {
pcpaSetSendPacket(stream, TRA_PUT, "0");
}
void mxkPcpTdGet(pcpa_t* stream, void* data) {
// TODO: lol
pcpaSetSendPacket(stream, TRA_GET, "");
char* sPut = pcpaGetCommand(stream, TRA_GET);
pcpaSetSendPacket(stream, TRA_GET, "0");
if (sPut && strcmp(sPut, "?") == 0) {
pcpaAddSendPacket(stream, "address", "0");
} else {
pcpaSetBinaryMode(stream, binary_mode_send);
pcpaSetBeforeBinaryModeCallBackFunc(stream, mxkBinaryCallback, NULL);
BINARY_DATA_LEN = 0;
pcpaSetRecvBinaryBuffer(stream, BINARY_DATA, BINARY_DATA_LEN);
pcpaAddSendPacket(stream, "port", "40107");
pcpaAddSendPacket(stream, "size", "0");
}
}
void mxkPcpTdLogicalErase(pcpa_t* stream, void* data) {
pcpaSetSendPacket(stream, TRA_LOGICALERASE, "");

6
src/micetools/segastructs.h
View File

@ -3,7 +3,7 @@
#include <stdint.h>
#pragma pack(push, 1)
typedef struct _AM_APPBOOT {
typedef struct AM_APPBOOT {
uint32_t m_Crc;
uint32_t m_Format;
char m_GameId[4];
@ -16,13 +16,13 @@ typedef struct _AM_APPBOOT {
uint32_t m_NetworkAddr;
} AM_APPBOOT;
typedef struct _AM_APPBOOT_128 {
typedef struct AM_APPBOOT_128 {
AM_APPBOOT m_Header;
uint8_t Rsv18[88];
uint8_t m_Seed[16];
} AM_APPBOOT_128;
typedef struct _AM_APPBOOT_256 {
typedef struct AM_APPBOOT_256 {
AM_APPBOOT m_Header;
uint8_t Rsv18[216];
uint8_t m_Seed[16];

14
src/micetools/util/meson.build
View File

@ -11,6 +11,7 @@ executable(
'micedump/platform.c',
'micedump/sram.c',
# 'micedump/superio.c',
'micedump/cmos.c',
],
link_with: [
mxklib,
@ -21,6 +22,7 @@ executable(
amPlatform,
amDongle,
amSerialId,
amCmos,
],
)
@ -77,3 +79,15 @@ executable(
amiDebug,
],
)
executable(
'micereset',
win_subsystem: subsystem,
sources: [
'micereset.c',
],
link_with: [
amiTimer,
amEeprom,
amSram,
],
)

57
src/micetools/util/micedump/cmos.c Normal file
View File

@ -0,0 +1,57 @@
#include <Windows.h>
#include <stdio.h>
/*
Cmos:
00-01: 00 21 <- "00 21" = "Boot: USB, HDD", "10 20" = "Boot HDD,USB"
02-0F: 43 65 87 a9 0b 21 43 65 87 a9 3b 93 99 54
10-19: 35 25 00 00 00 40 4f 40 50 08
1A-1B: 1a 08
1C-1D: 1a 08 <- USB flags(?). 08 = normal, 09 = disabled
1E-1F: 1a 0a
20-2F: 03 14 1d 12 28 00 00 00 00 07 00 00 00 00 00 08
30-3F: 01 80 ce 10 14 00 8a 48 06 01 d4 ff ff 1f 04 00
40-4B: 60 a0 9f 0b a0 29 47 15 7d 80 90 3f
4C: 00 <- SEGA flags. 00 = None, 02 = Security freeze, 03 = Freeze + Certified
4D: 9d
4E: 00 <- 00 = Boot HDD first, 01 = Boot USB first
4F: b4
50-5F: 25 d6 e7 8f 7f 22 72 af b5 1a 00 8f 1c 3c c0 90
60: 00
61: 00
62-6F: 06 37 50 8c 66 bd ac 38 7b 52 4a 04 4c dc
70-7F: 82 62 0d 2a 5d 1c 32 6e 05 af 44 c3 45 2e 08 96
*/
#include "../lib/am/amCmos.h"
AM_CMOS_CONFIG config = {
.index = { 0, 0, 0, 0 },
.m_MbrCount = 0,
};
BOOL miceDumpCMOS() {
amCmosDebugLevel = 1;
fprintf(stderr, "Dumping RTC CMOS using %s\n", amCmosVersion);
AM_CMOS_STATUS err = amCmosInit(&config);
if (err != AM_CMOS_STATUS_OK) {
fprintf(stderr, "amCmosInit failed: %d\n", err);
amCmosExit();
return FALSE;
}
for (BYTE index = 0; index < 0x80; index++) {
BYTE data;
amCmosReadByteInRearpart(index, &data);
printf(" %02x", data);
}
puts("");
amCmosExit();
return TRUE;
}

7
src/micetools/util/micedump/kc_mxkeychip.c
View File

@ -53,7 +53,7 @@ AM_DONGLE_STATUS amlib_init_dongle(void) {
return AM_DONGLE_STATUS_OK;
}
void miceDumpKCMxkeychip(void) {
BOOL miceDumpKCMxkeychip(void) {
amDongleDebugLevel = 1;
fprintf(stderr, "Dumping dongle using %s\n", amDongleVersion);
@ -61,7 +61,7 @@ void miceDumpKCMxkeychip(void) {
WSADATA wsaData;
if (WSAStartup(2, &wsaData)) {
puts("Failed to WSAStartup");
return;
return FALSE;
}
AM_DONGLE_STATUS err;
@ -69,7 +69,7 @@ void miceDumpKCMxkeychip(void) {
if (err != AM_DONGLE_STATUS_OK) {
printf("Failed to init dongle:%d\n", err);
amDongleExit();
return;
return FALSE;
}
printf("Keychip ID: %s\n", amlibDongle.keychipId);
@ -108,4 +108,5 @@ void miceDumpKCMxkeychip(void) {
puts("");
amDongleExit();
return TRUE;
}

6
src/micetools/util/micedump/kc_pic.c
View File

@ -5,14 +5,14 @@
#include "../lib/am/amSerialId.h"
#include "../lib/mxk/mxk.h"
void miceDumpKCPIC() {
BOOL miceDumpKCPIC() {
fprintf(stderr, "Dumping dongle using mxk\n");
MXK_STATUS status;
status = mxkInit();
if (status != MXK_STATUS_OK) {
amiDebugLog("Failed to mxkInit(): %d", status);
return;
return FALSE;
}
/**
@ -45,4 +45,6 @@ void miceDumpKCPIC() {
char gameId[4];
mxkAbGameId(MXK_CACHE_USE, gameId, &err);
printf(" Game ID: %.*s\n", 4, gameId);
return TRUE;
}

2
src/micetools/util/micedump/main.c
View File

@ -17,6 +17,8 @@ int main(int argc, char** argv) {
miceDumpKCMxkeychip();
else if (strcmp(argv[i], "kcpic") == 0)
miceDumpKCPIC();
else if (strcmp(argv[i], "cmos") == 0)
miceDumpCMOS();
else
printf("Unknown dump type: %s\n", argv[i]);
}

19
src/micetools/util/micedump/micedump.h
View File

@ -1,8 +1,11 @@
void miceDumpDMI(void);
void miceDumpEEPROM(void);
void miceDumpKCMxkeychip(void);
void miceDumpKCN2(void);
void miceDumpKCPIC(void);
void miceDumpPlatform(void);
void miceDumpSRAM(void);
void miceDumpSuperIO(void);
#include <Windows.h>
BOOL miceDumpDMI(void);
BOOL miceDumpEEPROM(void);
BOOL miceDumpKCMxkeychip(void);
BOOL miceDumpKCN2(void);
BOOL miceDumpKCPIC(void);
BOOL miceDumpPlatform(void);
BOOL miceDumpSRAM(void);
BOOL miceDumpSuperIO(void);
BOOL miceDumpCMOS(void);

4
src/micetools/util/micedump/platform.c
View File

@ -7,7 +7,7 @@ static const char* sBoardType[] = {
"RingEdge", "RingWide (Spec 1)", "RingWide (Spec 2)", "RingEdge 2", "Unknown",
};
void miceDumpPlatform(void) {
BOOL miceDumpPlatform(void) {
fprintf(stderr, "Dumping platform information using %s\n", amPlatformVersion);
AM_PLATFORM_BOARD_TYPE boardType;
@ -17,4 +17,6 @@ void miceDumpPlatform(void) {
printf("Board type: %s\n", sBoardType[boardType]);
printf("Platform ID: %s\n", platformId.strPlatformId);
return TRUE;
}

54
src/micetools/util/micereset.c Normal file
View File

@ -0,0 +1,54 @@
#include <Windows.h>
#include <setupapi.h>
#include <shellapi.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "../lib/am/amEeprom.h"
#include "../lib/am/amSram.h"
BOOL wipe_eeprom() {
if (amEepromInit(NULL) != AM_EEPROM_STATUS_OK) return FALSE;
BYTE data[0x20];
memset(data, 0xff, sizeof data);
// Static = 0 and 32
// Game data is 1000-1fff = block 128-255
for (int i = 0; i < 256; i++) {
if (i == 0) continue;
if (i == 32) continue;
printf("Wiping EEPROM block %d\n", i);
amEepromWrite(i * 0x20, data, sizeof data);
}
amEepromExit();
return TRUE;
}
BOOL wipe_sram() {
if (amSramInit() != AM_SRAM_STATUS_OK) return FALSE;
DWORD nbytes = amSram.m_size.LowPart;
printf("Wiping %d bytes of SRAM\n", nbytes);
BYTE* buffer = malloc(nbytes);
ZeroMemory(buffer, nbytes);
amSramWrite(buffer, 0, nbytes);
free(buffer);
amSramExit();
return TRUE;
}
// void wait_for_dip() {
// puts("Press Test or System to continue");
// amDipswInit();
// }
int main(int argc, char** argv) {
wipe_eeprom();
wipe_sram();
return 0;
}

277
src/micetools/util/storagecraft.c
View File

@ -3,6 +3,53 @@
#include "../dll/hooks/drive/drive.h"
#define SECTOR_SIZE BLOCK_SIZE_HDD
#define HEADS_PER_CYLINDER 255
#define SECTORS_PER_TRACK 63
#define TRUECRYPT "\"C:\\Program Files (x86)\\TrueCrypt\\TrueCrypt.exe\""
#define OSR_PASSWORD "nogamenolife"
#define OSR_MOUNTPOINT "R:"
#define OSR_FLAGS "/w /q /m ro"
BYTE WINDOWS_MBR_BOOTSTRAP[MBR_BOOTSTRAP_SIZE] = {
0x33, 0xc0, 0x8e, 0xd0, 0xbc, 0x00, 0x7c, 0xfb, 0x50, 0x07, 0x50, 0x1f, 0xfc, 0xbe, 0x1b, 0x7c,
0xbf, 0x1b, 0x06, 0x50, 0x57, 0xb9, 0xe5, 0x01, 0xf3, 0xa4, 0xcb, 0xbd, 0xbe, 0x07, 0xb1, 0x04,
0x38, 0x6e, 0x00, 0x7c, 0x09, 0x75, 0x13, 0x83, 0xc5, 0x10, 0xe2, 0xf4, 0xcd, 0x18, 0x8b, 0xf5,
0x83, 0xc6, 0x10, 0x49, 0x74, 0x19, 0x38, 0x2c, 0x74, 0xf6, 0xa0, 0xb5, 0x07, 0xb4, 0x07, 0x8b,
0xf0, 0xac, 0x3c, 0x00, 0x74, 0xfc, 0xbb, 0x07, 0x00, 0xb4, 0x0e, 0xcd, 0x10, 0xeb, 0xf2, 0x88,
0x4e, 0x10, 0xe8, 0x46, 0x00, 0x73, 0x2a, 0xfe, 0x46, 0x10, 0x80, 0x7e, 0x04, 0x0b, 0x74, 0x0b,
0x80, 0x7e, 0x04, 0x0c, 0x74, 0x05, 0xa0, 0xb6, 0x07, 0x75, 0xd2, 0x80, 0x46, 0x02, 0x06, 0x83,
0x46, 0x08, 0x06, 0x83, 0x56, 0x0a, 0x00, 0xe8, 0x21, 0x00, 0x73, 0x05, 0xa0, 0xb6, 0x07, 0xeb,
0xbc, 0x81, 0x3e, 0xfe, 0x7d, 0x55, 0xaa, 0x74, 0x0b, 0x80, 0x7e, 0x10, 0x00, 0x74, 0xc8, 0xa0,
0xb7, 0x07, 0xeb, 0xa9, 0x8b, 0xfc, 0x1e, 0x57, 0x8b, 0xf5, 0xcb, 0xbf, 0x05, 0x00, 0x8a, 0x56,
0x00, 0xb4, 0x08, 0xcd, 0x13, 0x72, 0x23, 0x8a, 0xc1, 0x24, 0x3f, 0x98, 0x8a, 0xde, 0x8a, 0xfc,
0x43, 0xf7, 0xe3, 0x8b, 0xd1, 0x86, 0xd6, 0xb1, 0x06, 0xd2, 0xee, 0x42, 0xf7, 0xe2, 0x39, 0x56,
0x0a, 0x77, 0x23, 0x72, 0x05, 0x39, 0x46, 0x08, 0x73, 0x1c, 0xb8, 0x01, 0x02, 0xbb, 0x00, 0x7c,
0x8b, 0x4e, 0x02, 0x8b, 0x56, 0x00, 0xcd, 0x13, 0x73, 0x51, 0x4f, 0x74, 0x4e, 0x32, 0xe4, 0x8a,
0x56, 0x00, 0xcd, 0x13, 0xeb, 0xe4, 0x8a, 0x56, 0x00, 0x60, 0xbb, 0xaa, 0x55, 0xb4, 0x41, 0xcd,
0x13, 0x72, 0x36, 0x81, 0xfb, 0x55, 0xaa, 0x75, 0x30, 0xf6, 0xc1, 0x01, 0x74, 0x2b, 0x61, 0x60,
0x6a, 0x00, 0x6a, 0x00, 0xff, 0x76, 0x0a, 0xff, 0x76, 0x08, 0x6a, 0x00, 0x68, 0x00, 0x7c, 0x6a,
0x01, 0x6a, 0x10, 0xb4, 0x42, 0x8b, 0xf4, 0xcd, 0x13, 0x61, 0x61, 0x73, 0x0e, 0x4f, 0x74, 0x0b,
0x32, 0xe4, 0x8a, 0x56, 0x00, 0xcd, 0x13, 0xeb, 0xd6, 0x61, 0xf9, 0xc3, 0x49, 0x6e, 0x76, 0x61,
0x6c, 0x69, 0x64, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x00, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x6e,
0x67, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74,
0x65, 0x6d, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x70, 0x65, 0x72, 0x61,
0x74, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x44, 0x63, 0x46, 0xa4, 0x2b, 0xd1, 0x00, 0x00,
};
// Assumes a SECTOR_SIZE of 512
#define _KiB(x) (DWORD)(x * 2)
#define _MiB(x) (DWORD)(x * 1024 * 2)
#define _GiB(x) (DWORD)(x * 1024 * 1024 * 2)
#define _GMKiB(g, m, k) (_GiB(g) + _MiB(m) + _KiB(k))
physical_disk_t newSSD = {
.m_SerialNumber = 0x00144DB0,
@ -10,27 +57,27 @@ physical_disk_t newSSD = {
.m_BootPartition = 1,
.m_HasSegaboot = TRUE,
.m_BlockSize = BLOCK_SIZE_HDD,
.m_TotalSize = 64 * 1024 * 1024 * (1024 / BLOCK_SIZE_HDD),
.m_TotalSize = 0, // Force re-calculation
.m_DiskType = DiskType_HardDisk,
.m_IsFormatted = true,
.m_Partitions = {
// 1.5GB boot partition
{ .m_Size = 0x300B85, .m_Filesystem = MBR_FS_NTFS },
{ .m_Size = _GMKiB(1, 513, 450.5), .m_Filesystem = MBR_FS_NTFS },
// 1.5GB OS recovery
{ .m_Size = 0x300BC4, .m_Filesystem = MBR_FS_NTFS },
{ .m_Size = _GMKiB(1, 513, 482), .m_Filesystem = MBR_FS_NTFS },
},
.m_Extended = {
{ 0x102d83, MBR_FS_FAT16, SPD_OS }, // 512MB OS update
{ 0x403947, MBR_FS_FAT16, SPD_Patch0 }, // 2GB patch0
{ 0x403947, MBR_FS_FAT16, SPD_Patch1 }, // 2GB patch1
{ 0x48ed459, MBR_FS_NTFS, SPD_AppData }, // 40GB appdata
{ 0x20014aa, MBR_FS_FAT16, SPD_Original0 }, // 16GB original0
{ _GMKiB(0, 517, 705.5), MBR_FS_FAT16, SPD_OS }, // 512MB OS update
{ _GMKiB(0, 2055, 163.5), MBR_FS_FAT16, SPD_Patch0 }, // 2GB patch0
{ _GMKiB(0, 2055, 163.5), MBR_FS_FAT16, SPD_Patch1 }, // 2GB patch1
{ _GMKiB(36, 474, 556.5), MBR_FS_NTFS, SPD_AppData }, // 40GB appdata
{ _GMKiB(16, 2, 597), MBR_FS_FAT16, SPD_Original0 }, // 16GB original0
{ 0 }, // End of table
},
};
sbr_t SegaBootRecord0;
sbr_t SegaBootRecord1;
sbr_t SegaBootRecord0 = { 0 };
sbr_t SegaBootRecord1 = { 0 };
sbr_slot_t* get_sbr_slot(spd_slot_t slot) {
switch (slot) {
case SPD_Original0:
@ -132,6 +179,8 @@ void init_pd(physical_disk_t* pConfig) {
if (extendedPartNo) {
pConfig->m_Partitions[extendedPartNo - 1].m_Size = currentLBA - extendedStart;
}
pConfig->m_TotalSize = currentLBA;
} else {
// Raw disks have just a single spanning volume
pConfig->m_Partitions[0].m_PartitionNumber = 1;
@ -142,21 +191,47 @@ void init_pd(physical_disk_t* pConfig) {
}
}
BYTE writeBuffer[1024];
void write_buffer(HANDLE hDisk, LONG nOffset, DWORD nBytes, physical_disk_t* pConfig) {
LARGE_INTEGER offset;
offset.QuadPart = nOffset * pConfig->m_BlockSize;
SetFilePointerEx(hDisk, offset, NULL, FILE_BEGIN);
DWORD nOut;
WriteFile(hDisk, writeBuffer, nBytes, &nOut, NULL);
inline void set_chs(BYTE* chs, WORD cylinder, BYTE head, BYTE sector) {
chs[0] = head;
chs[1] = ((sector & 0x3f) | ((cylinder & 0x300) >> 2)) & 0xff;
chs[2] = cylinder & 0xff;
}
inline void set_chs_from_lba(BYTE* chs, DWORD lba) {
WORD cylinder = (lba / (HEADS_PER_CYLINDER * SECTORS_PER_TRACK)) & 0xffff;
BYTE head = ((lba / SECTORS_PER_TRACK) % HEADS_PER_CYLINDER) & 0xff;
BYTE sector = ((lba % SECTORS_PER_TRACK) + 1) & 0xff;
set_chs(chs, cylinder, head, sector);
}
inline void fix_partition_chs(PMBR_PARTITION partition) {
set_chs_from_lba(partition->start_chs, partition->lba);
set_chs_from_lba(partition->end_chs, partition->lba + partition->sectors - 1);
}
BYTE writeBuffer[1024];
void write_buffer(HANDLE hDisk, DWORD nBlock, DWORD nBytes, physical_disk_t* pConfig) {
LARGE_INTEGER offset;
offset.HighPart = 0;
offset.LowPart = nBlock;
offset.QuadPart *= pConfig->m_BlockSize;
SetFilePointerEx(hDisk, offset, NULL, FILE_BEGIN);
printf("Performing write: %d@%08x%08x\n", nBytes, offset.HighPart, offset.LowPart);
DWORD nOut;
WriteFile(hDisk, writeBuffer, nBytes, &nOut, NULL);
if (nOut != nBytes) {
printf("WRITE FAILED!! %d\n", GetLastError());
CloseHandle(hDisk);
exit(1);
}
}
// TODO: Write start_chs lol
void write_mbr(HANDLE hDisk, LONG nOffset, physical_disk_t* pConfig) {
printf("Writing MBR at block %d\n", nOffset);
mbr_t* mbr = (mbr_t*)writeBuffer;
PMBR_HEADER mbr = (PMBR_HEADER)writeBuffer;
memset(mbr, 0, sizeof *mbr);
memcpy_s(mbr->bootstrap_code, sizeof mbr->bootstrap_code, WINDOWS_MBR_BOOTSTRAP,
sizeof WINDOWS_MBR_BOOTSTRAP);
mbr->sig[0] = 0x55;
mbr->sig[1] = 0xAA;
@ -168,14 +243,17 @@ void write_mbr(HANDLE hDisk, LONG nOffset, physical_disk_t* pConfig) {
mbr->partitions[i].type = pConfig->m_Partitions[i].m_Filesystem;
mbr->partitions[i].lba = pConfig->m_Partitions[i].m_PhysicalLBA;
mbr->partitions[i].sectors = pConfig->m_Partitions[i].m_Size;
fix_partition_chs(&(mbr->partitions[i]));
}
write_buffer(hDisk, nOffset, sizeof *mbr, pConfig);
}
void write_ext_header(HANDLE hDisk, LONG nOffset, physical_disk_t* pConfig, DWORD nPartition) {
printf("Writing extended header at block %d\n", nOffset);
printf(" -> Part %d = %d\n", nPartition + 5, nOffset);
mbr_t* mbr = (mbr_t*)writeBuffer;
PMBR_HEADER mbr = (PMBR_HEADER)writeBuffer;
memset(mbr, 0, sizeof *mbr);
mbr->sig[0] = 0x55;
@ -183,23 +261,33 @@ void write_ext_header(HANDLE hDisk, LONG nOffset, physical_disk_t* pConfig, DWOR
mbr->partitions[0].status = MBR_FLAG_NONE;
mbr->partitions[0].type = pConfig->m_Extended[nPartition].m_Filesystem;
mbr->partitions[0].lba = EXT_HEADER_GAP;
mbr->partitions[0].lba = pConfig->m_Extended[nPartition].m_PhysicalLBA;
mbr->partitions[0].sectors = pConfig->m_Extended[nPartition].m_Size;
fix_partition_chs(&(mbr->partitions[0]));
// Write the EBR value
mbr->partitions[0].lba = EXT_HEADER_GAP;
if (pConfig->m_Extended[nPartition + 1].m_Size) {
mbr->partitions[1].status = MBR_FLAG_NONE;
// ! mxinstaller expects to see CHS here, then uses the LBA values
mbr->partitions[1].type = MBR_FS_EXT_CHS;
mbr->partitions[1].lba = pConfig->m_Extended[nPartition + 1].m_PhysicalLBA - EXT_HEADER_GAP;
mbr->partitions[1].sectors = pConfig->m_Extended[nPartition + 1].m_Size + EXT_HEADER_GAP;
fix_partition_chs(&(mbr->partitions[1]));
// Write the EBR values
mbr->partitions[1].lba = pConfig->m_Extended[nPartition + 1].m_PhysicalLBA -
pConfig->m_Extended[0].m_PhysicalLBA;
mbr->partitions[1].sectors = pConfig->m_Extended[nPartition + 1].m_Size + EXT_HEADER_GAP;
mbr->partitions[1].end_chs[0] = 0xFE;
mbr->partitions[1].end_chs[1] = 0xFF;
mbr->partitions[1].end_chs[2] = 0xFF;
}
write_buffer(hDisk, nOffset, sizeof *mbr, pConfig);
}
void write_pd(HANDLE hDisk, physical_disk_t* pConfig) {
puts("Force-allocating disk space");
printf("Pre-allocating disk space (0x%x blocks)\n", pConfig->m_TotalSize);
write_buffer(hDisk, pConfig->m_TotalSize - 1, pConfig->m_BlockSize, pConfig);
// Write MBR headers
@ -209,10 +297,9 @@ void write_pd(HANDLE hDisk, physical_disk_t* pConfig) {
write_ext_header(hDisk, headerLBA, pConfig, i);
if (i == 0 && pConfig->m_HasSegaboot) {
puts("Writing segaboot");
// SEGA Partition Description
spd_t* spd = (spd_t*)writeBuffer;
ZeroMemory(spd, sizeof *spd);
spd->version = SPD_VERSION;
for (size_t j = 0; pConfig->m_Extended[j].m_Size; j++) {
@ -225,25 +312,159 @@ void write_pd(HANDLE hDisk, physical_disk_t* pConfig) {
spd->crc = amiCrc32RCalc(sizeof *spd - 4, &(spd->version), 0);
write_buffer(hDisk, headerLBA + SPD_OFFSET, sizeof *spd, pConfig);
// TODO: Actually populate the SBRs
// SEGA Boot Record 0 and 1. The two are a redundant copy of each other
memcpy(writeBuffer, &SegaBootRecord0, sizeof SegaBootRecord0);
write_buffer(hDisk, headerLBA + SBR0_OFFSET, sizeof SegaBootRecord0, pConfig);
memcpy(writeBuffer, &SegaBootRecord1, sizeof SegaBootRecord1);
write_buffer(hDisk, headerLBA + SBR1_OFFSET, sizeof SegaBootRecord1, pConfig);
printf(" -> SEGA structures = %d+[1/2/3]\n", headerLBA);
}
}
}
void print_bar(LONGLONG nCurrent, LONGLONG nMax) {
printf("[");
DWORD filled = ((float)nCurrent / (float)nMax) * 40;
int i = 0;
for (; i < filled; i++) printf("=");
for (; i < 40; i++) printf(" ");
printf("] %3.2f%%\r", (float)nCurrent / (float)nMax * 100);
}
void end_bar() { printf("[========================================] 100.00%%\n"); }
BOOL mount_OSR(LPSTR lpOSRPath) {
char szTcCommand[1024];
sprintf_s(szTcCommand, sizeof szTcCommand, "%s /p %s /v %s /l %s %s", TRUECRYPT, OSR_PASSWORD,
lpOSRPath, OSR_MOUNTPOINT, OSR_FLAGS);
int dTcRet = system(szTcCommand);
if (dTcRet != 0) {
printf("Failed to mount OSR: %d\n", dTcRet);
printf("Command used was: %s\n", szTcCommand);
return FALSE;
}
return TRUE;
}
BOOL dismount_OSR() {
char szTcCommand[1024];
sprintf_s(szTcCommand, sizeof szTcCommand, "%s /q /d %s", TRUECRYPT, OSR_MOUNTPOINT, OSR_FLAGS);
int dTcRet = system(szTcCommand);
if (dTcRet != 0) {
printf("Failed to dismount OSR: %d\n", dTcRet);
printf("Command used was: %s\n", szTcCommand);
return FALSE;
}
return TRUE;
}
void install_OSR(HANDLE hDisk, LPSTR lpOSRPath) {
if (!mount_OSR(lpOSRPath)) return;
HANDLE hOSR = CreateFileA("\\\\.\\" OSR_MOUNTPOINT, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hOSR == INVALID_HANDLE_VALUE) {
printf("Failed to open OSR! %d\n", GetLastError());
return;
}
DISK_GEOMETRY dg;
DWORD nBytesReturned;
DeviceIoControl(hOSR, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &dg, sizeof dg, &nBytesReturned,
NULL);
LONGLONG nBytes =
dg.BytesPerSector * dg.SectorsPerTrack * dg.TracksPerCylinder * dg.Cylinders.QuadPart;
SetFilePointer(hDisk, 63 * 512, NULL, FILE_BEGIN);
puts("Installing Operating System");
BYTE block[4096];
int print_tick = 0;
for (LONGLONG i = 0; nBytes;) {
DWORD nRead = sizeof block;
if (nRead > nBytes) nRead = (DWORD)nBytes;
ReadFile(hOSR, block, nRead, &nRead, NULL);
if (nRead == 0) {
if (GetLastError() == ERROR_SUCCESS) break;
printf("Failed to read OSR. Code: %d\n", GetLastError());
goto end;
return;
}
DWORD nWrote = 0;
WriteFile(hDisk, block, nRead, &nWrote, NULL);
if (nWrote != nRead) {
printf("Failed to write OSR to disk. Code: %d\n", GetLastError());
goto end;
return;
}
if (print_tick++ == 512) {
print_tick = 0;
print_bar(i, nBytes);
}
i += nRead;
}
end_bar();
end:
CloseHandle(hOSR);
dismount_OSR();
}
void install_OSR_xcopy(LPSTR lpDiskPath, LPSTR lpOSRPath) {
if (!mount_OSR(lpOSRPath)) return;
printf("Installing OS using xcopy %s -> %s\n", OSR_MOUNTPOINT, lpDiskPath);
char szXcCommand[1024];
sprintf_s(szXcCommand, sizeof szXcCommand, "xcopy %s %s /e /c /h /y /q", OSR_MOUNTPOINT, lpDiskPath);
int dTcRet = system(szXcCommand);
if (dTcRet != 0) {
printf("Failed to xcopy OSR: %d\n", dTcRet);
printf("Command used was: %s\n", szXcCommand);
return FALSE;
}
return TRUE;
dismount_OSR();
}
int main(int argc, char* argv[]) {
amiCrc32RInit();
init_pd(&newSSD);
HANDLE hDisk = INVALID_HANDLE_VALUE;
SetLastError(0);
hDisk = CreateFileA("H:\\NewDiskImage.img", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
// hDisk = CreateFileA("H:\\NewDiskImage.img", GENERIC_READ | GENERIC_WRITE,
// FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,
// FILE_ATTRIBUTE_NORMAL, NULL);
hDisk = CreateFileA("\\\\.\\PHYSICALDRIVE4", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hDisk == INVALID_HANDLE_VALUE) {
printf("Failed to open disk! %d\n", GetLastError());
return 1;
}
write_pd(hDisk, &newSSD);
// install_OSR(hDisk, "H:\\Arcades\\RingOS\\RecoverOS\\0009\\Minint\\system32\\OSR");
// install_OSR_xcopy(hDisk, "H:\\Arcades\\RingOS\\RecoverOS\\0009\\Minint\\system32\\OSR");
puts("Please mount OS at W:");
system("pause");
install_OSR_xcopy("W:", "H:\\Arcades\\RingOS\\RecoverOS\\0009\\Minint\\system32\\OSR");
FlushFileBuffers(hDisk);
CloseHandle(hDisk);
return 0;
}

2
src/patches/maimai_dump_.patch
View File

@ -19,3 +19,5 @@
*00c89320 : 00000000 > 01000000 # amBackupDebugLevel
*00c88bb4 : 00000000 > 01000000 # amHwResetDebugLevel
*00c830e8 : 00000000 > 01000000 # LOG_EN
*00b93c30 : 680074007400700073003a002f002f006d0079002d00610069006d0065002e006e00650074002f00610069006d0065002f0069002f0072006500670069007300740071002e00680074006d006c003f00610063003d000000 > 680074007400700073003a002f002f006d006900630065006e00650074002e006300610074006700690072006c002e00610072006d0079002f00710072003f00610063003d00000000000000000000000000000000000000 # aime URL