clientcrush.c

#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<unistd.h>
#include<sys/socket.h>
#include<sys/select.h>
#include<sys/time.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<errno.h>
#include <openssl/evp.h>

struct sockaddr_in srv_addr, my_addr, client_addr;
int sk,sudp;  			// socket: uno per server e uno per clientp2p
struct timeval  tempo;
char simbolo;
char shell;
char turno;
fd_set 	master,	//i descittori
read_fd; // fd di appoggio per la select
int		maxfd;

int conta;
void help()
{
    printf("ti verranno asseganti job da elaborare \n se vuoi uscire basta che premi q\n");
    
}


void print_bytes(const unsigned char* buf, int len) {
    int i;
    for (i = 0; i < len - 1; i++)
        
        printf("%02X", buf[len - 1]);
}
void quit()
{
    
    
    if (close(sk)==-1) //chiudo tcp
    {
        printf("errore chiusura");
        exit(1);
    }
    
    printf("ti sei disconesso con successo\n");
    exit(0);
}





void connectserver(char* ip, char* porta)
{
    long ret;
    sk = socket(AF_INET, SOCK_STREAM, 0);		//afinet =ipv4  stream e' TCP, 0 protoccolo
    if (sk==-1)
    {
        printf("errore nel creare socket\n");
        exit(1);
    }
    
    memset(&srv_addr, 0, sizeof(srv_addr));     //azzero la struttura
    srv_addr.sin_family=AF_INET;					// famiglia ipv4
    srv_addr.sin_port = htons(atoi(porta));			//porta
    ret = inet_pton(AF_INET, ip, &srv_addr.sin_addr); // per formato di rete
    
    if (ret==-1)
    {
        printf("errore formato di rete\n");
        exit(1);
    }
    
    
    ret = connect(sk,(struct sockaddr *)&srv_addr, sizeof(srv_addr));  // mi collego con il server
    
    if (ret==-1)
    {
        printf("errore connessione\n");
        exit(1);
    }
    else
        printf("connessione riuscita\n");
    return;
}



void calcolaLI(long i,unsigned char* l, unsigned char** p, int index)
{
    // i e' il numero di blocchi
    // n e' dimblocchi
    int n=16;
    char ris = 0;
    unsigned char L[16];
    //p=malloc(sizeof(unsigned char*)* i);
    p[0]=malloc(16);
#pragma omp parallel for
    for (int z=0; z<n; z++) //prima volta
    {
        L[z]=l[z];
    }
    
    
    char carry=0;
    //ultimo char e ' per vedere se completato... ***********
#pragma omp parallel for
    for (int z=1; z<index; z++) {           //scarto le prime L fino a index mio
        for (int j=0; j<16; j++) {
            ris = l[j]&127 || L[j]&127;
            //p[z][j]+= l[j] + carry;
            L[j]+=l[j] + carry;
            if (ris==1 && (L[j]&127)==0)
                carry=1;
            else
                carry=0;
        }
        carry=0;
    }
#pragma omp parallel for
    for (int j=0; j<16; j++) //prima volta
    {
        ris = l[j]&127 || p[0][j]&127;
        p[0][j]+= l[j] + carry;
        if (ris==1 && (p[0][j]&127)==0)
            carry=1;
        else
            carry=0;
        
        
    }
    carry=0;
#pragma omp parallel for
    for (int z=1; z<i; z++) { //L che mi servono dal mio index alla dim del blocco
        for (int j=0; j<16; j++) {
            ris = l[j]&127 || p[z-1][j]&127;
            p[z][j]= l[j] + carry + p[z-1][j];
            if (ris==1 && (p[z][j]&127)==0)
                carry=1;
            else
                carry=0;
            
        }
        carry=0;
    }
    
}

void mexserver() //gestisco i job
{
    
    long ret,quanti=0;
    char key[32] ;
    unsigned char * msg;
    long numblocchi;
    unsigned char **p;
    unsigned char zero[16];
    int index;
    EVP_CIPHER_CTX* ctx;
    unsigned char ** ciphertext;
    
    unsigned char* L;
    printf("mexdalserver\n");
    //key=malloc(32);
    ret = recv(sk, (void *)key, 32, 0);//key
    if(ret==-1) {
        printf("mexserver errore: errore in ricezione idjob dal server!\n");
        exit(1);
    }
    
    printf("key : \n");
    
    printf("key : %s\n",key);
    
    printf("\n");
    if(ret==0) { //server si e' disconnesso
        printf("Il server ha chiuso la connessione!!/n");
        exit(3);
    }
    ret = recv(sk, (void *)&index, sizeof(int), 0); //mi serve per il calcolo di p
    if(ret==-1) {
        printf("mexserver errore: errore in ricezione lunghezza dal server3!\n");
        exit(1);
    }
    printf("ricevuto index: %d\n",index);
    ret = recv(sk, (void *)&quanti, sizeof(long), 0); //ricevo lunghezza stringa
    if(ret==-1) {
        printf("mexserver errore: errore in ricezione lunghezza dal server1!\n");
        exit(1);
    }
    printf("ricevuto quanti: %ld\n",quanti);
    msg=malloc(quanti);
    ret = recv(sk, (void *)msg, quanti, 0); //ricevo file da cifrare
    if(ret==-1) {
        printf("mexserver errore: errore in ricezione lunghezza dal server2!\n");
        exit(1);
    }
    printf("ricevuto msg\n");
    printf("\n MSG %s\n",msg);
    numblocchi=quanti/16;
    printf("stai elaborando %ld\n",numblocchi);
    printf("blocchi \n");
    //**************************
    exit(1);//****************crush************************
    //****************************
    p=malloc(sizeof(unsigned char*)* numblocchi );
#pragma omp parallel for
    for (int z=1; z<numblocchi; z++) {
        p[z]=malloc(16);
        //l'ultimo carattere mi dice se completato..
    }
    ciphertext=malloc(sizeof(unsigned char*)*numblocchi);
    ctx = (EVP_CIPHER_CTX*)malloc(sizeof(EVP_CIPHER_CTX));
    EVP_CIPHER_CTX_init(ctx);
    int outlen=0;
    L=malloc(16);
    /* Context setup for encryption */
    EVP_EncryptInit(ctx, EVP_aes_256_ecb(), key, NULL);
    EVP_CIPHER_CTX_set_padding(ctx, 0);
    EVP_EncryptUpdate(ctx, L, &outlen, (unsigned char*)zero, 16);
    if (!EVP_EncryptFinal(ctx, L+outlen, &outlen)) { // se == 0 -> errore
     	printf("Errore in EVP_EncryptFinal\n");
    	exit(-1);
	}
	EVP_CIPHER_CTX_cleanup(ctx);
	EVP_CIPHER_CTX_free(ctx);
    for (int i=0; i<16; i++)
        printf(" %02X",  (unsigned char)L[i]);
    printf("\n");
    memset(zero, 0, 16);
    zero[15]=1;
    for (int i; i<16; i++)
        L[i]|=zero[i];
    
    //L trovata adessi IL;
    calcolaLI(numblocchi, L, p,index);
    char carry=0;
    char ris;
#pragma omp parallel for private(ctx, outlen)
    for (int i=0;i<numblocchi ; i++) { //fa il cipher
        for(int z=0;z <16;z++){
            // msg[i*16+z]+=p[i][z];{
            ris = msg[i*16+z]&127 || p[i][z]&127;
            msg[i*16+z]+= p[i][z] + carry;
            if (ris==1 && (msg[i*16+z]&127)==0)
                carry=1;
            else
                carry=0;
        }
        ciphertext[i]=malloc(16);
        carry=0;
        ctx = (EVP_CIPHER_CTX*)malloc(sizeof(EVP_CIPHER_CTX));
        EVP_CIPHER_CTX_init(ctx);
        outlen = 0;
        EVP_EncryptInit(ctx, EVP_aes_256_ecb(), key, NULL);
        EVP_CIPHER_CTX_set_padding(ctx, 0);
        EVP_EncryptUpdate(ctx, ciphertext[i], &outlen, &msg[i*16], 16);
        if (!EVP_EncryptFinal(ctx, ciphertext[i]+outlen, &outlen)) { // se == 0 -> errore
        	printf("Errore in EVP_EncryptFinal\n");
           	exit(-1);
		}
        EVP_CIPHER_CTX_cleanup(ctx);
		EVP_CIPHER_CTX_free(ctx);
        
    }
    
    
#pragma omp parallel for
    for (int i=0;i<numblocchi ; i++) { //xor tra i cipher calcolati
        for(int z=0;z <16;z++)
            zero[z]^=ciphertext[i][z];
        
    }
    char x='a';
    ret=send(sk,(void*)&x,sizeof(char),0);//mando risultato
    if (ret ==-1)
    {
        printf ("errore nel mandare comando e' il mex d'uscita");
        exit(1);
    }
    printf("zero : \n");
    for (int i=0; i<16; i++)
        printf(" %02X",  (unsigned char)zero[i]);
    printf("\n");
    ret=send(sk,(void*)zero,16,0);//mando risultato
    if (ret ==-1)
    {
        printf ("errore nel mandare comando e' il mex d'uscita");
        exit(1);
    }
    printf("finito un job\n");
}






void tastiera()

{
    char s;
    scanf("%s",&s);
    if(s=='q')
    {
        quit();
    }
    else
        printf("comando non riconosciuto");
    fflush(stdin);
}
int main(int quantiparametri,char* arg[])
{
    int i;
    int scaduto;  //per il timer
    long ret;
    int quanti;
    if (quantiparametri != 3)
    {
        printf ("devi passare 2 parametri : ip e porta \n");
        exit(1);
    }
    help();
    
    printf("dimmi quanti core/thread hai a disposizione \n");
    printf(">");
    scanf("%d",&quanti);
    if (quanti<1 || quanti>1024)
    {
        printf("formato num core e' sbagliato\n");
        exit(1);
        
    }
    connectserver(arg[1],arg[2]);
    ret=send(sk,(void*)&quanti,sizeof(int),0);  //gli mando prima quanto e' grande l'utente
    if (ret ==-1)
    {
        printf ("errore send numcores");
        exit(1);
    }
    printf ("connessi\n");
    help();
    FD_ZERO(&master);	//azzero master
    FD_ZERO(&read_fd);
    FD_SET(sk,&master);   //setto server
    FD_SET(0,&master);		//setto 0 per tastiera
    
    maxfd=sk;
    
    
    for (;;)
        
    {
        read_fd=master;  //perche la select mi 'danegerebbe' master
        fflush(stdout);
        scaduto=select(maxfd+1, &read_fd, NULL, NULL, NULL);
        if (scaduto==-1)
        {
            printf("errrore select\n");
            exit(1);
        }
        printf("evento");
        for (i=0; i<=maxfd;i++)
        {
            if(FD_ISSET(i, &read_fd))
            {
                if (i==0) //tastiera
                {
                    tastiera();
                    
                }
                else
                    if (i==sk) //mex dal server
                        mexserver();
                
            }
        }
    }
    return 0;
}