Costruiamo un programma per crittografare del testo

Transcript

1 Costruiamo un programma per crittografare del testo Per codificare un messaggio in modo tale che il suo testo non risulti leggibile a persone che non siano in possesso dell'opportuna procedura di decodifica, è necessario che: la procedura utilizzata per la codifica del testo non sia troppo ovvia la procedura di codifica sia invertibile, in modo tale che si possa riottenere il messaggio "in chiaro" a partire dal testo cifrato Costruiamo quindi una "ricetta", basata su queste caratteristiche, che permetta di codificare un testo utilizzando i seguenti ingredienti: direttive per il preprocessore allocazione dinamica della memoria aritmetica dei puntatori operatori bit-a-bit Alcune note sulla direttiva define Per definire una macro con la direttiva #define si possono usare due metodi: 1. Inserire la direttiva #define all'interno del codice; ad esempio #define NUM 50 permette di assegnare alla macro NUM il valore int vettore[num]; /* quando il preprocessore analizza il testo, questa macro verrà sostituita con il valore 50 */...

2 2. Non inserire alcuna direttiva all'interno del codice, utilizzare la macro come se essa fosse stata definita... int vettore[num];... e modificare il comando di compilazione: gcc -DNOME_MACRO=VALORE programma.c -o prova La direttiva #define permette di definire anche delle funzioni #define PER(a,b) (a) * (b)... codice... int numero = 4; double valore = 6; PER(numero,valore); -> viene espansa in (numero) * (valore)... codice... le parentesi tonde servono ad evitare che PER(numero + valore,valore); venga espansa in numero + valore * valore (che non e' ciò che ci aspettiamo...) se scrivo #define PER(a,b) (a) * (b); non serve inserire il ';'... codice... int numero = 4; double valore = 6; PER(numero,valore) -> viene espansa in (numero) * (valore);... codice... La macro predefinita FILE contiene il nome del file che viene compilato

3 Nota: l'operatore bit-a-bit XOR se l'operatore XOR bit-a-bit viene applicato a due bit, uno dei quali si supponga noto, allora: Bit di partenza Bit noto applico XOR Bit noto Applico XOR 1 1 -> 0 1 -> > 1 1 -> 0 quindi se applico due volte l'operatore XOR, mantenendo costante il valore del secondo bit, alla fine riottengo il valore del bit iniziale Partendo da una stringa, l 'algoritmo da applicarle per la codifica è il seguente: 1. Prendo 1 char dalla stringa 2. scambio, all'interno della rappresentazione binaria del char, ogni bit dispari con il successivo pari 3. Suddivido i caratteri che compongono la stringa in gruppi composti da 4 caratteri ciascuno; 4 variabili da un byte costituiscono una variabile da 4 byte, quindi tratto ciascun gruppo come se fosse formato da una sola variabile di tipo intero. 4. Applico lo XOR bit a bit a tale intero usando come riferimento un numero intero inserito dall'utente Attenzione: se codifico 4 char alla volta, significa che la lunghezza della stringa, compreso il terminatore, deve essere multipla di 4. Se così non fosse, devo modificare la lunghezza della stringa aggiungendovi dei caratteri.

4 Come strutturiamo il codice? Durante l'operazione di cifratura dei caratteri, la stringa che deve essere codificata ed il valore intero introdotto dall'utente NON devono in alcun modo essere modificati; se la stringa venisse modificata il testo iniziale potrebbe essere alterato e se il numero inserito dall'utente venisse alterato non sarebbe più possibile invertire l'algoritmo di codifica. Dividiamo perciò il codice in più file, in modo tale che non risulti possibile al programmatore alterare il valore di tali variabili: codifica.c codifica.h prog.c eventuali direttive per il preprocessore variabili globali cui accedono le funzioni prototipi delle funzioni main() implementazioni delle funzioni Quali funzioni è necessario implementare per poter ottenere il risultato richiesto? Quali devono essere i prototipi di tali funzioni? Prima di scrivere i prototipi pensiamo a quale modalità utilizzare per svolgere le operazioni richieste. Per inserire 4 char in un int possiamo seguire due strade: 1. Copiare, all'interno dell'int (4 Byte), i valori dei 4 char (1 Byte l'uno)

5 (v. inizio lezione 16) 2. Utilizzare i 4 char già disponibili, inseriti in un array, ed interpretare le 4 sequenze da 8 bit (char) l'una come un'unica sequenza da 32 bit (intero) char parola[4]; /* ho a disposizione 4 char -> 4 Byte */ int p_int; /* considero l'intera area di memoria da 4 Byte e la interpreto come se essa contenesse la rappresentazione di una variabile di tipo intero */ p_int = (int *) parola; Se seguiamo il secondo metodo, possiamo fare in modo che la medesima area di memoria possa essere interpretata, di volta in volta, come composta da elementi di tipo diverso, una volta da char, una volta da int ed una volta da double. Passiamo alle implementazioni: 1. Una funzione deve occuparsi di chiedere all'utente di inserire una stringa di caratteri. Essendo il puntatore a char con cui viene gestita la stringa una variabile di tipo globale, non è necessario che la funzione accetti parametri o restituisca un valore. 2. Prima di codificare la stringa è necessario verificare che il numero di caratteri in essa contenuti sia multiplo di 4; una funzione deve occuparsi di effettuare questo controllo e di inserire dei caratteri aggiuntivi, ad esempio degli 0, nel caso in cui questa condizione non fosse verificata. La funzione deve effettuare una copia della stringa originale, restituire un puntatore ad una stringa contenente un numero complessivo di caratteri multiplo di 4 e liberare l'area di memoria in cui era stata salvata la stringa originale. 3. Dato un char, una funzione deve essere in grado di scambiare i bit dispari della sua rappresentazione binaria con gli adiacenti pari. Effettuato lo scambio, non è necessario restituire alcun valore. 4. Una funzione si deve occupare di chiedere all'utente di inserire un numero intero, numero che verrà poi utilizzato per applicare lo XOR. La variabile in cui viene inserito questo valore è globale, quindi la funzione non accetta parametri e non restituisce alcun valore. 5. Dato un gruppo di 4 char, una funzione deve interpretare questi 4 valori come se essi costituissero un int; la funzione deve poi applicare l'operatore XOR a tale intero utilizzando come secondo operando il valore intero inserito dall'utente. La funzione agisce su un'area di memoria gestita mediante una variabile globale, quindi non necessita di parametri e non deve restituire valori.

6 6. Una volta ottenuti gli int, una funzione può occuparsi della loro visualizzazione. /* inizio del file codifica.h */ /* qui andrebbero inseriti dei commenti per descrivere i compiti svolti dalle funzioni */ void inserisci_stringa(void); void controlla(void); void scambia_bit(void); void sceglixor(void); void applicaxor(void); void mostra_int(void); /* fine del file codifica.h */ /* inizio del file codifica.c */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* il carattere '\' serve per scrivere una direttiva su più di una riga. La macro FILE viene automaticamente inizializzata in modo tale da contenere il nome del file in cui la macro stessa viene inserita. In questo caso, la macro ha il valore codifica.c */ #define Errore(a) \ printf("\nerrore di allocazione nella funzione %s del file %s",a, FILE ) /* le variabili globali */ static int interoxor; static char *stringa_da_cifrare; /* puntatore alla stringa inserita dall'utente */ /* puntatore alla stringa contenente un numero di caratteri multiplo di 8 */ static char *stringa_4;

7 void inserisci_stringa(void) {/* allocazione di memoria per il primo puntatore a char */ stringa_da_cifrare = (char*) malloc (MAX_CHAR * sizeof(char)); if(stringa_da_cifrare == NULL) {Errore("inserisci stringa"); exit(0); printf("inserisci una stringa avente al massimo %d caratteri",max_char-1); gets(stringa_da_cifrare); void controlla(void) {int lunghezza; lunghezza = strlen(stringa_da_cifrare) + 1; /* includo anche il terminatore */ if( (lunghezza%4)!= 0 ) /* lunghezza NON è multiplo di 4 */ {lunghezza = lunghezza + (4 - (lunghezza % 4)); /* ora lo è! */ stringa_4 = (char*) calloc(lunghezza, sizeof(char)); /* inizializza l'area con degli 0 */ if(stringa_4 == NULL) {Errore("controlla");; exit(0); strcpy(stringa_4,stringa_da_cifrare); free(stringa_da_cifrare); /* libero l'area di memoria occupata dalla stringa originale */ void scambia_bit(void) {int i,j,bitpari,bitdispari; char valore; i = 0; while(*(stringa_4+i)) {valore = 0 ; for(j=0;j<4;j++) {bitdispari = ((*(stringa_4+i))>>(2*j)) & 1; bitpari = ((*(stringa_4+i))>>(2*j+1)) & 1; valore = valore ^ (bitdispari<< (2*j+1)); valore = valore ^ (bitpari<< (2*j)); *(stringa_4+i) = valore; i++;

8 void sceglixor(void) {printf("\n Inserisci il numero segreto da usare per lo XOR: "); scanf("%d",& interoxor ); void applicaxor(void) {int* int_pointer; int i = -1; /* serve per scorrere la stringa di char */ /* suddivido i char in gruppi da 4 e li interpreto, di volta in volta, come se fossero degli int termino le operazioni quando arrivo all'ultimo gruppo di 4 char (lo riconosco perchè, di sicuro, l'ultimo char del gruppo ha un codice ASCII pari a 0) Uso il costrutto do-while() perché lo XOR deve essere effettuato anche sull'ultimo gruppo di 4 char */ int_pointer = (int*) stringa_4; do {*int_pointer = *int_pointer ^ interoxor; int_pointer ++; /* avanzo di 4 Byte, ovvero di un int */ i = i + 4; /* avanzo di 4 Byte, ovvero di 4 char */ while( stringa_4[i]!= 0 ); void mostra_int(void) {int *int_pointer,i=-1; int_pointer=(char*) stringa_4; do {printf("\n %d ",*int_pointer); int_pointer++; i+=4; while(!stringa_4[i]);

9 /* fine del file codifica.c */ /* inizio del file prog.c */ #include <codifica.h> int main() { printf("\n inizia la procedura per la codifica di una stringa di testo \n"); inserisci_stringa(); controlla(); scambia_bit(); sceglixor(); applicaxor(); mostra_int(); printf("\n la procedura per la codifica di una stringa di testo e\' terminata \n"); return 0; /* fine del file prog.c */ Quali sono i comandi di compilazione per passare dai file appena costruiti all'eseguibile? 1. Effettuare la sola compilazione del file codifica.c e definire, in concomitanza con la compilazione, la macro MAX_CHAR ed il suo valore gcc -DMAX_CHAR=50 -c codifica.c -o codifica.o 2. Effettuare la sola compilazione del file prog.c gcc -c prog.c -o prog.o 3. Utilizzare il linker per unire i due codici oggetto appena prodotti gcc codifica.o prog.o -o prog_codifica NOTA:

10 Per generalizzare quanto fatto sopra, si può inserire nel file codifica.c una funzione che permetta di effettuare automaticamente tutti i passaggi, a parte l'inserimento del numero intero con cui effettuare lo XOR. void traduci(void); void traduci(void) { inserisci_stringa(); controlla(); scambia_bit(); applicaxor(); mostra_int(); IMPORTANTE: gli indici degli array non devono essere necessariamente dei numeri interi positivi int a,i; int *vettore = (int *) malloc(50 * sizeof(int)); if(vettore == NULL) {printf("allocazione fallita");exit(0); for(i=0;i<50;i++) vettore[i] = i; /* il puntatore vettore fa riferimento al primo elemento dell'array */ a = vettore[0]; /* ad a viene assegnato il valore del primo elemento, 0*/ vettore = vettore + 8; /* ora vettore fa riferimento al nono elemento dell'array */ a = * vettore; /* ad a viene assegnato il valore del nono elemento, 8*/ a = vettore[0]; /* un altro modo di assegnare ad a il valore del nono elemento, 8 */ a = *(vettore-8); /* assegno ad a il valore dell'elemento che si trova 8 posizioni prima del nono, ovvero del primo elemento dell'area di memoria, 0 */ a = vettore[-8]; /* un altro modo di riscrivere l'istruzione precedente */ Esercizio: 1. Scrivere il prototipo e l'implementazione di una funzione che restituisce un valore di tipo puntatore ad intero e che non accetta alcun parametro. La funzione deve chiedere all'utente di inserire, utilizzando la tastiera, un numero intero compreso tra 10 e 100; tale valore deve essere assegnato ad una variabile globale. La funzione deve poi allocare un'area di memoria di dimensione tale da contenere un

11 numero di elementi di tipo int pari al valore inserito dall'utente. Tali valori devono essere inizializzati con numeri casuali compresi tra 100 e 200 e tra 400 e 500. Completata l'inizializzazione la funzione deve restituire un valore pari all'indirizzo del primo elemento dell'array. NOTA: la funzione deve controllare se, dopo la chiamata alla funzione malloc, l'allocazione dell'area di memoria sia avvenuta o meno. 2. Scrivere il prototipo e l'implementazione di una funzione che accetta come parametro un valore di tipo puntatore ad intero e che non restituisce alcun valore; l'array cui fa riferimento il puntatore è quello inizializzato al punto precedente. La sua dimensione, quindi, è pari al valore assegnato alla variabile globale. La funzione deve disporre gli elementi dell'array di int in ordine crescente. Fatto questo, i soli elementi compresi tra 400 e 500 devono essere disposti in ordine decrescente. 3. Scrivere il prototipo e l'implementazione di una funzione che accetta come parametro un valore di tipo puntatore ad intero e che non restituisce alcun valore; l'array cui fa riferimento il puntatore è quello inizializzato al punto (1). La sua dimensione, quindi, è pari al valore assegnato alla variabile globale. La funzione deve visualizzare la rappresentazione in base due del valore di ciascuno degli elementi dell'array a. b. Scrivere il prototipo e l'implementazione di una funzione che accetta come parametro un puntatore ad un array di char (la cui dimensione (terminatore compreso) sia multipla di 4). La funzione deve visualizzare i valori contenuti nell'array interpretandoli come char, come int e come float. Scrivere il prototipo e l'implementazione di una funzione che accetta come parametro un puntatore a char ed un intero. La funzione deve disporre in ordine crescente gli elementi dell'array, il cui numero è pari al valore dell'intero che la funzione riceve come secondo parametro. Scrivere analoghe funzioni per l'ordinamento degli int, dei float e dei double. Sfruttando queste funzioni, vi viene in mente come crearne una nuova che ordini un qualsiasi array (formato da char, int, float o double), disponendone gli elementi in ordine crescente? c. Implementare la funzione scambia_bit() in modalità ricorsiva d. Invertire l'algoritmo per la codifica dei caratteri

12