Compare commits
4 Commits
matcher/NH
...
agent/w092
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
208136ad47 | ||
|
|
c44a615a53 | ||
|
|
a84dfba152 | ||
|
|
09b459d8f3 |
487
libs/RevoEX/src/net/aes.c
Normal file
487
libs/RevoEX/src/net/aes.c
Normal file
@@ -0,0 +1,487 @@
|
||||
#include <revolution.h>
|
||||
#include <revolution/net.h>
|
||||
#include <string.h>
|
||||
|
||||
// TODO: Not yet in the SDK
|
||||
typedef struct NETAESContext NETAESContext;
|
||||
|
||||
// TODO: Not yet in the SDK
|
||||
typedef struct NETAESBlockMode {
|
||||
void (*encrypt)(NETAESContext* ctx, u8* dst, const u8* src); // 0x00
|
||||
void (*decrypt)(NETAESContext* ctx, u8* dst, const u8* src); // 0x04
|
||||
} NETAESBlockMode;
|
||||
|
||||
// TODO: Not yet in the SDK
|
||||
struct NETAESContext {
|
||||
u32 iv[4]; // 0x00
|
||||
u32 rk[60]; // 0x10
|
||||
u32 flags; // 0x100
|
||||
const NETAESBlockMode* mode; // 0x104
|
||||
};
|
||||
|
||||
extern const NETAESBlockMode NET_AES_BLOCK_MODE_CBC;
|
||||
|
||||
static const u8 AESiSubShiftTable[0x100] = {
|
||||
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
|
||||
0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
|
||||
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
|
||||
0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
|
||||
0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
|
||||
0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
|
||||
0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
|
||||
0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
|
||||
0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
|
||||
0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
|
||||
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
|
||||
0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
|
||||
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
|
||||
0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
|
||||
0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
|
||||
0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
|
||||
0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
|
||||
0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
|
||||
0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
|
||||
0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
|
||||
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
|
||||
0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
|
||||
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
|
||||
0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
|
||||
0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
|
||||
0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
|
||||
0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
|
||||
0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
|
||||
0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
|
||||
0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
|
||||
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
|
||||
0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
|
||||
};
|
||||
|
||||
static const u8 AESiInvSubShiftTable[0x100] = {
|
||||
0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
|
||||
0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
|
||||
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
|
||||
0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
|
||||
0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
|
||||
0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
|
||||
0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
|
||||
0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
|
||||
0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
|
||||
0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
|
||||
0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
|
||||
0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
|
||||
0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
|
||||
0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
|
||||
0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
|
||||
0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
|
||||
0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
|
||||
0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
|
||||
0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
|
||||
0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
|
||||
0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
|
||||
0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
|
||||
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
|
||||
0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
|
||||
0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
|
||||
0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
|
||||
0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
|
||||
0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
|
||||
0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
|
||||
0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
|
||||
0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
|
||||
0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
|
||||
};
|
||||
|
||||
static const u8 AESiRoundKeyRcon0[0x1E] = {
|
||||
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
|
||||
0x1B, 0x36, 0x6C, 0xD8, 0xAB, 0x4D, 0x9A, 0x2F,
|
||||
0x5E, 0xBC, 0x63, 0xC6, 0x97, 0x35, 0x6A, 0xD4,
|
||||
0xB3, 0x7D, 0xFA, 0xEF, 0xC5, 0x91
|
||||
};
|
||||
|
||||
static const u32 AESiEncryptTable[0x100] = {
|
||||
0x6363A5C6, 0x7C7C84F8, 0x777799EE, 0x7B7B8DF6,
|
||||
0xF2F20DFF, 0x6B6BBDD6, 0x6F6FB1DE, 0xC5C55491,
|
||||
0x30305060, 0x01010302, 0x6767A9CE, 0x2B2B7D56,
|
||||
0xFEFE19E7, 0xD7D762B5, 0xABABE64D, 0x76769AEC,
|
||||
0xCACA458F, 0x82829D1F, 0xC9C94089, 0x7D7D87FA,
|
||||
0xFAFA15EF, 0x5959EBB2, 0x4747C98E, 0xF0F00BFB,
|
||||
0xADADEC41, 0xD4D467B3, 0xA2A2FD5F, 0xAFAFEA45,
|
||||
0x9C9CBF23, 0xA4A4F753, 0x727296E4, 0xC0C05B9B,
|
||||
0xB7B7C275, 0xFDFD1CE1, 0x9393AE3D, 0x26266A4C,
|
||||
0x36365A6C, 0x3F3F417E, 0xF7F702F5, 0xCCCC4F83,
|
||||
0x34345C68, 0xA5A5F451, 0xE5E534D1, 0xF1F108F9,
|
||||
0x717193E2, 0xD8D873AB, 0x31315362, 0x15153F2A,
|
||||
0x04040C08, 0xC7C75295, 0x23236546, 0xC3C35E9D,
|
||||
0x18182830, 0x9696A137, 0x05050F0A, 0x9A9AB52F,
|
||||
0x0707090E, 0x12123624, 0x80809B1B, 0xE2E23DDF,
|
||||
0xEBEB26CD, 0x2727694E, 0xB2B2CD7F, 0x75759FEA,
|
||||
0x09091B12, 0x83839E1D, 0x2C2C7458, 0x1A1A2E34,
|
||||
0x1B1B2D36, 0x6E6EB2DC, 0x5A5AEEB4, 0xA0A0FB5B,
|
||||
0x5252F6A4, 0x3B3B4D76, 0xD6D661B7, 0xB3B3CE7D,
|
||||
0x29297B52, 0xE3E33EDD, 0x2F2F715E, 0x84849713,
|
||||
0x5353F5A6, 0xD1D168B9, 0x00000000, 0xEDED2CC1,
|
||||
0x20206040, 0xFCFC1FE3, 0xB1B1C879, 0x5B5BEDB6,
|
||||
0x6A6ABED4, 0xCBCB468D, 0xBEBED967, 0x39394B72,
|
||||
0x4A4ADE94, 0x4C4CD498, 0x5858E8B0, 0xCFCF4A85,
|
||||
0xD0D06BBB, 0xEFEF2AC5, 0xAAAAE54F, 0xFBFB16ED,
|
||||
0x4343C586, 0x4D4DD79A, 0x33335566, 0x85859411,
|
||||
0x4545CF8A, 0xF9F910E9, 0x02020604, 0x7F7F81FE,
|
||||
0x5050F0A0, 0x3C3C4478, 0x9F9FBA25, 0xA8A8E34B,
|
||||
0x5151F3A2, 0xA3A3FE5D, 0x4040C080, 0x8F8F8A05,
|
||||
0x9292AD3F, 0x9D9DBC21, 0x38384870, 0xF5F504F1,
|
||||
0xBCBCDF63, 0xB6B6C177, 0xDADA75AF, 0x21216342,
|
||||
0x10103020, 0xFFFF1AE5, 0xF3F30EFD, 0xD2D26DBF,
|
||||
0xCDCD4C81, 0x0C0C1418, 0x13133526, 0xECEC2FC3,
|
||||
0x5F5FE1BE, 0x9797A235, 0x4444CC88, 0x1717392E,
|
||||
0xC4C45793, 0xA7A7F255, 0x7E7E82FC, 0x3D3D477A,
|
||||
0x6464ACC8, 0x5D5DE7BA, 0x19192B32, 0x737395E6,
|
||||
0x6060A0C0, 0x81819819, 0x4F4FD19E, 0xDCDC7FA3,
|
||||
0x22226644, 0x2A2A7E54, 0x9090AB3B, 0x8888830B,
|
||||
0x4646CA8C, 0xEEEE29C7, 0xB8B8D36B, 0x14143C28,
|
||||
0xDEDE79A7, 0x5E5EE2BC, 0x0B0B1D16, 0xDBDB76AD,
|
||||
0xE0E03BDB, 0x32325664, 0x3A3A4E74, 0x0A0A1E14,
|
||||
0x4949DB92, 0x06060A0C, 0x24246C48, 0x5C5CE4B8,
|
||||
0xC2C25D9F, 0xD3D36EBD, 0xACACEF43, 0x6262A6C4,
|
||||
0x9191A839, 0x9595A431, 0xE4E437D3, 0x79798BF2,
|
||||
0xE7E732D5, 0xC8C8438B, 0x3737596E, 0x6D6DB7DA,
|
||||
0x8D8D8C01, 0xD5D564B1, 0x4E4ED29C, 0xA9A9E049,
|
||||
0x6C6CB4D8, 0x5656FAAC, 0xF4F407F3, 0xEAEA25CF,
|
||||
0x6565AFCA, 0x7A7A8EF4, 0xAEAEE947, 0x08081810,
|
||||
0xBABAD56F, 0x787888F0, 0x25256F4A, 0x2E2E725C,
|
||||
0x1C1C2438, 0xA6A6F157, 0xB4B4C773, 0xC6C65197,
|
||||
0xE8E823CB, 0xDDDD7CA1, 0x74749CE8, 0x1F1F213E,
|
||||
0x4B4BDD96, 0xBDBDDC61, 0x8B8B860D, 0x8A8A850F,
|
||||
0x707090E0, 0x3E3E427C, 0xB5B5C471, 0x6666AACC,
|
||||
0x4848D890, 0x03030506, 0xF6F601F7, 0x0E0E121C,
|
||||
0x6161A3C2, 0x35355F6A, 0x5757F9AE, 0xB9B9D069,
|
||||
0x86869117, 0xC1C15899, 0x1D1D273A, 0x9E9EB927,
|
||||
0xE1E138D9, 0xF8F813EB, 0x9898B32B, 0x11113322,
|
||||
0x6969BBD2, 0xD9D970A9, 0x8E8E8907, 0x9494A733,
|
||||
0x9B9BB62D, 0x1E1E223C, 0x87879215, 0xE9E920C9,
|
||||
0xCECE4987, 0x5555FFAA, 0x28287850, 0xDFDF7AA5,
|
||||
0x8C8C8F03, 0xA1A1F859, 0x89898009, 0x0D0D171A,
|
||||
0xBFBFDA65, 0xE6E631D7, 0x4242C684, 0x6868B8D0,
|
||||
0x4141C382, 0x9999B029, 0x2D2D775A, 0x0F0F111E,
|
||||
0xB0B0CB7B, 0x5454FCA8, 0xBBBBD66D, 0x16163A2C
|
||||
};
|
||||
|
||||
static const u32 AESiDecryptTable[0x100] = {
|
||||
0xF4A75051, 0x4165537E, 0x17A4C31A, 0x275E963A,
|
||||
0xAB6BCB3B, 0x9D45F11F, 0xFA58ABAC, 0xE303934B,
|
||||
0x30FA5520, 0x766DF6AD, 0xCC769188, 0x024C25F5,
|
||||
0xE5D7FC4F, 0x2ACBD7C5, 0x35448026, 0x62A38FB5,
|
||||
0xB15A49DE, 0xBA1B6725, 0xEA0E9845, 0xFEC0E15D,
|
||||
0x2F7502C3, 0x4CF01281, 0x4697A38D, 0xD3F9C66B,
|
||||
0x8F5FE703, 0x929C9515, 0x6D7AEBBF, 0x5259DA95,
|
||||
0xBE832DD4, 0x7421D358, 0xE0692949, 0xC9C8448E,
|
||||
0xC2896A75, 0x8E7978F4, 0x583E6B99, 0xB971DD27,
|
||||
0xE14FB6BE, 0x88AD17F0, 0x20AC66C9, 0xCE3AB47D,
|
||||
0xDF4A1863, 0x1A3182E5, 0x51336097, 0x537F4562,
|
||||
0x6477E0B1, 0x6BAE84BB, 0x81A01CFE, 0x082B94F9,
|
||||
0x48685870, 0x45FD198F, 0xDE6C8794, 0x7BF8B752,
|
||||
0x73D323AB, 0x4B02E272, 0x1F8F57E3, 0x55AB2A66,
|
||||
0xEB2807B2, 0xB5C2032F, 0xC57B9A86, 0x3708A5D3,
|
||||
0x2887F230, 0xBFA5B223, 0x036ABA02, 0x16825CED,
|
||||
0xCF1C2B8A, 0x79B492A7, 0x07F2F0F3, 0x69E2A14E,
|
||||
0xDAF4CD65, 0x05BED506, 0x34621FD1, 0xA6FE8AC4,
|
||||
0x2E539D34, 0xF355A0A2, 0x8AE13205, 0xF6EB75A4,
|
||||
0x83EC390B, 0x60EFAA40, 0x719F065E, 0x6E1051BD,
|
||||
0x218AF93E, 0xDD063D96, 0x3E05AEDD, 0xE6BD464D,
|
||||
0x548DB591, 0xC45D0571, 0x06D46F04, 0x5015FF60,
|
||||
0x98FB2419, 0xBDE997D6, 0x4043CC89, 0xD99E7767,
|
||||
0xE842BDB0, 0x898B8807, 0x195B38E7, 0xC8EEDB79,
|
||||
0x7C0A47A1, 0x420FE97C, 0x841EC9F8, 0x00000000,
|
||||
0x80868309, 0x2BED4832, 0x1170AC1E, 0x5A724E6C,
|
||||
0x0EFFFBFD, 0x8538560F, 0xAED51E3D, 0x2D392736,
|
||||
0x0FD9640A, 0x5CA62168, 0x5B54D19B, 0x362E3A24,
|
||||
0x0A67B10C, 0x57E70F93, 0xEE96D2B4, 0x9B919E1B,
|
||||
0xC0C54F80, 0xDC20A261, 0x774B695A, 0x121A161C,
|
||||
0x93BA0AE2, 0xA02AE5C0, 0x22E0433C, 0x1B171D12,
|
||||
0x090D0B0E, 0x8BC7ADF2, 0xB6A8B92D, 0x1EA9C814,
|
||||
0xF1198557, 0x75074CAF, 0x99DDBBEE, 0x7F60FDA3,
|
||||
0x01269FF7, 0x72F5BC5C, 0x663BC544, 0xFB7E345B,
|
||||
0x4329768B, 0x23C6DCCB, 0xEDFC68B6, 0xE4F163B8,
|
||||
0x31DCCAD7, 0x63851042, 0x97224013, 0xC6112084,
|
||||
0x4A247D85, 0xBB3DF8D2, 0xF93211AE, 0x29A16DC7,
|
||||
0x9E2F4B1D, 0xB230F3DC, 0x8652EC0D, 0xC1E3D077,
|
||||
0xB3166C2B, 0x70B999A9, 0x9448FA11, 0xE9642247,
|
||||
0xFC8CC4A8, 0xF03F1AA0, 0x7D2CD856, 0x3390EF22,
|
||||
0x494EC787, 0x38D1C1D9, 0xCAA2FE8C, 0xD40B3698,
|
||||
0xF581CFA6, 0x7ADE28A5, 0xB78E26DA, 0xADBFA43F,
|
||||
0x3A9DE42C, 0x78920D50, 0x5FCC9B6A, 0x7E466254,
|
||||
0x8D13C2F6, 0xD8B8E890, 0x39F75E2E, 0xC3AFF582,
|
||||
0x5D80BE9F, 0xD0937C69, 0xD52DA96F, 0x2512B3CF,
|
||||
0xAC993BC8, 0x187DA710, 0x9C636EE8, 0x3BBB7BDB,
|
||||
0x267809CD, 0x5918F46E, 0x9AB701EC, 0x4F9AA883,
|
||||
0x956E65E6, 0xFFE67EAA, 0xBCCF0821, 0x15E8E6EF,
|
||||
0xE79BD9BA, 0x6F36CE4A, 0x9F09D4EA, 0xB07CD629,
|
||||
0xA4B2AF31, 0x3F23312A, 0xA59430C6, 0xA266C035,
|
||||
0x4EBC3774, 0x82CAA6FC, 0x90D0B0E0, 0xA7D81533,
|
||||
0x04984AF1, 0xECDAF741, 0xCD500E7F, 0x91F62F17,
|
||||
0x4DD68D76, 0xEFB04D43, 0xAA4D54CC, 0x9604DFE4,
|
||||
0xD1B5E39E, 0x6A881B4C, 0x2C1FB8C1, 0x65517F46,
|
||||
0x5EEA049D, 0x8C355D01, 0x877473FA, 0x0B412EFB,
|
||||
0x671D5AB3, 0xDBD25292, 0x105633E9, 0xD647136D,
|
||||
0xD7618C9A, 0xA10C7A37, 0xF8148E59, 0x133C89EB,
|
||||
0xA927EECE, 0x61C935B7, 0x1CE5EDE1, 0x47B13C7A,
|
||||
0xD2DF599C, 0xF2733F55, 0x14CE7918, 0xC737BF73,
|
||||
0xF7CDEA53, 0xFDAA5B5F, 0x3D6F14DF, 0x44DB8678,
|
||||
0xAFF381CA, 0x68C43EB9, 0x24342C38, 0xA3405FC2,
|
||||
0x1DC37216, 0xE2250CBC, 0x3C498B28, 0x0D9541FF,
|
||||
0xA8017139, 0x0CB3DE08, 0xB4E49CD8, 0x56C19064,
|
||||
0xCB84617B, 0x32B670D5, 0x6C5C7448, 0xB85742D0
|
||||
};
|
||||
|
||||
|
||||
static void NETiAESEncryptoBlock(NETAESContext* ctx, u8* dst, const u8* src);
|
||||
static void NETiAESDecryptoBlock(NETAESContext* ctx, u8* dst, const u8* src);
|
||||
|
||||
void AESiEncryptBlock(NETAESContext* ctx, u32* dst, const u32* src) {
|
||||
const u32* rk;
|
||||
u32 s0;
|
||||
u32 s1;
|
||||
u32 s2;
|
||||
u32 s3;
|
||||
u32 i;
|
||||
u32 rounds;
|
||||
|
||||
s0 = src[0] ^ ctx->rk[0];
|
||||
s1 = src[1] ^ ctx->rk[1];
|
||||
s2 = src[2] ^ ctx->rk[2];
|
||||
s3 = src[3] ^ ctx->rk[3];
|
||||
|
||||
rounds = ctx->flags >> 24;
|
||||
rk = ctx->rk + 4;
|
||||
while (--rounds != 0) {
|
||||
u32 x0 = AESiEncryptTable[s0 >> 24];
|
||||
u32 x1 = AESiEncryptTable[s1 >> 24];
|
||||
u32 x2 = AESiEncryptTable[s2 >> 24];
|
||||
u32 x3 = AESiEncryptTable[s3 >> 24];
|
||||
u32 y0 = AESiEncryptTable[(s0 >> 16) & 0xFF];
|
||||
u32 y1 = AESiEncryptTable[(s1 >> 16) & 0xFF];
|
||||
u32 y2 = AESiEncryptTable[(s2 >> 16) & 0xFF];
|
||||
u32 y3 = AESiEncryptTable[(s3 >> 16) & 0xFF];
|
||||
u32 z0 = AESiEncryptTable[(s0 >> 8) & 0xFF];
|
||||
u32 z1 = AESiEncryptTable[(s1 >> 8) & 0xFF];
|
||||
u32 z2 = AESiEncryptTable[(s2 >> 8) & 0xFF];
|
||||
u32 z3 = AESiEncryptTable[(s3 >> 8) & 0xFF];
|
||||
u32 w0 = AESiEncryptTable[s0 & 0xFF];
|
||||
u32 w1 = AESiEncryptTable[s1 & 0xFF];
|
||||
u32 w2 = AESiEncryptTable[s2 & 0xFF];
|
||||
u32 w3 = AESiEncryptTable[s3 & 0xFF];
|
||||
s0 = rk[0] ^ ((x0 >> 8) | (x0 << 24)) ^ ((y1 >> 16) | (y1 << 16)) ^ ((z2 >> 24) | (z2 << 8)) ^ w3;
|
||||
s1 = rk[1] ^ ((x1 >> 8) | (x1 << 24)) ^ ((y2 >> 16) | (y2 << 16)) ^ ((z3 >> 24) | (z3 << 8)) ^ w0;
|
||||
s2 = rk[2] ^ ((x2 >> 8) | (x2 << 24)) ^ ((y3 >> 16) | (y3 << 16)) ^ ((z0 >> 24) | (z0 << 8)) ^ w1;
|
||||
s3 = rk[3] ^ ((x3 >> 8) | (x3 << 24)) ^ ((y0 >> 16) | (y0 << 16)) ^ ((z1 >> 24) | (z1 << 8)) ^ w2;
|
||||
rk += 4;
|
||||
}
|
||||
|
||||
dst[0] = (AESiSubShiftTable[s0 >> 24] << 24) | (AESiSubShiftTable[(s1 >> 16) & 0xFF] << 16)
|
||||
| (AESiSubShiftTable[(s2 >> 8) & 0xFF] << 8) | AESiSubShiftTable[s3 & 0xFF] | rk[0];
|
||||
dst[1] = (AESiSubShiftTable[s1 >> 24] << 24) | (AESiSubShiftTable[(s2 >> 16) & 0xFF] << 16)
|
||||
| (AESiSubShiftTable[(s3 >> 8) & 0xFF] << 8) | AESiSubShiftTable[s0 & 0xFF] | rk[1];
|
||||
dst[2] = (AESiSubShiftTable[s2 >> 24] << 24) | (AESiSubShiftTable[(s3 >> 16) & 0xFF] << 16)
|
||||
| (AESiSubShiftTable[(s0 >> 8) & 0xFF] << 8) | AESiSubShiftTable[s1 & 0xFF] | rk[2];
|
||||
dst[3] = (AESiSubShiftTable[s3 >> 24] << 24) | (AESiSubShiftTable[(s0 >> 16) & 0xFF] << 16)
|
||||
| (AESiSubShiftTable[(s1 >> 8) & 0xFF] << 8) | AESiSubShiftTable[s2 & 0xFF] | rk[3];
|
||||
}
|
||||
|
||||
void AESiDecryptBlock(NETAESContext* ctx, u32* dst, const u32* src) {
|
||||
const u32* rk;
|
||||
u32 s0;
|
||||
u32 s1;
|
||||
u32 s2;
|
||||
u32 s3;
|
||||
u32 i;
|
||||
u32 j;
|
||||
u32 rounds;
|
||||
|
||||
rounds = ctx->flags >> 24;
|
||||
rk = ctx->rk + rounds * 4;
|
||||
if (ctx->flags & 0x00800000) {
|
||||
for (i = 1; i < rounds; i++) {
|
||||
for (j = 0; j < 4; j++) {
|
||||
u32 x = ctx->rk[i * 4 + j];
|
||||
u32 x2 = (((x & 0x80808080) >> 7) * 0x1B) ^ ((x & 0x7F7F7F7F) << 1);
|
||||
u32 x4 = (((x2 & 0x80808080) >> 7) * 0x1B) ^ ((x2 & 0x7F7F7F7F) << 1);
|
||||
u32 x8 = (((x4 & 0x80808080) >> 7) * 0x1B) ^ ((x4 & 0x7F7F7F7F) << 1);
|
||||
u32 t = x ^ x8;
|
||||
t ^= x4 ^ ((t << 8) | (t >> 24));
|
||||
t ^= x2 ^ ((t << 8) | (t >> 24));
|
||||
t ^= x ^ ((t << 8) | (t >> 24));
|
||||
ctx->rk[i * 4 + j] = t;
|
||||
}
|
||||
}
|
||||
ctx->flags &= ~0x00800000;
|
||||
}
|
||||
|
||||
s0 = src[0] ^ rk[0];
|
||||
s1 = src[1] ^ rk[1];
|
||||
s2 = src[2] ^ rk[2];
|
||||
s3 = src[3] ^ rk[3];
|
||||
rk -= 4;
|
||||
|
||||
while (--rounds != 0) {
|
||||
u32 t0 = ((AESiDecryptTable[s0 >> 24] >> 8) | (AESiDecryptTable[s0 >> 24] << 24))
|
||||
^ ((AESiDecryptTable[(s3 >> 16) & 0xFF] >> 16) | (AESiDecryptTable[(s3 >> 16) & 0xFF] << 16))
|
||||
^ ((AESiDecryptTable[(s2 >> 8) & 0xFF] >> 24) | (AESiDecryptTable[(s2 >> 8) & 0xFF] << 8))
|
||||
^ AESiDecryptTable[s1 & 0xFF]
|
||||
^ rk[0];
|
||||
u32 t1 = ((AESiDecryptTable[s1 >> 24] >> 8) | (AESiDecryptTable[s1 >> 24] << 24))
|
||||
^ ((AESiDecryptTable[(s0 >> 16) & 0xFF] >> 16) | (AESiDecryptTable[(s0 >> 16) & 0xFF] << 16))
|
||||
^ ((AESiDecryptTable[(s3 >> 8) & 0xFF] >> 24) | (AESiDecryptTable[(s3 >> 8) & 0xFF] << 8))
|
||||
^ AESiDecryptTable[s2 & 0xFF]
|
||||
^ rk[1];
|
||||
u32 t2 = ((AESiDecryptTable[s2 >> 24] >> 8) | (AESiDecryptTable[s2 >> 24] << 24))
|
||||
^ ((AESiDecryptTable[(s1 >> 16) & 0xFF] >> 16) | (AESiDecryptTable[(s1 >> 16) & 0xFF] << 16))
|
||||
^ ((AESiDecryptTable[(s0 >> 8) & 0xFF] >> 24) | (AESiDecryptTable[(s0 >> 8) & 0xFF] << 8))
|
||||
^ AESiDecryptTable[s3 & 0xFF]
|
||||
^ rk[2];
|
||||
u32 t3 = ((AESiDecryptTable[s3 >> 24] >> 8) | (AESiDecryptTable[s3 >> 24] << 24))
|
||||
^ ((AESiDecryptTable[(s2 >> 16) & 0xFF] >> 16) | (AESiDecryptTable[(s2 >> 16) & 0xFF] << 16))
|
||||
^ ((AESiDecryptTable[(s1 >> 8) & 0xFF] >> 24) | (AESiDecryptTable[(s1 >> 8) & 0xFF] << 8))
|
||||
^ AESiDecryptTable[s0 & 0xFF]
|
||||
^ rk[3];
|
||||
s0 = t0;
|
||||
s1 = t1;
|
||||
s2 = t2;
|
||||
s3 = t3;
|
||||
rk -= 4;
|
||||
}
|
||||
|
||||
dst[0] = (AESiInvSubShiftTable[s0 >> 24] << 24) ^ (AESiInvSubShiftTable[(s3 >> 16) & 0xFF] << 16)
|
||||
^ (AESiInvSubShiftTable[(s2 >> 8) & 0xFF] << 8) ^ AESiInvSubShiftTable[s1 & 0xFF] ^ rk[0];
|
||||
dst[1] = (AESiInvSubShiftTable[s1 >> 24] << 24) ^ (AESiInvSubShiftTable[(s0 >> 16) & 0xFF] << 16)
|
||||
^ (AESiInvSubShiftTable[(s3 >> 8) & 0xFF] << 8) ^ AESiInvSubShiftTable[s2 & 0xFF] ^ rk[1];
|
||||
dst[2] = (AESiInvSubShiftTable[s2 >> 24] << 24) ^ (AESiInvSubShiftTable[(s1 >> 16) & 0xFF] << 16)
|
||||
^ (AESiInvSubShiftTable[(s0 >> 8) & 0xFF] << 8) ^ AESiInvSubShiftTable[s3 & 0xFF] ^ rk[2];
|
||||
dst[3] = (AESiInvSubShiftTable[s3 >> 24] << 24) ^ (AESiInvSubShiftTable[(s2 >> 16) & 0xFF] << 16)
|
||||
^ (AESiInvSubShiftTable[(s1 >> 8) & 0xFF] << 8) ^ AESiInvSubShiftTable[s0 & 0xFF] ^ rk[3];
|
||||
}
|
||||
|
||||
s32 NETAESCreateEx(NETAESContext* ctx, const u8* key, u32 keyLen, const u8* iv, const NETAESBlockMode* mode) {
|
||||
s32 ret = 0;
|
||||
u32* w;
|
||||
u32* rk;
|
||||
u32 tmp;
|
||||
u32 nk;
|
||||
u32 i;
|
||||
|
||||
if (keyLen != 0x10 && keyLen != 0x18 && keyLen != 0x20) {
|
||||
OSReport("NETAESCreateEx() failed! (key-length is allowed only 16, 20, 24 BYTEs)");
|
||||
} else {
|
||||
ctx->flags |= 0x00800000;
|
||||
ctx->mode = mode;
|
||||
ctx->flags = (ctx->flags & 0x00FFFFFF) | ((keyLen >> 2) + 6) << 24;
|
||||
memcpy(ctx->iv, iv, 0x10);
|
||||
w = ctx->rk;
|
||||
memcpy(w, key, keyLen);
|
||||
|
||||
nk = keyLen >> 2;
|
||||
rk = w + nk;
|
||||
tmp = rk[-1];
|
||||
i = nk;
|
||||
while (i < ((ctx->flags >> 24) + 1) * 4) {
|
||||
if (i % nk == 0) {
|
||||
tmp = AESiSubShiftTable[tmp >> 24]
|
||||
^ (AESiSubShiftTable[tmp & 0xFF] << 8)
|
||||
^ (AESiSubShiftTable[(tmp >> 8) & 0xFF] << 16)
|
||||
^ (AESiSubShiftTable[(tmp >> 16) & 0xFF] << 24)
|
||||
^ (AESiRoundKeyRcon0[i / nk - 1] << 24);
|
||||
} else if (nk > 6 && i % nk == 4) {
|
||||
tmp = AESiSubShiftTable[tmp & 0xFF]
|
||||
^ (AESiSubShiftTable[(tmp >> 8) & 0xFF] << 8)
|
||||
^ (AESiSubShiftTable[(tmp >> 16) & 0xFF] << 16)
|
||||
^ (AESiSubShiftTable[tmp >> 24] << 24);
|
||||
}
|
||||
tmp ^= w[i - nk];
|
||||
*rk++ = tmp;
|
||||
i++;
|
||||
}
|
||||
ret = 1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
s32 NETAESCreate(NETAESContext* ctx, const u8* key, u32 keyLen, const u8* iv) {
|
||||
return NETAESCreateEx(ctx, key, keyLen, iv, &NET_AES_BLOCK_MODE_CBC);
|
||||
}
|
||||
|
||||
void NETAESDelete(NETAESContext* ctx) {
|
||||
}
|
||||
|
||||
s32 NETAESEncrypt(NETAESContext* ctx, u8* dst, const u8* src, s32 len) {
|
||||
s32 ret = 0;
|
||||
void (*encrypt)(NETAESContext* ctx, u8* dst, const u8* src) = ctx->mode->encrypt;
|
||||
|
||||
if (encrypt == NULL) {
|
||||
OSReport("this mode cannot support encryption!");
|
||||
} else if (len & 0xF) {
|
||||
OSReport("length has not suited to AES block alignment!");
|
||||
} else {
|
||||
while (len != 0) {
|
||||
encrypt(ctx, dst, src);
|
||||
src += 0x10;
|
||||
dst += 0x10;
|
||||
len -= 0x10;
|
||||
}
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
s32 NETAESDecrypt(NETAESContext* ctx, u8* dst, const u8* src, s32 len) {
|
||||
s32 ret = 0;
|
||||
void (*decrypt)(NETAESContext* ctx, u8* dst, const u8* src) = ctx->mode->decrypt;
|
||||
|
||||
if (decrypt == NULL) {
|
||||
OSReport("this mode cannot support decryption!");
|
||||
} else if (len & 0xF) {
|
||||
OSReport("length has not suited to AES block alignment!");
|
||||
} else {
|
||||
while (len != 0) {
|
||||
decrypt(ctx, dst, src);
|
||||
src += 0x10;
|
||||
dst += 0x10;
|
||||
len -= 0x10;
|
||||
}
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void NETiAESEncryptoBlock(NETAESContext* ctx, u8* dst, const u8* src) {
|
||||
u32 block[4];
|
||||
|
||||
block[0] = ((const u32*)src)[0] ^ ctx->iv[0];
|
||||
block[1] = ((const u32*)src)[1] ^ ctx->iv[1];
|
||||
block[2] = ((const u32*)src)[2] ^ ctx->iv[2];
|
||||
block[3] = ((const u32*)src)[3] ^ ctx->iv[3];
|
||||
AESiEncryptBlock(ctx, (u32*)dst, block);
|
||||
ctx->iv[0] = ((const u32*)dst)[0];
|
||||
ctx->iv[1] = ((const u32*)dst)[1];
|
||||
ctx->iv[2] = ((const u32*)dst)[2];
|
||||
ctx->iv[3] = ((const u32*)dst)[3];
|
||||
}
|
||||
|
||||
static void NETiAESDecryptoBlock(NETAESContext* ctx, u8* dst, const u8* src) {
|
||||
u32 iv[4];
|
||||
|
||||
iv[0] = ctx->iv[0];
|
||||
iv[1] = ctx->iv[1];
|
||||
iv[2] = ctx->iv[2];
|
||||
iv[3] = ctx->iv[3];
|
||||
ctx->iv[0] = ((const u32*)src)[0];
|
||||
ctx->iv[1] = ((const u32*)src)[1];
|
||||
ctx->iv[2] = ((const u32*)src)[2];
|
||||
ctx->iv[3] = ((const u32*)src)[3];
|
||||
AESiDecryptBlock(ctx, (u32*)dst, (const u32*)src);
|
||||
((u32*)dst)[0] ^= iv[0];
|
||||
((u32*)dst)[1] ^= iv[1];
|
||||
((u32*)dst)[2] ^= iv[2];
|
||||
((u32*)dst)[3] ^= iv[3];
|
||||
}
|
||||
|
||||
const NETAESBlockMode NET_AES_BLOCK_MODE_CBC = {NETiAESEncryptoBlock, NETiAESDecryptoBlock};
|
||||
92
libs/RevoEX/src/net/hmac.c
Normal file
92
libs/RevoEX/src/net/hmac.c
Normal file
@@ -0,0 +1,92 @@
|
||||
#include <revolution.h>
|
||||
#include <revolution/net.h>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
// TODO: Not yet in the SDK
|
||||
typedef struct {
|
||||
u32 digestSize; // 0x00
|
||||
u32 blockSize; // 0x04
|
||||
u32 contextSize; // 0x08
|
||||
void* unk_0x0C; // 0x0C
|
||||
void (*init)(void* context); // 0x10
|
||||
void (*update)(void* context, const void* input, u32 length); // 0x14
|
||||
void (*getDigest)(void* context, void* digest); // 0x18
|
||||
} NETHASHInterface;
|
||||
|
||||
// TODO: Not yet in the SDK
|
||||
typedef struct NETHMACContext {
|
||||
NETHASHInterface hash; // 0x00
|
||||
u32 keyLen; // 0x1C
|
||||
u8 hashCtx[0x60]; // 0x20
|
||||
u8 keyBuf[0x40]; // 0x80
|
||||
} NETHMACContext; // 0xC0
|
||||
|
||||
void NETHMACInit(NETHMACContext* ctx, const NETHASHInterface* template, const void* key,
|
||||
u32 keyLen) {
|
||||
u8 ipad[64];
|
||||
u8* hctx = ctx->hashCtx;
|
||||
u32 i;
|
||||
|
||||
ctx->hash.digestSize = template->digestSize;
|
||||
ctx->hash.blockSize = template->blockSize;
|
||||
ctx->hash.contextSize = template->contextSize;
|
||||
ctx->hash.unk_0x0C = template->unk_0x0C;
|
||||
ctx->hash.init = template->init;
|
||||
ctx->hash.update = template->update;
|
||||
ctx->hash.getDigest = template->getDigest;
|
||||
|
||||
if (ctx->hash.contextSize > 0x60 || ctx->hash.blockSize > 0x40) {
|
||||
OSReport("%s(%d):[warning in %s]", "hmac.c", 100, __FUNCTION__);
|
||||
OSReport("specified interface needs too large workmemory.");
|
||||
OSReport("\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (keyLen <= ctx->hash.blockSize) {
|
||||
memcpy(ctx->keyBuf, key, keyLen);
|
||||
ctx->keyLen = keyLen;
|
||||
} else {
|
||||
ctx->hash.init(hctx);
|
||||
ctx->hash.update(hctx, key, keyLen);
|
||||
ctx->hash.getDigest(hctx, ctx->keyBuf);
|
||||
ctx->keyLen = ctx->hash.digestSize;
|
||||
}
|
||||
|
||||
keyLen = ctx->keyLen;
|
||||
for (i = 0; i < keyLen; i++) {
|
||||
ipad[i] = ctx->keyBuf[i] ^ 0x36;
|
||||
}
|
||||
memset(ipad + keyLen, 0x36, ctx->hash.blockSize - keyLen);
|
||||
|
||||
ctx->hash.init(ctx->hashCtx);
|
||||
ctx->hash.update(ctx->hashCtx, ipad, ctx->hash.blockSize);
|
||||
}
|
||||
|
||||
void NETHMACUpdate(NETHMACContext* ctx, const void* data, u32 len) {
|
||||
ctx->hash.update(ctx->hashCtx, data, len);
|
||||
}
|
||||
|
||||
void NETHMACGetDigest(NETHMACContext* ctx, void* digest) {
|
||||
u8* hctx = ctx->hashCtx;
|
||||
u8 inner[64];
|
||||
u8 opad[64];
|
||||
u32 i;
|
||||
|
||||
ctx->hash.getDigest(hctx, inner);
|
||||
|
||||
{
|
||||
u32 keyLen = ctx->keyLen;
|
||||
for (i = 0; i < keyLen; i++) {
|
||||
opad[i] = ctx->keyBuf[i] ^ 0x5c;
|
||||
}
|
||||
memset(opad + keyLen, 0x5c, ctx->hash.blockSize - keyLen);
|
||||
}
|
||||
|
||||
hctx = ctx->hashCtx;
|
||||
|
||||
ctx->hash.init(hctx);
|
||||
ctx->hash.update(hctx, opad, ctx->hash.blockSize);
|
||||
ctx->hash.update(hctx, inner, ctx->hash.digestSize);
|
||||
ctx->hash.getDigest(hctx, digest);
|
||||
}
|
||||
165
libs/RevoEX/src/net/md5.c
Normal file
165
libs/RevoEX/src/net/md5.c
Normal file
@@ -0,0 +1,165 @@
|
||||
#include <revolution/net.h>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
static void ProcessBlock(NETMD5Context* context);
|
||||
|
||||
static u32 t[64] = {
|
||||
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
|
||||
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
|
||||
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
|
||||
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
|
||||
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
|
||||
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
|
||||
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
|
||||
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
|
||||
};
|
||||
|
||||
static u32 k[48] = {
|
||||
1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12,
|
||||
5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2,
|
||||
0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9,
|
||||
};
|
||||
|
||||
static u8 padding = 0x80;
|
||||
|
||||
#define MD5_ROT(x, s) (((x) << (s)) | ((x) >> (32 - (s))))
|
||||
|
||||
void NETMD5Init(NETMD5Context* context) {
|
||||
context->a = 0x67452301;
|
||||
context->b = 0xefcdab89;
|
||||
context->c = 0x98badcfe;
|
||||
context->d = 0x10325476;
|
||||
context->length = 0;
|
||||
}
|
||||
|
||||
void NETMD5Update(NETMD5Context* context, const void* input, u32 length) {
|
||||
const u8* input8 = input;
|
||||
u32 used = context->length & 63;
|
||||
s32 gap;
|
||||
|
||||
context->length += length;
|
||||
gap = 64 - used;
|
||||
|
||||
if (gap > length) {
|
||||
if (length != 0) {
|
||||
memcpy(&context->buffer8[used], input8, length);
|
||||
}
|
||||
} else {
|
||||
memcpy(&context->buffer8[used], input8, gap);
|
||||
ProcessBlock(context);
|
||||
|
||||
input8 += gap;
|
||||
length -= gap;
|
||||
|
||||
gap = length >> 6;
|
||||
while (gap > 0) {
|
||||
memcpy(context->buffer8, input8, 64);
|
||||
input8 += 64;
|
||||
ProcessBlock(context);
|
||||
gap--;
|
||||
}
|
||||
|
||||
if ((length &= 63) != 0) {
|
||||
memcpy(context->buffer8, input8, length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void NETMD5GetDigest(NETMD5Context* context, void* digest) {
|
||||
u64 bits = context->length << 3;
|
||||
u32 used;
|
||||
u32 gap;
|
||||
|
||||
NETMD5Update(context, &padding, 1);
|
||||
|
||||
used = context->length & 63;
|
||||
gap = 64 - used;
|
||||
|
||||
if (gap < 8) {
|
||||
memset(&context->buffer8[used], 0, gap);
|
||||
ProcessBlock(context);
|
||||
used = 0;
|
||||
gap = 64;
|
||||
}
|
||||
|
||||
if (gap > 8) {
|
||||
memset(&context->buffer8[used], 0, gap - 8);
|
||||
}
|
||||
|
||||
context->buffer32[14] = ((u32)bits >> 24) | (((u32)bits >> 8) & 0xFF00) |
|
||||
(((u32)bits << 8) & 0xFF0000) | ((u32)bits << 24);
|
||||
context->buffer32[15] = ((u32)(bits >> 32) >> 24) | (((u32)(bits >> 32) >> 8) & 0xFF00) |
|
||||
(((u32)(bits >> 32) << 8) & 0xFF0000) | ((u32)(bits >> 32) << 24);
|
||||
ProcessBlock(context);
|
||||
|
||||
__stwbrx(context->a, digest, 0);
|
||||
__stwbrx(context->b, (u8*)digest + 4, 0);
|
||||
__stwbrx(context->c, (u8*)digest + 8, 0);
|
||||
__stwbrx(context->d, (u8*)digest + 0xC, 0);
|
||||
|
||||
memset(context, 0, sizeof(NETMD5Context));
|
||||
}
|
||||
|
||||
#define F(x, y, z) (((x) & (y)) | ((z) & ~(x)))
|
||||
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
|
||||
#define H(x, y, z) ((x) ^ (y) ^ (z))
|
||||
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
|
||||
|
||||
#define STEP(a, b, c, d, f, xi, ti, s) \
|
||||
do { \
|
||||
u8* xi_ = (u8*)(xi); \
|
||||
u32 xt_ = __lwbrx(xi_, 0) + (ti); \
|
||||
a = (((a) + f(b, c, d) + xt_) << (s) | \
|
||||
((a) + f(b, c, d) + __lwbrx(xi_, 0) + (ti)) >> (32 - (s))) + \
|
||||
(b); \
|
||||
} while (0)
|
||||
|
||||
static void ProcessBlock(NETMD5Context* context) {
|
||||
u32 a = context->a;
|
||||
u32 b = context->b;
|
||||
u32 c = context->c;
|
||||
u32 d = context->d;
|
||||
const u32* tp = t;
|
||||
const u32* kp = k;
|
||||
u8* xb = context->buffer8;
|
||||
u8* xp = xb;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 4; i++, tp += 4) {
|
||||
STEP(a, b, c, d, F, xp, tp[0], 7);
|
||||
xp += 4;
|
||||
STEP(d, a, b, c, F, xp, tp[1], 12);
|
||||
xp += 4;
|
||||
STEP(c, d, a, b, F, xp, tp[2], 17);
|
||||
xp += 4;
|
||||
STEP(b, c, d, a, F, xp, tp[3], 22);
|
||||
xp += 4;
|
||||
}
|
||||
|
||||
for (i = 0; i < 4; i++, tp += 4, kp += 4) {
|
||||
STEP(a, b, c, d, G, xb + kp[0] * 4, tp[0], 5);
|
||||
STEP(d, a, b, c, G, xb + kp[1] * 4, tp[1], 9);
|
||||
STEP(c, d, a, b, G, xb + kp[2] * 4, tp[2], 14);
|
||||
STEP(b, c, d, a, G, xb + kp[3] * 4, tp[3], 20);
|
||||
}
|
||||
|
||||
for (i = 0; i < 4; i++, tp += 4, kp += 4) {
|
||||
STEP(a, b, c, d, H, xb + kp[0] * 4, tp[0], 4);
|
||||
STEP(d, a, b, c, H, xb + kp[1] * 4, tp[1], 11);
|
||||
STEP(c, d, a, b, H, xb + kp[2] * 4, tp[2], 16);
|
||||
STEP(b, c, d, a, H, xb + kp[3] * 4, tp[3], 23);
|
||||
}
|
||||
|
||||
for (i = 0; i < 4; i++, tp += 4, kp += 4) {
|
||||
STEP(a, b, c, d, I, xb + kp[0] * 4, tp[0], 6);
|
||||
STEP(d, a, b, c, I, xb + kp[1] * 4, tp[1], 10);
|
||||
STEP(c, d, a, b, I, xb + kp[2] * 4, tp[2], 15);
|
||||
STEP(b, c, d, a, I, xb + kp[3] * 4, tp[3], 21);
|
||||
}
|
||||
|
||||
context->a += a;
|
||||
context->b += b;
|
||||
context->c += c;
|
||||
context->d += d;
|
||||
}
|
||||
118
libs/RevoEX/src/net/neterrorcode.c
Normal file
118
libs/RevoEX/src/net/neterrorcode.c
Normal file
@@ -0,0 +1,118 @@
|
||||
#include <revolution.h>
|
||||
#include <revolution/net.h>
|
||||
|
||||
extern s32 NCDiGetEnabledConfigList(u32* list0, u32* list1, u32* list2);
|
||||
|
||||
s32 GetStartupErrorCode(s32 err, s32 type);
|
||||
|
||||
s32 NETiGetConnectionTypeFromConfigList(u32 config0, u32 config1, u32 config2) {
|
||||
u32 mask;
|
||||
s32 i;
|
||||
s32 ret = 0x63;
|
||||
|
||||
if (config0 != 0) {
|
||||
if (config1 == 0 && config2 == 0) {
|
||||
for (mask = 1, i = 0; i < 32; i++, mask <<= 1) {
|
||||
switch (config0 & mask) {
|
||||
case 0:
|
||||
break;
|
||||
default:
|
||||
goto find0;
|
||||
}
|
||||
}
|
||||
i = -1;
|
||||
find0:
|
||||
ret = i + 0x14;
|
||||
goto end;
|
||||
}
|
||||
} else if (config1 != 0) {
|
||||
if (config2 == 0) {
|
||||
for (mask = 1, i = 0; i < 32; i++, mask <<= 1) {
|
||||
switch (config1 & mask) {
|
||||
case 0:
|
||||
break;
|
||||
default:
|
||||
goto find1;
|
||||
}
|
||||
}
|
||||
i = -1;
|
||||
find1:
|
||||
ret = i + 0x1e;
|
||||
goto end;
|
||||
}
|
||||
} else if (config2 != 0) {
|
||||
for (mask = 1, i = 0; i < 32; i++, mask <<= 1) {
|
||||
switch (config2 & mask) {
|
||||
case 0:
|
||||
break;
|
||||
default:
|
||||
goto find2;
|
||||
}
|
||||
}
|
||||
i = -1;
|
||||
find2:
|
||||
ret = i + 0x28;
|
||||
}
|
||||
|
||||
end:
|
||||
return ret;
|
||||
}
|
||||
|
||||
int NETGetStartupErrorCode(int err) {
|
||||
u32 config[3];
|
||||
s32 type = 0x63;
|
||||
|
||||
if (NCDiGetEnabledConfigList(&config[0], &config[1], &config[2]) >= 0) {
|
||||
type = NETiGetConnectionTypeFromConfigList(config[0], config[1], config[2]);
|
||||
}
|
||||
|
||||
if (type < 0) {
|
||||
err = (s32)0x80000000;
|
||||
type = 0x63;
|
||||
}
|
||||
|
||||
return GetStartupErrorCode(err, type) - type;
|
||||
}
|
||||
|
||||
int NETGetStartupErrorCodeEx(int err, int type) {
|
||||
return GetStartupErrorCode(err, type) - type;
|
||||
}
|
||||
|
||||
s32 GetStartupErrorCode(s32 err, s32 type) {
|
||||
if (err >= 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (err) {
|
||||
case -0x2D:
|
||||
return 0xFFFF3BE8;
|
||||
case -0x1C:
|
||||
return 0xFFFF3B84;
|
||||
case -0x3E:
|
||||
return 0xFFFF3B20;
|
||||
case -0x6F:
|
||||
return 0xFFFF3224;
|
||||
case -0x79:
|
||||
if (type >= 0x14 && type < 0x1E) {
|
||||
return 0xFFFF3738;
|
||||
}
|
||||
return 0xFFFF38C8;
|
||||
case -0x70:
|
||||
case -0x4C:
|
||||
case -0x30:
|
||||
case -0x27:
|
||||
if (type >= 0x14 && type < 0x1E) {
|
||||
return 0xFFFF3738;
|
||||
}
|
||||
return 0xFFFF379C;
|
||||
case -0x66:
|
||||
case -0x65:
|
||||
case -0x64:
|
||||
return 0xFFFF34E0;
|
||||
case (s32)0x80000000:
|
||||
return 0xFFFF3C4C;
|
||||
default:
|
||||
OSReport("Unknown SOStartup Error: %d\n", err);
|
||||
return 0xFFFF3C4C;
|
||||
}
|
||||
}
|
||||
224
libs/RevoEX/src/net/sha1.c
Normal file
224
libs/RevoEX/src/net/sha1.c
Normal file
@@ -0,0 +1,224 @@
|
||||
#include <revolution/net.h>
|
||||
|
||||
#include <string.h>
|
||||
|
||||
typedef struct NETSHA1Interface {
|
||||
u32 digestSize;
|
||||
u32 blockSize;
|
||||
u32 contextSize;
|
||||
void* unk_0x0C;
|
||||
void (*init)(NETSHA1Context* context);
|
||||
void (*update)(NETSHA1Context* context, const void* input, u32 length);
|
||||
void (*getDigest)(NETSHA1Context* context, void* digest);
|
||||
void* unk_0x1C;
|
||||
} NETSHA1Interface;
|
||||
|
||||
typedef struct {
|
||||
u32 state[5];
|
||||
union {
|
||||
u32 buffer32[16];
|
||||
u8 buffer8[64];
|
||||
};
|
||||
u32 used;
|
||||
u32 blocksLo;
|
||||
u32 blocksHi;
|
||||
} NETSHA1iContext;
|
||||
|
||||
static const u8 padlead = 0x80;
|
||||
static const u8 padalign[8];
|
||||
|
||||
#define SHA1_ROT(x, s) (((x) << (s)) | ((x) >> (32 - (s))))
|
||||
|
||||
static void NETSHA1iProcessBlock(NETSHA1Context* context) {
|
||||
NETSHA1iContext* ctx = (NETSHA1iContext*)context;
|
||||
u32 w[16];
|
||||
u32 a;
|
||||
u32 b;
|
||||
u32 c;
|
||||
u32 d;
|
||||
u32 e;
|
||||
u32 f;
|
||||
int i;
|
||||
|
||||
a = ctx->state[0];
|
||||
b = ctx->state[1];
|
||||
c = ctx->state[2];
|
||||
d = ctx->state[3];
|
||||
e = ctx->state[4];
|
||||
|
||||
for (i = 0; i < 16; i++) {
|
||||
w[i] = ctx->buffer32[i];
|
||||
}
|
||||
|
||||
i = 0;
|
||||
|
||||
for (; i < 20; i++) {
|
||||
u32* wp = w;
|
||||
f = (b & c) | (d & ~b);
|
||||
f += 0x5A827999;
|
||||
if (i >= 16) {
|
||||
wp[i & 15] = SHA1_ROT(
|
||||
(wp[(i - 3) & 15] ^ wp[(i - 8) & 15]) ^
|
||||
(wp[(i - 16) & 15] ^ wp[(i - 14) & 15]),
|
||||
1);
|
||||
}
|
||||
f += e;
|
||||
f += SHA1_ROT(a, 5);
|
||||
f += wp[i & 15];
|
||||
e = d;
|
||||
d = c;
|
||||
c = SHA1_ROT(b, 30);
|
||||
b = a;
|
||||
a = f;
|
||||
}
|
||||
|
||||
for (; i < 40; i++) {
|
||||
f = b ^ c ^ d;
|
||||
f += 0x6ED9EBA1;
|
||||
if (i >= 16) {
|
||||
w[i & 15] = SHA1_ROT(
|
||||
(w[(i - 3) & 15] ^ w[(i - 8) & 15]) ^
|
||||
(w[(i - 16) & 15] ^ w[(i - 14) & 15]),
|
||||
1);
|
||||
}
|
||||
f += e + SHA1_ROT(a, 5) + w[i & 15];
|
||||
e = d;
|
||||
d = c;
|
||||
c = SHA1_ROT(b, 30);
|
||||
b = a;
|
||||
a = f;
|
||||
}
|
||||
|
||||
for (; i < 60; i++) {
|
||||
f = (b & (c | d)) | (c & d);
|
||||
f += 0x8F1BBCDC;
|
||||
if (i >= 16) {
|
||||
w[i & 15] = SHA1_ROT(
|
||||
(w[(i - 3) & 15] ^ w[(i - 8) & 15]) ^
|
||||
(w[(i - 16) & 15] ^ w[(i - 14) & 15]),
|
||||
1);
|
||||
}
|
||||
f += e + SHA1_ROT(a, 5) + w[i & 15];
|
||||
e = d;
|
||||
d = c;
|
||||
c = SHA1_ROT(b, 30);
|
||||
b = a;
|
||||
a = f;
|
||||
}
|
||||
|
||||
for (; i < 80; i++) {
|
||||
f = b ^ c ^ d;
|
||||
f += 0xCA62C1D6;
|
||||
if (i >= 16) {
|
||||
w[i & 15] = SHA1_ROT(
|
||||
(w[(i - 3) & 15] ^ w[(i - 8) & 15]) ^
|
||||
(w[(i - 16) & 15] ^ w[(i - 14) & 15]),
|
||||
1);
|
||||
}
|
||||
f += e + SHA1_ROT(a, 5) + w[i & 15];
|
||||
e = d;
|
||||
d = c;
|
||||
c = SHA1_ROT(b, 30);
|
||||
b = a;
|
||||
a = f;
|
||||
}
|
||||
|
||||
ctx->state[0] += a;
|
||||
ctx->state[1] += b;
|
||||
ctx->state[2] += c;
|
||||
ctx->state[3] += d;
|
||||
ctx->state[4] += e;
|
||||
}
|
||||
|
||||
void NETSHA1Init(NETSHA1Context* context) {
|
||||
NETSHA1iContext* ctx = (NETSHA1iContext*)context;
|
||||
|
||||
ctx->blocksLo = 0;
|
||||
ctx->blocksHi = 0;
|
||||
ctx->used = 0;
|
||||
ctx->state[0] = 0x67452301;
|
||||
ctx->state[1] = 0xefcdab89;
|
||||
ctx->state[2] = 0x98badcfe;
|
||||
ctx->state[3] = 0x10325476;
|
||||
ctx->state[4] = 0xc3d2e1f0;
|
||||
}
|
||||
|
||||
void NETSHA1Update(NETSHA1Context* context, const void* input, u32 length) {
|
||||
NETSHA1iContext* ctx = (NETSHA1iContext*)context;
|
||||
|
||||
while (length != 0) {
|
||||
u32 fill = 64 - ctx->used;
|
||||
|
||||
if (fill > length) {
|
||||
fill = length;
|
||||
}
|
||||
|
||||
memcpy(&ctx->buffer8[ctx->used], input, fill);
|
||||
input = (const u8*)input + fill;
|
||||
length -= fill;
|
||||
ctx->used += fill;
|
||||
|
||||
if (ctx->used >= 64) {
|
||||
NETSHA1iProcessBlock(context);
|
||||
ctx->used = 0;
|
||||
if (++ctx->blocksLo == 0) {
|
||||
ctx->blocksHi++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void NETSHA1GetDigest(NETSHA1Context* context, void* digest) {
|
||||
NETSHA1iContext* ctx = (NETSHA1iContext*)context;
|
||||
union {
|
||||
u64 v;
|
||||
u32 w[2];
|
||||
} bits;
|
||||
u32 remaining;
|
||||
|
||||
bits.w[1] = (ctx->blocksLo << 9) + (ctx->used << 3);
|
||||
bits.w[0] = (ctx->blocksHi << 9) + (ctx->blocksLo >> 23);
|
||||
NETSHA1Update(context, &padlead, 1);
|
||||
|
||||
if (64 - ctx->used < 8) {
|
||||
NETSHA1Update(context, padalign, 64 - ctx->used);
|
||||
}
|
||||
|
||||
for (remaining = 56 - ctx->used; remaining != 0;) {
|
||||
u32 fill = 64 - ctx->used;
|
||||
|
||||
if (fill > remaining) {
|
||||
fill = remaining;
|
||||
}
|
||||
|
||||
memset(&ctx->buffer8[ctx->used], 0, fill);
|
||||
remaining -= fill;
|
||||
ctx->used += fill;
|
||||
|
||||
if (ctx->used >= 64) {
|
||||
NETSHA1iProcessBlock(context);
|
||||
ctx->used = 0;
|
||||
if (++ctx->blocksLo == 0) {
|
||||
ctx->blocksHi++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
NETSHA1Update(context, &bits, sizeof(bits));
|
||||
memcpy(digest, ctx->state, 0x14);
|
||||
}
|
||||
|
||||
static const NETSHA1Interface sha1template = {
|
||||
0x14,
|
||||
0x40,
|
||||
0x60,
|
||||
NULL,
|
||||
NETSHA1Init,
|
||||
NETSHA1Update,
|
||||
NETSHA1GetDigest,
|
||||
NULL,
|
||||
};
|
||||
|
||||
const NETSHA1Interface* NETGetSHA1Interface(void) {
|
||||
return &sha1template;
|
||||
}
|
||||
Reference in New Issue
Block a user