765 lignes
22 Kio
MQL5
765 lignes
22 Kio
MQL5
//+------------------------------------------------------------------+
|
|
//| Main.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_SIMETRIC_AES_MAIN_MQH
|
|
#define CRYPTOBYLEO_SRC_SIMETRIC_AES_MAIN_MQH
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
#include "Defines.mqh"
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
namespace TSN
|
|
{
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
class CAes
|
|
{
|
|
public:
|
|
// se peude modifcar directamtne fuera..
|
|
uint8_t m_iv[AES_BLOCKLEN]; // vecotr de inicizlaicion
|
|
uint m_ks; // desde donde inica el buffer pasado para cifrar\descifrar
|
|
|
|
private:
|
|
//_--
|
|
ENUM_AES_TYPE_CRYPTH m_method;
|
|
ENUM_AES_LAST_ERR m_last_err;
|
|
|
|
//---
|
|
int m_ivs;
|
|
bool m_save_last_ivs_in_cbc;
|
|
|
|
//---
|
|
int m_round_key_s; // size
|
|
uint8_t m_round_key[AES_MAX_KEY_FINAL_S]; // round key
|
|
|
|
//---
|
|
uint m_ncol; // nuymeo de columnas en la clave (4 = clavelen\4) (Nk)
|
|
uint m_ncol_last; // m_ncol-1 (para fast %)
|
|
uint m_nr; // numero de rondas (nk+6)
|
|
int m_expected_len_key; // tamaño de clave que se espera
|
|
|
|
|
|
//---
|
|
void AddRoundKey(uint round, uint8_t& state[]) const;
|
|
|
|
__forceinline uint8_t xtime(uint8_t x) const;
|
|
|
|
|
|
public:
|
|
CAes(void);
|
|
~CAes(void) {}
|
|
|
|
//---
|
|
void KeyExpansion(const uint8_t& key[]);
|
|
|
|
|
|
//---
|
|
void Method(ENUM_AES_TYPE_CRYPTH tcrypht);
|
|
|
|
//---
|
|
bool Init(const uint8_t &key[]);
|
|
bool Init(const uint8_t& key[], const uint8_t& iv[]);
|
|
|
|
//--- Base / ECB
|
|
void CifradoInverso(uint8_t& state[]) const;
|
|
void Cifrar(uint8_t& state[]) const;
|
|
|
|
//--- Cbc con IV secuencial
|
|
void CbcCifrado(uint8_t &buf[], uint length);
|
|
void CbcDescifra(uint8_t& buf[], uint length);
|
|
__forceinline bool CbcSaveLastIv() const { return m_save_last_ivs_in_cbc; }
|
|
void CbcSaveLastIv(bool v) { m_save_last_ivs_in_cbc = v; }
|
|
|
|
//--- CTR
|
|
void CtrCryptX(uint8_t& buf[], uint length);
|
|
|
|
//---
|
|
static void CorrectPadding(uchar& in[]);
|
|
static bool QuitarPadding(uchar& in[]);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
CAes::CAes(void)
|
|
: m_save_last_ivs_in_cbc(true)
|
|
{
|
|
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CAes::KeyExpansion(const uint8_t & key[])
|
|
{
|
|
unsigned int i, j, k;
|
|
uint8_t tempa[4]; // Used for the column/row operations
|
|
|
|
//--- Copiamos.
|
|
// Primera pasada copiamos por cada columa 4 valores..
|
|
// [] .... m_col
|
|
// []
|
|
// []
|
|
// []
|
|
for(i = 0; i < m_ncol; ++i)
|
|
{
|
|
m_round_key[(i * 4) + 0] = key[(i * 4) + 0];
|
|
m_round_key[(i * 4) + 1] = key[(i * 4) + 1];
|
|
m_round_key[(i * 4) + 2] = key[(i * 4) + 2];
|
|
m_round_key[(i * 4) + 3] = key[(i * 4) + 3];
|
|
}
|
|
|
|
|
|
//---
|
|
// luego empzamos en la utliam fila hasta el numero de rondas * 4 +1
|
|
for(i = m_ncol; i < AES_COL_S * (m_nr + 1); ++i)
|
|
{
|
|
{
|
|
// Obtenemos palabra
|
|
k = (i - 1) * 4;
|
|
tempa[0] = m_round_key[k + 0];
|
|
tempa[1] = m_round_key[k + 1];
|
|
tempa[2] = m_round_key[k + 2];
|
|
tempa[3] = m_round_key[k + 3];
|
|
}
|
|
|
|
if((i & m_ncol_last) == 0) // % mncol
|
|
{
|
|
// This function shifts the 4 bytes in a word to the left once.
|
|
// [a0,a1,a2,a3] becomes [a1,a2,a3,a0]
|
|
|
|
// Function RotWord()
|
|
{
|
|
const uint8_t u8tmp = tempa[0];
|
|
tempa[0] = tempa[1];
|
|
tempa[1] = tempa[2];
|
|
tempa[2] = tempa[3];
|
|
tempa[3] = u8tmp;
|
|
}
|
|
|
|
// SubWord() is a function that takes a four-byte input word and
|
|
// applies the S-box to each of the four bytes to produce an output word.
|
|
|
|
// Function Subword()
|
|
{
|
|
tempa[0] = getSBoxValue(tempa[0]);
|
|
tempa[1] = getSBoxValue(tempa[1]);
|
|
tempa[2] = getSBoxValue(tempa[2]);
|
|
tempa[3] = getSBoxValue(tempa[3]);
|
|
}
|
|
|
|
tempa[0] = tempa[0] ^ g_aes_rcon[i / m_ncol];
|
|
}
|
|
//#if defined(AES256) && (AES256 == 1)
|
|
if(m_method == AES_CRYPTH_256 && (i & m_ncol_last) == 4)
|
|
{
|
|
// Function Subword()
|
|
{
|
|
tempa[0] = getSBoxValue(tempa[0]);
|
|
tempa[1] = getSBoxValue(tempa[1]);
|
|
tempa[2] = getSBoxValue(tempa[2]);
|
|
tempa[3] = getSBoxValue(tempa[3]);
|
|
}
|
|
}
|
|
//#endif
|
|
j = i * 4;
|
|
k = (i - m_ncol) * 4;
|
|
m_round_key[j + 0] = m_round_key[k + 0] ^ tempa[0];
|
|
m_round_key[j + 1] = m_round_key[k + 1] ^ tempa[1];
|
|
m_round_key[j + 2] = m_round_key[k + 2] ^ tempa[2];
|
|
m_round_key[j + 3] = m_round_key[k + 3] ^ tempa[3];
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CAes::Method(ENUM_AES_TYPE_CRYPTH tcrypht)
|
|
{
|
|
m_method = tcrypht;
|
|
switch(tcrypht)
|
|
{
|
|
case AES_CRYPTH_128:
|
|
{
|
|
m_round_key_s = 176;
|
|
m_expected_len_key = 16;
|
|
m_ncol = 4;
|
|
m_ncol_last = 3;
|
|
m_nr = 10;
|
|
break;
|
|
}
|
|
case AES_CRYPTH_256:
|
|
{
|
|
m_round_key_s = 240;
|
|
m_expected_len_key = 32;
|
|
m_ncol = 8;
|
|
m_ncol_last = 7;
|
|
m_nr = 14;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
// fllabkac a 128
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CAes::Init(const uint8_t &key[])
|
|
{
|
|
if(ArraySize(key) != m_expected_len_key)
|
|
{
|
|
m_last_err = AES_LAST_ERR_INVALID_KEY_LEN;
|
|
return false;
|
|
}
|
|
KeyExpansion(key);
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CAes::Init(const uint8_t &key[], const uint8_t &iv[])
|
|
{
|
|
if(ArraySize(key) != m_expected_len_key)
|
|
{
|
|
m_last_err = AES_LAST_ERR_INVALID_KEY_LEN;
|
|
return false;
|
|
}
|
|
KeyExpansion(key);
|
|
|
|
//---
|
|
const int t = ArraySize(iv);
|
|
if(t != AES_BLOCKLEN)
|
|
{
|
|
m_last_err = AES_LAST_ERR_INVALID_IV_SIZE;
|
|
return false;
|
|
}
|
|
|
|
//---
|
|
for(int i = 0; i < AES_BLOCKLEN; i++)
|
|
{
|
|
m_iv[i] = iv[i];
|
|
}
|
|
|
|
//---
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
// con el buffer acutal aplicamos un xor con el key
|
|
void CAes::AddRoundKey(uint round, uint8_t& state[]) const
|
|
{
|
|
uint8_t i;
|
|
for(i = 0; i < 4; ++i)
|
|
{
|
|
// unrolled
|
|
AesStateAcces(i, 0) ^= m_round_key[(round * AES_COL_S * 4) + (i * AES_COL_S) + 0];
|
|
AesStateAcces(i, 1) ^= m_round_key[(round * AES_COL_S * 4) + (i * AES_COL_S) + 1];
|
|
AesStateAcces(i, 2) ^= m_round_key[(round * AES_COL_S * 4) + (i * AES_COL_S) + 2];
|
|
AesStateAcces(i, 3) ^= m_round_key[(round * AES_COL_S * 4) + (i * AES_COL_S) + 3];
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
// Suma corregida por lo visto en mapa finito de 256
|
|
__forceinline uint8_t CAes::xtime(uint8_t x) const
|
|
{
|
|
return ((x << 1) ^ (((x >> 7) & 1) * 0x1b));
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
// por cda elemento lo sutitlmis con la posicion en que cae en la talba sbox
|
|
/*
|
|
void CAes::SubBytes(uint8_t &state[]) const
|
|
{
|
|
uint8_t i, j;
|
|
for(i = 0; i < 4; ++i)
|
|
{
|
|
AesStateAcces(0, i) = getSBoxValue(AesStateAcces(0, i));
|
|
AesStateAcces(1, i) = getSBoxValue(AesStateAcces(1, i));
|
|
AesStateAcces(2, i) = getSBoxValue(AesStateAcces(2, i));
|
|
AesStateAcces(3, i) = getSBoxValue(AesStateAcces(3, i));
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void CAes::ShiftRows(uint8_t &state[]) const
|
|
{
|
|
uint8_t temp;
|
|
|
|
// Rotate first row 1 columns to left
|
|
temp = AesStateAcces(0, 1);
|
|
AesStateAcces(0, 1) = AesStateAcces(1, 1);
|
|
AesStateAcces(1, 1) = AesStateAcces(2, 1);
|
|
AesStateAcces(2, 1) = AesStateAcces(3, 1);
|
|
AesStateAcces(3, 1) = temp;
|
|
|
|
// Rotate second row 2 columns to left
|
|
temp = AesStateAcces(0, 2);
|
|
AesStateAcces(0, 2) = AesStateAcces(2, 2);
|
|
AesStateAcces(2, 2) = temp;
|
|
temp = AesStateAcces(1, 2);
|
|
AesStateAcces(1, 2) = AesStateAcces(3, 2);
|
|
AesStateAcces(3, 2) = temp;
|
|
|
|
// Rotate third row 3 columns to left
|
|
temp = AesStateAcces(0, 3);
|
|
AesStateAcces(0, 3) = AesStateAcces(3, 3);
|
|
AesStateAcces(3, 3) = AesStateAcces(2, 3);
|
|
AesStateAcces(2, 3) = AesStateAcces(1, 3);
|
|
AesStateAcces(1, 3) = temp;
|
|
}*/
|
|
/*
|
|
//+------------------------------------------------------------------+
|
|
void CAes::MixColumns(uint8_t &state[]) const
|
|
{
|
|
uint8_t temp = AesStateAcces(0, 1);
|
|
AesStateAcces(0, 1) = AesStateAcces(1, 1);
|
|
AesStateAcces(1, 1) = AesStateAcces(2, 1);
|
|
AesStateAcces(2, 1) = AesStateAcces(3, 1);
|
|
AesStateAcces(3, 1) = temp;
|
|
// Rotate second row 2 columns to left
|
|
temp = AesStateAcces(0, 2);
|
|
AesStateAcces(0, 2) = AesStateAcces(2, 2);
|
|
AesStateAcces(2, 2) = temp;
|
|
temp = AesStateAcces(1, 2);
|
|
AesStateAcces(1, 2) = AesStateAcces(3, 2);
|
|
AesStateAcces(3, 2) = temp;
|
|
// Rotate third row 3 columns to left
|
|
temp = AesStateAcces(0, 3);
|
|
AesStateAcces(0, 3) = AesStateAcces(3, 3);
|
|
AesStateAcces(3, 3) = AesStateAcces(2, 3);
|
|
AesStateAcces(2, 3) = AesStateAcces(1, 3);
|
|
AesStateAcces(1, 3) = temp;
|
|
}
|
|
*/
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
/*
|
|
void CAes::InvMixColumns(uint8_t &state[]) const
|
|
{
|
|
int i;
|
|
uint8_t a, b, c, d;
|
|
for(i = 0; i < 4; ++i)
|
|
{
|
|
a = AesStateAcces(i, 0);
|
|
b = AesStateAcces(i, 1);
|
|
c = AesStateAcces(i, 2);
|
|
d = AesStateAcces(i, 3);
|
|
AesStateAcces(i, 0) = AesMultiply(a, 0x0e) ^ AesMultiply(b, 0x0b) ^ AesMultiply(c, 0x0d) ^ AesMultiply(d, 0x09);
|
|
AesStateAcces(i, 1) = AesMultiply(a, 0x09) ^ AesMultiply(b, 0x0e) ^ AesMultiply(c, 0x0b) ^ AesMultiply(d, 0x0d);
|
|
AesStateAcces(i, 2) = AesMultiply(a, 0x0d) ^ AesMultiply(b, 0x09) ^ AesMultiply(c, 0x0e) ^ AesMultiply(d, 0x0b);
|
|
AesStateAcces(i, 3) = AesMultiply(a, 0x0b) ^ AesMultiply(b, 0x0d) ^ AesMultiply(c, 0x09) ^ AesMultiply(d, 0x0e);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void CAes::InvSubBytes(uint8_t &state[]) const
|
|
{
|
|
uint8_t i;
|
|
for(i = 0; i < 4; ++i)
|
|
{
|
|
AesStateAcces(0, i) = getSBoxInvert(AesStateAcces(0, i));
|
|
AesStateAcces(1, i) = getSBoxInvert(AesStateAcces(1, i));
|
|
AesStateAcces(2, i) = getSBoxInvert(AesStateAcces(2, i));
|
|
AesStateAcces(3, i) = getSBoxInvert(AesStateAcces(3, i));
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void CAes::InvShiftRows(uint8_t &state[]) const
|
|
{
|
|
// Rotate first row 1 columns to right
|
|
uint8_t temp = AesStateAcces(3, 1);
|
|
AesStateAcces(3, 1) = AesStateAcces(2, 1);
|
|
AesStateAcces(2, 1) = AesStateAcces(1, 1);
|
|
AesStateAcces(1, 1) = AesStateAcces(0, 1);
|
|
AesStateAcces(0, 1) = temp;
|
|
// Rotate second row 2 columns to right
|
|
temp = AesStateAcces(0, 2);
|
|
AesStateAcces(0, 2) = AesStateAcces(2, 2);
|
|
AesStateAcces(2, 2) = temp;
|
|
temp = AesStateAcces(1, 2);
|
|
AesStateAcces(1, 2) = AesStateAcces(3, 2);
|
|
AesStateAcces(3, 2) = temp;
|
|
// Rotate third row 3 columns to right
|
|
temp = AesStateAcces(0, 3);
|
|
AesStateAcces(0, 3) = AesStateAcces(1, 3);
|
|
AesStateAcces(1, 3) = AesStateAcces(2, 3);
|
|
AesStateAcces(2, 3) = AesStateAcces(3, 3);
|
|
AesStateAcces(3, 3) = temp;
|
|
}
|
|
*/
|
|
//+------------------------------------------------------------------+
|
|
//| Cifrado\Descifrado de un block de 16 exactos |
|
|
//+------------------------------------------------------------------+
|
|
void CAes::Cifrar(uint8_t& state[]) const
|
|
{
|
|
uint8_t round = 0;
|
|
|
|
// Add the First round key to the buf before starting the rounds.
|
|
AddRoundKey(0, state);
|
|
|
|
// There will be m_nr rounds.
|
|
// The first m_nr-1 rounds are identical.
|
|
// These m_nr rounds are executed in the loop below.
|
|
// Last one without MixColumns()
|
|
for(round = 1; ; ++round)
|
|
{
|
|
//--- Subbytes
|
|
// SubBytes(state);
|
|
uint8_t i;
|
|
for(i = 0; i < 4; ++i)
|
|
{
|
|
// unrrolled
|
|
AesStateAcces(0, i) = getSBoxValue(AesStateAcces(0, i));
|
|
AesStateAcces(1, i) = getSBoxValue(AesStateAcces(1, i));
|
|
AesStateAcces(2, i) = getSBoxValue(AesStateAcces(2, i));
|
|
AesStateAcces(3, i) = getSBoxValue(AesStateAcces(3, i));
|
|
}
|
|
|
|
//--- Shift rows
|
|
// Inline
|
|
//ShiftRows(state);
|
|
// temp;
|
|
// Rotate first row 1 columns to left
|
|
uint8_t temp = AesStateAcces(0, 1);
|
|
AesStateAcces(0, 1) = AesStateAcces(1, 1);
|
|
AesStateAcces(1, 1) = AesStateAcces(2, 1);
|
|
AesStateAcces(2, 1) = AesStateAcces(3, 1);
|
|
AesStateAcces(3, 1) = temp;
|
|
// Rotate second row 2 columns to left
|
|
temp = AesStateAcces(0, 2);
|
|
AesStateAcces(0, 2) = AesStateAcces(2, 2);
|
|
AesStateAcces(2, 2) = temp;
|
|
temp = AesStateAcces(1, 2);
|
|
AesStateAcces(1, 2) = AesStateAcces(3, 2);
|
|
AesStateAcces(3, 2) = temp;
|
|
// Rotate third row 3 columns to left
|
|
temp = AesStateAcces(0, 3);
|
|
AesStateAcces(0, 3) = AesStateAcces(3, 3);
|
|
AesStateAcces(3, 3) = AesStateAcces(2, 3);
|
|
AesStateAcces(2, 3) = AesStateAcces(1, 3);
|
|
AesStateAcces(1, 3) = temp;
|
|
|
|
//---
|
|
if(round == m_nr)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//--- Mix columns
|
|
//MixColumns(state); Inline
|
|
uint8_t Tmp, Tm, t;
|
|
//---
|
|
for(i = 0; i < 4; ++i)
|
|
{
|
|
t = AesStateAcces(i, 0);
|
|
Tm = t ^ AesStateAcces(i, 1);
|
|
Tmp = Tm ^ AesStateAcces(i, 2) ^ AesStateAcces(i, 3);
|
|
|
|
//---
|
|
Tm = xtime(Tm);
|
|
AesStateAcces(i, 0) ^= Tm ^ Tmp ;
|
|
Tm = AesStateAcces(i, 1) ^ AesStateAcces(i, 2) ;
|
|
Tm = xtime(Tm);
|
|
AesStateAcces(i, 1) ^= Tm ^ Tmp ;
|
|
Tm = AesStateAcces(i, 2) ^ AesStateAcces(i, 3) ;
|
|
Tm = xtime(Tm);
|
|
AesStateAcces(i, 2) ^= Tm ^ Tmp ;
|
|
Tm = AesStateAcces(i, 3) ^ t ;
|
|
Tm = xtime(Tm);
|
|
AesStateAcces(i, 3) ^= Tm ^ Tmp ;
|
|
}
|
|
|
|
//---
|
|
AddRoundKey(round, state);
|
|
}
|
|
|
|
//---
|
|
// Add round key to last round
|
|
AddRoundKey(m_nr, state);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void CAes::CifradoInverso(uint8_t& state[]) const
|
|
{
|
|
//---
|
|
// Add the First round key to the buf before starting the rounds.
|
|
AddRoundKey(m_nr, state);
|
|
|
|
// There will be m_nr rounds.
|
|
// The first m_nr-1 rounds are identical.
|
|
// These m_nr rounds are executed in the loop below.
|
|
// Last one without InvMixColumn()
|
|
for(uint8_t round = uchar(m_nr - 1); ; --round)
|
|
{
|
|
//---
|
|
// InvShiftRows
|
|
// Rotate first row 1 columns to right
|
|
uint8_t temp = AesStateAcces(3, 1);
|
|
AesStateAcces(3, 1) = AesStateAcces(2, 1);
|
|
AesStateAcces(2, 1) = AesStateAcces(1, 1);
|
|
AesStateAcces(1, 1) = AesStateAcces(0, 1);
|
|
AesStateAcces(0, 1) = temp;
|
|
// Rotate second row 2 columns to right
|
|
temp = AesStateAcces(0, 2);
|
|
AesStateAcces(0, 2) = AesStateAcces(2, 2);
|
|
AesStateAcces(2, 2) = temp;
|
|
temp = AesStateAcces(1, 2);
|
|
AesStateAcces(1, 2) = AesStateAcces(3, 2);
|
|
AesStateAcces(3, 2) = temp;
|
|
// Rotate third row 3 columns to right
|
|
temp = AesStateAcces(0, 3);
|
|
AesStateAcces(0, 3) = AesStateAcces(1, 3);
|
|
AesStateAcces(1, 3) = AesStateAcces(2, 3);
|
|
AesStateAcces(2, 3) = AesStateAcces(3, 3);
|
|
AesStateAcces(3, 3) = temp;
|
|
|
|
//--- SubBytes
|
|
// InvSubBytes(state);
|
|
for(uint8_t i = 0; i < 4; ++i)
|
|
{
|
|
AesStateAcces(0, i) = getSBoxInvert(AesStateAcces(0, i));
|
|
AesStateAcces(1, i) = getSBoxInvert(AesStateAcces(1, i));
|
|
AesStateAcces(2, i) = getSBoxInvert(AesStateAcces(2, i));
|
|
AesStateAcces(3, i) = getSBoxInvert(AesStateAcces(3, i));
|
|
}
|
|
|
|
//---
|
|
AddRoundKey(round, state);
|
|
if(round == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//---
|
|
// InvMixColumns(state);
|
|
uint8_t a, b, c, d;
|
|
for(int i = 0; i < 4; ++i)
|
|
{
|
|
a = AesStateAcces(i, 0);
|
|
b = AesStateAcces(i, 1);
|
|
c = AesStateAcces(i, 2);
|
|
d = AesStateAcces(i, 3);
|
|
AesStateAcces(i, 0) = AesMultiply(a, 0x0e) ^ AesMultiply(b, 0x0b) ^ AesMultiply(c, 0x0d) ^ AesMultiply(d, 0x09);
|
|
AesStateAcces(i, 1) = AesMultiply(a, 0x09) ^ AesMultiply(b, 0x0e) ^ AesMultiply(c, 0x0b) ^ AesMultiply(d, 0x0d);
|
|
AesStateAcces(i, 2) = AesMultiply(a, 0x0d) ^ AesMultiply(b, 0x09) ^ AesMultiply(c, 0x0e) ^ AesMultiply(d, 0x0b);
|
|
AesStateAcces(i, 3) = AesMultiply(a, 0x0b) ^ AesMultiply(b, 0x0d) ^ AesMultiply(c, 0x09) ^ AesMultiply(d, 0x0e);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Cifrado\Descifrado CBC |
|
|
//+------------------------------------------------------------------+
|
|
// buf = entrada se cifra
|
|
// lenght multiplde blockslen (si no esta ajusta padding con len % BLOCK len eso te da lo que falta lo sumas y rellenas)
|
|
void CAes::CbcCifrado(uint8_t &buf[], uint length)
|
|
{
|
|
//---
|
|
m_ivs = -1;
|
|
for(m_ks = 0; m_ks < length; m_ks += AES_BLOCKLEN)
|
|
{
|
|
//--- Xor
|
|
// The block in AES is always 128bit no matter the key size
|
|
if(m_ivs == -1)
|
|
{
|
|
for(uint k = 0; k < AES_BLOCKLEN; ++k)
|
|
buf[m_ks + k] ^= m_iv[k];
|
|
}
|
|
else
|
|
{
|
|
for(uint k = 0; k < AES_BLOCKLEN; ++k)
|
|
buf[m_ks + k] ^= buf[m_ivs + k];
|
|
}
|
|
|
|
//---
|
|
// cifra desde m_ks
|
|
Cifrar(buf);
|
|
|
|
//---
|
|
m_ivs = (int)m_ks; // Ahora punta ahi..
|
|
}
|
|
|
|
//---
|
|
/* store Iv in ctx for next call */
|
|
if(m_save_last_ivs_in_cbc)
|
|
{
|
|
ArrayCopy(m_iv, buf, 0, m_ivs, AES_BLOCKLEN); // memcpy(ctx->Iv, Iv, AES_BLOCKLEN);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
void CAes::CbcDescifra(uchar &buf[], uint length)
|
|
{
|
|
//---
|
|
m_ivs = -1;
|
|
uint8_t storeNextIv[AES_BLOCKLEN];
|
|
|
|
//---
|
|
for(m_ks = 0; m_ks < length; m_ks += AES_BLOCKLEN)
|
|
{
|
|
//--- Copiamos en el temporañ
|
|
//memcpy(storeNextIv, buf, AES_BLOCKLEN);
|
|
for(int i = 0; i < AES_BLOCKLEN; i++)
|
|
storeNextIv[i] = buf[m_ks + i];
|
|
|
|
//---
|
|
CifradoInverso(buf);
|
|
|
|
//---
|
|
//XorWithIv(buf, ctx->Iv);
|
|
//--- Xor
|
|
// The block in AES is always 128bit no matter the key size
|
|
if(m_ivs == -1)
|
|
{
|
|
for(uint k = 0; k < AES_BLOCKLEN; ++k)
|
|
buf[m_ks + k] ^= m_iv[k];
|
|
}
|
|
else
|
|
{
|
|
for(uint k = 0; k < AES_BLOCKLEN; ++k)
|
|
buf[m_ks + k] ^= buf[m_ivs + k];
|
|
}
|
|
|
|
//---
|
|
// memcpy(ctx->Iv, storeNextIv, AES_BLOCKLEN);,
|
|
for(int i = 0; i < AES_BLOCKLEN; i++)
|
|
{
|
|
m_iv[i] = storeNextIv[i];
|
|
}
|
|
|
|
// buf += AES_BLOCKLEN; ya se hace en el foir
|
|
}
|
|
// Nota que nosotros no hacesmos suma de putneros para iterar
|
|
// Si no que tenemso un integer que es como nuestro puntero de lecutra
|
|
// ENtonces nosotros modificamos eso..
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CAes::CtrCryptX(uint8_t& buf[], uint length)
|
|
{
|
|
//---
|
|
uint8_t buffer[AES_BLOCKLEN];
|
|
|
|
//---
|
|
uint i;
|
|
int bi;
|
|
m_ks = 0; // start en 0
|
|
|
|
// La idea aqui es ir cifrando iv y aplicar xor con el buffer
|
|
//---
|
|
for(i = 0, bi = AES_BLOCKLEN; i < length; ++i, ++bi)
|
|
{
|
|
if(bi == AES_BLOCKLEN) /* we need to regen xor compliment in buffer */
|
|
{
|
|
// memcpy(buffer, m_iv, AES_BLOCKLEN);
|
|
for(int k = 0; k < AES_BLOCKLEN; k++)
|
|
{
|
|
buffer[k] = m_iv[k];
|
|
}
|
|
|
|
//---
|
|
Cifrar(buffer);
|
|
|
|
//---
|
|
// Sumar en 1 (base 256)
|
|
/* Increment Iv and handle overflow */
|
|
for(bi = (AES_BLOCKLEN - 1); bi >= 0; --bi)
|
|
{
|
|
/* inc will overflow */
|
|
if(m_iv[bi] == 255)
|
|
{
|
|
m_iv[bi] = 0;
|
|
continue;
|
|
}
|
|
m_iv[bi] += 1;
|
|
break;
|
|
}
|
|
bi = 0;
|
|
}
|
|
|
|
//-- xor
|
|
buf[i] = (buf[i] ^ buffer[bi]);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
static void CAes::CorrectPadding(uchar &in[])
|
|
{
|
|
//---
|
|
const int t = ArraySize(in);
|
|
uchar ext = uchar(t % AES_BLOCKLEN);
|
|
if(ext == 0)
|
|
ext = 16;
|
|
|
|
//----
|
|
const int fs = t + ext;
|
|
ArrayResize(in, fs);
|
|
|
|
//---
|
|
for(int i = t; i < fs; i++)
|
|
{
|
|
in[i] = ext;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
static bool CAes::QuitarPadding(uchar &in[])
|
|
{
|
|
//---
|
|
const int t = ArraySize(in);
|
|
if(t < 1)
|
|
return true; // raro no hay nada.. asi que no hayt errores
|
|
const uchar last = in[t - 1];
|
|
|
|
//--- Check de range
|
|
if(last < 1 || last > AES_BLOCKLEN)
|
|
return false;
|
|
|
|
//---
|
|
const int fs = int(t - last);
|
|
for(int i = fs; i < t; i++)
|
|
{
|
|
if(in[i] != last)
|
|
return false;
|
|
}
|
|
|
|
//---
|
|
ArrayResize(in, fs);
|
|
|
|
//---
|
|
return true;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
#endif // CRYPTOBYLEO_SRC_SIMETRIC_AES_MAIN_MQH
|