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)); }