/*

Legal Notice: Some portions of the source code contained in this file were

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

code distribution packages. */

#include "Tcdefs.h"

#include <memory.h>

#include <stdlib.h>

#include "Rmd160.h"

#ifndef TC_WINDOWS_BOOT

#include "Sha2.h"

char* k = hmac->k;

char* u = hmac->u;

uint32 c;

#ifdef TC_WINDOWS_BOOT

/* In bootloader mode, least significant bit of iterations is a boolean (TRUE for boot derivation mode, FALSE otherwise)

/* iteration 1 */

memcpy (k, salt, salt_len); /* salt */

/* big-endian block number */

memset (&k[salt_len], 0, 3);

k[salt_len + 3] = (char) b;

void derive_key_sha256 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen)

hmac_sha256_ctx hmac;

sha256_ctx* ctx;

char* buf = hmac.k;

char *k, /* secret key */

int lk, /* length of the key in bytes */

char *d, /* data and also output buffer of at least 64 bytes */

)

{

hmac_sha512_ctx hmac;

/* If the key is longer than the hash algorithm block size,

let key = ripemd160(key), as per HMAC specifications. */

{

RMD160_CTX tctx;

keylen = RIPEMD160_DIGESTSIZE;

burn (&tctx, sizeof(tctx)); // Prevent leaks

/* perform inner RIPEMD-160 */

ctx = &(hmac.inner_digest_ctx);

/* start out by storing key in pads */

memset(k_pad, 0x36, 64);

/* XOR key with ipad and opad values */

{

k_pad[i] ^= key[i];

}

/* perform outer RIPEMD-160 */

ctx = &(hmac.outer_digest_ctx);

memset(k_pad, 0x5c, 64);

{

k_pad[i] ^= key[i];

}

/* iteration 1 */

memcpy (k, salt, salt_len); /* salt */

/* big-endian block number */

memset (&k[salt_len], 0, 3);

k[salt_len + 3] = (char) b;

}

void derive_key_ripemd160 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen)

int b, l, r;

hmac_ripemd160_ctx hmac;

RMD160_CTX* ctx;

unsigned char tk[RIPEMD160_DIGESTSIZE];

/* If the password is longer than the hash algorithm block size,

let password = ripemd160(password), as per HMAC specifications. */

{

RMD160_CTX tctx;

/* start out by storing key in pads */

memset(k_pad, 0x36, 64);

/* XOR key with ipad and opad values */

{

k_pad[b] ^= pwd[b];

}

/* perform outer RIPEMD-160 */

ctx = &(hmac.outer_digest_ctx);

memset(k_pad, 0x5c, 64);

{

k_pad[b] ^= pwd[b];

}

/* iteration 1 */

memcpy (k, salt, salt_len); /* salt */

/* big-endian block number */

k[salt_len + 3] = (char) b;

hmac_whirlpool_internal (pwd, pwd_len, k, salt_len + 4, hmac);

{

switch (pkcs5_prf_id)

{

return L"HMAC-SHA-512";

return L"HMAC-SHA-256";

return L"HMAC-RIPEMD-160";

return L"HMAC-Whirlpool";

case STREEBOG:

return L"HMAC-STREEBOG";

return L"(Unknown)";

}

}

switch (pkcs5_prf_id)

{

if (truecryptMode)

return bBoot ? 1000 : 2000;

else if (pim == 0)

return bBoot? pim * 2048 : 15000 + pim * 1000;

}

return truecryptMode? 1000 : ((pim == 0)? 500000 : 15000 + pim * 1000);

return truecryptMode? 1000 : ((pim == 0)? 500000 : 15000 + pim * 1000);

case SHA256:

return bBoot? pim * 2048 : 15000 + pim * 1000;

}

if (truecryptMode)

return 1000;

else if (pim == 0)

return bBoot? pim * 2048 : 15000 + pim * 1000;

}

TC_THROW_FATAL_EXCEPTION; // Unknown/wrong ID

}

return 0;