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:
Per il processo inverso, invece:
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
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 = me mod n, dove m e’ il messaggio.
Decriptaggio
Partendo dal testo criptato si usa la formula m = cd 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.
]]>Quello che vedete ora nell’editor e’ il codice di base per un robot molto semplice che non fa altro che muoversi avanti e indietro e girare il suo cannone di 360 gradi, sparando quando vede un nemico. Ma analizziamo piu’ da vicino il codice:
public class MURobot extends Robot {
Creiamo una classe che eredita tutti gli attributi e i metodi dalla classe di base Robot.
/* Qui possiamo dichiarare tutte le variabili utilizzate dal nostro robot,
* in questo caso non ne abbiamo.
*/
public void run() {
while(true) {
ahead(100);
turnGunRight(360);
back(100);
turnGunRight(360);
}
}
Dopo aver dichiarato le eventuali variabili utilizzate all’interno della classe, vediamo il metodo run(). Questo metodo viene chiamato ogni qualvolta inizia la battaglia. All’interno di run() si trova quasi sempre un ciclo infinito: se l’esecuzione di run() termina, infatti, il nostro robot non fara’ altro che stare fermo e sparare ai robot che rientrano nel suo campo visivo. Se dobbiamo svolgere delle azioni particolari, come il posizionamento in una particolare zona della mappa, conviene inserirle prima di entrare nel ciclo infinito.
All’interno del ciclo il robot si muove in avanti (ahead(100)) fa un giro completo del cannone, torna indietro, fa lo stesso giro e cosi’ finche’ non viene distrutto o distrugge tutti i robot nell’arena.
public void onScannedRobot(ScannedRobotEvent e) {
fire(1);
}
public void onHitByBullet(HitByBulletEvent e) {
turnLeft(90 - e.getBearing());
}
}
L’ultimo metodo viene chiamato quando il nostro robot viene colpito da un proiettile: per evitare di essere colpiti di nuovo il robot si gira nella direzione perpendicolare al proiettile e quindi si sposta grazie alle istruzioni all’interno del metodo run(). Il metodo getBearing() restituisce l’angolo tra la direzione in cui ci stiamo muovendo e la direzione del proiettile ed e’ sempre compreso tra -180 e 180, ed e’ uno dei tanti metodi di cui vi parlavo in precedenza.
Se provate a iniziare una battaglia tra questo robot e altri leggermente piu’ avanzati presenti gia’ di default, vi accorgerete che le sue prestazioni non sono proprio ottimali, di fatto perdera’ la maggior parte delle battaglie se non tutte (ovviamente dipende contro chi lo fate combattere), ma e’ comunque un inizio. Il metodo migliore per realizzare robot sempre piu’ avanzati e’ cominciare da subito a crearne: ricordate anche che avendo abbastanza padronanza con Java non ci sono limiti a quello che si puo’ realizzare!
]]>