void put_cycle(t_struck *s)
{
char *tmp;
mlx_string_put(M, s->img.menu, 10, 20, black(900), "Cycle =");
tmp = ft_itoa(s->cycle);
mlx_string_put(M, s->img.menu, 270, 20, E(699), tmp);
free(tmp);
mlx_string_put(M, s->img.menu, 50, 40, black(900), "Cycles/turn");
mlx_string_put(M, s->img.menu, 170, 40, black(900), "=");
tmp = ft_itoa(s->turn);
mlx_string_put(M, s->img.menu, 280, 40, burn(999), tmp);
free(tmp);
mlx_string_put(M, s->img.menu, 10, 80, black(900), "Processes =");
tmp = ft_itoa(s->nb_proc);
mlx_string_put(M, s->img.menu, 270, 80, E(699), tmp);
mlx_string_put(M, s->img.menu, 20, 740, black(900), "Cycles_to_die");
mlx_string_put(M, s->img.menu, 170, 740, black(900), "=");
free(tmp);
tmp = ft_itoa(s->img.cycle_to_die);
mlx_string_put(M, s->img.menu, 280, 740, burn(999), tmp);
free(tmp);
mlx_string_put(M, s->img.menu, 20, 760, black(900), "Check =");
tmp = ft_itoa(s->img.check);
mlx_string_put(M, s->img.menu, 280, 760,
(s->img.check < 9) ? burn(999) : burn(200), tmp);
free(tmp);
}
int crypto_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *h, size_t hlen,
const unsigned char *c, size_t clen,
const unsigned char *nonce,
const unsigned char *key
)
{
int result = -1;
unsigned char tag[BYTES(MRS_T)];
mrs_state_t state;
if (clen < BYTES(MRS_T)) { return -1; }
/* decryption phase */
mrs_init(state, key, c + clen - BYTES(MRS_T), WORDS(MRS_T), ENC_TAG); /* initialise with key and authentication tag */
mrs_decrypt_data(state, m, c, clen - BYTES(MRS_T));
*mlen = clen - BYTES(MRS_T);
/* absorption phase */
mrs_init(state, key, nonce, WORDS(MRS_N), ABS_TAG);
mrs_absorb_data(state, h, hlen);
mrs_absorb_data(state, m, *mlen);
mrs_finalise(state, hlen, *mlen, tag);
/* verification phase */
result = mrs_verify_tag(c + clen - BYTES(MRS_T), tag);
/* burn decrypted plaintext on authentication failure */
if(result != 0) { burn(m, 0, *mlen); }
burn(state, 0, sizeof(mrs_state_t));
return result;
}
void derive_u_whirlpool (char *pwd, int pwd_len, char *salt, int salt_len, int iterations, char *u, int b)
{
char j[WHIRLPOOL_DIGESTSIZE], k[WHIRLPOOL_DIGESTSIZE];
char init[128];
char counter[4];
int c, i;
/* iteration 1 */
memset (counter, 0, 4);
counter[3] = (char) b;
memcpy (init, salt, salt_len); /* salt */
memcpy (&init[salt_len], counter, 4); /* big-endian block number */
hmac_whirlpool (pwd, pwd_len, init, salt_len + 4, j, WHIRLPOOL_DIGESTSIZE);
memcpy (u, j, WHIRLPOOL_DIGESTSIZE);
/* remaining iterations */
for (c = 1; c < iterations; c++)
{
hmac_whirlpool (pwd, pwd_len, j, WHIRLPOOL_DIGESTSIZE, k, WHIRLPOOL_DIGESTSIZE);
for (i = 0; i < WHIRLPOOL_DIGESTSIZE; i++)
{
u[i] ^= k[i];
j[i] = k[i];
}
}
/* Prevent possible leaks. */
burn (j, sizeof(j));
burn (k, sizeof(k));
}
void hmac_whirlpool
(
char *k, /* secret key */
int lk, /* length of the key in bytes */
char *d, /* input data. d pointer is guaranteed to be at least 32-bytes long */
int ld /* length of data in bytes */
)
{
hmac_whirlpool_ctx hmac;
char key[WHIRLPOOL_DIGESTSIZE];
/* If the key is longer than the hash algorithm block size,
let key = whirlpool(key), as per HMAC specifications. */
if (lk > WHIRLPOOL_BLOCKSIZE)
{
WHIRLPOOL_CTX tctx;
WHIRLPOOL_init (&tctx);
WHIRLPOOL_add ((unsigned char *) k, lk * 8, &tctx);
WHIRLPOOL_finalize (&tctx, (unsigned char *) key);
k = key;
lk = WHIRLPOOL_DIGESTSIZE;
burn (&tctx, sizeof(tctx)); // Prevent leaks
}
hmac_whirlpool_internal(k, lk, d, ld, &hmac);
/* Prevent leaks */
burn(&hmac, sizeof(hmac));
}
void clean_cmd_line()
{
wchar_t *cmd_w = GetCommandLineW();
char *cmd_a = GetCommandLineA();
burn(cmd_w, wcslen(cmd_w) * sizeof(wchar_t));
burn(cmd_a, strlen(cmd_a) * sizeof(char));
}
void hmac_sha256
(
char *k, /* secret key */
int lk, /* length of the key in bytes */
char *d, /* data */
int ld /* length of data in bytes */
)
{
hmac_sha256_ctx hmac;
char key[SHA256_DIGESTSIZE];
/* If the key is longer than the hash algorithm block size,
let key = sha256(key), as per HMAC specifications. */
if (lk > SHA256_BLOCKSIZE)
{
sha256_ctx tctx;
sha256_begin (&tctx);
sha256_hash ((unsigned char *) k, lk, &tctx);
sha256_end ((unsigned char *) key, &tctx);
k = key;
lk = SHA256_DIGESTSIZE;
burn (&tctx, sizeof(tctx)); // Prevent leaks
}
hmac_sha256_internal(k, lk, d, ld, &hmac);
/* Prevent leaks */
burn(&hmac, sizeof(hmac));
burn(key, sizeof(key));
}
int blake2b_final(blake2b_state *S, void *out, size_t outlen) {
uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
unsigned int i;
/* Sanity checks */
if (S == NULL || out == NULL || outlen < S->outlen) {
return -1;
}
/* Is this a reused state? */
if (S->f[0] != 0) {
return -1;
}
blake2b_increment_counter(S, S->buflen);
blake2b_set_lastblock(S);
memset(&S->buf[S->buflen], 0, BLAKE2B_BLOCKBYTES - S->buflen); /* Padding */
blake2b_compress(S, S->buf);
for (i = 0; i < 8; ++i) { /* Output full hash to temp buffer */
store64(buffer + sizeof(S->h[i]) * i, S->h[i]);
}
memcpy(out, buffer, S->outlen);
burn(buffer, sizeof(buffer));
burn(S->buf, sizeof(S->buf));
burn(S->h, sizeof(S->h));
return 0;
}
static void kbdint_free(struct ssh_kbdint *kbd){
int i,n=kbd->nprompts;
if(kbd->name)
free(kbd->name);
if(kbd->instruction)
free(kbd->instruction);
if(kbd->prompts){
for(i=0;i<n;++i){
burn(kbd->prompts[i]);
free(kbd->prompts[i]);
}
free(kbd->prompts);
}
if(kbd->answers){
for(i=0;i<n;++i){
burn(kbd->answers[i]);
free(kbd->answers[i]);
}
free(kbd->answers);
}
if(kbd->echo){
free(kbd->echo);
}
free(kbd);
}
void WipeCache ()
{
burn (CachedPasswords, sizeof (CachedPasswords));
burn (CachedPim, sizeof (CachedPim));
nPasswordIdx = 0;
cacheEmpty = 1;
}
int norx_aead_decrypt(
unsigned char *p, size_t *plen,
const unsigned char *h, size_t hlen,
const unsigned char *c, size_t clen,
const unsigned char *t, size_t tlen,
const unsigned char *nonce,
const unsigned char *key
)
{
unsigned char tag[BYTES(NORX_A)];
norx_state_t state;
int result = -1;
if (clen < BYTES(NORX_A))
return -1;
#if defined(DEBUG)
printf("DECRYPTION\n");
#endif
norx_init(state, key, nonce);
norx_process_header(state, h, hlen);
norx_decrypt_msg(state, p, c, clen - BYTES(NORX_A));
norx_process_trailer(state, t, tlen);
norx_output_tag(state, tag);
*plen = clen - BYTES(NORX_A);
result = norx_verify_tag(c + clen - BYTES(NORX_A), tag);
if(result != 0) /* burn decrypted plaintext on auth failure */
burn(p, 0, clen - BYTES(NORX_A));
burn(state, 0, sizeof(norx_state_t));
return result;
}
static void kbdint_clean(struct ssh_kbdint *kbd){
int i,n=kbd->nprompts;
if(kbd->name){
free(kbd->name);
kbd->name=NULL;
}
if(kbd->instruction){
free(kbd->instruction);
kbd->instruction=NULL;
}
if(kbd->prompts){
for(i=0;i<n;++i){
burn(kbd->prompts[i]);
free(kbd->prompts[i]);
}
free(kbd->prompts);
kbd->prompts=NULL;
}
if(kbd->answers){
for(i=0;i<n;++i){
burn(kbd->answers[i]);
free(kbd->answers[i]);
}
free(kbd->answers);
kbd->answers=NULL;
}
if(kbd->echo){
free(kbd->echo);
kbd->echo=NULL;
}
kbd->nprompts=0;
}
int norx_aead_decrypt(
unsigned char *m, size_t *mlen,
const unsigned char *a, size_t alen,
const unsigned char *c, size_t clen,
const unsigned char *z, size_t zlen,
const unsigned char *nonce,
const unsigned char *key
)
{
int result = -1;
unsigned char tag[BYTES(NORX_T)];
norx_state_t state;
if (clen < BYTES(NORX_T)) {
return -1;
}
norx_init(state, key, nonce);
norx_absorb_data(state, a, alen, HEADER_TAG);
norx_decrypt_data(state, m, c, clen - BYTES(NORX_T));
norx_absorb_data(state, z, zlen, TRAILER_TAG);
norx_finalise(state, tag);
*mlen = clen - BYTES(NORX_T);
result = norx_verify_tag(c + clen - BYTES(NORX_T), tag);
if (result != 0) { /* burn decrypted plaintext on auth failure */
burn(m, 0, clen - BYTES(NORX_T));
}
burn(state, 0, sizeof(norx_state_t));
return result;
}
void hmac_ripemd160 (char *key, int keylen, char *input_digest, int len)
{
hmac_ripemd160_ctx hmac;
unsigned char tk[RIPEMD160_DIGESTSIZE];
/* If the key is longer than the hash algorithm block size,
let key = ripemd160(key), as per HMAC specifications. */
if (keylen > RIPEMD160_BLOCKSIZE)
{
RMD160_CTX tctx;
RMD160Init(&tctx);
RMD160Update(&tctx, (const unsigned char *) key, keylen);
RMD160Final(tk, &tctx);
key = (char *) tk;
keylen = RIPEMD160_DIGESTSIZE;
burn (&tctx, sizeof(tctx)); // Prevent leaks
}
hmac_ripemd160_internal (key, keylen, input_digest, len, &hmac);
burn (&hmac, sizeof(hmac));
burn (tk, sizeof(tk));
}
void burn(struct tree * tree) {
if (tree == NULL) { return; }
burn(tree->dot);
burn(tree->dash);
free(tree);
}
void norx_decrypt_data(norx_state_t state, unsigned char *out, const unsigned char * in, size_t inlen)
{
if (inlen > 0)
{
size_t lane = 0;
norx_state_t sum;
norx_state_t state2;
memset(sum, 0, sizeof(norx_state_t));
while (inlen >= BYTES(NORX_R))
{
/* branch */
memcpy(state2, state, sizeof(norx_state_t));
norx_branch(state2, lane++);
/* decrypt */
norx_decrypt_block(state2, out, in);
#if defined(NORX_DEBUG)
printf("Decrypt block (lane: %lu)\n", lane - 1);
norx_debug(state2, in, BYTES(NORX_R), out, BYTES(NORX_R));
#endif
/* merge */
norx_merge(sum, state2);
inlen -= BYTES(NORX_R);
in += BYTES(NORX_R);
out += BYTES(NORX_R);
}
/* last block, 0 <= inlen < BYTES(NORX_R) */
/* branch */
memcpy(state2, state, sizeof(norx_state_t));
norx_branch(state2, lane++);
/* decrypt */
norx_decrypt_lastblock(state2, out, in, inlen);
#if defined(NORX_DEBUG)
printf("Decrypt lastblock (lane: %lu)\n", lane - 1);
norx_debug(state2, in, inlen, out, inlen);
#endif
/* merge */
norx_merge(sum, state2);
memcpy(state, sum, sizeof(norx_state_t));
burn(state2, 0, sizeof(norx_state_t));
burn(sum, 0, sizeof(norx_state_t));
#if defined(NORX_DEBUG)
printf("Decryption finalised\n");
norx_debug(state, NULL, 0, NULL, 0);
#endif
}
}
void derive_key_sha256 (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen)
{
hmac_sha256_ctx hmac;
int b, l, r;
#ifndef TC_WINDOWS_BOOT
char key[SHA256_DIGESTSIZE];
/* If the password is longer than the hash algorithm block size,
let pwd = sha256(pwd), as per HMAC specifications. */
if (pwd_len > SHA256_BLOCKSIZE)
{
sha256_ctx tctx;
sha256_begin (&tctx);
sha256_hash ((unsigned char *) pwd, pwd_len, &tctx);
sha256_end ((unsigned char *) key, &tctx);
pwd = key;
pwd_len = SHA256_DIGESTSIZE;
burn (&tctx, sizeof(tctx)); // Prevent leaks
}
#endif
if (dklen % SHA256_DIGESTSIZE)
{
l = 1 + dklen / SHA256_DIGESTSIZE;
}
else
{
l = dklen / SHA256_DIGESTSIZE;
}
r = dklen - (l - 1) * SHA256_DIGESTSIZE;
/* first l - 1 blocks */
for (b = 1; b < l; b++)
{
derive_u_sha256 (pwd, pwd_len, salt, salt_len, iterations, b, &hmac);
memcpy (dk, hmac.u, SHA256_DIGESTSIZE);
dk += SHA256_DIGESTSIZE;
}
/* last block */
derive_u_sha256 (pwd, pwd_len, salt, salt_len, iterations, b, &hmac);
memcpy (dk, hmac.u, r);
/* Prevent possible leaks. */
burn (&hmac, sizeof(hmac));
#ifndef TC_WINDOWS_BOOT
burn (key, sizeof(key));
#endif
}
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;
#ifndef TC_WINDOWS_BOOT
unsigned char tk[RIPEMD160_DIGESTSIZE];
/* If the password is longer than the hash algorithm block size,
let password = ripemd160(password), as per HMAC specifications. */
if (pwd_len > RIPEMD160_BLOCKSIZE)
{
RMD160_CTX tctx;
RMD160Init(&tctx);
RMD160Update(&tctx, (const unsigned char *) pwd, pwd_len);
RMD160Final(tk, &tctx);
pwd = (char *) tk;
pwd_len = RIPEMD160_DIGESTSIZE;
burn (&tctx, sizeof(tctx)); // Prevent leaks
}
#endif
if (dklen % RIPEMD160_DIGESTSIZE)
{
l = 1 + dklen / RIPEMD160_DIGESTSIZE;
}
else
{
l = dklen / RIPEMD160_DIGESTSIZE;
}
r = dklen - (l - 1) * RIPEMD160_DIGESTSIZE;
/* first l - 1 blocks */
for (b = 1; b < l; b++)
{
derive_u_ripemd160 (pwd, pwd_len, salt, salt_len, iterations, b, &hmac);
memcpy (dk, hmac.u, RIPEMD160_DIGESTSIZE);
dk += RIPEMD160_DIGESTSIZE;
}
/* last block */
derive_u_ripemd160 (pwd, pwd_len, salt, salt_len, iterations, b, &hmac);
memcpy (dk, hmac.u, r);
/* Prevent possible leaks. */
burn (&hmac, sizeof(hmac));
#ifndef TC_WINDOWS_BOOT
burn (tk, sizeof(tk));
#endif
}
void derive_key_whirlpool (char *pwd, int pwd_len, char *salt, int salt_len, uint32 iterations, char *dk, int dklen)
{
hmac_whirlpool_ctx hmac;
char key[WHIRLPOOL_DIGESTSIZE];
int b, l, r;
/* If the password is longer than the hash algorithm block size,
let pwd = whirlpool(pwd), as per HMAC specifications. */
if (pwd_len > WHIRLPOOL_BLOCKSIZE)
{
WHIRLPOOL_CTX tctx;
WHIRLPOOL_init (&tctx);
WHIRLPOOL_add ((unsigned char *) pwd, pwd_len * 8, &tctx);
WHIRLPOOL_finalize (&tctx, (unsigned char *) key);
pwd = key;
pwd_len = WHIRLPOOL_DIGESTSIZE;
burn (&tctx, sizeof(tctx)); // Prevent leaks
}
if (dklen % WHIRLPOOL_DIGESTSIZE)
{
l = 1 + dklen / WHIRLPOOL_DIGESTSIZE;
}
else
{
l = dklen / WHIRLPOOL_DIGESTSIZE;
}
r = dklen - (l - 1) * WHIRLPOOL_DIGESTSIZE;
/* first l - 1 blocks */
for (b = 1; b < l; b++)
{
derive_u_whirlpool (pwd, pwd_len, salt, salt_len, iterations, b, &hmac);
memcpy (dk, hmac.u, WHIRLPOOL_DIGESTSIZE);
dk += WHIRLPOOL_DIGESTSIZE;
}
/* last block */
derive_u_whirlpool (pwd, pwd_len, salt, salt_len, iterations, b, &hmac);
memcpy (dk, hmac.u, r);
/* Prevent possible leaks. */
burn (&hmac, sizeof(hmac));
burn (key, sizeof(key));
}
void norx_output_tag(norx_state_t state, unsigned char * tag)
{
norx_word_t * S = state->S;
uint8_t lastblock[BYTES(RATE)];
size_t i;
norx_finalize(state);
for (i = 0; i < WORDS(RATE); ++i)
STORE(lastblock + i * BYTES(NORX_W), S[i]);
memcpy(tag, lastblock, BYTES(NORX_A));
burn(lastblock, 0, BYTES(RATE)); /* burn full state dump */
burn(state, 0, sizeof(norx_state_t)); /* at this point we can also burn the state */
}
static NORX_INLINE void norx_decrypt_lastblock(norx_state_t state, uint8_t *out, const uint8_t * in, size_t inlen)
{
norx_word_t * S = state->S;
uint8_t lastblock[BYTES(NORX_R)];
size_t i;
S[15] ^= PAYLOAD_TAG;
norx_permute(state);
for(i = 0; i < WORDS(NORX_R); ++i) {
STORE(lastblock + i * BYTES(NORX_W), S[i]);
}
memcpy(lastblock, in, inlen);
lastblock[inlen] ^= 0x01;
lastblock[BYTES(NORX_R) - 1] ^= 0x80;
for (i = 0; i < WORDS(NORX_R); ++i) {
const norx_word_t c = LOAD(lastblock + i * BYTES(NORX_W));
STORE(lastblock + i * BYTES(NORX_W), S[i] ^ c);
S[i] = c;
}
memcpy(out, lastblock, inlen);
burn(lastblock, 0, sizeof lastblock);
}
void mrs_finalise(mrs_state_t state, size_t hlen, size_t mlen, unsigned char * tag)
{
mrs_word_t * S = state->S;
uint8_t lastblock[BYTES(MRS_R)];
size_t i;
/* finalise state */
mrs_permute(state);
S[0] ^= hlen;
S[1] ^= mlen;
mrs_permute(state);
/* extract tag */
for (i = 0; i < WORDS(MRS_R); ++i)
{
STORE(lastblock + i * BYTES(MRS_W), S[i]);
}
memcpy(tag, lastblock, BYTES(MRS_T));
#if defined(MRS_DEBUG)
printf("FINALISED:\n");
print_state(state->S);
#endif
burn(lastblock, 0, BYTES(MRS_R));
}
static MRS_INLINE void mrs_decrypt_lastblock(mrs_state_t state, unsigned char * out, const unsigned char * in, size_t inlen)
{
size_t i;
mrs_word_t * S = state->S;
uint8_t lastblock[BYTES(MRS_R)];
mrs_permute(state);
for(i = 0; i < WORDS(MRS_R); ++i)
{
STORE(lastblock + i * BYTES(MRS_W), S[i]);
}
/* undo padding */
memcpy(lastblock, in, inlen);
/*lastblock[inlen] ^= 0x01;
lastblock[BYTES(MRS_R) - 1] ^= 0x80;*/
for (i = 0; i < WORDS(MRS_R); ++i)
{
const mrs_word_t c = LOAD(lastblock + i * BYTES(MRS_W));
STORE(lastblock + i * BYTES(MRS_W), S[i] ^ c);
S[i] = c;
}
memcpy(out, lastblock, inlen);
#if defined(MRS_DEBUG)
printf("DECRYPTING LASTBLOCK:\n");
print_bytes(lastblock, BYTES(MRS_R));
printf("STATE:\n");
print_state(state->S);
#endif
burn(lastblock, 0, sizeof lastblock);
}
void mrs_absorb_lastblock(mrs_state_t state, const unsigned char * in, size_t inlen)
{
uint8_t lastblock[BYTES(MRS_B)];
mrs_pad(lastblock, sizeof lastblock, in, inlen);
mrs_absorb_block(state, lastblock);
burn(lastblock, 0, BYTES(MRS_B));
}
/* copy file f to file g, for longcount bytes */
int copyfile(FILE * f, FILE * g, word32 longcount)
{
int count, status = 0;
do { /* read and write the whole file... */
if (longcount < (word32) DISKBUFSIZE)
count = (int) longcount;
else
count = DISKBUFSIZE;
count = fread(textbuf, 1, count, f);
if (count > 0) {
if (CONVERSION != NO_CONV) {
int i;
for (i = 0; i < count; i++)
textbuf[i] = (CONVERSION == EXT_CONV) ?
EXT_C(textbuf[i]) :
INT_C(textbuf[i]);
}
if (fwrite(textbuf, 1, count, g) != count) {
/* Problem: return error value */
status = -1;
break;
}
longcount -= count;
#ifdef MACTC5
mac_poll_for_break();
#endif
}
/* if text block was short, exit loop */
} while (count == DISKBUFSIZE);
burn(textbuf); /* burn sensitive data on stack */
return status;
} /* copyfile */
static VC_INLINE void ChaCha20RngReKey (ChaCha20RngCtx* pCtx, int useCallBack)
{
/* fill rs_buf with the keystream */
if (pCtx->m_rs_have)
memset(pCtx->m_rs_buf + sizeof(pCtx->m_rs_buf) - pCtx->m_rs_have, 0, pCtx->m_rs_have);
ChaCha256Encrypt(&pCtx->m_chachaCtx, pCtx->m_rs_buf, sizeof (pCtx->m_rs_buf),
pCtx->m_rs_buf);
/* mix in optional user provided data */
if (pCtx->m_getRandSeedCallback && useCallBack) {
unsigned char dat[CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ];
size_t i;
pCtx->m_getRandSeedCallback (dat, sizeof (dat));
for (i = 0; i < (CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ); i++)
pCtx->m_rs_buf[i] ^= dat[i];
burn (dat, sizeof(dat));
}
/* immediately reinit for backtracking resistance */
ChaCha256Init (&pCtx->m_chachaCtx, pCtx->m_rs_buf, pCtx->m_rs_buf + CHACHA20RNG_KEYSZ, 20);
memset(pCtx->m_rs_buf, 0, CHACHA20RNG_KEYSZ + CHACHA20RNG_IVSZ);
pCtx->m_rs_have = sizeof (pCtx->m_rs_buf) - CHACHA20RNG_KEYSZ - CHACHA20RNG_IVSZ;
}
int
rsa_private_encrypt(unitptr outbuf, byteptr inbuf, short bytes,
unitptr E, unitptr D, unitptr P, unitptr Q, unitptr U, unitptr N)
/* Encrypt a message digest with a private key.
* Returns <0 on error:
* -1: generic error
* -4: Key too big
* -5: Key too small
*/
{
unit temp[MAX_UNIT_PRECISION];
unit DP[MAX_UNIT_PRECISION], DQ[MAX_UNIT_PRECISION];
byte *p;
int i;
unsigned int blocksize;
/* PGP doesn't store these coefficents, so we need to compute them. */
mp_move(temp,P);
mp_dec(temp);
mp_mod(DP,D,temp);
mp_move(temp,Q);
mp_dec(temp);
mp_mod(DQ,D,temp);
p = (byte *)temp;
/* We are building the mpi in place, except for a possible
* byte-order swap to little-endian at the end. Thus, we
* need to fill the buffer with leading 0's in the unused
* most significant byte positions.
*/
blocksize = countbytes(N) - 1; /* Space available for data */
for (i = units2bytes(global_precision) - blocksize; i > 0; --i)
*p++ = 0;
i = blocksize - 2 - bytes; /* Padding needed */
i -= sizeof(asn_array); /* Space for type encoding */
if (i < 0) {
i = -4; /* Error code */
goto Cleanup;
}
*p++ = MD_ENCRYPTED_BYTE; /* Type byte */
memset(p, ~0, i); /* All 1's padding */
p += i;
*p++ = 0; /* Zero framing byte */
memcpy(p, asn_array, sizeof(asn_array)); /* ASN data */
p += sizeof(asn_array);
memcpy(p, inbuf, bytes); /* User data */
mp_convert_order((byte *)temp);
i = mp_modexp_crt(outbuf, temp, P, Q, DP, DQ, U); /* Encrypt */
if (i < 0)
i = -1;
Cleanup:
burn(temp);
return i;
} /* rsa_private_encrypt */
void dc_clean_pass_cache()
{
dsk_pass *d_pass;
dsk_pass *c_pass;
int loirql;
if (loirql = (KeGetCurrentIrql() == PASSIVE_LEVEL)) {
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite(&p_resource, TRUE);
}
for (d_pass = f_pass; d_pass;)
{
c_pass = d_pass;
d_pass = d_pass->next;
/* zero password data */
burn(c_pass, sizeof(dsk_pass));
/* free memory if possible */
if (loirql != 0) mm_secure_free(c_pass);
}
f_pass = NULL;
if (loirql != 0) {
ExReleaseResourceLite(&p_resource);
KeLeaveCriticalRegion();
}
}
/**
* 473
*/
int main(int argc, char * argv[]) {
int test, i, j, k;
char c;
for (scanf("%d", &test); test > 0; test--) {
scanf("%d %d %d", &songsSize, &diskLen, &disksSize);
for (i = 1; i <= songsSize; i++) {
scanf("%d%c", &songs[i], &c);
}
for (i = 0; i <= songsSize; i++) {
for (j = 0; j <= diskLen; j++) {
for (k = 0; k <= disksSize; k++) {
dp[i][j][k] = -1;
}
}
}
if (DEBUG)
printDP();
printf("%d\n", burn(1, 0, disksSize));
if (DEBUG)
printDP();
if (test > 1) {
printf("\n");
}
}
return 0;
}
void *orenbrot(void *d)
{
int l[3];
long double z[4];
long double tmp;
t_thread *m;
m = (t_thread*)d;
l[0] = m->lim[0] - 1;
while (++l[0] < m->lim[2] && (l[1] = m->lim[1] - 1))
while (++l[1] < m->lim[3] && (l[2] = -1))
{
z[2] = -0.7 + m->s->x / X;
z[3] = 0.27015 + m->s->y / Y;
z[0] = 1.5 * (l[0] - X / 2) / (0.5 * X) * m->s->z[0] + m->s->m[0];
z[1] = (l[1] - Y / 2) / (0.5 * Y) * m->s->z[0] + m->s->m[1];
while (++l[2] < m->s->imax && (z[0] * z[0] + z[1] * z[1]) < 4)
{
tmp = z[0];
z[0] = fabsl(z[0] * z[0]) - fabsl(z[1] * z[1]) + z[2];
z[1] = fabsl(2 * z[1] * tmp) - z[3];
}
(l[2] == m->s->imax) ? px_img(m->s, l[0], l[1],
black(fmod(fabsl(l[2] / z[0]), 999))) :
px_img(m->s, l[0], l[1], burn(fabsl(l[2] * z[1])));
}
return (NULL);
}
void blake2b_too(void *pout, const void *in)
{
uint8_t *out = (uint8_t *)pout;
uint8_t out_buffer[64];
uint8_t in_buffer[64];
blake2b_state blake_state;
blake2b_init(&blake_state, 64);
blake_state.buflen = blake_state.buf[1] = 4;
my_blake2b_update(&blake_state, in, 72);
blake2b_final(&blake_state, out_buffer, 64);
memcpy(out, out_buffer, 32);
out += 32;
register uint8_t i = 29;
while (i--) {
memcpy(in_buffer, out_buffer, 64);
blake2b(out_buffer, in_buffer, NULL, 0);
memcpy(out, out_buffer, 32);
out += 32;
}
memcpy(in_buffer, out_buffer, 64);
blake2b(out_buffer, in_buffer, NULL, 0);
memcpy(out, out_buffer, 64);
burn(&blake_state, sizeof(blake_state));
}
