int main(int argc, char **argv)
{
int rc = 0;
prng_state prng;
int prng_index, hash_index;
rsa_key key;
int i;
ltc_mp = tfm_desc;
prng_index = register_prng(&sprng_desc); /* (fortuna_desc is a good choice if your platform's PRNG sucks.) */
if (prng_index == -1) {
fail("Failed to register a RNG");
}
hash_index = register_hash(&sha256_desc);
if (hash_index == -1) {
fail("Failed to register sha256 hasher");
}
if ((rc = rng_make_prng(128, prng_index, &prng, NULL)) != CRYPT_OK) {
fail("rng_make_prng failed: %s", error_to_string(rc));
}
read_rsakey(&key, "privatekey.bin");
for (i = 1; i < argc; i++) {
sign_file(argv[i], &key, &prng, prng_index, hash_index);
}
rsa_free(&key);
return 0;
}
int main(void)
{
register_cipher(&rijndael_enc_desc);
register_prng(&yarrow_desc);
register_hash(&sha256_desc);
return 0;
}
static int sqlcipher_ltc_activate(void *ctx) {
unsigned char random_buffer[FORTUNA_MAX_SZ];
#ifndef SQLCIPHER_LTC_NO_MUTEX_RAND
if(ltc_rand_mutex == NULL){
ltc_rand_mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
}
sqlite3_mutex_enter(ltc_rand_mutex);
#endif
sqlcipher_memset(random_buffer, 0, FORTUNA_MAX_SZ);
if(ltc_init == 0) {
if(register_prng(&fortuna_desc) < 0) return SQLITE_ERROR;
if(register_cipher(&rijndael_desc) < 0) return SQLITE_ERROR;
if(register_hash(&sha512_desc) < 0) return SQLITE_ERROR;
if(register_hash(&sha256_desc) < 0) return SQLITE_ERROR;
if(register_hash(&sha1_desc) < 0) return SQLITE_ERROR;
if(fortuna_start(&prng) != CRYPT_OK) {
return SQLITE_ERROR;
}
ltc_init = 1;
}
ltc_ref_count++;
#ifndef SQLCIPHER_TEST
sqlite3_randomness(FORTUNA_MAX_SZ, random_buffer);
#endif
#ifndef SQLCIPHER_LTC_NO_MUTEX_RAND
sqlite3_mutex_leave(ltc_rand_mutex);
#endif
if(sqlcipher_ltc_add_random(ctx, random_buffer, FORTUNA_MAX_SZ) != SQLITE_OK) {
return SQLITE_ERROR;
}
sqlcipher_memset(random_buffer, 0, FORTUNA_MAX_SZ);
return SQLITE_OK;
}
static int sqlcipher_ltc_activate(void *ctx) {
ltc_ctx *ltc = (ltc_ctx*)ctx;
int random_buffer_sz = 32;
unsigned char random_buffer[random_buffer_sz];
if(ltc_init == 0) {
if(register_prng(&fortuna_desc) != CRYPT_OK) return SQLITE_ERROR;
if(register_cipher(&rijndael_desc) != CRYPT_OK) return SQLITE_ERROR;
if(register_hash(&sha1_desc) != CRYPT_OK) return SQLITE_ERROR;
ltc_init = 1;
}
if(fortuna_start(&(ltc->prng)) != CRYPT_OK) {
return SQLITE_ERROR;
}
sqlite3_randomness(random_buffer_sz, &random_buffer);
if(sqlcipher_ltc_add_random(ctx, random_buffer, random_buffer_sz) != SQLITE_OK) {
return SQLITE_ERROR;
}
if(sqlcipher_ltc_add_random(ctx, <c, sizeof(ltc_ctx*)) != SQLITE_OK) {
return SQLITE_ERROR;
}
if(fortuna_ready(&(ltc->prng)) != CRYPT_OK) {
return SQLITE_ERROR;
}
return SQLITE_OK;
}
/* format is ltc_mp, cipher_desc, [cipher_desc], NULL, hash_desc, [hash_desc], NULL, prng_desc, [prng_desc], NULL */
int crypt_fsa(void *mp, ...)
{
va_list args;
void *p;
va_start(args, mp);
if (mp != NULL) {
XMEMCPY(<c_mp, mp, sizeof(ltc_mp));
}
while ((p = va_arg(args, void*)) != NULL) {
if (register_cipher(p) == -1) {
va_end(args);
return CRYPT_INVALID_CIPHER;
}
}
while ((p = va_arg(args, void*)) != NULL) {
if (register_hash(p) == -1) {
va_end(args);
return CRYPT_INVALID_HASH;
}
}
while ((p = va_arg(args, void*)) != NULL) {
if (register_prng(p) == -1) {
va_end(args);
return CRYPT_INVALID_PRNG;
}
}
va_end(args);
return CRYPT_OK;
}
CTomcryptInternals(void)
{
int ErrorCode = register_cipher(&rijndael_desc);
if (ErrorCode == -1)
{
throw ExInternalError(std::string("Cannot register AES cipher."));
}
ErrorCode = register_prng(&fortuna_desc);
if (ErrorCode == -1)
{
throw ExInternalError(std::string("Cannot register fortuna pseudo random generator."));
}
int const GeneratorID = find_prng("fortuna");
ErrorCode = rng_make_prng(128, GeneratorID, &mRandomGenerator, NULL);
if (ErrorCode != CRYPT_OK)
{
throw ExInternalError(std::string("Error while starting random generator: ")+std::string(error_to_string(ErrorCode)));
}
ErrorCode = register_hash(&sha256_desc);
if (ErrorCode == -1)
{
throw ExInternalError(std::string("Cannot register SHA2 hash."));
}
return;
}
/* format is ltc_mp, cipher_desc, [cipher_desc], NULL, hash_desc, [hash_desc], NULL, prng_desc, [prng_desc], NULL */
int crypt_fsa(void *mp, ...)
{
int err;
va_list args;
void *p;
va_start(args, mp);
if (mp != NULL) {
XMEMCPY(<c_mp, mp, sizeof(ltc_mp));
}
while ((p = va_arg(args, void*)) != NULL) {
if ((err = register_cipher(p)) != CRYPT_OK) {
va_end(args);
return err;
}
}
while ((p = va_arg(args, void*)) != NULL) {
if ((err = register_hash(p)) != CRYPT_OK) {
va_end(args);
return err;
}
}
while ((p = va_arg(args, void*)) != NULL) {
if ((err = register_prng(p)) != CRYPT_OK) {
va_end(args);
return err;
}
}
va_end(args);
return CRYPT_OK;
}
int initEncrypt(){
prng_index = register_prng(&fortuna_desc);
hash_index = register_hash(&sha256_desc);
int err;
if ((err = rng_make_prng(128, find_prng("fortuna"), &prng, NULL)) != CRYPT_OK) {
printf("Error setting up PRNG, %s\n", error_to_string(err));
exit(EXIT_FAILURE);
}
return 0;
}
void register_algs(void)
{
int x;
register_cipher (&rc6_desc);
register_cipher (&des3_desc);
if (register_hash(&sha256_desc) == -1) {
fprintf(stderr, "Error registering SHA256\n");
exit(-1);
}
if (register_prng(&yarrow_desc) == -1) {
fprintf(stderr, "Error registering yarrow PRNG\n");
exit(-1);
}
if (register_prng(&sprng_desc) == -1) {
fprintf(stderr, "Error registering sprng PRNG\n");
exit(-1);
}
}
void CryptHelpers::Init()
{
ltc_mp = ltm_desc;
g_PRNGDescId = register_prng( &yarrow_desc );
if ( g_PRNGDescId == -1 )
RageException::Throw( "Could not register PRNG Descriptor" );
g_PRNGDesc = &yarrow_desc;
rng_make_prng(1024, g_PRNGDescId, &g_PRNGState, NULL);
g_SHA1DescId = register_hash( &sha1_desc );
if ( g_SHA1DescId == -1 )
RageException::Throw( "Could not register SHA1 Descriptor" );
g_SHA1Desc = &sha1_desc;
}
int pkcs_1_pss_test(void)
{
struct ltc_prng_descriptor* no_prng_desc = no_prng_desc_get();
int prng_idx = register_prng(no_prng_desc);
int hash_idx = find_hash("sha1");
unsigned int i;
unsigned int j;
DO(prng_is_valid(prng_idx));
DO(hash_is_valid(hash_idx));
for (i = 0; i < sizeof(testcases_pss)/sizeof(testcases_pss[0]); ++i) {
testcase_t* t = &testcases_pss[i];
rsa_key k, *key = &k;
DOX(mp_init_multi(&key->e, &key->d, &key->N, &key->dQ,
&key->dP, &key->qP, &key->p, &key->q, NULL), t->name);
DOX(mp_read_unsigned_bin(key->e, t->rsa.e, t->rsa.e_l), t->name);
DOX(mp_read_unsigned_bin(key->d, t->rsa.d, t->rsa.d_l), t->name);
DOX(mp_read_unsigned_bin(key->N, t->rsa.n, t->rsa.n_l), t->name);
DOX(mp_read_unsigned_bin(key->dQ, t->rsa.dQ, t->rsa.dQ_l), t->name);
DOX(mp_read_unsigned_bin(key->dP, t->rsa.dP, t->rsa.dP_l), t->name);
DOX(mp_read_unsigned_bin(key->qP, t->rsa.qInv, t->rsa.qInv_l), t->name);
DOX(mp_read_unsigned_bin(key->q, t->rsa.q, t->rsa.q_l), t->name);
DOX(mp_read_unsigned_bin(key->p, t->rsa.p, t->rsa.p_l), t->name);
key->type = PK_PRIVATE;
for (j = 0; j < sizeof(t->data)/sizeof(t->data[0]); ++j) {
rsaData_t* s = &t->data[j];
unsigned char buf[20], obuf[256];
unsigned long buflen = sizeof(buf), obuflen = sizeof(obuf);
int stat;
prng_descriptor[prng_idx].add_entropy(s->o2, s->o2_l, (prng_state*)no_prng_desc);
DOX(hash_memory(hash_idx, s->o1, s->o1_l, buf, &buflen), s->name);
DOX(rsa_sign_hash(buf, buflen, obuf, &obuflen, (prng_state*)no_prng_desc, prng_idx, hash_idx, s->o2_l, key), s->name);
DOX(obuflen == (unsigned long)s->o3_l?CRYPT_OK:CRYPT_FAIL_TESTVECTOR, s->name);
DOX(memcmp(s->o3, obuf, s->o3_l)==0?CRYPT_OK:CRYPT_FAIL_TESTVECTOR, s->name);
DOX(rsa_verify_hash(obuf, obuflen, buf, buflen, hash_idx, s->o2_l, &stat, key), s->name);
DOX(stat == 1?CRYPT_OK:CRYPT_FAIL_TESTVECTOR, s->name);
} /* for */
mp_clear_multi(key->d, key->e, key->N, key->dQ, key->dP, key->qP, key->p, key->q, NULL);
} /* for */
unregister_prng(no_prng_desc);
no_prng_desc_free(no_prng_desc);
return 0;
}
int main(int argc, char** argv)
{
// Usage: rsa_make_key <private key file> <public key file>
const char* private_key = ARGV(1);
const char* public_key = ARGV(2);
ltc_mp = ltm_desc;
// Register PRNG algorithm.
const int prng_idx = register_prng(&sprng_desc);
if (prng_idx < 0) return error(CRYPT_INVALID_PRNG);
// Generate key.
rsa_key key;
const int bitsize = 2048;
int err = rsa_make_key(NULL, prng_idx, bitsize/8, 65537, &key);
if (err != CRYPT_OK) return error(err);
// Export private key.
unsigned char out[bitsize * 5 / 8]; // guesstimate
unsigned long outlen = sizeof(out);
err = rsa_export(out, &outlen, PK_PRIVATE, &key);
if (err != CRYPT_OK) return error(err, &key);
// Save private key.
FILE* f = fopen(private_key, "wb");
if (!f) return error(CRYPT_FILE_NOTFOUND, &key);
outlen = (unsigned long)fwrite(out, 1, outlen, f);
fclose(f);
if (!outlen) return error(CRYPT_ERROR, &key);
// Export public key.
outlen = sizeof(out);
err = rsa_export(out, &outlen, PK_PUBLIC, &key);
if (err != CRYPT_OK) return error(err, &key);
// Save public key.
f = fopen(public_key, "wb");
if (!f) return error(CRYPT_FILE_NOTFOUND, &key);
outlen = (unsigned long)fwrite(out, 1, outlen, f);
fclose(f);
if (!outlen) return error(CRYPT_ERROR, &key);
rsa_free(&key);
return 0;
}
int pkcs_1_eme_test(void)
{
int prng_idx = register_prng(&no_prng_desc);
int hash_idx = find_hash("sha1");
unsigned int i;
DO(prng_is_valid(prng_idx));
DO(hash_is_valid(hash_idx));
for (i = 0; i < sizeof(testcases_eme)/sizeof(testcases_eme[0]); ++i) {
testcase_t* t = &testcases_eme[i];
rsa_key k, *key = &k;
DOX(mp_init_multi(&key->e, &key->d, &key->N, &key->dQ,
&key->dP, &key->qP, &key->p, &key->q, NULL), t->name);
DOX(mp_read_unsigned_bin(key->e, t->rsa.e, t->rsa.e_l), t->name);
DOX(mp_read_unsigned_bin(key->d, t->rsa.d, t->rsa.d_l), t->name);
DOX(mp_read_unsigned_bin(key->N, t->rsa.n, t->rsa.n_l), t->name);
DOX(mp_read_unsigned_bin(key->dQ, t->rsa.dQ, t->rsa.dQ_l), t->name);
DOX(mp_read_unsigned_bin(key->dP, t->rsa.dP, t->rsa.dP_l), t->name);
DOX(mp_read_unsigned_bin(key->qP, t->rsa.qInv, t->rsa.qInv_l), t->name);
DOX(mp_read_unsigned_bin(key->q, t->rsa.q, t->rsa.q_l), t->name);
DOX(mp_read_unsigned_bin(key->p, t->rsa.p, t->rsa.p_l), t->name);
key->type = PK_PRIVATE;
unsigned int j;
for (j = 0; j < sizeof(t->data)/sizeof(t->data[0]); ++j) {
rsaData_t* s = &t->data[j];
unsigned char buf[256], obuf[256];
unsigned long buflen = sizeof(buf), obuflen = sizeof(obuf);
int stat;
prng_descriptor[prng_idx].add_entropy(s->o2, s->o2_l, NULL);
DOX(rsa_encrypt_key_ex(s->o1, s->o1_l, obuf, &obuflen, NULL, 0, NULL, prng_idx, -1, LTC_PKCS_1_V1_5, key), s->name);
DOX(obuflen == (unsigned long)s->o3_l?CRYPT_OK:CRYPT_FAIL_TESTVECTOR, s->name);
DOX(memcmp(s->o3, obuf, s->o3_l)==0?CRYPT_OK:CRYPT_FAIL_TESTVECTOR, s->name);
DOX(rsa_decrypt_key_ex(obuf, obuflen, buf, &buflen, NULL, 0, -1, LTC_PKCS_1_V1_5, &stat, key), s->name);
DOX(stat == 1?CRYPT_OK:CRYPT_FAIL_TESTVECTOR, s->name);
} /* for */
mp_clear_multi(key->d, key->e, key->N, key->dQ, key->dP, key->qP, key->p, key->q, NULL);
} /* for */
unregister_prng(&no_prng_desc);
return 0;
}
int generateRandom(unsigned char *array, unsigned long len)
{
int err, x;
prng_state prng;
if (register_prng(&yarrow_desc) == -1) {
return ERROR_PRNG;
}
if ((err = rng_make_prng(128, find_prng("yarrow"), &prng, NULL)) != CRYPT_OK) {
return err;
}
x = yarrow_read(array, len, &prng);
if (x != len) {
return ERROR_READ_IV;
}
sprng_done(&prng);
return CRYPT_OK;
}
int luaopen_crypto_ecdh( lua_State* L) {
#if 0 //probably useless, to be delegated to lrng
/* Register random number generator */
if( -1 == register_prng( & fortuna_desc))
luaL_error(L, "'fortuna' registration has failed\n");
#endif
/* Register big math lib for tomcrypt */
ltc_mp = ltm_desc;
luaL_register(L, MYNAME, R);
lua_pushliteral(L, "version");
lua_pushliteral(L, MYVERSION);
lua_settable(L, -3);
return 1;
}
int luaopen_crypto_rng(lua_State* L) {
if (register_prng(&fortuna_desc) == -1)
luaL_error(L, "'fortuna' registration has failed\n");
luaL_newmetatable(L, MYTYPE);
lua_setglobal(L, MYNAME);
luaL_register(L, MYNAME, R);
lua_pushliteral(L, "version");
lua_pushliteral(L, MYVERSION);
lua_settable(L, -3);
lua_pushliteral(L, "__index");
lua_pushvalue(L, -2);
lua_settable(L, -3);
lua_pushliteral(L, "__tostring");
lua_pushliteral(L, "tostring");
lua_gettable(L, -3);
lua_settable(L, -3);
return 1;
}
BOOL CRSADlg::OnInitDialog()
{
CDialog::OnInitDialog();
// TODO: Add extra initialization here
// 添加list数据
for(int i = 0; i < MAX_LIST; i++)
{
if(!g_AsyAlgList[i].strName.IsEmpty())
{
m_ListBox.InsertString(i, g_AsyAlgList[i].strName);
}
}
m_ListBox.SetCurSel(0);
g_AsyAlgList_Index = g_AsyAlgList[0].index;
/* register prng/hash */
if (register_prng(&sprng_desc) == -1)
{
MessageBox("Error registering sprng");
}
/* register a math library (in this case TomsFastMath)*/
ltc_mp = ltm_desc;
if (register_hash(&sha1_desc) == -1)
{
MessageBox("Error registering sha1");
}
hash_idx = find_hash("sha1");
prng_idx = find_prng("sprng");
UpdateData(TRUE);
m_e = _T("010001");
m_e_n = _T("3");
UpdateData(FALSE);
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
int setup_crypt(void)
{
int err;
if(register_prng(&yarrow_desc) != CRYPT_OK) {
printf("Could not register prng.\n");
return -1;
}
printf("prng registered...\n");
if ((err = rng_make_prng(128, find_prng("yarrow"), &prng, NULL)) != CRYPT_OK) {
printf("Could not make prng: %s\n", error_to_string(err));
return -1;
}
/* generate a 1536 bit RSA key. This duplicates the exported key size
of Mythic's algorithm, but other sizes would work as well */
if ((err = rsa_make_key(&prng, find_prng("yarrow"), 192, 65537, &key)) != CRYPT_OK) {
printf("Could not generate RSA key: %s\n", error_to_string(err));
return -1;
}
printf("RSA key generated...\n");
/* export the key starting at keybuff[10] so we can prepend the
fixed header the client expects */
exported_key_len = sizeof(exported_key_buffer);
if ((err = rsa_export(&exported_key_buffer[10], &exported_key_len, PK_PUBLIC, &key)) != CRYPT_OK) {
printf("Could not export RSA public key: %s\n", error_to_string(err));
return -1;
}
printf("RSA public key exported (%lu bytes)...\n", exported_key_len);
/* some sort of protocol version information proceeds the key when
we send it. If not correct, login.dll generates version mismatch
error message. */
*((unsigned long *)&exported_key_buffer[0]) = htonl(LOGIN_PROTOCOL_VERSION);
*((unsigned short *)&exported_key_buffer[4]) = htons(1);
/* add the size */
*((unsigned short *)&exported_key_buffer[6]) = htons(exported_key_len);
*((unsigned short *)&exported_key_buffer[8]) = htons(exported_key_len);
return 0;
}
C4Err C4_Init()
{
C4Err err = kC4Err_NoErr;
ltc_mp = ltm_desc;
register_prng (&sprng_desc);
register_hash (&md5_desc);
register_hash (&sha1_desc);
register_hash (&sha256_desc);
register_hash (&sha384_desc);
register_hash (&sha512_desc);
register_hash (&sha224_desc);
register_hash (&skein256_desc);
register_hash (&skein512_desc);
register_hash (&skein1024_desc);
register_hash (&sha512_256_desc);
register_cipher (&aes_desc);
register_cipher (&twofish_desc);
return err;
}
void nabto_random(uint8_t* buf, size_t len) {
static bool isInitialized = false;
size_t bytes;
if (!isInitialized) {
int wprng;
int status;
register_prng(&fortuna_desc);
wprng = find_prng("fortuna");
status = rng_make_prng(128, wprng, &unabto_prng_state, NULL);
if (status != CRYPT_OK) {
NABTO_LOG_FATAL(("Could not initialize random function"));
return;
}
isInitialized = true;
}
bytes = fortuna_desc.read(buf, len, &unabto_prng_state);
if (bytes != len) {
NABTO_LOG_FATAL(("Random function did not give required bytes"));
}
}
int main() {
ltc_mp = ltm_desc;
rsa_key priv_key, pub_key;
int hash_idx, prng_idx;
int ret = rsa_import(openssl_private_rsa, sizeof(openssl_private_rsa), &priv_key);
ret = rsa_import(openssl_public_rsa, sizeof(openssl_public_rsa), &pub_key);
if (register_hash(&sha1_desc) == -1) {
printf("Error registering SHA1\n");
return -1;
}
hash_idx = find_hash("sha1");
register_prng(&sprng_desc);
prng_idx = find_prng("sprng");
prng_state prng;
int err;
if ((err = yarrow_start(&prng)) != CRYPT_OK) {
printf("Start error: %s\n", error_to_string(err));
}
/* add entropy */
if ((err = yarrow_add_entropy("hello world", 11, &prng))
!= CRYPT_OK) {
printf("Add_entropy error: %s\n", error_to_string(err));
}
int stat;
unsigned char buf[1024];
long size = 1024;
//ret = rsa_decrypt_key(sig, strlen(sig), buf, &size, 0, 0, hash_idx, &stat, &key);
ret = rsa_sign_hash(hash, strlen(hash), buf, &size, &prng, prng_idx, hash_idx, 0, &priv_key);
ret = rsa_verify_hash(sig, strlen(sig), hash, strlen(hash), hash_idx, 0, &stat, &pub_key);
printf("status is : %d\n", ret);
//load stuff!
return 0;
}
static void reg_algs(void)
{
int err;
#ifdef LTC_RIJNDAEL
register_cipher (&aes_desc);
#endif
#ifdef LTC_BLOWFISH
register_cipher (&blowfish_desc);
#endif
#ifdef LTC_XTEA
register_cipher (&xtea_desc);
#endif
#ifdef LTC_RC5
register_cipher (&rc5_desc);
#endif
#ifdef LTC_RC6
register_cipher (&rc6_desc);
#endif
#ifdef LTC_SAFERP
register_cipher (&saferp_desc);
#endif
#ifdef LTC_TWOFISH
register_cipher (&twofish_desc);
#endif
#ifdef LTC_SAFER
register_cipher (&safer_k64_desc);
register_cipher (&safer_sk64_desc);
register_cipher (&safer_k128_desc);
register_cipher (&safer_sk128_desc);
#endif
#ifdef LTC_RC2
register_cipher (&rc2_desc);
#endif
#ifdef LTC_DES
register_cipher (&des_desc);
register_cipher (&des3_desc);
#endif
#ifdef LTC_CAST5
register_cipher (&cast5_desc);
#endif
#ifdef LTC_NOEKEON
register_cipher (&noekeon_desc);
#endif
#ifdef LTC_SKIPJACK
register_cipher (&skipjack_desc);
#endif
#ifdef LTC_KHAZAD
register_cipher (&khazad_desc);
#endif
#ifdef LTC_ANUBIS
register_cipher (&anubis_desc);
#endif
#ifdef LTC_KSEED
register_cipher (&kseed_desc);
#endif
#ifdef LTC_KASUMI
register_cipher (&kasumi_desc);
#endif
#ifdef LTC_MULTI2
register_cipher (&multi2_desc);
#endif
#ifdef LTC_TIGER
register_hash (&tiger_desc);
#endif
#ifdef LTC_MD2
register_hash (&md2_desc);
#endif
#ifdef LTC_MD4
register_hash (&md4_desc);
#endif
#ifdef LTC_MD5
register_hash (&md5_desc);
#endif
#ifdef LTC_SHA1
register_hash (&sha1_desc);
#endif
#ifdef LTC_SHA224
register_hash (&sha224_desc);
#endif
#ifdef LTC_SHA256
register_hash (&sha256_desc);
#endif
#ifdef LTC_SHA384
register_hash (&sha384_desc);
#endif
#ifdef LTC_SHA512
register_hash (&sha512_desc);
#endif
#ifdef LTC_RIPEMD128
register_hash (&rmd128_desc);
#endif
#ifdef LTC_RIPEMD160
register_hash (&rmd160_desc);
#endif
#ifdef LTC_RIPEMD256
register_hash (&rmd256_desc);
#endif
#ifdef LTC_RIPEMD320
register_hash (&rmd320_desc);
#endif
#ifdef LTC_WHIRLPOOL
register_hash (&whirlpool_desc);
#endif
#ifdef LTC_CHC_HASH
register_hash(&chc_desc);
if ((err = chc_register(register_cipher(&aes_desc))) != CRYPT_OK) {
fprintf(stderr, "chc_register error: %s\n", error_to_string(err));
exit(EXIT_FAILURE);
}
#endif
#ifndef LTC_YARROW
#error This demo requires Yarrow.
#endif
register_prng(&yarrow_desc);
#ifdef LTC_FORTUNA
register_prng(&fortuna_desc);
#endif
#ifdef LTC_RC4
register_prng(&rc4_desc);
#endif
#ifdef LTC_SOBER128
register_prng(&sober128_desc);
#endif
if ((err = rng_make_prng(128, find_prng("yarrow"), &yarrow_prng, NULL)) != CRYPT_OK) {
fprintf(stderr, "rng_make_prng failed: %s\n", error_to_string(err));
exit(EXIT_FAILURE);
}
}
int main(int argc, char **argv)
{
rsa_key rsakey;
char fname[256];
char *hashname;
char expiry[256];
unsigned char buf[4096], rsabuf[2048], md[MAXBLOCKSIZE], sig[512];
unsigned long buflen, rsalen, mdlen, siglen;
FILE *infile;
int i;
int opt_v2 = 0;
int opt_fullkey = 0;
int argoffset = 0;
if (argc < 3) {
fprintf(stderr, "Usage: %s [--fullkey] [--v2 expiry] hashname key_file_name [signed_file_name]\n", argv[0]);
return EXIT_FAILURE;
}
LTC_ARGCHK(register_hash(&sha256_desc) != -1);
LTC_ARGCHK(register_hash(&sha512_desc) != -1);
LTC_ARGCHK(register_hash(&rmd160_desc) != -1);
LTC_ARGCHK(register_hash(&whirlpool_desc) != -1);
LTC_ARGCHK(register_prng(&sprng_desc) != -1);
ltc_mp = tfm_desc;
for ( i=1; i < argc; i++) {
if (strcmp(argv[i], OPT_V2)==0) {
opt_v2 = 1;
strncpy(expiry, argv[i+1], 256);
i++;
argoffset=argoffset+2;
continue;
}
if (strcmp(argv[i], OPT_FULLKEY)==0) {
opt_fullkey = 1;
argoffset++;
continue;
}
/* done! get out softly */
i=argc;
}
hashname = argv[1+argoffset];
/* get hashes of file */
mdlen = sizeof(md);
if ( argc - argoffset > 3) {
DO(hash_file(find_hash(argv[1+argoffset]), argv[3+argoffset], md, &mdlen));
} else {
DO(hash_filehandle(find_hash(argv[1+argoffset]), stdin, md, &mdlen));
}
/* read keyblob and import key from it */
strncpy(fname, argv[2+argoffset], 256);
strncat(fname, ".private", 256);
infile = fopen(fname, "rb");
LTC_ARGCHK(infile != NULL);
buflen = fread(buf, 1, sizeof(buf), infile);
fclose(infile);
/* now try to import the RSA key */
DO(rsa_import(buf, buflen, &rsakey));
/* now sign the hashes */
siglen = sizeof(sig);
DO(rsa_sign_hash(md, mdlen, sig, &siglen, NULL, find_prng("sprng"), find_hash(hashname), 8, &rsakey));
/* open output file */
if (opt_v2==1) {
fprintf(stdout, "sig02: %s ", hashname);
} else {
fprintf(stdout, "sig01: %s ", hashname);
}
/* read keyblob and import key from it */
strncpy(fname, argv[2+argoffset], 256);
strncat(fname, ".public", 256);
infile = fopen(fname, "rb");
LTC_ARGCHK(infile != NULL);
buflen = fread(buf, 1, sizeof(buf), infile);
fclose(infile);
if (opt_fullkey==1) {
i = 0;
} else {
i = buflen-32;
}
for ( ; i < buflen; i++)
fprintf(stdout, "%02x", buf[i]);
fprintf(stdout, " ");
if (opt_v2==1) {
fprintf(stdout, expiry);
fprintf(stdout, " ");
}
for (i = 0; i < siglen; i++)
fprintf(stdout, "%02x", sig[i]);
fprintf(stdout, "\n");
rsa_free(&rsakey);
return EXIT_SUCCESS;
}
void register_algs(void)
{
int x;
#ifdef LTC_RIJNDAEL
register_cipher (&aes_desc);
#endif
#ifdef LTC_BLOWFISH
register_cipher (&blowfish_desc);
#endif
#ifdef LTC_XTEA
register_cipher (&xtea_desc);
#endif
#ifdef LTC_RC5
register_cipher (&rc5_desc);
#endif
#ifdef LTC_RC6
register_cipher (&rc6_desc);
#endif
#ifdef LTC_SAFERP
register_cipher (&saferp_desc);
#endif
#ifdef LTC_TWOFISH
register_cipher (&twofish_desc);
#endif
#ifdef LTC_SAFER
register_cipher (&safer_k64_desc);
register_cipher (&safer_sk64_desc);
register_cipher (&safer_k128_desc);
register_cipher (&safer_sk128_desc);
#endif
#ifdef LTC_RC2
register_cipher (&rc2_desc);
#endif
#ifdef LTC_DES
register_cipher (&des_desc);
register_cipher (&des3_desc);
#endif
#ifdef LTC_CAST5
register_cipher (&cast5_desc);
#endif
#ifdef LTC_NOEKEON
register_cipher (&noekeon_desc);
#endif
#ifdef LTC_SKIPJACK
register_cipher (&skipjack_desc);
#endif
#ifdef LTC_KHAZAD
register_cipher (&khazad_desc);
#endif
#ifdef LTC_ANUBIS
register_cipher (&anubis_desc);
#endif
if (register_hash(&sha256_desc) == -1) {
printf("Error registering LTC_SHA256\n");
exit(-1);
}
if (register_prng(&yarrow_desc) == -1) {
printf("Error registering yarrow PRNG\n");
exit(-1);
}
if (register_prng(&sprng_desc) == -1) {
printf("Error registering sprng PRNG\n");
exit(-1);
}
}
/*++
Alcoext_Init
Initialises the extension for a regular interpreter.
Arguments:
interp - Current interpreter.
Return Value:
A standard Tcl result.
--*/
int
Alcoext_Init(
Tcl_Interp *interp
)
{
ExtState *statePtr;
StateList *stateListPtr;
// Wide integer support was added in Tcl 8.4.
#ifdef USE_TCL_STUBS
if (Tcl_InitStubs(interp, "8.4", 0) == NULL) {
return TCL_ERROR;
}
#else // USE_TCL_STUBS
if (Tcl_PkgRequire(interp, "Tcl", "8.4", 0) == NULL) {
return TCL_ERROR;
}
#endif // USE_TCL_STUBS
if (Tcl_PkgProvide(interp, PACKAGE_NAME, PACKAGE_VERSION) != TCL_OK) {
return TCL_ERROR;
}
//
// Check if the library is already initialised before locking
// the global initialisation mutex (improves loading time).
//
if (!initialised) {
Tcl_MutexLock(&initMutex);
// Check initialisation status again now that we're in the mutex.
if (!initialised) {
#ifdef _WINDOWS
// Initialise the OS version structure.
osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
GetVersionExA(&osVersion);
ZeroMemory(&winProcs, sizeof(WinProcs));
winProcs.module = LoadLibraryA("kernel32.dll");
if (winProcs.module != NULL) {
//
// These functions must be resolved on run-time for backwards
// compatibility on older Windows systems (earlier than NT v5).
//
winProcs.getDiskFreeSpaceEx = (GetDiskFreeSpaceExProc)
GetProcAddress(winProcs.module, "GetDiskFreeSpaceExA");
winProcs.findFirstVolumeMountPoint = (FindFirstVolumeMountPointProc)
GetProcAddress(winProcs.module, "FindFirstVolumeMountPointA");
winProcs.findNextVolumeMountPoint = (FindNextVolumeMountPointProc)
GetProcAddress(winProcs.module, "FindNextVolumeMountPointA");
winProcs.findVolumeMountPointClose = (FindVolumeMountPointCloseProc)
GetProcAddress(winProcs.module, "FindVolumeMountPointClose");
winProcs.getVolumeNameForVolumeMountPoint = (GetVolumeNameForVolumeMountPointProc)
GetProcAddress(winProcs.module, "GetVolumeNameForVolumeMountPointA");
}
//
// If GetVolumeInformation() is called on a floppy drive or a CD-ROM
// drive that does not have a disk inserted, the system will display
// a message box asking the user to insert one.
//
SetErrorMode(SetErrorMode(0) | SEM_FAILCRITICALERRORS);
#endif // _WINDOWS
// An exit handler must only be registered once.
Tcl_CreateExitHandler(ExitHandler, NULL);
// Register ciphers, hashes, and PRNGs for LibTomCrypt.
register_cipher(&des3_desc);
register_cipher(&aes_desc);
register_cipher(&anubis_desc);
register_cipher(&blowfish_desc);
register_cipher(&cast5_desc);
register_cipher(&des_desc);
register_cipher(&khazad_desc);
register_cipher(&noekeon_desc);
register_cipher(&rc2_desc);
register_cipher(&rc5_desc);
register_cipher(&rc6_desc);
register_cipher(&saferp_desc);
register_cipher(&safer_k128_desc);
register_cipher(&safer_k64_desc);
register_cipher(&safer_sk128_desc);
register_cipher(&safer_sk64_desc);
register_cipher(&skipjack_desc);
register_cipher(&twofish_desc);
register_cipher(&xtea_desc);
register_hash(&md2_desc);
register_hash(&md4_desc);
register_hash(&md5_desc);
register_hash(&rmd128_desc);
register_hash(&rmd160_desc);
register_hash(&sha1_desc);
register_hash(&sha224_desc);
register_hash(&sha256_desc);
register_hash(&sha384_desc);
register_hash(&sha512_desc);
register_hash(&tiger_desc);
register_hash(&whirlpool_desc);
register_prng(&fortuna_desc);
register_prng(&rc4_desc);
register_prng(&sober128_desc);
register_prng(&sprng_desc);
register_prng(&yarrow_desc);
initialised = 1;
}
Tcl_MutexUnlock(&initMutex);
}
// Allocate state structures.
stateListPtr = (StateList *)ckalloc(sizeof(StateList));
statePtr = (ExtState *)ckalloc(sizeof(ExtState));
statePtr->cryptTable = (Tcl_HashTable *)ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(statePtr->cryptTable, TCL_STRING_KEYS);
#ifndef _WINDOWS
statePtr->glftpdTable = (Tcl_HashTable *)ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(statePtr->glftpdTable, TCL_STRING_KEYS);
#endif // !_WINDOWS
//
// Since callbacks registered with Tcl_CallWhenDeleted() are not executed in
// certain situations (calling Tcl_Finalize() or invoking the "exit" command),
// these resources must be freed by an exit handler registered with
// Tcl_CreateExitHandler().
//
stateListPtr->interp = interp;
stateListPtr->state = statePtr;
stateListPtr->next = NULL;
stateListPtr->prev = NULL;
Tcl_MutexLock(&stateMutex);
// Insert at the list head.
if (stateListHead == NULL) {
stateListHead = stateListPtr;
} else {
stateListPtr->next = stateListHead;
stateListHead->prev = stateListPtr;
stateListHead = stateListPtr;
}
Tcl_MutexUnlock(&stateMutex);
// Clean up state on interpreter deletion.
Tcl_CallWhenDeleted(interp, InterpDeleteHandler, (ClientData)statePtr);
// Create Tcl commands.
Tcl_CreateObjCommand(interp, "::alcoholicz::compress", CompressObjCmd,
(ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);
Tcl_CreateObjCommand(interp, "::alcoholicz::crypt", CryptObjCmd,
(ClientData)statePtr, (Tcl_CmdDeleteProc *)NULL);
Tcl_CreateObjCommand(interp, "::alcoholicz::decode", EncodingObjCmd,
(ClientData)decodeFuncts, (Tcl_CmdDeleteProc *)NULL);
Tcl_CreateObjCommand(interp, "::alcoholicz::encode", EncodingObjCmd,
(ClientData)encodeFuncts, (Tcl_CmdDeleteProc *)NULL);
//
// These commands are not created for safe interpreters because
// they interact with the file system and/or other processes.
//
if (!Tcl_IsSafe(interp)) {
Tcl_CreateObjCommand(interp, "::alcoholicz::volume", VolumeObjCmd,
(ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);
#ifdef _WINDOWS
Tcl_CreateObjCommand(interp, "::alcoholicz::ioftpd", IoFtpdObjCmd,
(ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);
#else // _WINDOWS
Tcl_CreateObjCommand(interp, "::alcoholicz::glftpd", GlFtpdObjCmd,
(ClientData)statePtr, (Tcl_CmdDeleteProc *)NULL);
#endif // _WINDOWS
}
Tcl_Eval(interp, "namespace eval ::alcoholicz {"
"namespace export compress crypt encode decode volume "
#ifdef _WINDOWS
"ioftpd"
#else
"glftpd"
#endif // _WINDOWS
"}"
);
return TCL_OK;
}
int main(int argc,char** argv)
{
char pm, operation=-1, found=1, pw1[128], pw2[128], ae1[15], ae2[15];
u32 i;
PK0102 ce;
PK0304 le;
PK0506 ed;
for (pm=1; pm < argc; pm++)
{
char opt;
if (argv[pm][0] != '/') continue;
if (argv[pm][1] == '?') {
printf( "Encrypts or decrypts an archive following WinZip(R) 9 specifications.\n\n" \
"ZAES /D | /E:keysize [/2] archive.zip\n\n" \
" /D decrypts AES encrypted entries\n" \
" /E:keysize encrypts with 128, 192 or 256-bit keys (keysize 1, 2 or 3)\n" \
" /2 AE-2 format (sets CRC-32 to zero)\n");
return 1;
}
opt = toupper(argv[pm][1]);
if (opt== 'E') {
Mode = atol(&argv[pm][3]);
operation = 0;
filter = encrypt_authenticate;
if (Mode < 1 || Mode > 3)
Z_ERROR("Bad encryption mode specified!");
SaltSize = KS[Mode].Salt;
KeySize = KS[Mode].Key;
found++;
continue;
}
if (opt== 'D') {
operation = 1;
filter = authenticate_decrypt;
found++;
continue;
}
if (opt== '2') {
AE2 = 1;
found++;
printf("WARNING: according to AE-2 specifications, CRC-32 will be set to zero\n"\
"in encrypted entries. Reverting to original archive after decryption will\n"\
"be impossible with this utility!\n");
continue;
}
}
argv+=found;
argc-=found;
if (operation == -1) Z_ERROR("You must specify /E or /D switch!\nTry ZAES /?");
if (argc < 1) Z_ERROR("You must give a ZIP archive to process!");
register_prng(&sprng_desc);
register_cipher(&aes_desc);
register_hash(&sha1_desc);
//~ printf("DEBUG: sha1 id=%d, aes id=%d\n", find_hash("sha1"), find_cipher("aes"));
if ( (ZIN=fopen(argv[0],"rb")) == 0 || (ZIN2=fopen(argv[0],"rb")) == 0 )
Z_ERROR("Can't open input ZIP archive");
if ( (ZOUT=topen(ae1)) == 0 || (ZTMP=topen(ae2)) == 0)
Z_ERROR("Can't open temporary output files");
setvbuf(ZIN , 0, _IOFBF, BLOCK);
setvbuf(ZOUT, 0, _IOFBF, BLOCK);
/* assumiamo uno ZIP senza commento! */
fseek(ZIN2,-22,SEEK_END);
safeRead(&ed, ZIN2, sizeof(PK0506));
if (ed.Sig != 0x06054B50)
#ifdef HANDLE_COMMENT
{
fseek(ZIN2, -0xFFFF, SEEK_END);
fread(p, 1, 4, ZIN2);
#else
Z_ERROR("End directory marker not found!");
#endif
/* verifica un minimo di coerenza nella ENDDIR */
if (ed.Disk != 0)
Z_ERROR("Can't process a spanned archive");
while(1) {
printf("Enter password: "******"\rFor your safety, please use a password of 8 characters or more.\n");
continue;
}
if (operation) {
printf("\n");
break;
}
printf("\rVerify password: "******"Passwords don't match!\n");
continue;
}
printf("\n");
break;
}
#define PUTN(x) { fileCopy(stdout, ZIN, x.NameLen); fseek(ZIN, -x.NameLen, SEEK_CUR); }
fseek(ZIN2, ed.Offset, SEEK_SET);
for (i=0; i < ed.Total; i++)
{
safeRead(&ce, ZIN2, sizeof(PK0102));
if (ce.Sig != 0x02014B50)
Z_ERROR("Expected central directory marker not found");
/* Assume i dati corretti dalla LE */
fseek(ZIN, ce.Offset, SEEK_SET);
safeRead(&le, ZIN, sizeof(PK0304));
if (le.Sig != 0x04034B50)
Z_ERROR("Expected local entry marker not found");
if ( ((le.Flag & 1) && !operation) || /* doesn't encrypt already encrypted */
(!(le.Flag & 1) && operation) || /* doesn't decrypt already decrypted */
((le.Flag & 1) && operation && le.CompMethod != 99) || /* doesn't decrypt not AES encrypted */
!le.CompSize )
{
ce.Offset = ftell(ZOUT);
safeWrite(ZOUT, &le, sizeof(PK0304));
printf(" copying: "); PUTN(le);
fileCopy(ZOUT, ZIN, le.NameLen+le.ExtraLen+le.CompSize);
printf("\n");
safeWrite(ZTMP, &ce, sizeof(PK0102));
fileCopy(ZTMP, ZIN2, ce.NameLen+ce.ExtraLen);
continue;
}
if (!operation)
{
AE_EXTRA ae = {0x9901, 7, AE2+1, 0x4541, Mode, 0};
ae.CompMethod = ce.CompMethod;
ce.CompMethod = 99;
if (AE2) ce.Crc32 = 0;
ce.Flag |= 1;
ce.ExtraLen += 11;
ce.CompSize += SaltSize + 12; /* variable salt, fixed password check and hmac */
ce.Offset = ftell(ZOUT);
safeWrite(ZTMP, &ce, sizeof(PK0102));
fileCopy(ZTMP, ZIN2, ce.NameLen+ce.ExtraLen-11);
safeWrite(ZTMP, &ae, 11);
printf(" encrypting: "); PUTN(le);
Encrypt(&le, &ae, pw1);
printf("\n");
}
else
{
ce.Offset = ftell(ZOUT);
printf(" decrypting: "); PUTN(le);
Decrypt(&le, pw1); /* Decrypts contents */
printf("\n");
ce.CompMethod = le.CompMethod;
if (AE2) ce.Crc32 = 0;
ce.Flag ^= 1;
ce.ExtraLen -= 11;
ce.CompSize = le.CompSize;
safeWrite(ZTMP, &ce, sizeof(PK0102));
/* Copy the extra data (may be LE != CE) */
fileCopy(ZTMP, ZIN2, ce.NameLen);
for(ce.ExtraLen+=11; ce.ExtraLen;)
{
u16 u[2];
safeRead(u, ZIN2, 4);
ce.ExtraLen -= (4 + u[1]);
if (u[0] == 0x9901)
{
fseek(ZIN2, u[1], SEEK_CUR);
continue;
}
safeWrite(ZTMP, u, 4);
fileCopy(ZTMP, ZIN2, u[1]);
}
}
}
ed.Offset = ftell(ZOUT); /* new central directory start */
ed.Size = ftell(ZTMP); /* new central directory size */
fseek(ZTMP, 0, SEEK_SET);
fclose(ZIN);
fclose(ZIN2);
/* Copies central directory */
fileCopy(ZOUT, ZTMP, ed.Size);
safeWrite(ZOUT, &ed, sizeof(PK0506));
fclose(ZTMP);
fclose(ZOUT);
remove(ae2);
if (remove(argv[0]))
{
printf("Can't remove old archive; new one is in file '%s'\n", ae1);
} else
if (rename(ae1, argv[0]))
{
printf("Can't rename old archive; new one is in file '%s'\n", ae1);
}
memset(&BUF, 0, sizeof(BUF));
memset(&ctr, 0, sizeof(ctr));
memset(pw1, 0, 128);
memset(pw2, 0, 128);
return 0;
}
/* Register the compiled in ciphers.
* This should be run before using any of the ciphers/hashes */
void crypto_init() {
const struct ltc_cipher_descriptor *regciphers[] = {
#if DROPBEAR_AES
&aes_desc,
#endif
#if DROPBEAR_BLOWFISH
&blowfish_desc,
#endif
#if DROPBEAR_TWOFISH
&twofish_desc,
#endif
#if DROPBEAR_3DES
&des3_desc,
#endif
NULL
};
const struct ltc_hash_descriptor *reghashes[] = {
/* we need sha1 for hostkey stuff regardless */
&sha1_desc,
#if DROPBEAR_MD5_HMAC
&md5_desc,
#endif
#if DROPBEAR_SHA256
&sha256_desc,
#endif
#if DROPBEAR_SHA384
&sha384_desc,
#endif
#if DROPBEAR_SHA512
&sha512_desc,
#endif
NULL
};
int i;
for (i = 0; regciphers[i] != NULL; i++) {
if (register_cipher(regciphers[i]) == -1) {
dropbear_exit("Error registering crypto");
}
}
for (i = 0; reghashes[i] != NULL; i++) {
if (register_hash(reghashes[i]) == -1) {
dropbear_exit("Error registering crypto");
}
}
#if DROPBEAR_LTC_PRNG
dropbear_ltc_prng = register_prng(&dropbear_prng_desc);
if (dropbear_ltc_prng == -1) {
dropbear_exit("Error registering crypto");
}
#endif
#if DROPBEAR_ECC
ltc_mp = ltm_desc;
dropbear_ecc_fill_dp();
#endif
}
/*++
Initialise
Initialises the library; allocating and registering resources.
Arguments:
None.
Return Value:
None.
--*/
static void
Initialise(
void
)
{
DebugPrint("Initialise: initialised=%d\n", initialised);
//
// Check if the library is already initialised before locking
// the global initialisation mutex (improves loading time).
//
if (initialised) {
return;
}
Tcl_MutexLock(&initMutex);
// Check initialisation status again now that we are in the mutex.
if (!initialised) {
#ifdef _WINDOWS
// Initialise the OS version structure.
osVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
GetVersionExA(&osVersion);
ZeroMemory(&winProcs, sizeof(WinProcs));
winProcs.module = LoadLibraryA("kernel32.dll");
if (winProcs.module != NULL) {
//
// These functions must be resolved on run-time for backwards
// compatibility on older Windows systems (earlier than NT v5).
//
winProcs.getDiskFreeSpaceEx = (GetDiskFreeSpaceExProc)
GetProcAddress(winProcs.module, "GetDiskFreeSpaceExA");
winProcs.findFirstVolumeMountPoint = (FindFirstVolumeMountPointProc)
GetProcAddress(winProcs.module, "FindFirstVolumeMountPointA");
winProcs.findNextVolumeMountPoint = (FindNextVolumeMountPointProc)
GetProcAddress(winProcs.module, "FindNextVolumeMountPointA");
winProcs.findVolumeMountPointClose = (FindVolumeMountPointCloseProc)
GetProcAddress(winProcs.module, "FindVolumeMountPointClose");
winProcs.getVolumeNameForVolumeMountPoint = (GetVolumeNameForVolumeMountPointProc)
GetProcAddress(winProcs.module, "GetVolumeNameForVolumeMountPointA");
}
//
// If GetVolumeInformation() is called on a floppy drive or a CD-ROM
// drive that does not have a disk inserted, the system will display
// a message box asking the user to insert one.
//
SetErrorMode(SetErrorMode(0) | SEM_FAILCRITICALERRORS);
#endif // _WINDOWS
// Register ciphers, hashes, and PRNGs for LibTomCrypt.
register_cipher(&des3_desc);
register_cipher(&aes_desc);
register_cipher(&anubis_desc);
register_cipher(&blowfish_desc);
register_cipher(&cast5_desc);
register_cipher(&des_desc);
register_cipher(&khazad_desc);
register_cipher(&noekeon_desc);
register_cipher(&rc2_desc);
register_cipher(&rc5_desc);
register_cipher(&rc6_desc);
register_cipher(&saferp_desc);
register_cipher(&safer_k128_desc);
register_cipher(&safer_k64_desc);
register_cipher(&safer_sk128_desc);
register_cipher(&safer_sk64_desc);
register_cipher(&skipjack_desc);
register_cipher(&twofish_desc);
register_cipher(&xtea_desc);
register_hash(&md2_desc);
register_hash(&md4_desc);
register_hash(&md5_desc);
register_hash(&rmd128_desc);
register_hash(&rmd160_desc);
register_hash(&rmd256_desc);
register_hash(&rmd320_desc);
register_hash(&sha1_desc);
register_hash(&sha224_desc);
register_hash(&sha256_desc);
register_hash(&sha384_desc);
register_hash(&sha512_desc);
register_hash(&tiger_desc);
register_hash(&whirlpool_desc);
register_prng(&fortuna_desc);
register_prng(&rc4_desc);
register_prng(&sober128_desc);
register_prng(&sprng_desc);
register_prng(&yarrow_desc);
Tcl_CreateExitHandler(ExitHandler, NULL);
initialised = 1;
}
Tcl_MutexUnlock(&initMutex);
}
