nique_372/CryptoByLeo
Watch
1
0
Fork
You've already forked CryptoByLeo
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
CryptoByLeo/Src/Hash/SHA256.mqh
Nique_372 b9280c9446 new files added
2026-08-13 14:01:20 -05:00

388 lines
13 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| 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
Reference in a new issue View git blame Copy permalink