You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

164 lines
5.2 KiB
C

5 years ago
#include <stdio.h>
#include "gcrypt.h"
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>
#include <strings.h>
#include <omp.h>
#include <time.h>
5 years ago
#include <inttypes.h>
#include "cryptwrapper.h"
#include "rainbowvalue.h"
#include "readBulk.h"
int main(int argc, char const *argv[]) {
if (argc < 3) {
5 years ago
printf("please select rainbow table and encrypted file\n");
return 1;
}
FILE *fptr_rainbow = fopen(argv[1], "rb");
FILE *fptr_encry = fopen(argv[2], "rb");
5 years ago
if (fptr_encry == NULL) {
printf("could not open encrypted file %s\n", argv[1]);
5 years ago
return 1;
}
if (fptr_rainbow == NULL) {
printf("could not open rainbow table file %s\n", argv[2]);
5 years ago
return 1;
}
mycryptwrapper_init();
// to calculate hash without trailing 256 bits of decrypted file
size_t mens = gcry_md_get_algo_dlen(algo);
void *digest = malloc(mens);
5 years ago
// initialization vector for decryption and encryption
size_t len = 8;
size_t file_len;
if (fseek(fptr_encry, 0, SEEK_END)) {
perror("could not ssek end of file\n");
return 1;
5 years ago
}
file_len = ftell(fptr_encry);
if (file_len == 0) {
5 years ago
perror("file length is 0\n");
return 1;
}
rewind(fptr_encry); // go to beginning of file
uint8_t *buf = malloc(file_len);
if (fread(buf, sizeof(uint8_t), file_len, fptr_encry) != file_len) {
5 years ago
perror("could not read complete file\n");
return 1;
}
//encrypted file is stored in buf and can now be decrypted
struct s_rainbowvalue256 *rs = malloc(sizeof(struct s_rainbowvalue256) * BULKSIZE);
5 years ago
size_t num_rainbow_values;
// read a block of rainbow values
clock_t old_clock;
5 years ago
int success = 0;
while ((num_rainbow_values = fread(rs, sizeof(struct s_rainbowvalue256), BULKSIZE, fptr_rainbow)) != 0) {
if (success == 1) { break; }
5 years ago
printf("read %d rainbow values\n", (int) num_rainbow_values);
// iterate through rainbow values and decrypt
old_clock=clock();
#pragma omp parallel for
for (size_t i = 0; i < num_rainbow_values; i++) {
uint8_t *decrypted_buf = malloc(file_len);//allocate mem for decrypted buffer
5 years ago
gcry_cipher_hd_t dhd;
if (gcry_cipher_open(&dhd, cipher, GCRY_CIPHER_MODE_CFB, 0)) { perror("could not open cypher\n"); }
if (gcry_cipher_setkey(dhd, rs[i].hash, 8)) { perror("could not set key\n"); };
void *iv = malloc(len);
memset(iv, 0, len);
if (gcry_cipher_setiv(dhd, iv, len)) { perror("could not set init vector\n"); }
if (gcry_cipher_decrypt(dhd, decrypted_buf, file_len, buf, file_len)) { perror("could not decrypt\n"); }
5 years ago
//mycryptwrapper_print(decrypted_buf,file_len);
//printf("pw: %s\nfile:%s\n",rs[i].pw,decrypted_buf);
if (check_sha256_tag(decrypted_buf, file_len)) {
5 years ago
printf("pw: %s\n", rs[i].pw);
char *enc_fname = malloc(strlen(argv[2]) + 5);
5 years ago
strcpy(enc_fname, argv[2]);
strcat(enc_fname, ".decr");
FILE *encrypted_fptr = fopen(enc_fname, "wb");
if (fwrite(decrypted_buf, 1, file_len - 32, encrypted_fptr) != file_len - 32) {
5 years ago
perror("couln not write all data to decrypted file");
//return 1;
#pragma omp exitregion
};
printf("successfully saved decrypted data in %s\n", enc_fname);
//return 0;
success = 1;
#pragma omp exitregion
}
5 years ago
free(iv);
free(decrypted_buf);
gcry_cipher_close(dhd);
if (success == 1) {
#pragma omp exitregion
}
}// end for parallel
float sec = (float)((clock()-old_clock))/(float)CLOCKS_PER_SEC;
printf("Clocks per sec: %ld\ncalc/sec: %f\n",CLOCKS_PER_SEC, (float)BULKSIZE/sec);
if (success == 1) {
return 0;
5 years ago
}
}// end while
5 years ago
/*while (fread(&r, sizeof(struct s_rainbowvalue256), 1,fptr)) {//reading hash values from rainbowtable
gcry_cipher_hd_t dhd;
gcry_error_t err= gcry_cipher_open(&dhd,cipher,GCRY_CIPHER_MODE_CFB,0);
if (err){
printf("could not open handle\n");
}
err = gcry_cipher_setkey(dhd,r.hash,8);
if (err) {
printf("could not set key \n");
}
memset(iv,0,len);
err = gcry_cipher_setiv(dhd, iv , len);
if (err){
printf("could not init init vector");
}
memset(out,0,256);
err = gcry_cipher_decrypt(dhd,out,256,encrypted_secret,strlen(encrypted_secret));
if (err){
printf("could not decrypt\n");
}
if (strcmp(out,dummydata)==0){
printf("pw: %sfor data: %s\npwhash: ", r.pw, (char*)out);
mycryptwrapper_print(r.hash, strlen(r.hash));
gcry_cipher_close(dhd);//close cipher
return 0;
}
gcry_cipher_close(dhd);//close cipher
}
*/
if (success == 0) {
5 years ago
printf("\nnothing found\n");
}
//printdata(digest,mens);
return 0;
}