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