static int test_bf_cfb64(void)
{
unsigned char cbc_in[40], cbc_out[40], iv[8];
int n, ret = 1;
BF_KEY key;
BF_LONG len;
len = strlen(cbc_data) + 1;
BF_set_key(&key, 16, cbc_key);
memset(cbc_in, 0, 40);
memset(cbc_out, 0, 40);
memcpy(iv, cbc_iv, 8);
n = 0;
BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13,
&key, iv, &n, BF_ENCRYPT);
BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]),
len - 13, &key, iv, &n, BF_ENCRYPT);
if (!TEST_mem_eq(cbc_out, (int)len, cfb64_ok, (int)len))
ret = 0;
n = 0;
memcpy(iv, cbc_iv, 8);
BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT);
BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17,
&key, iv, &n, BF_DECRYPT);
if (!TEST_mem_eq(cbc_in, (int)len, cbc_data, (int)len))
ret = 0;
return ret;
}
main()
{
char from[128], to[128];
int len = 128;
/* define a structure to hold the key */
BF_KEY key;
/* a temp buffer to read user input (the user's password) */
char temp_buf[16];
/* don't worry about these two: just define/use them */
int n = 0; /* internal blowfish variables */
unsigned char iv[8]; /* Initialization Vector */
/* fill the IV with zeros (or any other fixed data) */
memset(iv, 0, 8);
/* call this function once to setup the cipher key */
BF_set_key(&key, 16, temp_buf);
/*
* This is how you encrypt an input char* buffer "from", of length "len"
* onto output buffer "to", using key "key". Jyst pass "iv" and "&n" as
* shown, and don't forget to actually tell the function to BF_ENCRYPT.
*/
BF_cfb64_encrypt(from, to, len, &key, iv, &n, BF_ENCRYPT);
/* Decrypting is the same: just pass BF_DECRYPT instead */
BF_cfb64_encrypt(from, to, len, &key, iv, &n, BF_DECRYPT);
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
const int count = *pcount;
int index;
size_t *lws = local_work_size ? &local_work_size : NULL;
global_work_size = local_work_size ? (count + local_work_size - 1) / local_work_size * local_work_size : count;
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(index = 0; index < count; index++)
{
unsigned char hash[20];
SHA_CTX ctx;
SHA1_Init(&ctx);
SHA1_Update(&ctx, (unsigned char *)saved_key[index], strlen(saved_key[index]));
SHA1_Final((unsigned char *)hash, &ctx);
memcpy(inbuffer[index].v, hash, 20);
inbuffer[index].length = 20;
}
/// Copy data to gpu
HANDLE_CLERROR(clEnqueueWriteBuffer(queue[gpu_id], mem_in, CL_FALSE, 0,
insize, inbuffer, 0, NULL, multi_profilingEvent[0]),
"Copy data to gpu");
/// Run kernel
HANDLE_CLERROR(clEnqueueNDRangeKernel(queue[gpu_id], crypt_kernel, 1,
NULL, &global_work_size, lws, 0, NULL,
multi_profilingEvent[1]), "Run kernel");
/// Read the result back
HANDLE_CLERROR(clEnqueueReadBuffer(queue[gpu_id], mem_out, CL_TRUE, 0,
outsize, outbuffer, 0, NULL, multi_profilingEvent[2]), "Copy result back");
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(index = 0; index < count; index++)
{
BF_KEY bf_key;
SHA_CTX ctx;
int bf_ivec_pos;
unsigned char ivec[8];
unsigned char output[1024];
bf_ivec_pos = 0;
memcpy(ivec, cur_salt->iv, 8);
BF_set_key(&bf_key, cur_salt->key_size, (const unsigned char*)outbuffer[index].v);
BF_cfb64_encrypt(cur_salt->content, output, cur_salt->length, &bf_key, ivec, &bf_ivec_pos, 0);
SHA1_Init(&ctx);
SHA1_Update(&ctx, output, cur_salt->original_length);
SHA1_Final((unsigned char*)crypt_out[index], &ctx);
}
return count;
}
static int
bf_cfb64_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
BF_cfb64_encrypt(data, res, dlen, &od->u.bf.key, od->iv,
&od->u.bf.num, BF_DECRYPT);
return 0;
}
void CSporeEncrypt::BF_decrypt(const unsigned char *keydata, int keydatalen, unsigned char *in, unsigned char *out, unsigned int inlen)
{
BF_KEY key;
unsigned char ivec[32];
int num = 0;
// set up for decryption
BF_set_key(&key, keydatalen, keydata);
memset(ivec, '\0', 32);
BF_cfb64_encrypt(in, out, inlen, &key, ivec, &num, BF_DECRYPT);
}
int bffilebuf::__writetofile(size_t len)
{
if (writebuf && out) {
unsigned char crypt[BUF_SIZE];
BF_cfb64_encrypt(writebuf, crypt, (long)len, &key, ivec, &num, BF_ENCRYPT);
out->write((const char *)crypt, len);
if (!out->bad() && !out->fail()) {
setp((char *)writebuf, (char *)(writebuf + BUF_SIZE - 1));
return 0;
}
}
return EOF;
}
int bffilebuf::underflow()
{
if (readbuf && in) {
unsigned char crypt[BUF_SIZE - 1];
in->read((char *)crypt, BUF_SIZE - 1);
streamsize read = in->gcount();
if (read) {
BF_cfb64_encrypt(crypt, readbuf, (long)read, &key, ivec, &num, BF_DECRYPT);
remaining -= read;
setg((char *)readbuf, (char *)readbuf, (char *)(readbuf + read));
return readbuf[0];
}
}
return EOF;
}
int
do_BF_cfb64_encrypt (const unsigned char *in,
long istart,
unsigned char *out,
long ostart,
long length,
const BF_KEY *schedule,
unsigned char *ivec,
int num,
int enc)
{
BF_cfb64_encrypt(&in[istart], &out[ostart], length,
schedule, ivec, &num, enc);
return (num);
}
static
void do_encrypt(apr_pool_t *p, const char *key, char *str, int len, int enc)
{
apr_md5_ctx_t my_md5;
unsigned char *hash = apr_pcalloc(p, APR_MD5_DIGESTSIZE);
apr_md5_init(&my_md5);
apr_md5_update(&my_md5, key, (unsigned int)len);
apr_md5_final(hash, &my_md5);
BF_KEY my_bf;
BF_set_key(&my_bf, APR_MD5_DIGESTSIZE, hash);
int num = 0;
unsigned char iv[8] = {0,0,0,0,0,0,0,0};
BF_cfb64_encrypt(str, str, len, &my_bf, iv, &num, enc);
}
static int test(void)
{
unsigned char cbc_in[40],cbc_out[40],iv[8];
int i,n,err=0;
BF_KEY key;
BF_LONG data[2];
unsigned char out[8];
BF_LONG len;
#ifdef CHARSET_EBCDIC
ebcdic2ascii(cbc_data, cbc_data, TINYCLR_SSL_STRLEN(cbc_data));
#endif
TINYCLR_SSL_PRINTF("testing blowfish in raw ecb mode\n");
for (n=0; n<2; n++)
{
#ifdef CHARSET_EBCDIC
ebcdic2ascii(bf_key[n], bf_key[n], TINYCLR_SSL_STRLEN(bf_key[n]));
#endif
BF_set_key(&key,TINYCLR_SSL_STRLEN(bf_key[n]),(unsigned char *)bf_key[n]);
data[0]=bf_plain[n][0];
data[1]=bf_plain[n][1];
BF_encrypt(data,&key);
if (TINYCLR_SSL_MEMCMP(&(bf_cipher[n][0]),&(data[0]),8) != 0)
{
TINYCLR_SSL_PRINTF("BF_encrypt error encrypting\n");
TINYCLR_SSL_PRINTF("got :");
for (i=0; i<2; i++)
TINYCLR_SSL_PRINTF("%08lX ",(unsigned long)data[i]);
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF("expected:");
for (i=0; i<2; i++)
TINYCLR_SSL_PRINTF("%08lX ",(unsigned long)bf_cipher[n][i]);
err=1;
TINYCLR_SSL_PRINTF("\n");
}
BF_decrypt(&(data[0]),&key);
if (TINYCLR_SSL_MEMCMP(&(bf_plain[n][0]),&(data[0]),8) != 0)
{
TINYCLR_SSL_PRINTF("BF_encrypt error decrypting\n");
TINYCLR_SSL_PRINTF("got :");
for (i=0; i<2; i++)
TINYCLR_SSL_PRINTF("%08lX ",(unsigned long)data[i]);
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF("expected:");
for (i=0; i<2; i++)
TINYCLR_SSL_PRINTF("%08lX ",(unsigned long)bf_plain[n][i]);
TINYCLR_SSL_PRINTF("\n");
err=1;
}
}
TINYCLR_SSL_PRINTF("testing blowfish in ecb mode\n");
for (n=0; n<NUM_TESTS; n++)
{
BF_set_key(&key,8,ecb_data[n]);
BF_ecb_encrypt(&(plain_data[n][0]),out,&key,BF_ENCRYPT);
if (TINYCLR_SSL_MEMCMP(&(cipher_data[n][0]),out,8) != 0)
{
TINYCLR_SSL_PRINTF("BF_ecb_encrypt blowfish error encrypting\n");
TINYCLR_SSL_PRINTF("got :");
for (i=0; i<8; i++)
TINYCLR_SSL_PRINTF("%02X ",out[i]);
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF("expected:");
for (i=0; i<8; i++)
TINYCLR_SSL_PRINTF("%02X ",cipher_data[n][i]);
err=1;
TINYCLR_SSL_PRINTF("\n");
}
BF_ecb_encrypt(out,out,&key,BF_DECRYPT);
if (TINYCLR_SSL_MEMCMP(&(plain_data[n][0]),out,8) != 0)
{
TINYCLR_SSL_PRINTF("BF_ecb_encrypt error decrypting\n");
TINYCLR_SSL_PRINTF("got :");
for (i=0; i<8; i++)
TINYCLR_SSL_PRINTF("%02X ",out[i]);
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF("expected:");
for (i=0; i<8; i++)
TINYCLR_SSL_PRINTF("%02X ",plain_data[n][i]);
TINYCLR_SSL_PRINTF("\n");
err=1;
}
}
TINYCLR_SSL_PRINTF("testing blowfish set_key\n");
for (n=1; n<KEY_TEST_NUM; n++)
{
BF_set_key(&key,n,key_test);
BF_ecb_encrypt(key_data,out,&key,BF_ENCRYPT);
/* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */
if (TINYCLR_SSL_MEMCMP(out,&(key_out[i=n-1][0]),8) != 0)
{
TINYCLR_SSL_PRINTF("blowfish setkey error\n");
err=1;
}
}
TINYCLR_SSL_PRINTF("testing blowfish in cbc mode\n");
len=TINYCLR_SSL_STRLEN(cbc_data)+1;
BF_set_key(&key,16,cbc_key);
TINYCLR_SSL_MEMSET(cbc_in,0,sizeof cbc_in);
TINYCLR_SSL_MEMSET(cbc_out,0,sizeof cbc_out);
TINYCLR_SSL_MEMCPY(iv,cbc_iv,sizeof iv);
BF_cbc_encrypt((unsigned char *)cbc_data,cbc_out,len,
&key,iv,BF_ENCRYPT);
if (TINYCLR_SSL_MEMCMP(cbc_out,cbc_ok,32) != 0)
{
err=1;
TINYCLR_SSL_PRINTF("BF_cbc_encrypt encrypt error\n");
for (i=0; i<32; i++) TINYCLR_SSL_PRINTF("0x%02X,",cbc_out[i]);
}
TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
BF_cbc_encrypt(cbc_out,cbc_in,len,
&key,iv,BF_DECRYPT);
if (TINYCLR_SSL_MEMCMP(cbc_in,cbc_data,TINYCLR_SSL_STRLEN(cbc_data)+1) != 0)
{
TINYCLR_SSL_PRINTF("BF_cbc_encrypt decrypt error\n");
err=1;
}
TINYCLR_SSL_PRINTF("testing blowfish in cfb64 mode\n");
BF_set_key(&key,16,cbc_key);
TINYCLR_SSL_MEMSET(cbc_in,0,40);
TINYCLR_SSL_MEMSET(cbc_out,0,40);
TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
n=0;
BF_cfb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,
&key,iv,&n,BF_ENCRYPT);
BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]),&(cbc_out[13]),len-13,
&key,iv,&n,BF_ENCRYPT);
if (TINYCLR_SSL_MEMCMP(cbc_out,cfb64_ok,(int)len) != 0)
{
err=1;
TINYCLR_SSL_PRINTF("BF_cfb64_encrypt encrypt error\n");
for (i=0; i<(int)len; i++) TINYCLR_SSL_PRINTF("0x%02X,",cbc_out[i]);
}
n=0;
TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
BF_cfb64_encrypt(cbc_out,cbc_in,17,
&key,iv,&n,BF_DECRYPT);
BF_cfb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,
&key,iv,&n,BF_DECRYPT);
if (TINYCLR_SSL_MEMCMP(cbc_in,cbc_data,(int)len) != 0)
{
TINYCLR_SSL_PRINTF("BF_cfb64_encrypt decrypt error\n");
err=1;
}
TINYCLR_SSL_PRINTF("testing blowfish in ofb64\n");
BF_set_key(&key,16,cbc_key);
TINYCLR_SSL_MEMSET(cbc_in,0,40);
TINYCLR_SSL_MEMSET(cbc_out,0,40);
TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
n=0;
BF_ofb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,&key,iv,&n);
BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]),
&(cbc_out[13]),len-13,&key,iv,&n);
if (TINYCLR_SSL_MEMCMP(cbc_out,ofb64_ok,(int)len) != 0)
{
err=1;
TINYCLR_SSL_PRINTF("BF_ofb64_encrypt encrypt error\n");
for (i=0; i<(int)len; i++) TINYCLR_SSL_PRINTF("0x%02X,",cbc_out[i]);
}
n=0;
TINYCLR_SSL_MEMCPY(iv,cbc_iv,8);
BF_ofb64_encrypt(cbc_out,cbc_in,17,&key,iv,&n);
BF_ofb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,&key,iv,&n);
if (TINYCLR_SSL_MEMCMP(cbc_in,cbc_data,(int)len) != 0)
{
TINYCLR_SSL_PRINTF("BF_ofb64_encrypt decrypt error\n");
err=1;
}
return(err);
}
int
main(int argc, char *argv[])
{
BF_KEY key;
unsigned char ukey[32]; /* FGG changed mistake */
unsigned char indata[40], outdata[40], ivec[32]={0}; /* FGG changed mistake */
int num=0; /* FGG changed mistake */
int by=0,i=0;
int encordec=-1;
char *cp,ch;
FILE *fp,*fp2;
long ct_repeat=0;
long ct_repeat_max=1;
int ct_return=0;
if (getenv("CT_REPEAT_MAIN")!=NULL) ct_repeat_max=atol(getenv("CT_REPEAT_MAIN"));
if (argc<3)
{
fprintf(stderr, "Usage: blowfish {e|d} <intput> <output> key\n");
exit(EXIT_FAILURE);
}
if (*argv[1]=='e' || *argv[1]=='E')
encordec = 1;
else if (*argv[1]=='d' || *argv[1]=='D')
encordec = 0;
else
{
fprintf(stderr, "Usage: blowfish {e|d} <intput> <output> key\n");
exit(EXIT_FAILURE);
}
/* Read the key */
cp = argv[4];
while(i < 64 && *cp) /* the maximum key length is 32 bytes and */
{ /* hence at most 64 hexadecimal digits */
ch = toupper(*cp++); /* process a hexadecimal digit */
if(ch >= '0' && ch <= '9')
by = (by << 4) + ch - '0';
else if(ch >= 'A' && ch <= 'F')
by = (by << 4) + ch - 'A' + 10;
else /* error if not hexadecimal */
{
printf("key must be in hexadecimal notation\n");
exit(EXIT_FAILURE);
}
/* store a key byte for each pair of hexadecimal digits */
if(i++ & 1)
ukey[i / 2 - 1] = by & 0xff;
}
BF_set_key(&key,8,ukey);
if(*cp)
{
printf("Bad key value.\n");
exit(EXIT_FAILURE);
}
/* open the input and output files */
if ((fp = fopen(argv[2],"r"))==0)
{
fprintf(stderr, "Usage: blowfish {e|d} <intput> <output> key\n");
exit(EXIT_FAILURE);
};
if ((fp2 = fopen(argv[3],"w"))==0)
{
fprintf(stderr, "Usage: blowfish {e|d} <intput> <output> key\n");
exit(EXIT_FAILURE);
};
i=0;
while(!feof(fp))
{
int current_num;
unsigned char current_ivec[32];
int j;
while(!feof(fp) && i<40)
indata[i++]=getc(fp);
/* backup for multiple loop_wrap run */
current_num = num;
memcpy(current_ivec, ivec, 32);
for (ct_repeat=0; ct_repeat<ct_repeat_max; ct_repeat++)
{
/* The call to BF_cfb64_encrypt modifies ivec and num. We need to make a
copy and to restore it before each iteration of the kernel to make sure
we do not alter the output of the application. */
num = current_num;
memcpy(ivec, current_ivec, 32);
BF_cfb64_encrypt(indata,outdata,i,&key,ivec,&num,encordec);
}
for(j=0;j<i;j++)
{
/*printf("%c",outdata[j]);*/
fputc(outdata[j],fp2);
}
i=0;
}
fclose(fp);
fclose(fp2);
return 0;
}
void
main_blowfish(char *op)
{
BF_KEY key;
unsigned char ukey[8];
unsigned char indata[40],outdata[40],ivec[8];
int num;
int by=0,i=0;
int encordec=-1;
char *cp,ch;
FILE *fp,*fp2;
int argc = 5;
char *argv[5];
argv[0]="";
argv[1]=op;
argv[2]="";
argv[3]="";
argv[4]="1234567890abcdeffedcba0987654321";
if (argc<3)
{
printf("Usage: blowfish {e|d} <intput> <output> key\n");
exit(-1);
}
if (*argv[1]=='e' || *argv[1]=='E')
{
encordec = 1;
fp = filein_blowfishenc;
fp2 = fileout_blowfishenc;
}
else if (*argv[1]=='d' || *argv[1]=='D')
{
encordec = 0;
fp = filein_blowfishdec;
fp2 = fileout_blowfishdec;
}
else
{
printf("Usage: blowfish {e|d} <intput> <output> key\n");
exit(-1);
}
/* Read the key */
cp = argv[4];
/*pthread_mutex_lock(&mutex_print);
printf("\nblowfish opcao %s encordec %d fp %x fp2 %x \n",op, encordec, fp, fp2);
printf("\nchave %s \n",cp);
pthread_mutex_unlock(&mutex_print);*/
while(i < 64 && *cp) /* the maximum key length is 32 bytes and */
{ /* hence at most 64 hexadecimal digits */
ch = toupper(*cp++); /* process a hexadecimal digit */
if(ch >= '0' && ch <= '9')
by = (by << 4) + ch - '0';
else if(ch >= 'A' && ch <= 'F')
by = (by << 4) + ch - 'A' + 10;
else /* error if not hexadecimal */
{
printf("key must be in hexadecimal notation\n");
exit(-1);
}
/* store a key byte for each pair of hexadecimal digits */
if(i++ & 1)
ukey[i / 2 - 1] = by & 0xff;
}
BF_set_key(&key,8,ukey);
if(*cp)
{
printf("Bad key value.\n");
exit(-1);
}
/* open the input and output files */
/*if ((fp = fopen(argv[2],"r"))==0)
{
printf("Usage: blowfish {e|d} <intput> <output> key\n");
exit(-1);
};
if ((fp2 = fopen(argv[3],"w"))==0)
{
printf("Usage: blowfish {e|d} <intput> <output> key\n");
exit(-1);
};*/
i=0;
while(!feof(fp))
{
int j;
while(!feof(fp)&& i<40)
indata[i++]=getc(fp);
BF_cfb64_encrypt(indata,outdata,i,&key,ivec,&num,encordec);
pthread_mutex_lock(&mutex_print);
for(j=0; j<i; j++)
{
//printf("%c",outdata[j]);
//fprintf(fp2,"%c",outdata[j]);
fputc(outdata[j],fp2);
}
pthread_mutex_unlock(&mutex_print);
i=0;
}
fclose(fp);
//close(fp2);
//exit(1);
return;
}
int
main() {
BIO *bio;
RSA *rsa=0, *rsa_pub, *rsa_priv=0;
char buf[4096], enc[4096], dec[4096];
BUF_MEM *ptr;
int len, enc_len, dec_len;
int i;
BF_KEY key;
char ivec_orig[8] = {1, 2, 3, 4, 5, 6, 7, 8}, ivec[8];
do {
//OpenSSL_add_all_algorithms();
//OpenSSL_add_all_ciphers();
//OpenSSL_add_all_digests();
printf("generate_key:\n");
rsa = RSA_generate_key(1024, 3, gen_cb, 0);
printf("\n");
printf("pem public key:\n");
bio = BIO_new(BIO_s_mem());
i = PEM_write_bio_RSAPublicKey(bio, rsa);
BIO_flush(bio);
i = BIO_get_mem_ptr(bio, &ptr);
printf("pem public key len=%d\n", ptr->length);
fwrite(ptr->data, ptr->length, 1, stdout);
len = ptr->length;
memcpy(buf, ptr->data, len);
BIO_free(bio);
printf("\n");
bio = BIO_new_mem_buf(buf, len);
rsa_pub = PEM_read_bio_RSAPublicKey(bio, 0, 0, 0);
BIO_free(bio);
printf("pem private key:\n");
bio = BIO_new(BIO_s_mem());
i = PEM_write_bio_RSAPrivateKey(bio, rsa, 0, 0, 0, 0, 0);
BIO_flush(bio);
i = BIO_get_mem_ptr(bio, &ptr);
printf("pem private key i=%d len=%d\n", i, ptr->length);
fwrite(ptr->data, ptr->length, 1, stdout);
len = ptr->length;
memcpy(buf, ptr->data, len);
BIO_free(bio);
printf("\n");
bio = BIO_new_mem_buf(buf, len);
rsa_priv = PEM_read_bio_RSAPrivateKey(bio, 0, 0, 0);
BIO_free(bio);
/* encrypt */
printf("buffer:\n");
len = sprintf(buf, "1234567890123456");
len = 128/8;
RAND_bytes(buf, len);
printf("buf_len=%d\n", len);
//printf("%s", dec);
for(i=0; i<len; i++) {
printf("%02x", (unsigned int)buf[i]&0xff);
}
printf("\n");
printf("public_encrypt:\n");
memset(enc, 0, sizeof(enc));
enc_len = RSA_public_encrypt(len, buf, enc, rsa_pub, RSA_PKCS1_OAEP_PADDING);
if( enc_len < 0 ) {
printf("err=%ld\n", ERR_get_error());
break;
}
printf("enc_len=%d\n", enc_len);
for(i=0; i<enc_len; i++) {
printf("%02x", (unsigned int)enc[i]&0xff);
}
printf("\n");
printf("public_decrypt:\n");
memset(dec, 0, sizeof(dec));
dec_len = RSA_private_decrypt(enc_len, enc, dec, rsa_priv, RSA_PKCS1_OAEP_PADDING);
if( dec_len < 0 ) {
printf("err=%ld\n", ERR_get_error());
break;
}
printf("dec_len=%d\n", dec_len);
for(i=0; i<dec_len; i++) {
printf("%02x", (unsigned int)dec[i]&0xff);
}
printf("\n");
// blowfish
BF_set_key(&key, dec_len, dec);
i = 0;
memcpy(ivec, ivec_orig, 8);
memset(buf, 0, sizeof(buf));
BF_cfb64_encrypt(enc, buf, enc_len, &key, ivec, &i, BF_ENCRYPT);
printf("BF_cfb64_encrypt:\n");
for(i=0; i<enc_len; i++) {
printf("%02x", (unsigned int)buf[i]&0xff);
}
printf("\n");
i = 0;
memcpy(ivec, ivec_orig, 8);
memset(enc, 0, sizeof(buf));
BF_cfb64_encrypt(buf, enc, enc_len, &key, ivec, &i, BF_DECRYPT);
printf("BF_cfb64_decrypt:\n");
for(i=0; i<enc_len; i++) {
printf("%02x", (unsigned int)enc[i]&0xff);
}
printf("\n");
} while(0);
if( rsa ) {
RSA_free(rsa);
}
return 0;
}
void check_packets(u_char *foo, const struct pcap_pkthdr *header, const unsigned char *data) {
int len = header->caplen, rlen, bytes = 0, hlen, end = 0, pos, dlen = 0, done = 0;
unsigned char *ptr = (unsigned char *) data, rbuf[6000], wbuf[6000];
if (!rawmode) {
if (do_hdr_size) {
ptr += do_hdr_size;
len -= do_hdr_size;
if ((ptr[0] & 240) != 0x60)
return;
} else {
ptr += 14;
len -= 14;
}
}
if (len < 58) // too short
return;
if (ptr[6] != NXT_DST)
return;
if (ptr[42] != 0x10 || ptr[43] != 4 || ptr[48] != 0x11 || ptr[49] != 4 || ptr[54] != 0x12)
return;
if (memcmp(ptr + 50, (char *) &seq, 4) != 0)
return;
if (seq == 1)
memcpy((char *) &id, ptr + 44, 4);
else if (memcmp(ptr + 44, (char *) &id, 4) != 0)
return;
dlen = 40 + (ptr[41] + 1) * 8;
rlen = len - 54;
pos = 54;
while (rlen > 0 && end == 0 && dlen >= pos && done == 0) {
if (ptr[pos] == 0)
done = 1;
else if (ptr[pos] < 0x12)
return;
else if (ptr[pos] > 0x1f)
return;
else if (ptr[pos] == 0x1f)
end = 1;
else {
if ((hlen = ptr[pos + 1]) >= rlen)
return;
if (bytes + hlen >= sizeof(rbuf))
return;
memcpy(rbuf + bytes, ptr + pos + 2, hlen);
rlen = rlen - (hlen + 2);
pos = pos + hlen + 2;
bytes = bytes + hlen;
}
}
if (bytes > 0) {
if (key != NULL) {
BF_cfb64_encrypt((unsigned char *) rbuf, (unsigned char *) wbuf, bytes, &bfkey, (unsigned char *) vec, &num, BF_DECRYPT);
memcpy(rbuf, wbuf, bytes);
}
fwrite(rbuf, 1, bytes, f);
}
printf("Received packet seq# %d\n", seq);
seq++;
if (end) {
printf("All received.\n");
fclose(f);
exit(0);
}
}
// Checks if the given password is valid
bool Tester::check(const Memblock &mblock)
{
const String2Key &s2k = m_key.string2Key();
int32_t tmp = 0;
// Generate key from password
s2k.generateKey(mblock, m_keydata, m_keySize);
// Decrypt first data block in order to check the first two bits of
// the MPI. If they are correct, there's a good chance that the
// password is correct, too.
#if 1
memcpy(m_ivec, s2k.ivec(), m_blockSize);
switch (m_cipher) {
case CryptUtils::CIPHER_CAST5: {
CAST_KEY ck;
CAST_set_key(&ck, m_keySize, m_keydata);
CAST_cfb64_encrypt(m_in, m_out, CAST_BLOCK, &ck, m_ivec, &tmp, CAST_DECRYPT);
}
break;
case CryptUtils::CIPHER_BLOWFISH: {
BF_KEY ck;
BF_set_key(&ck, m_keySize, m_keydata);
BF_cfb64_encrypt(m_in, m_out, BF_BLOCK, &ck, m_ivec, &tmp, BF_DECRYPT);
}
break;
case CryptUtils::CIPHER_AES128:
case CryptUtils::CIPHER_AES192:
case CryptUtils::CIPHER_AES256: {
AES_KEY ck;
AES_set_encrypt_key(m_keydata, m_keySize * 8, &ck);
AES_cfb128_encrypt(m_in, m_out, AES_BLOCK_SIZE, &ck, m_ivec, &tmp, AES_DECRYPT);
}
break;
default:
break;
}
uint32_t num_bits = ((m_out[0] << 8) | m_out[1]);
if (num_bits < MIN_BN_BITS || num_bits > m_bits) {
return false;
}
#endif
// Decrypt all data
memcpy(m_ivec, s2k.ivec(), m_blockSize);
tmp = 0;
switch (m_cipher) {
case CryptUtils::CIPHER_CAST5: {
CAST_KEY ck;
CAST_set_key(&ck, m_keySize, m_keydata);
CAST_cfb64_encrypt(m_in, m_out, m_datalen, &ck, m_ivec, &tmp, CAST_DECRYPT);
}
break;
case CryptUtils::CIPHER_BLOWFISH: {
BF_KEY ck;
BF_set_key(&ck, m_keySize, m_keydata);
BF_cfb64_encrypt(m_in, m_out, m_datalen, &ck, m_ivec, &tmp, BF_DECRYPT);
}
break;
case CryptUtils::CIPHER_AES128:
case CryptUtils::CIPHER_AES192:
case CryptUtils::CIPHER_AES256: {
AES_KEY ck;
AES_set_encrypt_key(m_keydata, m_keySize * 8, &ck);
AES_cfb128_encrypt(m_in, m_out, m_datalen, &ck, m_ivec, &tmp, AES_DECRYPT);
}
break;
default:
break;
}
// Verify
bool checksumOk = false;
switch (s2k.usage()) {
case 254: {
uint8_t checksum[SHA_DIGEST_LENGTH];
pgpry_SHA_CTX ctx;
pgpry_SHA1_Init(&ctx);
pgpry_SHA1_Update(&ctx, m_out, m_datalen - SHA_DIGEST_LENGTH);
pgpry_SHA1_Final(checksum, &ctx);
if (memcmp(checksum, m_out + m_datalen - SHA_DIGEST_LENGTH, SHA_DIGEST_LENGTH) == 0) {
checksumOk = true;
}
} break;
case 0:
case 255: {
uint16_t sum = 0;
for (uint32_t i = 0; i < m_datalen - 2; i++) {
sum += m_out[i];
}
if (sum == ((m_out[m_datalen - 2] << 8) | m_out[m_datalen - 1])) {
checksumOk = true;
}
} break;
default:
break;
}
// If the checksum is ok, try to parse the first MPI of the private key
if (checksumOk) {
BIGNUM *b = NULL;
uint32_t blen = (num_bits + 7) / 8;
if (blen < m_datalen && ((b = BN_bin2bn(m_out + 2, blen, NULL)) != NULL)) {
BN_free(b);
return true;
}
}
return false;
}
int
startup(int argc, char *argv[])
{
BF_KEY key;
unsigned char ukey[8];
unsigned char indata[40],outdata[40],ivec[8];
int num;
int by=0,i=0;
int encordec=-1;
char *cp,ch;
FILE *fp,*fp2;
if (argc<3)
{
printf("Usage: blowfish {e|d} <intput> <output> key\n");
exit(-1);
}
if (*argv[1]=='e' || *argv[1]=='E')
encordec = 1;
else if (*argv[1]=='d' || *argv[1]=='D')
encordec = 0;
else
{
printf("Usage: blowfish {e|d} <intput> <output> key\n");
exit(-1);
}
/* Read the key */
cp = argv[4];
while(i < 64 && *cp) /* the maximum key length is 32 bytes and */
{ /* hence at most 64 hexadecimal digits */
ch = toupper(*cp++); /* process a hexadecimal digit */
if(ch >= '0' && ch <= '9')
by = (by << 4) + ch - '0';
else if(ch >= 'A' && ch <= 'F')
by = (by << 4) + ch - 'A' + 10;
else /* error if not hexadecimal */
{
printf("key must be in hexadecimal notation\n");
exit(-1);
}
/* store a key byte for each pair of hexadecimal digits */
if(i++ & 1)
ukey[i / 2 - 1] = by & 0xff;
}
BF_set_key(&key,8,ukey);
if(*cp)
{
printf("Bad key value.\n");
exit(-1);
}
/* open the input and output files */
if ((fp = fopen(argv[2],"r"))==0)
{
printf("Usage: blowfish {e|d} <intput> <output> key\n");
exit(-1);
};
if ((fp2 = fopen(argv[3],"w"))==0)
{
printf("Usage: blowfish {e|d} <intput> <output> key\n");
exit(-1);
};
i=0;
while(!feof(fp))
{
int j;
while(!feof(fp) && i<40)
indata[i++]=getc(fp);
BF_cfb64_encrypt(indata,outdata,i,&key,ivec,&num,encordec);
for(j=0;j<i;j++)
{
/*printf("%c",outdata[j]);*/
fputc(outdata[j],fp2);
}
i=0;
}
close(fp);
close(fp2);
exit(1);
}
static int check(unsigned char *keydata, int ks)
{
// Decrypt first data block in order to check the first two bits of
// the MPI. If they are correct, there's a good chance that the
// password is correct, too.
unsigned char ivec[32];
unsigned char out[BIG_ENOUGH * 2] = { 0 };
int tmp = 0;
uint32_t num_bits;
int checksumOk;
int i;
// Quick Hack
memcpy(ivec, cur_salt->iv, blockSize(cur_salt->cipher_algorithm));
switch (cur_salt->cipher_algorithm) {
case CIPHER_IDEA: {
IDEA_KEY_SCHEDULE iks;
JtR_idea_set_encrypt_key(keydata, &iks);
JtR_idea_cfb64_encrypt(cur_salt->data, out, SALT_LENGTH, &iks, ivec, &tmp, IDEA_DECRYPT);
}
break;
case CIPHER_CAST5: {
CAST_KEY ck;
CAST_set_key(&ck, ks, keydata);
CAST_cfb64_encrypt(cur_salt->data, out, CAST_BLOCK, &ck, ivec, &tmp, CAST_DECRYPT);
}
break;
case CIPHER_BLOWFISH: {
BF_KEY ck;
BF_set_key(&ck, ks, keydata);
BF_cfb64_encrypt(cur_salt->data, out, BF_BLOCK, &ck, ivec, &tmp, BF_DECRYPT);
}
break;
case CIPHER_AES128:
case CIPHER_AES192:
case CIPHER_AES256: {
AES_KEY ck;
AES_set_encrypt_key(keydata, ks * 8, &ck);
AES_cfb128_encrypt(cur_salt->data, out, AES_BLOCK_SIZE, &ck, ivec, &tmp, AES_DECRYPT);
}
break;
case CIPHER_3DES: {
DES_cblock key1, key2, key3;
DES_cblock divec;
DES_key_schedule ks1, ks2, ks3;
int num = 0;
memcpy(key1, keydata + 0, 8);
memcpy(key2, keydata + 8, 8);
memcpy(key3, keydata + 16, 8);
memcpy(divec, ivec, 8);
DES_set_key((DES_cblock *)key1, &ks1);
DES_set_key((DES_cblock *)key2, &ks2);
DES_set_key((DES_cblock *)key3, &ks3);
DES_ede3_cfb64_encrypt(cur_salt->data, out, SALT_LENGTH, &ks1, &ks2, &ks3, &divec, &num, DES_DECRYPT);
}
break;
default:
printf("(check) Unknown Cipher Algorithm %d ;(\n", cur_salt->cipher_algorithm);
break;
}
num_bits = ((out[0] << 8) | out[1]);
if (num_bits < MIN_BN_BITS || num_bits > cur_salt->bits) {
return 0;
}
// Decrypt all data
memcpy(ivec, cur_salt->iv, blockSize(cur_salt->cipher_algorithm));
tmp = 0;
switch (cur_salt->cipher_algorithm) {
case CIPHER_IDEA: {
IDEA_KEY_SCHEDULE iks;
JtR_idea_set_encrypt_key(keydata, &iks);
JtR_idea_cfb64_encrypt(cur_salt->data, out, cur_salt->datalen, &iks, ivec, &tmp, IDEA_DECRYPT);
}
break;
case CIPHER_CAST5: {
CAST_KEY ck;
CAST_set_key(&ck, ks, keydata);
CAST_cfb64_encrypt(cur_salt->data, out, cur_salt->datalen, &ck, ivec, &tmp, CAST_DECRYPT);
}
break;
case CIPHER_BLOWFISH: {
BF_KEY ck;
BF_set_key(&ck, ks, keydata);
BF_cfb64_encrypt(cur_salt->data, out, cur_salt->datalen, &ck, ivec, &tmp, BF_DECRYPT);
}
break;
case CIPHER_AES128:
case CIPHER_AES192:
case CIPHER_AES256: {
AES_KEY ck;
AES_set_encrypt_key(keydata, ks * 8, &ck);
AES_cfb128_encrypt(cur_salt->data, out, cur_salt->datalen, &ck, ivec, &tmp, AES_DECRYPT);
}
break;
case CIPHER_3DES: {
DES_cblock key1, key2, key3;
DES_cblock divec;
DES_key_schedule ks1, ks2, ks3;
int num = 0;
memcpy(key1, keydata + 0, 8);
memcpy(key2, keydata + 8, 8);
memcpy(key3, keydata + 16, 8);
memcpy(divec, ivec, 8);
DES_set_key((DES_cblock *) key1, &ks1);
DES_set_key((DES_cblock *) key2, &ks2);
DES_set_key((DES_cblock *) key3, &ks3);
DES_ede3_cfb64_encrypt(cur_salt->data, out, cur_salt->datalen, &ks1, &ks2, &ks3, &divec, &num, DES_DECRYPT);
}
break;
default:
break;
}
// Verify
checksumOk = 0;
switch (cur_salt->usage) {
case 254: {
uint8_t checksum[SHA_DIGEST_LENGTH];
SHA_CTX ctx;
SHA1_Init(&ctx);
SHA1_Update(&ctx, out, cur_salt->datalen - SHA_DIGEST_LENGTH);
SHA1_Final(checksum, &ctx);
if (memcmp(checksum, out + cur_salt->datalen - SHA_DIGEST_LENGTH, SHA_DIGEST_LENGTH) == 0)
return 1; /* we have a 20 byte verifier ;) */
else
return 0;
} break;
case 0:
case 255: {
// https://tools.ietf.org/html/rfc4880#section-3.7.2
uint16_t sum = 0;
for (i = 0; i < cur_salt->datalen - 2; i++) {
sum += out[i];
}
if (sum == ((out[cur_salt->datalen - 2] << 8) | out[cur_salt->datalen - 1])) {
checksumOk = 1;
}
} break;
default:
break;
}
// If the checksum is ok, try to parse the first MPI of the private key
// Stop relying on checksum altogether, GnuPG ignores it (after
// documenting why though!)
if (checksumOk) {
BIGNUM *b = NULL;
uint32_t blen = (num_bits + 7) / 8;
int ret;
if (cur_salt->datalen == 24 && blen != 20) /* verifier 1 */
return 0;
if (blen < cur_salt->datalen && ((b = BN_bin2bn(out + 2, blen, NULL)) != NULL)) {
char *str = BN_bn2hex(b);
DSA dsa;
ElGamal_secret_key elg;
RSA_secret_key rsa;
if (strlen(str) != blen * 2) { /* verifier 2 */
OPENSSL_free(str);
return 0;
}
OPENSSL_free(str);
if (cur_salt->pk_algorithm == 17) { /* DSA check */
dsa.p = BN_bin2bn(cur_salt->p, cur_salt->pl, NULL);
// puts(BN_bn2hex(dsa.p));
dsa.q = BN_bin2bn(cur_salt->q, cur_salt->ql, NULL);
// puts(BN_bn2hex(dsa.q));
dsa.g = BN_bin2bn(cur_salt->g, cur_salt->gl, NULL);
// puts(BN_bn2hex(dsa.g));
dsa.priv_key = b;
dsa.pub_key = BN_bin2bn(cur_salt->y, cur_salt->yl, NULL);
// puts(BN_bn2hex(dsa.pub_key));
ret = check_dsa_secret_key(&dsa); /* verifier 3 */
if (ret != 0)
return 0;
}
if (cur_salt->pk_algorithm == 16 || cur_salt->pk_algorithm == 20) { /* ElGamal check */
elg.p = BN_bin2bn(cur_salt->p, cur_salt->pl, NULL);
// puts(BN_bn2hex(elg.p));
elg.g = BN_bin2bn(cur_salt->g, cur_salt->gl, NULL);
// puts(BN_bn2hex(elg.g));
elg.x = b;
// puts(BN_bn2hex(elg.x));
elg.y = BN_bin2bn(cur_salt->y, cur_salt->yl, NULL);
// puts(BN_bn2hex(elg.y));
ret = check_elg_secret_key(&elg); /* verifier 3 */
if (ret != 0)
return 0;
}
if (cur_salt->pk_algorithm == 1) { /* RSA check */
// http://www.ietf.org/rfc/rfc4880.txt
int length = 0;
length += give_multi_precision_integer(out, length, &cur_salt->dl, cur_salt->d);
length += give_multi_precision_integer(out, length, &cur_salt->pl, cur_salt->p);
length += give_multi_precision_integer(out, length, &cur_salt->ql, cur_salt->q);
rsa.n = BN_bin2bn(cur_salt->n, cur_salt->nl, NULL);
rsa.p = BN_bin2bn(cur_salt->p, cur_salt->pl, NULL);
rsa.q = BN_bin2bn(cur_salt->q, cur_salt->ql, NULL);
ret = check_rsa_secret_key(&rsa);
if (ret != 0)
return 0;
}
return 1;
}
}
return 0;
}
int main(int argc, char *argv[]) {
unsigned char *pkt1 = NULL, rbuf[3570], wbuf[3570], buf[4000];
unsigned char *src6 = NULL, *dst6 = NULL, srcmac[6] = "", *mac = srcmac, *dmac;
int pkt1_len = 0, flags = 0, i = 0, mtu = 0, bytes, seq = 0, id, rounds, wbytes, bufsize = 0, send = 2, num = 0;
char *interface, *key = NULL, hash[20], vec[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };;
int rawmode = 0, tcp_port = -1;
FILE *f;
BF_KEY bfkey;
if (argc < 4 || strncmp(argv[1], "-h", 2) == 0)
help(argv[0]);
while ((i = getopt(argc, argv, "rm:k:s:")) >= 0) {
switch (i) {
case 'r':
rawmode = 1;
thc_ipv6_rawmode(1);
break;
case 'k':
key = optarg;
break;
case 'm':
mtu = atoi(optarg);
break;
case 's':
send = atoi(optarg);
break;
default:
exit(-1);
}
}
if (argc < optind + 2) {
fprintf(stderr, "Error: Not enough parameters!\n");
help(argv[0]);
}
interface = argv[optind];
dst6 = thc_resolve6(argv[optind + 1]);
if ((f = fopen(argv[optind + 2], "r")) == NULL) {
fprintf(stderr, "Error: file %s not found\n", argv[optind + 2]);
exit(-1);
}
if (argc >= optind + 4 && argv[optind + 3] != NULL)
tcp_port = atoi(argv[optind + 3]);
if (mtu == 0)
mtu = thc_get_mtu(interface);
if (mtu <= 1000) {
fprintf(stderr, "Error: MTU of interface %s must be at least 1000 bytes\n", interface);
exit(-1);
}
mac = thc_get_own_mac(interface);
src6 = thc_get_own_ipv6(interface, dst6, PREFER_GLOBAL);
if ((dmac = thc_get_mac(interface, src6, dst6)) == NULL) {
fprintf(stderr, "Error: can not get MAC for target\n");
exit(-1);
}
srand(getpid());
mtu -= 128;
if (mtu % 255 == 0)
i = 2 * (mtu / 255);
else
i = 2 + 2 * (mtu / 255);
mtu = mtu - i;
if ((mtu + i + 14) % 8 > 0)
mtu = (((mtu + i + 14) / 8) * 8) - (i + 14);
if (mtu > 14 * 255)
mtu = 14 * 255;
if (key != NULL) {
memset(&bfkey, 0, sizeof(bfkey));
SHA1((unsigned char *) key, strlen(key), (unsigned char *) hash);
BF_set_key(&bfkey, sizeof(hash), (unsigned char *) hash);
memset(vec, 0, sizeof(vec));
num = 0;
}
id = rand();
buf[0] = 16;
buf[1] = 4;
memcpy(buf + 2, (char *) &id, 4);
buf[6] = 17;
buf[7] = 4;
while ((bytes = fread(rbuf, 1, mtu, f)) > 0) {
seq++;
if (key != NULL) {
BF_cfb64_encrypt((unsigned char *) rbuf, (unsigned char *) wbuf, bytes, &bfkey, (unsigned char *) vec, &num, BF_ENCRYPT);
memcpy(rbuf, wbuf, bytes);
}
memcpy(buf + 8, (char *) &seq, 4);
bufsize = 12;
rounds = bytes / 255;
for (i = 0; i <= rounds; i++) {
buf[bufsize] = i + 18;
if (i == rounds)
wbytes = bytes % 255;
else
wbytes = 255;
buf[bufsize + 1] = wbytes;
memcpy(buf + bufsize + 2, rbuf + 255 * i, wbytes);
bufsize += wbytes + 2;
}
if (bytes < mtu) {
buf[bufsize] = 0x1f;
buf[bufsize + 1] = 0;
bufsize = bufsize + 2;
}
if ((pkt1 = thc_create_ipv6_extended(interface, PREFER_GLOBAL, &pkt1_len, src6, dst6, 0, 0, 0, 0, 0)) == NULL)
return -1;
if (thc_add_hdr_dst(pkt1, &pkt1_len, buf, bufsize))
return -1;
if (tcp_port == -1) {
if (thc_add_icmp6(pkt1, &pkt1_len, ICMP6_ECHOREQUEST, 0, flags, NULL, 0, 0) < 0)
return -1;
} else {
if (thc_add_tcp(pkt1, &pkt1_len, (rand() % 45536) + 10000, tcp_port, rand(), 0, TCP_SYN, 5760, 0, NULL, 0, NULL, 0) < 0)
return -1;
}
if (thc_generate_pkt(interface, mac, dmac, pkt1, &pkt1_len) < 0) {
fprintf(stderr, "Error: Can not generate packet, exiting ...\n");
exit(-1);
}
printf("Sending packet seq# %d\n", seq);
for (i = 0; i < send; i++) {
thc_send_pkt(interface, pkt1, &pkt1_len);
usleep(100);
}
}
printf("All sent.\n");
return 0;
}
static int test(void)
{
unsigned char cbc_in[40],cbc_out[40],iv[8];
int i,n,err=0;
BF_KEY key;
BF_LONG data[2];
unsigned char out[8];
BF_LONG len;
printf("testing blowfish in raw ecb mode\n");
for (n=0; n<2; n++)
{
BF_set_key(&key,strlen(bf_key[n]),(unsigned char *)bf_key[n]);
data[0]=bf_plain[n][0];
data[1]=bf_plain[n][1];
BF_encrypt(data,&key);
if (memcmp(&(bf_cipher[n][0]),&(data[0]), sizeof data) != 0)
{
printf("BF_encrypt error encrypting\n");
printf("got :");
for (i=0; i<2; i++)
printf("%08lX ",(unsigned long)data[i]);
printf("\n");
printf("expected:");
for (i=0; i<2; i++)
printf("%08lX ",(unsigned long)bf_cipher[n][i]);
err=1;
printf("\n");
}
BF_decrypt(&(data[0]),&key);
if (memcmp(&(bf_plain[n][0]),&(data[0]),8) != 0)
{
printf("BF_encrypt error decrypting\n");
printf("got :");
for (i=0; i<2; i++)
printf("%08lX ",(unsigned long)data[i]);
printf("\n");
printf("expected:");
for (i=0; i<2; i++)
printf("%08lX ",(unsigned long)bf_plain[n][i]);
printf("\n");
err=1;
}
}
printf("testing blowfish in ecb mode\n");
for (n=0; n<NUM_TESTS; n++)
{
BF_set_key(&key,8,ecb_data[n]);
BF_ecb_encrypt(&(plain_data[n][0]),out,&key,BF_ENCRYPT);
if (memcmp(&(cipher_data[n][0]),out,8) != 0)
{
printf("BF_ecb_encrypt blowfish error encrypting\n");
printf("got :");
for (i=0; i<8; i++)
printf("%02X ",out[i]);
printf("\n");
printf("expected:");
for (i=0; i<8; i++)
printf("%02X ",cipher_data[n][i]);
err=1;
printf("\n");
}
BF_ecb_encrypt(out,out,&key,BF_DECRYPT);
if (memcmp(&(plain_data[n][0]),out,8) != 0)
{
printf("BF_ecb_encrypt error decrypting\n");
printf("got :");
for (i=0; i<8; i++)
printf("%02X ",out[i]);
printf("\n");
printf("expected:");
for (i=0; i<8; i++)
printf("%02X ",plain_data[n][i]);
printf("\n");
err=1;
}
}
printf("testing blowfish set_key\n");
for (n=1; n<KEY_TEST_NUM; n++)
{
BF_set_key(&key,n,key_test);
BF_ecb_encrypt(key_data,out,&key,BF_ENCRYPT);
if (memcmp(out,&(key_out[n-1][0]),8) != 0)
{
printf("blowfish setkey error\n");
err=1;
}
}
printf("testing blowfish in cbc mode\n");
len=strlen(cbc_data)+1;
BF_set_key(&key,16,cbc_key);
memset(cbc_in,0,sizeof cbc_in);
memset(cbc_out,0,sizeof cbc_out);
memcpy(iv,cbc_iv,sizeof iv);
BF_cbc_encrypt((unsigned char *)cbc_data,cbc_out,len,
&key,iv,BF_ENCRYPT);
if (memcmp(cbc_out,cbc_ok,32) != 0)
{
err=1;
printf("BF_cbc_encrypt encrypt error\n");
for (i=0; i<32; i++) printf("0x%02X,",cbc_out[i]);
}
memcpy(iv,cbc_iv,8);
BF_cbc_encrypt(cbc_out,cbc_in,len,
&key,iv,BF_DECRYPT);
if (memcmp(cbc_in,cbc_data,strlen(cbc_data)+1) != 0)
{
printf("BF_cbc_encrypt decrypt error\n");
err=1;
}
printf("testing blowfish in cfb64 mode\n");
BF_set_key(&key,16,cbc_key);
memset(cbc_in,0,40);
memset(cbc_out,0,40);
memcpy(iv,cbc_iv,8);
n=0;
BF_cfb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,
&key,iv,&n,BF_ENCRYPT);
BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]),&(cbc_out[13]),len-13,
&key,iv,&n,BF_ENCRYPT);
if (memcmp(cbc_out,cfb64_ok,(int)len) != 0)
{
err=1;
printf("BF_cfb64_encrypt encrypt error\n");
for (i=0; i<(int)len; i++) printf("0x%02X,",cbc_out[i]);
}
n=0;
memcpy(iv,cbc_iv,8);
BF_cfb64_encrypt(cbc_out,cbc_in,17,
&key,iv,&n,BF_DECRYPT);
BF_cfb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,
&key,iv,&n,BF_DECRYPT);
if (memcmp(cbc_in,cbc_data,(int)len) != 0)
{
printf("BF_cfb64_encrypt decrypt error\n");
err=1;
}
printf("testing blowfish in ofb64\n");
BF_set_key(&key,16,cbc_key);
memset(cbc_in,0,40);
memset(cbc_out,0,40);
memcpy(iv,cbc_iv,8);
n=0;
BF_ofb64_encrypt((unsigned char *)cbc_data,cbc_out,(long)13,&key,iv,&n);
BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]),
&(cbc_out[13]),len-13,&key,iv,&n);
if (memcmp(cbc_out,ofb64_ok,(int)len) != 0)
{
err=1;
printf("BF_ofb64_encrypt encrypt error\n");
for (i=0; i<(int)len; i++) printf("0x%02X,",cbc_out[i]);
}
n=0;
memcpy(iv,cbc_iv,8);
BF_ofb64_encrypt(cbc_out,cbc_in,17,&key,iv,&n);
BF_ofb64_encrypt(&(cbc_out[17]),&(cbc_in[17]),len-17,&key,iv,&n);
if (memcmp(cbc_in,cbc_data,(int)len) != 0)
{
printf("BF_ofb64_encrypt decrypt error\n");
err=1;
}
return(err);
}
int main(int argc, char *argv[])
{
unsigned char ukey[8];
unsigned char indata[40],outdata[40],ivec[8] = {0};
unsigned char check_outdata[40] = {
-11, 25, 13, -69, -45, -32, 31, 46,
-77, -34, 57, -26, 1, -125, -65, 119,
67, -82, -23, -42, -47, 51, 15, 71,
83, 30, 89, -58, 33, 67, -97, 87,
-61, -114, -87, -42, -111, -45, 15, 71
};
int num;
int by=0,i=0;
int encordec=-1;
char *cp,ch;
int n, n2;
initialise_board();
start_trigger();
for(n = 0; n < SCALE_FACTOR; ++n)
{
encordec = 1;
num=0;
/* Read the key */
cp = ckey;
while(i < 64 && *cp) /* the maximum key length is 32 bytes and */
{ /* hence at most 64 hexadecimal digits */
ch = *cp++; /* process a hexadecimal digit */
if(ch >= '0' && ch <= '9')
by = (by << 4) + ch - '0';
else if(ch >= 'A' && ch <= 'F')
by = (by << 4) + ch - 'A' + 10;
else /* error if not hexadecimal */
{
// printf("key must be in hexadecimal notation\n");
exit(-1);
}
/* store a key byte for each pair of hexadecimal digits */
if(i++ & 1)
ukey[i / 2 - 1] = by & 0xff;
}
BF_set_key(&key,8,ukey);
if(*cp)
{
//printf("Bad key value.\n");
exit(-1);
}
i=0;
for(n2 = 0; n2 < 256; ++n2)
{
while(i<40)
indata[i++]=rand();
BF_cfb64_encrypt(indata,outdata,i,&key,ivec,&num,encordec);
encordec = 1-encordec;
BF_cfb64_encrypt(outdata,indata,i,&key,ivec,&num,encordec);
i=0;
}
}
stop_trigger();
/* Verify that we have the correct result. */
int to_return = 0;
for (i = 0; i < 40; i++) {
if (outdata[i] != check_outdata[i]) {
to_return = -1;
break;
}
}
return to_return;
}
UT_Error ODc_Crypto::performDecrypt(GsfInput* pStream,
unsigned char* salt, UT_uint32 salt_length, UT_uint32 iter_count,
unsigned char* ivec, const std::string& password, UT_uint32 decrypted_size,
GsfInput** pDecryptedInput)
{
unsigned char sha1_password[PASSWORD_HASH_LEN];
char key[PBKDF2_KEYLEN];
// get the sha1 sum of the password
sha1_buffer(&password[0], password.size(), sha1_password);
// create a PBKDF2 key from the sha1 sum
int k = pbkdf2_sha1 ((const char*)sha1_password, PASSWORD_HASH_LEN, (const char*)salt, salt_length, iter_count, key, PBKDF2_KEYLEN);
if (k != 0)
return UT_ERROR;
// create the decryption key
BF_KEY bf_key;
BF_set_key(&bf_key, PBKDF2_KEYLEN, (const unsigned char*)key);
// perform the actual decryption
UT_sint32 content_size = gsf_input_size(pStream);
if (content_size == -1)
return UT_ERROR;
const unsigned char* content = gsf_input_read(pStream, content_size, NULL);
if (!content)
return UT_ERROR;
int num = 0;
unsigned char* content_decrypted = (unsigned char*)g_malloc(content_size);
BF_cfb64_encrypt(content, content_decrypted, content_size, &bf_key, ivec, &num, BF_DECRYPT);
// deflate the decrypted content
z_stream zs;
zs.zalloc = Z_NULL;
zs.zfree = Z_NULL;
zs.opaque = Z_NULL;
zs.avail_in = 0;
zs.next_in = Z_NULL;
int err;
err = inflateInit2(&zs, -MAX_WBITS);
if (err != Z_OK)
return UT_ERROR;
unsigned char* decrypted = (unsigned char*)g_malloc(decrypted_size);
zs.avail_in = content_size;
zs.avail_out = decrypted_size;
zs.next_in = content_decrypted;
zs.next_out = decrypted;
err = inflate(&zs, Z_FINISH);
FREEP(content_decrypted);
if (err != Z_STREAM_END)
{
inflateEnd(&zs);
FREEP(decrypted);
return UT_ERROR;
}
inflateEnd(&zs);
*pDecryptedInput = gsf_input_memory_new(decrypted, decrypted_size, TRUE);
return UT_OK;
}
int main(int argc, char **argv)
{
int option;
int do_encrypt = 0;
int do_decrypt = 0;
int direction;
int in; // Input file handle.
int out; // Output file handle.
unsigned char raw_key[16];
BF_KEY key;
unsigned char IV[8];
int IV_index;
while ((option = getopt(argc, argv, "ed")) != -1) {
switch (option) {
case 'e': do_encrypt = 1; direction = BF_ENCRYPT; break;
case 'd': do_decrypt = 1; direction = BF_DECRYPT; break;
}
}
if (argc - optind != 3) {
fprintf(stderr,
"Usage: %s -e|-d infile outfile \"pass phrase\"\n", argv[0]);
return 1;
}
if ((do_encrypt == 1 && do_decrypt == 1) ||
(do_encrypt == 0 && do_decrypt == 0)) {
fprintf(stderr, "Exactly one of -e or -d must be specified.\n");
return 1;
}
// Prepare the key.
strncpy(raw_key, argv[optind + 2], 16);
BF_set_key(&key, 16, raw_key);
// Prepare the IV.
memset(IV, 0, 8);
IV_index = 0;
// Open the files.
if ((in = open(argv[optind + 0], O_RDONLY)) == -1) {
perror("Error opening input file");
return 1;
}
if ((out = open(argv[optind + 1], O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1) {
perror("Error opening output file");
close(in);
return 1;
}
while ((count = read(in, buffer, BUFFER_SIZE)) > 0) {
BF_cfb64_encrypt(buffer, buffer, count, &key, IV, &IV_index, direction);
if (write(out, buffer, count) != count) {
perror("Error writing output");
break;
}
}
close(in);
close(out);
return 0;
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
int count = *pcount;
int index = 0;
#ifdef _OPENMP
#pragma omp parallel for
for (index = 0; index < count; index += MAX_KEYS_PER_CRYPT)
#endif
{
unsigned char key[MAX_KEYS_PER_CRYPT][32];
unsigned char hash[MAX_KEYS_PER_CRYPT][32];
BF_KEY bf_key;
int bf_ivec_pos, i;
unsigned char ivec[8];
unsigned char output[1024];
SHA_CTX ctx;
#ifdef MMX_COEF
int lens[MAX_KEYS_PER_CRYPT];
unsigned char *pin[MAX_KEYS_PER_CRYPT], *pout[MAX_KEYS_PER_CRYPT];
#endif
if(cur_salt->checksum_type == 0 && cur_salt->cipher_type == 0) {
for (i = 0; i < MAX_KEYS_PER_CRYPT; ++i) {
SHA1_Init(&ctx);
SHA1_Update(&ctx, (unsigned char *)saved_key[index+i], strlen(saved_key[index+i]));
SHA1_Final((unsigned char *)(hash[i]), &ctx);
}
#ifdef MMX_COEF
for (i = 0; i < MAX_KEYS_PER_CRYPT; ++i) {
lens[i] = 20;
pin[i] = hash[i];
pout[i] = key[i];
}
pbkdf2_sha1_sse((const unsigned char**)pin, lens, cur_salt->salt,
cur_salt->salt_length,
cur_salt->iterations, pout,
cur_salt->key_size, 0);
#else
pbkdf2_sha1(hash[0], 20, cur_salt->salt,
cur_salt->salt_length,
cur_salt->iterations, key[0],
cur_salt->key_size, 0);
#if !ARCH_LITTLE_ENDIAN
for (i = 0; i < cur_salt->key_size/sizeof(ARCH_WORD_32); ++i) {
((ARCH_WORD_32*)key[0])[i] = JOHNSWAP(((ARCH_WORD_32*)key[0])[i]);
}
#endif
#endif
for (i = 0; i < MAX_KEYS_PER_CRYPT; ++i) {
bf_ivec_pos = 0;
memcpy(ivec, cur_salt->iv, 8);
BF_set_key(&bf_key, cur_salt->key_size, key[i]);
BF_cfb64_encrypt(cur_salt->content, output, cur_salt->content_length, &bf_key, ivec, &bf_ivec_pos, 0);
SHA1_Init(&ctx);
SHA1_Update(&ctx, output, cur_salt->content_length);
SHA1_Final((unsigned char*)crypt_out[index+i], &ctx);
}
}
else {
SHA256_CTX ctx;
AES_KEY akey;
unsigned char iv[16];
for (i = 0; i < MAX_KEYS_PER_CRYPT; ++i) {
SHA256_Init(&ctx);
SHA256_Update(&ctx, (unsigned char *)saved_key[index+i], strlen(saved_key[index+i]));
SHA256_Final((unsigned char *)hash[i], &ctx);
}
#ifdef MMX_COEF
for (i = 0; i < MAX_KEYS_PER_CRYPT; ++i) {
lens[i] = 32;
pin[i] = hash[i];
pout[i] = key[i];
}
pbkdf2_sha1_sse((const unsigned char**)pin, lens, cur_salt->salt,
cur_salt->salt_length,
cur_salt->iterations, pout,
cur_salt->key_size, 0);
#else
pbkdf2_sha1(hash[0], 32, cur_salt->salt,
cur_salt->salt_length,
cur_salt->iterations, key[0],
cur_salt->key_size, 0);
#if !ARCH_LITTLE_ENDIAN
for (i = 0; i < cur_salt->key_size/sizeof(ARCH_WORD_32); ++i) {
((ARCH_WORD_32*)key[0])[i] = JOHNSWAP(((ARCH_WORD_32*)key[0])[i]);
}
#endif
#endif
for (i = 0; i < MAX_KEYS_PER_CRYPT; ++i) {
memcpy(iv, cur_salt->iv, 16);
memset(&akey, 0, sizeof(AES_KEY));
if(AES_set_decrypt_key(key[i], 256, &akey) < 0) {
fprintf(stderr, "AES_set_decrypt_key failed!\n");
}
AES_cbc_encrypt(cur_salt->content, output, cur_salt->content_length, &akey, iv, AES_DECRYPT);
SHA256_Init(&ctx);
SHA256_Update(&ctx, output, cur_salt->content_length);
SHA256_Final((unsigned char*)crypt_out[index+i], &ctx);
}
}
}
return count;
}
