414 lines
13 KiB
MQL5
414 lines
13 KiB
MQL5
//+------------------------------------------------------------------+
|
||
//| SHA3.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_SHA3_MQH
|
||
#define CRYPTOBYLEO_SRC_HASH_SHA3_MQH
|
||
|
||
//+------------------------------------------------------------------+
|
||
//| |
|
||
//+------------------------------------------------------------------+
|
||
#include "Base.mqh"
|
||
|
||
//+------------------------------------------------------------------+
|
||
//| |
|
||
//+------------------------------------------------------------------+
|
||
#define SHA3_DELIM_SHA3 (0x06)
|
||
#define SHA3_DELIM_SHAKE (0x1F)
|
||
|
||
//+------------------------------------------------------------------+
|
||
//| |
|
||
//+------------------------------------------------------------------+
|
||
namespace TSN
|
||
{
|
||
//--- keccak-f[1600] funcion base
|
||
// s =arrya de entarad (25) size ya con
|
||
static void CCryptoHash::SHA3_KECCAK_F(ulong &s[])
|
||
{
|
||
//--- Constatnes
|
||
static const int rho[25] = {0, 1, 62, 28, 27, 36, 44, 6, 55, 20, 3, 10, 43, 25, 39, 41, 45, 15, 21, 8, 18, 2, 61, 56, 14};
|
||
static const int pi[25] = {0, 10, 20, 5, 15, 16, 1, 11, 21, 6, 7, 17, 2, 12, 22, 23, 8, 18, 3, 13, 14, 24, 9, 19, 4};
|
||
static const ulong rc[24] =
|
||
{
|
||
0x0000000000000001, 0x0000000000008082, 0x800000000000808a, 0x8000000080008000,
|
||
0x000000000000808b, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009,
|
||
0x000000000000008a, 0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
|
||
0x000000008000808b, 0x800000000000008b, 0x8000000000008089, 0x8000000000008003,
|
||
0x8000000000008002, 0x8000000000000080, 0x000000000000800a, 0x800000008000000a,
|
||
0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008
|
||
};
|
||
// Nuestro "valor" en el cual operamos..
|
||
/*
|
||
mapa=
|
||
5 filas 5 columnas y cada valor es un lane de 64 bits
|
||
*/
|
||
|
||
//--- Temp
|
||
ulong c[5], d[5];
|
||
ulong b[25];
|
||
|
||
//--- Rondas.
|
||
for(int r = 0; r < 24; r++)
|
||
{
|
||
//--- theta
|
||
/* wiki
|
||
Calcula la paridad de cada una de las 5 w (320, cuando w = 64 )
|
||
columnas de 5 bits y realiza la operación OR exclusiva con dos columnas cercanas siguiendo un patrón regular.
|
||
Para ser precisos, a [ i ][ j ][ k ] ← a [ i ][ j ][ k ] ⊕ paridad(a[0...4][ j -1][ k ]) ⊕ paridad(a[0...4][ j +1][ k −1] )
|
||
*/
|
||
// Por cada columna
|
||
/*for(int x = 0; x < 5; x++)
|
||
c[x] = s[x] ^ s[x + 5] ^ s[x + 10] ^ s[x + 15] ^ s[x + 20];
|
||
*/ // Denserollado:
|
||
c[0] = s[0] ^ s[5] ^ s[10] ^ s[15] ^ s[20];
|
||
c[1] = s[1] ^ s[6] ^ s[11] ^ s[16] ^ s[21];
|
||
c[2] = s[2] ^ s[7] ^ s[12] ^ s[17] ^ s[22];
|
||
c[3] = s[3] ^ s[8] ^ s[13] ^ s[18] ^ s[23];
|
||
c[4] = s[4] ^ s[9] ^ s[14] ^ s[19] ^ s[24];
|
||
|
||
// Final
|
||
//for(int x = 0; x < 5; x++)
|
||
/*{
|
||
const ulong cr = c[(x + 1) % 5];
|
||
d[x] = c[(x + 4) % 5] ^ ((cr << 1) | (cr >> 63));
|
||
}*/
|
||
// Denserollado
|
||
{
|
||
const ulong cr = c[1];
|
||
d[0] = c[4] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
{
|
||
const ulong cr = c[2];
|
||
d[1] = c[0] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
{
|
||
const ulong cr = c[3];
|
||
d[2] = c[1] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
{
|
||
const ulong cr = c[4];
|
||
d[3] = c[2] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
{
|
||
const ulong cr = c[0];
|
||
d[4] = c[3] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
|
||
// unrrolled
|
||
s[0] ^= d[0];
|
||
s[1] ^= d[1];
|
||
s[2] ^= d[2];
|
||
s[3] ^= d[3];
|
||
s[4] ^= d[4];
|
||
s[5] ^= d[0];
|
||
s[6] ^= d[1];
|
||
s[7] ^= d[2];
|
||
s[8] ^= d[3];
|
||
s[9] ^= d[4];
|
||
s[10] ^= d[0];
|
||
s[11] ^= d[1];
|
||
s[12] ^= d[2];
|
||
s[13] ^= d[3];
|
||
s[14] ^= d[4];
|
||
s[15] ^= d[0];
|
||
s[16] ^= d[1];
|
||
s[17] ^= d[2];
|
||
s[18] ^= d[3];
|
||
s[19] ^= d[4];
|
||
s[20] ^= d[0];
|
||
s[21] ^= d[1];
|
||
s[22] ^= d[2];
|
||
s[23] ^= d[3];
|
||
s[24] ^= d[4];
|
||
|
||
//--- RHO+PI
|
||
for(int i = 0; i < 25; i++)
|
||
{
|
||
/*
|
||
Gire bit a bit cada una de las 25 palabras por un número triangular diferente 0, 1, 3, 6, 10, 15, .... (rho[])
|
||
Para ser precisos, a [0][0] no se rota, y para todo 0 ≤ t < 24 ,
|
||
a [ i ][ j ][ k ] ← a [ i ][ j ][ k −( t +1)( t +2)/2] , donde
|
||
*/
|
||
const int n = rho[i];
|
||
b[pi[i]] = (n == 0) ? s[i] : ((s[i] << n) | (s[i] >> (64 - n)));
|
||
}
|
||
|
||
//--- CHI fila a fila
|
||
for(int y = 0; y < 5; y++)
|
||
{
|
||
/*
|
||
Combinación bit a bit a lo largo de las filas, usando x ← x ⊕ (¬ y & z ) . Para ser precisos, a
|
||
[ i ][ j ][ k ] ← a [ i ][ j ][ k ] ⊕ (¬ a [ i ][ j + 1 ][ k ] &a a
|
||
[ i ][ j + 2 ][ k ]) . Esta es la única operación no lineal en SHA-3.
|
||
*/
|
||
//---
|
||
ulong row0 = b[5 * y], row1 = b[1 + 5 * y], row2 = b[2 + 5 * y], row3 = b[3 + 5 * y], row4 = b[4 + 5 * y];
|
||
|
||
//---
|
||
s[5 * y] = row0 ^ ((~row1) & row2);
|
||
s[1 + 5 * y] = row1 ^ ((~row2) & row3);
|
||
s[2 + 5 * y] = row2 ^ ((~row3) & row4);
|
||
s[3 + 5 * y] = row3 ^ ((~row4) & row0);
|
||
s[4 + 5 * y] = row4 ^ ((~row0) & row1);
|
||
}
|
||
|
||
//--- iota
|
||
s[0] ^= rc[r];
|
||
}
|
||
}
|
||
|
||
//---
|
||
// chunk_t = tamaño del bloquje en bytes que se procesar en cada it
|
||
// ins= tmaño del inpunt (in)
|
||
// in= input
|
||
// out=salida
|
||
// outl= tamaño de salida
|
||
static void CCryptoHash::SHA3_HASH(const uchar &in[], int ins, uchar &out[],
|
||
int outl, int chunk_t, uchar delim)
|
||
{
|
||
//--- state inciial
|
||
ulong s[25] = {0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL,
|
||
0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL, 0ULL
|
||
};
|
||
|
||
//--- paso 1 absorcion
|
||
int pos = 0;
|
||
while(ins - pos >= chunk_t)
|
||
{
|
||
for(int i = 0; i < chunk_t; i += 8)
|
||
{
|
||
const int k = pos + i;
|
||
s[i >> 3] ^= ((uint64_t)in[k]) | ((uint64_t)in[k + 1] << 8) |
|
||
((uint64_t)in[k + 2] << 16) | ((uint64_t)in[k + 3] << 24) |
|
||
((uint64_t)in[k + 4] << 32) | ((uint64_t)in[k + 5] << 40) |
|
||
((uint64_t)in[k + 6] << 48) | ((uint64_t)in[k + 7] << 56);;
|
||
}
|
||
|
||
//---
|
||
// HOT PATH inline aqui mismo
|
||
//------- statart of mixing
|
||
|
||
|
||
|
||
//--- Constatnes
|
||
static const int rho[25] = {0, 1, 62, 28, 27, 36, 44, 6, 55, 20, 3, 10, 43, 25, 39, 41, 45, 15, 21, 8, 18, 2, 61, 56, 14};
|
||
static const int pi[25] = {0, 10, 20, 5, 15, 16, 1, 11, 21, 6, 7, 17, 2, 12, 22, 23, 8, 18, 3, 13, 14, 24, 9, 19, 4};
|
||
static const ulong rc[24] =
|
||
{
|
||
0x0000000000000001, 0x0000000000008082, 0x800000000000808a, 0x8000000080008000,
|
||
0x000000000000808b, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009,
|
||
0x000000000000008a, 0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
|
||
0x000000008000808b, 0x800000000000008b, 0x8000000000008089, 0x8000000000008003,
|
||
0x8000000000008002, 0x8000000000000080, 0x000000000000800a, 0x800000008000000a,
|
||
0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008
|
||
};
|
||
// Nuestro "valor" en el cual operamos..
|
||
/*
|
||
mapa=
|
||
5 filas 5 columnas y cada valor es un lane de 64 bits
|
||
*/
|
||
|
||
//--- Temp
|
||
ulong c[5], d[5];
|
||
ulong b[25];
|
||
|
||
//--- Rondas.
|
||
for(int r = 0; r < 24; r++)
|
||
{
|
||
//--- theta
|
||
/* wiki
|
||
Calcula la paridad de cada una de las 5 w (320, cuando w = 64 )
|
||
columnas de 5 bits y realiza la operación OR exclusiva con dos columnas cercanas siguiendo un patrón regular.
|
||
Para ser precisos, a [ i ][ j ][ k ] ← a [ i ][ j ][ k ] ⊕ paridad(a[0...4][ j -1][ k ]) ⊕ paridad(a[0...4][ j +1][ k −1] )
|
||
*/
|
||
// Por cada columna
|
||
/*for(int x = 0; x < 5; x++)
|
||
c[x] = s[x] ^ s[x + 5] ^ s[x + 10] ^ s[x + 15] ^ s[x + 20];
|
||
*/ // Denserollado:
|
||
c[0] = s[0] ^ s[5] ^ s[10] ^ s[15] ^ s[20];
|
||
c[1] = s[1] ^ s[6] ^ s[11] ^ s[16] ^ s[21];
|
||
c[2] = s[2] ^ s[7] ^ s[12] ^ s[17] ^ s[22];
|
||
c[3] = s[3] ^ s[8] ^ s[13] ^ s[18] ^ s[23];
|
||
c[4] = s[4] ^ s[9] ^ s[14] ^ s[19] ^ s[24];
|
||
|
||
// Final
|
||
//for(int x = 0; x < 5; x++)
|
||
/*{
|
||
const ulong cr = c[(x + 1) % 5];
|
||
d[x] = c[(x + 4) % 5] ^ ((cr << 1) | (cr >> 63));
|
||
}*/
|
||
// Denserollado
|
||
{
|
||
const ulong cr = c[1];
|
||
d[0] = c[4] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
{
|
||
const ulong cr = c[2];
|
||
d[1] = c[0] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
{
|
||
const ulong cr = c[3];
|
||
d[2] = c[1] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
{
|
||
const ulong cr = c[4];
|
||
d[3] = c[2] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
{
|
||
const ulong cr = c[0];
|
||
d[4] = c[3] ^ ((cr << 1) | (cr >> 63));
|
||
}
|
||
|
||
// unrrolled
|
||
s[0] ^= d[0];
|
||
s[1] ^= d[1];
|
||
s[2] ^= d[2];
|
||
s[3] ^= d[3];
|
||
s[4] ^= d[4];
|
||
s[5] ^= d[0];
|
||
s[6] ^= d[1];
|
||
s[7] ^= d[2];
|
||
s[8] ^= d[3];
|
||
s[9] ^= d[4];
|
||
s[10] ^= d[0];
|
||
s[11] ^= d[1];
|
||
s[12] ^= d[2];
|
||
s[13] ^= d[3];
|
||
s[14] ^= d[4];
|
||
s[15] ^= d[0];
|
||
s[16] ^= d[1];
|
||
s[17] ^= d[2];
|
||
s[18] ^= d[3];
|
||
s[19] ^= d[4];
|
||
s[20] ^= d[0];
|
||
s[21] ^= d[1];
|
||
s[22] ^= d[2];
|
||
s[23] ^= d[3];
|
||
s[24] ^= d[4];
|
||
|
||
//--- RHO+PI
|
||
for(int i = 0; i < 25; i++)
|
||
{
|
||
/*
|
||
Gire bit a bit cada una de las 25 palabras por un número triangular diferente 0, 1, 3, 6, 10, 15, .... (rho[])
|
||
Para ser precisos, a [0][0] no se rota, y para todo 0 ≤ t < 24 ,
|
||
a [ i ][ j ][ k ] ← a [ i ][ j ][ k −( t +1)( t +2)/2] , donde
|
||
*/
|
||
const int n = rho[i];
|
||
b[pi[i]] = (n == 0) ? s[i] : ((s[i] << n) | (s[i] >> (64 - n)));
|
||
}
|
||
|
||
//--- CHI fila a fila
|
||
for(int y = 0; y < 5; y++)
|
||
{
|
||
/*
|
||
Combinación bit a bit a lo largo de las filas, usando x ← x ⊕ (¬ y & z ) . Para ser precisos, a
|
||
[ i ][ j ][ k ] ← a [ i ][ j ][ k ] ⊕ (¬ a [ i ][ j + 1 ][ k ] &a a
|
||
[ i ][ j + 2 ][ k ]) . Esta es la única operación no lineal en SHA-3.
|
||
*/
|
||
//---
|
||
ulong row0 = b[5 * y], row1 = b[1 + 5 * y], row2 = b[2 + 5 * y], row3 = b[3 + 5 * y], row4 = b[4 + 5 * y];
|
||
|
||
//---
|
||
s[5 * y] = row0 ^ ((~row1) & row2);
|
||
s[1 + 5 * y] = row1 ^ ((~row2) & row3);
|
||
s[2 + 5 * y] = row2 ^ ((~row3) & row4);
|
||
s[3 + 5 * y] = row3 ^ ((~row4) & row0);
|
||
s[4 + 5 * y] = row4 ^ ((~row0) & row1);
|
||
}
|
||
|
||
//--- iota
|
||
s[0] ^= rc[r];
|
||
}
|
||
|
||
|
||
|
||
//-----
|
||
//------- end of mixing
|
||
pos += chunk_t;
|
||
}
|
||
// Lo demas ya no inline dado que no da una ganancia sinficativa por lo visto
|
||
// dado qeu se llama poco...
|
||
|
||
//--- ultimo bloque parcial + padding (0x06 o 0x1F ... 0x80)
|
||
uchar block[200];
|
||
ArrayInitialize(block, 0);
|
||
|
||
//---
|
||
const int rem = ins - pos;
|
||
|
||
//---
|
||
for(int i = 0; i < rem; i++)
|
||
block[i] = in[pos + i];
|
||
|
||
//---
|
||
block[rem] = delim;
|
||
block[chunk_t - 1] |= 0x80;
|
||
|
||
//--- Ahora lo que sobra..
|
||
for(int i = 0; i < chunk_t; i += 8)
|
||
{
|
||
const ulong w = ((ulong)block[i]) | ((ulong)block[i + 1] << 8) |
|
||
((ulong)block[i + 2] << 16) | ((ulong)block[i + 3] << 24) |
|
||
((ulong)block[i + 4] << 32) | ((ulong)block[i + 5] << 40) |
|
||
((ulong)block[i + 6] << 48) | ((ulong)block[i + 7] << 56);
|
||
s[i >> 3] ^= w;
|
||
}
|
||
SHA3_KECCAK_F(s);
|
||
|
||
// Pase final exprimimos todo loq eu tenemos..
|
||
//---
|
||
int ops = 0;
|
||
while(ops < outl)
|
||
{
|
||
//---
|
||
int t = outl - ops; // tomado
|
||
if(t > chunk_t)
|
||
t = chunk_t; // clamp a lo maximo a tomar..
|
||
|
||
//---
|
||
for(int i = 0; i < t; i++)
|
||
{
|
||
// en que lane
|
||
// const int w = ; // i / 8
|
||
const int sh = (i & 7) << 3; // i % 8 * 8 - cuanto demzpasmroes del lane de 64 desde cuando se mrpiza
|
||
out[ops + i] = (uchar)(s[i >> 3] >> sh); // escribimos
|
||
}
|
||
ops += t; // aumentaos lo que ya tenemos
|
||
|
||
//---
|
||
if(ops < outl) // volvemos.. se requier mas de lo normal asi qeu aplicanos denuevo para la nueva salida
|
||
SHA3_KECCAK_F(s);
|
||
}
|
||
}
|
||
|
||
//+------------------------------------------------------------------+
|
||
//| Esepcific implemtantion |
|
||
//+------------------------------------------------------------------+
|
||
static __forceinline void CCryptoHash::SHA3_256(const uchar &in[], int ins, uchar &out[])
|
||
{
|
||
SHA3_HASH(in, ins, out, 32, 136, SHA3_DELIM_SHA3);
|
||
}
|
||
static __forceinline void CCryptoHash::SHA3_512(const uchar &in[], int ins, uchar &out[])
|
||
{
|
||
SHA3_HASH(in, ins, out, 64, 72, SHA3_DELIM_SHA3);
|
||
}
|
||
static __forceinline void CCryptoHash::SHAKE128(const uchar &in[], int ins, uchar &out[], int outl)
|
||
{
|
||
SHA3_HASH(in, ins, out, outl, 168, SHA3_DELIM_SHAKE);
|
||
}
|
||
static __forceinline void CCryptoHash::SHAKE256(const uchar &in[], int ins, uchar &out[], int outl)
|
||
{
|
||
SHA3_HASH(in, ins, out, outl, 136, SHA3_DELIM_SHAKE);
|
||
}
|
||
|
||
//---
|
||
}
|
||
//---
|
||
#endif // CRYPTOBYLEO_SRC_HASH_SHA3_MQH
|
||
//+------------------------------------------------------------------+
|