//+------------------------------------------------------------------+ //| SHA256.mqh | //| Copyright 2026, Niquel Mendoza | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2026, Niquel Mendoza" #property link "https://www.mql5.com" #property strict #ifndef CRYPTOBYLEO_SRC_HASH_SHA256_MQH #define CRYPTOBYLEO_SRC_HASH_SHA256_MQH //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ #include "Base.mqh" //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ #define CRYPTOBYLEO_SHA256_SIZET_FHASH (32) #define CRYPTOBYLEO_SHA256_SIZET_U32HASH (8) // versiones simplificadoas de la original // en ch // 11 // base = (x AND y) XOR (NOT x AND z) // el not es baicmante x XOR 1 // dado qeu si x = 0 0 XOR 1 = 1 y 1 XOR 1 = 0 (ahi esta flip volteado... ) // asi qeu quedaria (x AND y) XOR ((x XOR 1) AND z) AND tiene mayor precendecia, asi que podemos distirbyuir // (x AND y) XOR ((x AND z) XOR (1 and Z))) (1 ANd x siempre da x comoresultado) // (x AND y) XOR ((x AND z) Xor z) // Desnetolalmos x AND y xor x AND z xor z , hay comunes facotiruzamos // (x AND ((Y XOR Z)) XOR Z queda asi x and tiene mas priodiad que xor // nuevo = z XOR (x AND (y XOR z)) reducico en 3 operaciones.. #define CRYPTOBYLEO_SHA256_CH(x,y,z) ((z)^((x)&((y)^(z)))) //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ /* const uint32_t g_cryptbyleo_sha256_hinicial[CRYPTOBYLEO_SHA256_SIZET_U32HASH] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 }; */ //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ const uint32_t g_cryptbyleo_sha256f_k[64] = { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 }; //+------------------------------------------------------------------+ #define TSN_CRYPTBYLEO_SHA256_ROT_DER(v, b) ((v>>b) | (v <<(32 - b))) //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ namespace TSN { //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ static void CCryptoHash::SHA256(const uchar &inp[], int ins, uchar& out[]) { //--- Pase inical tema de padding int longitud_with_m = ins + 1 + 8; const ulong bits_len_mes = (ulong)ins << 3ULL; // %64 = &63 int relleno_con_zeros = (64 - (longitud_with_m & 63)) & 63; // longitud_with_m aqui lo podemos reintrepsta rcomo 1 extra y 8 de longitd fional BE uchar in[]; ArrayResize(in, (longitud_with_m + relleno_con_zeros)); // ArrayInitialize(in,0); // Copiamos los datos for(int i = 0; i < ins; i++) { in[i] = inp[i]; } // Primero in[ins++] = 0x80; // Ahora los ceros const int final_s = ins + relleno_con_zeros; // final for(; ins < final_s; ins++) { in[ins] = 0; // zeros } // Ahora si los ultimos const int longitud_final = final_s + 8; // ins = longitud_final - 1; // + 7 por que (+ 8 -1 8 para el final y -1 empza en el utlimo el) for(int k = 0; ins >= final_s; ins--, k += 8) { // BE // La idea es ir esribiendo lo que podmas aqui traemos los 8 bajos. in[ins] = uint8_t(bits_len_mes >> k); // zeros } //--------- // Base uint32_t h[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 }; // uint32_t palabras[64]; // Algoritmo en si for(int ip = 0; ip < longitud_final;) { //--- /* // pasamos a palabras de 32 (primante 16) for(int i = 0; i < 16; i++) { } */ //---- Unrolled (Tomamos 64 bytes a 16 words) #define SHA256_LOAD32(i) \ palabras[i] = uint32_t(in[ip++]) << 24 |\ uint32_t(in[ip++]) << 16 | \ uint32_t(in[ip++]) << 8 | \ uint32_t(in[ip++]); \ //--- SHA256_LOAD32(0) SHA256_LOAD32(1) SHA256_LOAD32(2) SHA256_LOAD32(3) SHA256_LOAD32(4) SHA256_LOAD32(5) SHA256_LOAD32(6) SHA256_LOAD32(7) SHA256_LOAD32(8) SHA256_LOAD32(9) SHA256_LOAD32(10) SHA256_LOAD32(11) SHA256_LOAD32(12) SHA256_LOAD32(13) SHA256_LOAD32(14) SHA256_LOAD32(15) //--- // Ahora las expandimos 16 a 64 palarbras (para nuestro bloque final) for(int i = 16; i < 64; i += 4) { uint32_t v, s0, s1; //--- ronda 1 v = palabras[i - 15]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 7) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 18) ^ (v >> 3); v = palabras[i - 2]; s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 17) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 19) ^ (v >> 10); palabras[i] = palabras[i - 16] + s0 + palabras[i - 7] + s1; //--- ronda 2 v = palabras[i - 14]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 7) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 18) ^ (v >> 3); v = palabras[i - 1]; s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 17) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 19) ^ (v >> 10); palabras[i + 1] = palabras[i - 15] + s0 + palabras[i - 6] + s1; //--- ronda 3 v = palabras[i - 13]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 7) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 18) ^ (v >> 3); v = palabras[i]; s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 17) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 19) ^ (v >> 10); palabras[i + 2] = palabras[i - 14] + s0 + palabras[i - 5] + s1; //--- ronda 4 v = palabras[i - 12]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 7) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 18) ^ (v >> 3); v = palabras[i + 1]; s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 17) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(v, 19) ^ (v >> 10); palabras[i + 3] = palabras[i - 13] + s0 + palabras[i - 4] + s1; } //--- // Ahora comprimirmos... uint32_t a = h[0], b = h[1], c = h[2], d = h[3]; uint32_t e = h[4], f = h[5], g = h[6], hh = h[7]; //--- // unrolled 8 for(int i = 0; i < 64; i += 8) { uint32_t t1, t2, s1, s0, ch, maj; // ronda 0 s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 6) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 11) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 25); // // base = (x AND y) XOR (NOT x AND z) // CRYPTOBYLEO_SHA256_MAJ ch = CRYPTOBYLEO_SHA256_CH(e, f, g); t1 = hh + s1 + ch + g_cryptbyleo_sha256f_k[i] + palabras[i]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 2) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 13) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 22); maj = (a & b) ^ (a & c) ^ (b & c); t2 = s0 + maj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; // ronda 1 s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 6) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 11) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 25); ch = CRYPTOBYLEO_SHA256_CH(e, f, g); t1 = hh + s1 + ch + g_cryptbyleo_sha256f_k[i + 1] + palabras[i + 1]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 2) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 13) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 22); maj = (a & b) ^ (a & c) ^ (b & c); t2 = s0 + maj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; // ronda 2 s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 6) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 11) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 25); ch = CRYPTOBYLEO_SHA256_CH(e, f, g); t1 = hh + s1 + ch + g_cryptbyleo_sha256f_k[i + 2] + palabras[i + 2]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 2) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 13) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 22); maj = (a & b) ^ (a & c) ^ (b & c); t2 = s0 + maj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; // ronda 3 s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 6) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 11) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 25); ch = CRYPTOBYLEO_SHA256_CH(e, f, g); t1 = hh + s1 + ch + g_cryptbyleo_sha256f_k[i + 3] + palabras[i + 3]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 2) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 13) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 22); maj = (a & b) ^ (a & c) ^ (b & c); t2 = s0 + maj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; // ronda 4 s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 6) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 11) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 25); ch = CRYPTOBYLEO_SHA256_CH(e, f, g); t1 = hh + s1 + ch + g_cryptbyleo_sha256f_k[i + 4] + palabras[i + 4]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 2) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 13) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 22); maj = (a & b) ^ (a & c) ^ (b & c); t2 = s0 + maj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; // ronda 5 s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 6) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 11) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 25); ch = CRYPTOBYLEO_SHA256_CH(e, f, g); t1 = hh + s1 + ch + g_cryptbyleo_sha256f_k[i + 5] + palabras[i + 5]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 2) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 13) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 22); maj = (a & b) ^ (a & c) ^ (b & c); t2 = s0 + maj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; // ronda 6 s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 6) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 11) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 25); ch = CRYPTOBYLEO_SHA256_CH(e, f, g); t1 = hh + s1 + ch + g_cryptbyleo_sha256f_k[i + 6] + palabras[i + 6]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 2) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 13) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 22); maj = (a & b) ^ (a & c) ^ (b & c); t2 = s0 + maj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; // ronda 7 s1 = TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 6) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 11) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(e, 25); ch = CRYPTOBYLEO_SHA256_CH(e, f, g); t1 = hh + s1 + ch + g_cryptbyleo_sha256f_k[i + 7] + palabras[i + 7]; s0 = TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 2) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 13) ^ TSN_CRYPTBYLEO_SHA256_ROT_DER(a, 22); maj = (a & b) ^ (a & c) ^ (b & c); t2 = s0 + maj; hh = g; g = f; f = e; e = d + t1; d = c; c = b; b = a; a = t1 + t2; } //--- h[0] += a; h[1] += b; h[2] += c; h[3] += d; h[4] += e; h[5] += f; h[6] += g; h[7] += hh; //--- Sigueinte bloque //ip += 64; } //--- //Expand8To32(h, out); //--- BE #define CRYPTOHASHBYLEO_HASH_ASSING32(INDEX) \ out[INDEX] = uint8_t(t >> 24); \ out[INDEX+1] = uint8_t(t >> 16); \ out[INDEX+2] = uint8_t(t >> 8); \ out[INDEX+3] = uint8_t(t); //--- uint32_t t = h[0]; CRYPTOHASHBYLEO_HASH_ASSING32(0) t = h[1]; CRYPTOHASHBYLEO_HASH_ASSING32(4) t = h[2]; CRYPTOHASHBYLEO_HASH_ASSING32(8) t = h[3]; CRYPTOHASHBYLEO_HASH_ASSING32(12) t = h[4]; CRYPTOHASHBYLEO_HASH_ASSING32(16) t = h[5]; CRYPTOHASHBYLEO_HASH_ASSING32(20) t = h[6]; CRYPTOHASHBYLEO_HASH_ASSING32(24) t = h[7]; CRYPTOHASHBYLEO_HASH_ASSING32(28) //--- #undef CRYPTOHASHBYLEO_HASH_ASSING32 } //--- Namepsace TSN } #endif // CRYPTOBYLEO_SRC_HASH_SHA256_MQH