int send_file(char* file_name, int sk) {
FILE* file;
FILE* fp;
int name_size; // size of the name of the file to be sent
int size,k_size; // size of the file to be sent
int ret, i;
unsigned char* buffer; // pointer to the buffer containing the file
char* sym_key;
int enckeysize;
int remote_random,local_random;
char* password;
//***** recieve the random value from server *****//
ret = recv(sk, &remote_random, sizeof(int), MSG_WAITALL);
file = fopen("key","r");
/* Retrieve the size of the key to be sent */
fseek(file,0,SEEK_END);
k_size = ftell(file);
/* Memory allocation for the key to be sent */
sym_key = malloc(k_size * sizeof (char));
fseek(file, 0, SEEK_SET);
/* Read key from file */
ret = fread(sym_key, 1, k_size, file);
//***** RSA ENCRYPTION PART BEGIN *****//
char* enckey;
RSA* rsa = RSA_new();
fp = fopen("pub.pem","r");
PEM_read_RSAPublicKey(fp,&rsa,NULL,NULL);
enckeysize =RSA_size(rsa);
enckey=malloc(enckeysize * sizeof(char));
RSA_encrypt(sym_key,enckey,k_size,rsa);
fclose(fp);
//*** RSA ENCRYPTION PART end ***//
/* Computation of the length of the filename */
name_size = strlen(file_name);
/* Open the file to be sent */
file = fopen(file_name,"r");
if(file == NULL) {
printf("\nError opening the file file\n");
return 1;
}
/* Retrieve the size of the file to be sent */
fseek(file,0,SEEK_END);
size = ftell(file);
/* Memory allocation for the file to be sent */
buffer = malloc(size * sizeof (char));
fseek(file, 0, SEEK_SET);
/* File reading */
ret = fread(buffer, 1, size, file);
if(ret < size) {
printf("\n Error reading the file \n");
return 1;
}
fclose(file);
/* The length of the file name is sent */
ret = send(sk, &name_size, sizeof(name_size), 0);
if(ret != sizeof(name_size)){
printf("\n Error trasmitting the length of the file name\n ");
return 1;
}
/* The file name is sent */
ret = send(sk, file_name, name_size, 0);
if(ret < name_size){
printf("\n Error transmitting the file name\n ");
return 1;
}
//****** Generate hash for freshness and origin(password) check *****//
time_t t;
int password_size;
int fresh_size;
char* fresh_txt;
t = time(NULL);
srand ( time(NULL));
local_random = rand();
file = fopen("passofA.txt","r");
fseek(file,0,SEEK_END);
password_size = ftell(file);
password = malloc(password_size * sizeof (char));
fseek(file, 0, SEEK_SET);
ret = fread(password, 1, password_size, file);
fclose(file);
int pass_hash_len;
const EVP_MD *md1;
md1 = EVP_get_digestbyname("sha1");
unsigned char pass_md_value[EVP_MD_size(md1)];
pass_hash_len=hash_gen(password,&pass_md_value[0]);
fresh_size=sizeof(password)+sizeof(local_random)+sizeof(remote_random);
fresh_txt = malloc(fresh_size);
int loc_rand_size=sizeof(local_random);
int rem_rand_size = sizeof(remote_random);
memcpy(fresh_txt,&pass_md_value[0],pass_hash_len);
memcpy(&fresh_txt[pass_hash_len],&local_random,loc_rand_size);
memcpy(&fresh_txt[pass_hash_len+loc_rand_size],&remote_random,rem_rand_size);
const EVP_MD *md;
md = EVP_get_digestbyname("sha1");
unsigned char md_value[EVP_MD_size(md)];
int md_len;
md_len=hash_gen(fresh_txt,&md_value[0]);
printf("\n Freshness Digest is: \n");
for(i = 0; i < md_len; i++) printbyte(md_value[i]);
printf("\n");
///*** SYMMETRIC KEY ENCRYPTION PART BEGIN ***///
char* totbuffer;
int nctot;
char *plaintext, *ciphertext;
int totbufsize = size+md_len;
totbuffer = malloc(totbufsize);
// message + digest for freshness and password
memcpy(totbuffer,buffer,size);
memcpy(&totbuffer[size],md_value,md_len);
ciphertext = malloc(totbufsize+128);
nctot = symmetric_encrypt(totbuffer,ciphertext,totbufsize); // encrypted size
//***** SYMMETRIC KEY encryption part END *****///
//***** concatenate enckey and ciphertext *****//
char* textnkeynhash;
int totsize;
totsize=nctot+enckeysize+loc_rand_size;
textnkeynhash=malloc(totsize);
memcpy(textnkeynhash,ciphertext,nctot);
memcpy(&textnkeynhash[nctot],enckey,enckeysize);
memcpy(&textnkeynhash[nctot+enckeysize],&local_random,loc_rand_size);
/* The file size is sent */
ret = send(sk, &totsize, sizeof(totsize), 0);
if(ret != sizeof(size)){
printf("\n Error transmitting the file size\n ");
return 1;
}
/* The file is sent */
ret = send(sk, textnkeynhash, totsize, 0);
if(ret < size){
printf("\n Error transmitting the file\n");
return 1;
}
printf("\n File %s with size %d bytes has been sent\n", file_name, totsize);
free(buffer);
free(ciphertext);
return 0;
}
static int ocd_encrypt(Npcrypt* crypt, char* data, int length, char** result, int* result_length) {
struct openssl_crypt_data* priv;
priv = (struct openssl_crypt_data*)crypt->priv;
return symmetric_encrypt(&priv->encrypt_ctx, data, length, result, result_length);
}
