Compare commits

...

4 Commits

Author SHA1 Message Date
Devin AI
208136ad47 net: aes flags expr + neterr switch idiom
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-09-30 02:55:45 +00:00
Devin AI
c44a615a53 net: switch-break idiom for bit-scan loop + decl order (neterr 124->6 diffs)
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-09-30 02:50:08 +00:00
Devin AI
a84dfba152 net/sha1: fold round accumulation into single expr (ProcessBlock 46 diffs)
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-09-30 02:41:13 +00:00
Devin AI
09b459d8f3 net: import prior md5/sha1/hmac/neterrorcode/aes work onto latest main
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-09-30 02:22:35 +00:00
5 changed files with 1086 additions and 0 deletions

487
libs/RevoEX/src/net/aes.c Normal file
View 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};

View 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
View 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;
}

View 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
View 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;
}