BigInteger p = BigInteger.probablePrime(keyLength/2, new SecureRandom()); // Generiamo un numero "probabilmente" primo, p
		BigInteger q = BigInteger.probablePrime(keyLength/2, new SecureRandom()); // Generiamo un numero "probabilmente" primo, q

		// Calcoliamo n e phi
		BigInteger n = p.multiply(q);
		BigInteger phi = p.subtract(new BigInteger("1")).multiply(q.subtract(new BigInteger("1")));

		// publicKey conterra' l'esponente pubblico e,
		// scegliendo e come il primo numero primo successivo a
		// p, esso sara' anche coprimo con phi (come richiesto nell'algoritmo)
		this.publicKey = p.nextProbablePrime();
		this.privateKey = publicKey.modInverse(phi);
		this.n = n;
	}

Una precisazione sulla funzione probablePrime() e nextProbablePrime(): esse restituiscono un numero che probabilmente e’ primo, utilizzando dei test di probabilita’ probabilistici. Il margine di errore e’ molto basso: per essere precisi, la probabilita’ che un numero restituito da queste due funzioni sia composto e’ sempre minore di 2^-100 e la velocita’ dell’algoritmo lo rende preferibile ad uno deterministico nella generazione delle chiavi. Una volta generate le chiavi, si possono gia’ creare le due funzioni di base per criptare/decriptare un numero intero. Ecco il codice:

	public BigInteger encrypt(BigInteger m) {
		return m.modPow(publicKey, n); // (m^publicKey) % n
	}
	public BigInteger decrypt(BigInteger m) {
		return m.modPow(privateKey, n); // (m^privateKey) % n
	}

Dovrebbe essere abbastanza chiaro. La funzione modPow(e, n) restituisce semplicemente this ^ e % n e ci risparmia un po di calcoli. Con queste due semplici funzioni possiamo pero’ criptare unicamente numeri interi; per poter usare l’algoritmo su un testo piu’ o meno lungo dobbiamo creare altre due funzioni che processano il testo in maniera tale da essere compatibile con l’algoritmo, i passi principali saranno questi:

1. aggiungere del padding (casuale) al testo in modo da renderlo divisibile in blocchi di uguali dimensioni. la dimensione di ogni blocco sara’ la lunghezza della chiave.
2. processare ogni blocco, convertire il testo in un intero e cifrarlo

Per il processo inverso, invece:

1. dividere il testo nel numero di blocchi in base alla chiave.
2. decriptare ogni blocco e convertire gli interi nel testo corrispondente
3. rimuovere il padding.

Ecco il codice con alcuni commenti esplicativi:

	public String encrypt(String m) {
		/* Per comodita' (piu' sotto si vedra' perche') convertiamo i
		 * caratteri del messaggio nel loro codice ASCII (esadecimale)
		 */
		String mHex = "";
		for (int i = 0; i < m.length(); i++) {
			mHex += Integer.toHexString(m.charAt(i));
		}

		/* Calcoliamo quanto padding e' necessario, chiamiamolo N, e poi concateniamo al messaggio
		 * N-1 bytes di padding casuale. L'ultimo non deve essere casuale ma deve contenere appunto
		 * il numero N, cosi' da poter poi rimuovere la giusta quantita di padding nella funzione decrypt().
		 */
		int padding = blockSize - (mHex.length()/2)%blockSize;
		for (int i = 0; i < padding-1; i++) { // Prima generiamo N-1 byte casuali
			int randomPadding = (int)(10*Math.random());
			mHex += randomPadding < 10 ? "0" + Integer.toHexString(randomPadding) : Integer.toHexString(randomPadding);
		}
		// Ultimo byte di padding
		mHex += padding < 10 ? "0" + Integer.toHexString(padding) : Integer.toHexString(padding);

		int numBlocks = (mHex.length()/2)/blockSize; // Numero di blocchi in cui dividere il messaggio

		String result = "", currentBlock = "";
		for (int b = 0; b < numBlocks; b++) {
			currentBlock = mHex.substring(b*blockSize*2, (b+1)*blockSize*2);

			/* Il blocco corrente, essendo una stringa in formato esadecimale,
			 * quindi un numero, puo' essere criptato con le due funzioni che abbiamo gia'
			 * creato precedentemente che accettano come argomento un BigInteger.
			 */
			// Questo costruttore accetta una stringa, e la base come secondo argomento
			BigInteger r = encrypt(new BigInteger(currentBlock, 16)); 

			/* Puo' accadere che la string che otteniamo come risultato abbia un byte in meno,
			 * in questo caso, per non avere problemi nel decriptare il messaggio, aggiungiamo
			 * uno zero iniziale che non cambia niente, ma la rende della dimensione corretta.
			 */
			if (r.toString(16).length() == blockSize*4) {
				result += r.toString(16);
			} else {
				result += ("0" + r.toString(16));
			}
		}
		return result;
	}

	public String decrypt(String m) {
		int numBlocks = (m.length()/2)/(blockSize*2);

		String temp = "", currentBlock = "";
		/* Questo ciclo, quasi uguale a quello della funzione encrypt(), scorre ogni
		 * blocco, lo decripta e concatena il risultato in una nuova stringa.
		 */
		for (int b = 0; b < numBlocks; b++) {
			currentBlock = m.substring(b*blockSize*4, (b+1)*blockSize*4);
			BigInteger r = decrypt(new BigInteger(currentBlock, 16));
			temp += r.toString(16);
		}

		/* Il padding e' uguale all'ultimo byte della
		 * stringa, come avevamo precedentemente impostato.
		 */
		int padding = Integer.parseInt(temp.substring(temp.length()-2), 16);
		int actualLength = temp.length() - padding*2;

		// Rimuove il padding
		temp = temp.substring(0, actualLength);

		String result = "";
		// Riconverte la stringa da esadecimale a testo
		for (int i = 0; i < temp.length(); i+=2) {
			result += (char)Integer.parseInt(temp.substring(i,i+2), 16);
		}
		return result;
	}

Tutto il codice e’ contenuto in questo archivio disponibile per il download.

L’idea di base della crittografia a chiave pubblica serve proprio a porre fine a questo inconveniente e a rendere non piu’ necessaria una comunicazione preliminare (e sicura) tra le parti per scambiarsi una chiave. In un algoritmo a chiave asimmetrica vengono infatti create due chiavi anziche’ una: quella pubblica verra’ usata da chi vuole cifrare un messaggio da inviare al possessore di quella chiave, quella privata verra’ utilizzata dallo stesso per decifrare il messaggio ricevuto. La chiave pubblica di ognuno viene, insomma, resa disponibile a chiunque voglia inviargli un messaggio, che sara’ poi decifrabile solamente usando la chiave privata, tenuta segreta.

Chiaramente le due chiavi devono essere correlate in qualche modo per avere la proprieta’ sopra descritta, e cioe’ che si possa crittografare un testo con una chiave (quella pubblica) e decriptarlo con un’altra (quella privata) ottenendo lo stesso testo di partenza. In particolare, esistendo questa relazione tra le chiavi bisogna evitare che dalla chiave pubblica, che tutti possono leggere, si possa risalire a quella privata. Bisogna cioe’ trovare un modo per generarla che sia facile da percorrere in un verso (cioe’ generare la chiave), ma che sia quasi impossibile da percorrere nell’altro, cioe’ trovare i dati usati per generarla partendo dalla chiave pubblica (altrimenti, una volta ottenuti i dati, si potrebbe generare la chiave privata ad essa associata).

I primi ad inventare un tale sistema furono W. Diffie e M. Hellman nel 1976, ma fu nel ‘77 che Rivest, Shamir e Adleman, tutti studenti del MIT, realizzarono uno degli algoritmi a chiave pubblica piu’ utilizzato al giorno d’oggi e che prende il nome di RSA. La sicurezza dell’algoritmo RSA si basa sulla difficolta’ di fattorizzare in tempi accettabili il prodotto di due grandi numeri primi: infatti, mentre e’ facilissimo calcolare il prodotto di questi due numeri, non esiste un algoritmo che possa fattorizzarlo velocemente. Nel resto di questo articolo vedremo a grandi linee come opera l’algoritmo RSA mentre nella seconda parte vedremo un’implementazione in Java.

In linea generale possiamo distinguere tre “fasi” dell’algoritmo: generazione delle chiavi, criptaggio, decriptaggio (si, lo so che suonano malissimo).

Generazione delle chiavi

1. Si generano due grandi numeri primi p, q tali che il loro prodotto n = pq ha la lunghezza in bit che desideriamo.
2. Si calcola n = pq, e phi = (p-1)(q-1)
3. Si sceglie un intero positvo e < phi e coprimo con phi (cioe’ MCD(e, phi) = 1)
4. Si calcola un intero positivo d < phi tale che ed ≡ 1 (mod phi)
5. La coppia (n, e) forma la chiave pubblica, la coppia (n, d) quella privata.

Criptaggio
Per criptare un messaggio si ottiene la chiave pubblica del destinatario e, dopo aver trasformato il messaggio di testo in un numero intero, si utilizza la formula c = m^e mod n, dove m e’ il messaggio.

Decriptaggio
Partendo dal testo criptato si usa la formula m = c^d mod n, dove c e’ il testo cifrato.

L’unico modo per decriptare un messaggio, come e’ evidente dall’algoritmo, e’ quello di essere a conoscenza dell’esponente segreto d e del modulo, n. Mentre l’esponente e’ segreto, il modulo e’ pubblico poiche’ e’ utilizzato anche per criptare il messaggio: ad ogni modo, per risalire a d, che permetterebbe di accedere al contenuto del messaggio, abbiamo bisogno non di n, ma di p e q, i due grandi numeri primi usati per generarlo. Se i numeri primi sono abbastanza grandi, e’ impossibile fattorizzare n in tempi accettabili con gli algoritmi attuali.

In questo articolo non abbiamo visto una prova teorica del funzionamento dell’RSA e cioe’ una prova del fatto che criptando un messaggio con la chiave pubblica e decriptandolo con la chiave privata si ottiene sempre di nuovo il messaggio in chiaro, ma potete trovare una dimostrazione (in inglese) a questo link: http://www.di-mgt.com.au/rsa_theory.pdf. Per comprenderla sono necessarie nozioni (non troppo avanzate) di teoria dei numeri.