static int
aes_init(EVP_CIPHER_CTX *ctx,
const unsigned char * key,
const unsigned char * iv,
int encp)
{
AES_KEY *k = ctx->cipher_data;
if (ctx->encrypt)
AES_set_encrypt_key(key, ctx->cipher->key_len * 8, k);
else
AES_set_decrypt_key(key, ctx->cipher->key_len * 8, k);
return 1;
}
void CryptState_genKey(cryptState_t *cs) {
RAND_bytes(cs->raw_key, AES_BLOCK_SIZE);
RAND_bytes(cs->encrypt_iv, AES_BLOCK_SIZE);
RAND_bytes(cs->decrypt_iv, AES_BLOCK_SIZE);
#ifndef USE_POLARSSL
AES_set_encrypt_key(cs->raw_key, 128, &cs->encrypt_key);
AES_set_decrypt_key(cs->raw_key, 128, &cs->decrypt_key);
#else
aes_setkey_enc(&cs->aes_enc, cs->raw_key, 128);
aes_setkey_dec(&cs->aes_dec, cs->raw_key, 128);
#endif
cs->bInit = true;
}
void Message::dechiffrement(const unsigned char *key){
unsigned char trame [1024];
const char *chif = this->chiffre.toStdString().c_str();
unsigned char iv[AES_BLOCK_SIZE];
memset(iv, 0x00, AES_BLOCK_SIZE);
AES_KEY dec_key;
AES_set_decrypt_key(key,256,&dec_key);
AES_cbc_encrypt((const unsigned char *)chif,trame,strlen(chif),&dec_key, iv,AES_DECRYPT);
this->msg = QString((const char *)trame);
}
main()
{
AES_set_encrypt_key(test_key, 128, &encks);
AES_set_decrypt_key(test_key, 128, &decks);
test_vector(vector_17, sizeof(vector_17));
test_vector(vector_31, sizeof(vector_31));
test_vector(vector_32, sizeof(vector_32));
test_vector(vector_47, sizeof(vector_47));
test_vector(vector_48, sizeof(vector_48));
test_vector(vector_64, sizeof(vector_64));
exit(0);
}
/*
* des - aes加密函数
* param - ciphertext: 密文数据
* plaintext: 解密后明文数据
* len: 密文数据长度，CBC模式以bytes为单位进行加密，该len长度有一定容错空间，解密不会出错。建议传入密文数据长度。
*
* ret - void
*/
void aes_decrypte(const u_char *ciphertext, u_char *plaintext, u_int len)
{
AES_KEY key;
unsigned char inner_iv[AES_BLOCK_SIZE * 4];
int nr_of_bits = 0;
memcpy(inner_iv, iv, sizeof(iv));
nr_of_bits = 8 * sizeof(rkey);
AES_set_decrypt_key(rkey, nr_of_bits, &key);
AES_cbc_encrypt(ciphertext, plaintext, len, &key, inner_iv, AES_DECRYPT);
}
static int aes_set_decrypt_key(struct ssh_cipher_struct *cipher, void *key,
void *IV) {
if (cipher->key == NULL) {
if (alloc_key(cipher) < 0) {
return -1;
}
if (AES_set_decrypt_key(key,cipher->keysize,cipher->key) < 0) {
SAFE_FREE(cipher->key);
return -1;
}
}
cipher->IV=IV;
return 0;
}
void encrypt_data(FILE* input_file, FILE* output_file)
{
unsigned char inbuf[80];
unsigned char outbuf[80];
unsigned char decbuf[80];
int inlen, outlen;
AES_KEY enc_key;
AES_KEY dec_key;
AES_set_encrypt_key(key, 128, &enc_key);
//while(1) {
int i;
inlen = 80;
outlen = 80;
// inlen = fread(inbuf, 1, 80, input_file);
for (i=0; i<inlen; i++) {
inbuf[i]=0;
}
printf("input data is \n");
for (i = 0; i < inlen; i++) {
printf("%c ", inbuf[i]);
}
printf("\n");
AES_encrypt(inbuf, outbuf, &enc_key);
printf("encrypted data is \n");
for (i = 0; i < inlen; i++) {
printf("%X ", outbuf[i]);
}
printf("\n");
AES_set_decrypt_key(key, 128, &dec_key);
AES_decrypt(outbuf, decbuf, &dec_key);
printf("decrypted data is \n");
for (i = 0; i < inlen; i++) {
printf("%c ", decbuf[i]);
}
printf("\n");
outlen = fwrite(outbuf, 1, inlen, output_file);
// if (outlen < AES_BLOCK_SIZE)
// {
// break;
// }
//}
}
void CryptState_setKey(cryptState_t *cs, const unsigned char *rkey, const unsigned char *eiv, const unsigned char *div)
{
memcpy(cs->raw_key, rkey, AES_BLOCK_SIZE);
memcpy(cs->encrypt_iv, eiv, AES_BLOCK_SIZE);
memcpy(cs->decrypt_iv, div, AES_BLOCK_SIZE);
#ifndef USE_POLARSSL
AES_set_encrypt_key(cs->decrypt_iv, 128, &cs->encrypt_key);
AES_set_decrypt_key(cs->raw_key, 128, &cs->decrypt_key);
#else
aes_setkey_enc(&cs->aes_enc, cs->decrypt_iv, 128);
aes_setkey_dec(&cs->aes_dec, cs->raw_key, 128);
#endif
cs->bInit = true;
}
static void aes256_init(ops_crypt_t *crypt)
{
if (crypt->encrypt_key)
free(crypt->encrypt_key);
crypt->encrypt_key=malloc(sizeof(AES_KEY));
if (AES_set_encrypt_key(crypt->key,KEYBITS_AES256,crypt->encrypt_key))
fprintf(stderr,"aes256_init: Error setting encrypt_key\n");
if (crypt->decrypt_key)
free(crypt->decrypt_key);
crypt->decrypt_key=malloc(sizeof(AES_KEY));
if (AES_set_decrypt_key(crypt->key,KEYBITS_AES256,crypt->decrypt_key))
fprintf(stderr,"aes256_init: Error setting decrypt_key\n");
}
guint8* aesBlockDecrypt(gchar *aesKey, gchar *aesIV, gchar *src, gint length) {
AES_KEY key;
AES_set_decrypt_key((const unsigned char *)aesKey, 128, &key);
guint8 iv[16];
memcpy(iv, aesIV, sizeof(iv));
gint aeslen = length & ~0xf;
guint8 *data = g_malloc(2048 * sizeof(guint8));
AES_cbc_encrypt((const unsigned char *)src, data, aeslen, &key, iv, AES_DECRYPT);
memcpy(data + aeslen, src + aeslen, length - aeslen);
return data;
}
void svCrypto::SetAESKey(svAESCrypt mode,
const uint8_t *plain_key, AES_KEY &crypt_key)
{
switch (mode) {
case svAES_ENCRYPT:
if (AES_set_encrypt_key(plain_key, aes_key_bits, &crypt_key) != 0)
throw svExCryptoSetAESEncryptKey();
break;
case svAES_DECRYPT:
if (AES_set_decrypt_key(plain_key, aes_key_bits, &crypt_key) != 0)
throw svExCryptoSetAESDecryptKey();
break;
}
}
vector<unsigned char> AES256_ige_decrypt(vector<unsigned char> encrypted_answer,vector<unsigned char> tmp_aes_iv,vector<unsigned char> tmp_aes_key)
{
vector<unsigned char> res(encrypted_answer.size(),0);
AES_KEY key;
// vector<unsigned char> x_0(tmp_aes_iv.begin(), tmp_aes_iv.begin()+10);
// vector<unsigned char> y_0(tmp_aes_iv.begin()+10, tmp_aes_iv.end());
// tmp_aes_iv = mergeVectors(y_0, x_0);
AES_set_decrypt_key(&tmp_aes_key[0], 256, &key);
AES_ige_encrypt(&encrypted_answer[0], &res[0], encrypted_answer.size(), &key, &tmp_aes_iv[0], AES_DECRYPT);
return res;
}
int decpry(char *ibuf, int len)
{
struct sys_key *pskey = get_shm();
struct sys_key skey;
memcpy(&skey, pskey, sizeof(struct sys_key));
AES_KEY dec_key;
unsigned char dec_out[len];
memset(dec_out, 0, len);
AES_set_decrypt_key(skey.key, KEYLEN*8, &dec_key);
AES_cbc_encrypt(ibuf, dec_out, len, &dec_key, skey.iv_dec,
AES_DECRYPT);
memcpy(ibuf, dec_out, len);
return 0;
}
/* Encrypt or decrypt one block with AES and the given key */
static void aesBlock(unsigned char out[16], const unsigned char key[],
int keyBits, const unsigned char in[16], int dir)
{
extern void exit(int status);
int retCode;
AES_KEY aesKey;
if (dir==AES_ENCRYPT)
retCode = AES_set_encrypt_key(key, keyBits, &aesKey);
else
retCode = AES_set_decrypt_key(key, keyBits, &aesKey);
if (retCode!=0) exit(retCode); /* Not very gracefull, but still... */
if (dir==AES_ENCRYPT) AES_encrypt(in, out, &aesKey);
else AES_decrypt(in, out, &aesKey);
}
bool AES_KW_Decrypt(COSE_Enveloped * pcose, const byte * pbKeyIn, size_t cbitKey, const byte * pbCipherText, size_t cbCipherText, byte * pbKeyOut, int * pcbKeyOut, cose_errback * perr)
{
byte rgbOut[256 / 8];
AES_KEY key;
CHECK_CONDITION(AES_set_decrypt_key(pbKeyIn, (int)cbitKey, &key) == 0, COSE_ERR_CRYPTO_FAIL);
CHECK_CONDITION(AES_unwrap_key(&key, NULL, rgbOut, pbCipherText, (int) cbCipherText), COSE_ERR_CRYPTO_FAIL);
memcpy(pbKeyOut, rgbOut, cbCipherText - 8);
*pcbKeyOut = (int) (cbCipherText - 8);
return true;
errorReturn:
return false;
}
main(){
AES_KEY AESkey;
unsigned char MBlock[16];
unsigned char MBlock2[16];
unsigned char CBlock[16];
unsigned char Key[16];
int i;
/*
* Key contains the actual 128-bit AES key. AESkey is a data structure
* holding a transformed version of the key, for efficiency.
*/
Key[0]=1;
for (i=1; i<=15; i++) {
Key[i] = 0;
}
AES_set_encrypt_key((const unsigned char *) Key, 128, &AESkey);
MBlock[0] = 1;
for (i=1; i<16; i++)
MBlock[i] = 0;
AES_encrypt((const unsigned char *) MBlock, CBlock, (const AES_KEY *) &AESkey);
for (i=0; i<16; i++)
printf("%X", CBlock[i]/16), printf("%X", CBlock[i]%16);
printf("\n");
/*
* We need to set AESkey appropriately before inverting AES.
* Note that the underlying key Key is the same; just the data structure
* AESkey is changing (for reasons of efficiency).
*/
AES_set_decrypt_key((const unsigned char *) Key, 128, &AESkey);
AES_decrypt((const unsigned char *) CBlock, MBlock2, (const AES_KEY *) &AESkey);
for (i=0; i<16; i++)
printf("%X", MBlock2[i]/16), printf("%X", MBlock2[i]%16);
printf("\n");
}
static ERL_NIF_TERM aes_ecb_decrypt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary in, out, key;
// key must be binary
if(!enif_inspect_binary(env, argv[0], &key)) {
return enif_make_badarg(env);
}
// key size should be 16 byte
if(key.size != 16) {
return enif_make_badarg(env);
}
// cipher must be binary
if(!enif_inspect_binary(env, argv[1], &in)) {
return enif_make_badarg(env);
}
// cipher shoule be 16 byte block
if(in.size % 16) {
return enif_make_badarg(env);
}
unsigned char* decoded = (unsigned char*)malloc(sizeof(unsigned char)*in.size);
struct aes_key_st* decrypt_key = (struct aes_key_st*)malloc(sizeof(AES_KEY));
memset(decrypt_key, 0, sizeof(AES_KEY));
AES_set_decrypt_key((unsigned char*)(key.data), 128, decrypt_key);
int i = 0;
for(i = 0; i < in.size; i += 16) {
AES_decrypt((unsigned char*)&in.data[i], (unsigned char*)&decoded[i], decrypt_key);
}
//Remove padding
unsigned char padding = (unsigned char) decoded[in.size-1];
if(!enif_alloc_binary(in.size - padding, &out)) {
free(decoded);
free(decrypt_key);
return enif_make_badarg(env);
}
strncpy((unsigned char*)out.data, decoded, in.size - padding);
free(decoded);
free(decrypt_key);
return enif_make_binary(env, &out);
}
/* aes crypto function wrapper - p_text : plain text, c_text : cipher text, aes_key : from GetKey, mode : ENCRYPT/DECRYPT, size : data size */
unsigned char* AES_Crypto(unsigned char* p_text, unsigned char* c_text, char* aes_key, unsigned char* iv, int mode, unsigned long size)
{
AES_KEY e_key, d_key;
AES_set_encrypt_key((unsigned char*)aes_key, 128, &e_key);
AES_set_decrypt_key((unsigned char*)aes_key, 128, &d_key);
if(mode == 1)
{
AES_cbc_encrypt(p_text, c_text, size, &e_key, iv, AES_ENCRYPT);
return c_text;
}
else
{
AES_cbc_encrypt(c_text, p_text, size, &d_key, iv, AES_DECRYPT);
return p_text;
}
}
static bool aes_block_decrypt(void * buffer, size_t len)
{
AES_KEY key;
char out[16];
size_t bc = len / 16;
char *cbuf = (char *)buffer;
if(NULL == buffer || len % 16 != 0)
return false;
AES_set_decrypt_key((const unsigned char*)aes_ukey, 128, &key);
for(size_t i = 0 ; i < bc ; i ++) {
AES_decrypt((const unsigned char*)(cbuf + i * 16), (unsigned char*)out, &key);
memcpy(cbuf + i * 16, out, 16);
}
return true;
}
void My_AES_CBC_Decrypt(u8 * key, u8 *InputMessage, u32 InputMessageLength, u8 *OutputMessage)
{
u8 *InBuf_ptr = InputMessage;
AES_KEY ass_key;
int length_in_pad = 0;
u8 iv[CRL_AES_BLOCK] = {0};
int i;
for(i = 0; i < CRL_AES_BLOCK; i++){
iv[i] = IV[i];
}
memset(&ass_key, 0, sizeof(AES_KEY));
if(AES_set_decrypt_key(key, 128, &ass_key) < 0){
printf("AES_Dec set key error...\n");
return ;
}
AES_cbc_encrypt(InputMessage, OutputMessage, InputMessageLength, &ass_key, iv, AES_DECRYPT);
}
//解密数据pData, 数据长度为length
bool CCryptAes::Decrypt(const unsigned char *pEncryptData, int length, unsigned char *pPlainData)
{
assert(pPlainData != NULL);
assert(pEncryptData != NULL);
AES_KEY aes;
unsigned char iv[AES_BLOCK_SIZE];
memset(iv, 0, sizeof(iv));
if (AES_set_decrypt_key(m_userKey, m_keyBits, &aes) < 0)
{
return false;
}
AES_cbc_encrypt(pEncryptData, pPlainData, length, &aes, iv, AES_DECRYPT);
return true;
}
int
rijndaelKeySetupDec(uint32 rk[], const uint8 cipherKey[], int keyBits)
{
int i, ret;
AES_KEY key;
memset((char *)&key, 0, sizeof(key));
ret = AES_set_decrypt_key(cipherKey, keyBits, &key);
if (ret < 0) {
printf("rijndaelKeySetupDec() : AES_set_decrypt_key failed %d\n", ret);
return ret; /* zero rounds ? */
}
for (i = 0; i < (4 * (key.rounds + 1)); i++)
rk[i] = key.rd_key[i];
return key.rounds;
}
void init_aes_unauth (const char server_nonce[16], const char hidden_client_nonce[32], int encrypt) {
static unsigned char buffer[64], hash[20];
memcpy (buffer, hidden_client_nonce, 32);
memcpy (buffer + 32, server_nonce, 16);
SHA1 (buffer, 48, aes_key_raw);
memcpy (buffer + 32, hidden_client_nonce, 32);
SHA1 (buffer, 64, aes_iv + 8);
memcpy (buffer, server_nonce, 16);
memcpy (buffer + 16, hidden_client_nonce, 32);
SHA1 (buffer, 48, hash);
memcpy (aes_key_raw + 20, hash, 12);
memcpy (aes_iv, hash + 12, 8);
memcpy (aes_iv + 28, hidden_client_nonce, 4);
if (encrypt == AES_ENCRYPT) {
AES_set_encrypt_key (aes_key_raw, 32*8, &aes_key);
} else {
AES_set_decrypt_key (aes_key_raw, 32*8, &aes_key);
}
}
int openssl_decrypt_init(struct openssl_decrypt **state,
const char *passphrase,
enum openssl_mode mode)
{
#ifndef HAVE_CRYPTO
fprintf(stderr, "This " PACKAGE_NAME " version was build "
"without OpenSSL support!\n");
return -1;
#endif // HAVE_CRYPTO
struct openssl_decrypt *s =
(struct openssl_decrypt *)
calloc(1, sizeof(struct openssl_decrypt));
MD5_CTX context;
unsigned char hash[16];
MD5Init(&context);
MD5Update(&context, (const unsigned char *) passphrase,
strlen(passphrase));
MD5Final(hash, &context);
switch(mode) {
case MODE_AES128_ECB:
#ifdef HAVE_CRYPTO
AES_set_decrypt_key(hash, 128, &s->key);
#endif
break;
case MODE_AES128_CTR:
#ifdef HAVE_CRYPTO
AES_set_encrypt_key(hash, 128, &s->key);
#endif
break;
default:
abort();
}
s->mode = mode;
*state = s;
return 0;
}
static int
aes_1(v_U32_t cryptHandle, tANI_U8 *keyBytes, tANI_U32 keyLen,
tANI_U8 at[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
tANI_U8 ri[ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE],
tANI_U8 b[AES_BLOCK_SIZE]) {
int retVal;
// AES_KEY aesKey;
tANI_U8 in[AES_BLOCK_SIZE];
tANI_U8 *out;
VOS_ASSERT (AES_BLOCK_SIZE == ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE*2);
// Concatenate A and R[i]
vos_mem_copy(in, at, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
vos_mem_copy(in + ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE,
ri, ANI_SSM_AES_KEY_WRAP_BLOCK_SIZE);
out = b;
#if 0
retVal = AES_set_decrypt_key(keyBytes, keyLen*8, &aesKey);
if (retVal != 0) {
ANI_SSM_LOG_E("AES_set_encrypt_key returned %d", retVal);
assert(0 && "AES_set_encrypt_key failed!");
return ANI_E_FAILED;
}
AES_decrypt(in, out, &aesKey);
#else
retVal = vos_decrypt_AES(cryptHandle, /* Handle */
in, /* input */
out, /* output */
keyBytes); /* key */
if (retVal != 0) {
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"vos_decrypt_AES returned %d", retVal);
}
#endif
return ANI_OK;
}
void CryptoUtils::initAESAuth (char authKey[192], char msgKey[16], qint32 encrypt) {
static uchar buffer[48], hash[20];
/*
Steps:
1) sha1_a = SHA1 (msg_key + substr (auth_key, 0, 32));
2) sha1_b = SHA1 (substr (auth_key, 32, 16) + msg_key + substr (auth_key, 48, 16));
3) sha1_с = SHA1 (substr (auth_key, 64, 32) + msg_key);
4) sha1_d = SHA1 (msg_key + substr (auth_key, 96, 32));
5) aes_key = substr (sha1_a, 0, 8) + substr (sha1_b, 8, 12) + substr (sha1_c, 4, 12);
6) aes_iv = substr (sha1_a, 8, 12) + substr (sha1_b, 0, 8) + substr (sha1_c, 16, 4) + substr (sha1_d, 0, 8);
*/
memcpy (buffer, msgKey, 16);
memcpy (buffer + 16, authKey, 32);
SHA1 (buffer, 48, hash);
memcpy (aes_key_raw, hash, 8);
memcpy (aes_iv, hash + 8, 12);
memcpy (buffer, authKey + 32, 16);
memcpy (buffer + 16, msgKey, 16);
memcpy (buffer + 32, authKey + 48, 16);
SHA1 (buffer, 48, hash);
memcpy (aes_key_raw + 8, hash + 8, 12);
memcpy (aes_iv + 12, hash, 8);
memcpy (buffer, authKey + 64, 32);
memcpy (buffer + 32, msgKey, 16);
SHA1 (buffer, 48, hash);
memcpy (aes_key_raw + 20, hash + 4, 12);
memcpy (aes_iv + 20, hash + 16, 4);
memcpy (buffer, msgKey, 16);
memcpy (buffer + 16, authKey + 96, 32);
SHA1 (buffer, 48, hash);
memcpy (aes_iv + 24, hash, 8);
if (encrypt == AES_ENCRYPT) {
AES_set_encrypt_key (aes_key_raw, 32*8, &aes_key);
} else {
AES_set_decrypt_key (aes_key_raw, 32*8, &aes_key);
}
Utils::secureZeroMemory (aes_key_raw, 0, sizeof (aes_key_raw));
}
/**
* Decrypt a password that is stored inthe MaxScale configuration file.
* If the password is not encrypted, ie is not a HEX string, then the
* original is returned, this allows for backward compatibility with
* unencrypted password.
*
* Note the return is always a malloc'd string that the caller must free
*
* @param crypt The encrypted password
* @return The decrypted password
*/
char *
decryptPassword(char *crypt)
{
MAXKEYS *keys;
AES_KEY aeskey;
unsigned char *plain;
char *ptr;
unsigned char encrypted[80];
int enlen;
keys = secrets_readKeys(NULL);
if (!keys)
return strdup(crypt);
/*
** If the input is not a HEX string return the input
** it probably was not encrypted
*/
for (ptr = crypt; *ptr; ptr++)
{
if (!isxdigit(*ptr))
{
free(keys);
return strdup(crypt);
}
}
enlen = strlen(crypt) / 2;
gw_hex2bin(encrypted, crypt, strlen(crypt));
if ((plain = (unsigned char *)malloc(80)) == NULL)
{
free(keys);
return NULL;
}
AES_set_decrypt_key(keys->enckey, 8 * MAXSCALE_KEYLEN, &aeskey);
AES_cbc_encrypt(encrypted, plain, enlen, &aeskey, keys->initvector, AES_DECRYPT);
free(keys);
return (char *)plain;
}
int my_aes_decrypt(char* key, char *in, int inlen, char* out)
{
if(!in || !key || !out) return 0;
AES_KEY aes;
if(AES_set_decrypt_key((unsigned char*)key, 128, &aes) < 0)
{
return 0;
}
// int len=strlen(in), en_len=0;
int en_len = 0;
while(en_len<inlen)
{
AES_decrypt((unsigned char*)in, (unsigned char*)out, &aes);
in+=AES_BLOCK_SIZE;
printf("AES_BLOCK_SIZE:%d\n", AES_BLOCK_SIZE);
out+=AES_BLOCK_SIZE;
en_len+=AES_BLOCK_SIZE;
}
return 1;
}
static int aes_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc)
{
int ret;
if ((ctx->cipher->flags & EVP_CIPH_MODE) == EVP_CIPH_CFB_MODE
|| (ctx->cipher->flags & EVP_CIPH_MODE) == EVP_CIPH_OFB_MODE
|| enc)
ret=AES_set_encrypt_key(key, ctx->key_len * 8, ctx->cipher_data);
else
ret=AES_set_decrypt_key(key, ctx->key_len * 8, ctx->cipher_data);
if(ret < 0)
{
EVPerr(EVP_F_AES_INIT_KEY,EVP_R_AES_KEY_SETUP_FAILED);
return 0;
}
return 1;
}
void CryptoUtils::initAESUnAuth (const char serverNonce[16], const char hiddenClientNonce[32], qint32 encrypt) {
static uchar buffer[64], hash[20];
memcpy (buffer, hiddenClientNonce, 32);
memcpy (buffer + 32, serverNonce, 16);
SHA1 (buffer, 48, aes_key_raw);
memcpy (buffer + 32, hiddenClientNonce, 32);
SHA1 (buffer, 64, aes_iv + 8);
memcpy (buffer, serverNonce, 16);
memcpy (buffer + 16, hiddenClientNonce, 32);
SHA1 (buffer, 48, hash);
memcpy (aes_key_raw + 20, hash, 12);
memcpy (aes_iv, hash + 12, 8);
memcpy (aes_iv + 28, hiddenClientNonce, 4);
if (encrypt == AES_ENCRYPT) {
AES_set_encrypt_key (aes_key_raw, 32*8, &aes_key);
} else {
AES_set_decrypt_key (aes_key_raw, 32*8, &aes_key);
}
Utils::secureZeroMemory (aes_key_raw, 0, sizeof (aes_key_raw));
}
