L'ARCHITETTURA CRITTOGRAFICA DI JAVA

• JCA (Java Cryptography Architecture)
• JCE (Java Cryptography Extension)

Nomenclatura e Riassunto dei Concetti Fondamentali

Messaggio in chiaro: il messaggio originale (leggibile da tutti)

Messaggio cifrato: il messaggio modificato per nasconderne il contenuto.

Algoritmo di cifratura: il metodo con il quale, dato un messaggio in chiaro, si produce il corrispondente messaggio cifrato.

Chiave di cifratura: quel valore introdotto nell’algoritmo di cifratura per "personalizzarlo" volta per volta (a parità di messaggio in chiaro, il messaggio cifrato ottenuto risulta completamente diverso cambiando la chiave).

Proprietà fondamentale: dal messaggio cifrato deve essere (praticamente) impossibile risalire al messaggio in chiaro.

Per garantire tale proprietà:

• non tenere segreto l’algoritmo di cifratura (che, anzi,
  è bene sia pubblico e ben conosciuto!)

• tenere invece segreta solo la chiave di cifratura.

Algoritmo a chiave simmetrica (o a chiave segreta):
c’è un’unica chiave che serve sia per cifrare che per decifrare.

Algoritmo a chiave asimmetrica (o a chiave pubblica):
ci sono due chiavi: se una viene usata per cifrare, occorre l’altra per decifrare (e viceversa) ® una segreta, l’altra pubblica.

IMPRONTA (DIGEST) di un messaggio: è una stringa di dimensione fissa calcolata a partire dal messaggio originale, ma indipendente dalla dimensione dello stesso.

Scopo: garantire l’integrità del messaggio (senza cifrarlo)

FIRMA (SIGNATURE) di un messaggio: è una stringa (spesso di dimensione fissa) calcolata a partire dal messaggio originale e da una chiave.

Scopo: firmare il messaggio, in modo da garantirne l’autenticità e la non ripudiabilità (senza cifrarlo).

Java Cryptography Architecture (JCA)

Due principi:

• indipendenza dall’implementazione e interoperabilità
• estendibilità e indipendenza degli algoritmi

Due tipi di classi:

• una engine class è una classe astratta che dichiara le funzionalità di un dato tipo di algoritmo crittografico, senza però fornire alcuna implementazione.
• un provider è un package che implementa un certo insieme di funzionalità crittografiche.

Caratteristiche:

• più provider, anche di diversi produttori, possono coesistere ed interoperare
• il provider di default si chiama sun, ed fa parte del JDK
• una installazione di Java (JDK o JRE) può avere più provider installati: altri possono essere aggiunti dinamicamente, tramite il metodo Security.addProvider()
• un programma può richiedere genericamente una implementazione di un dato algoritmo (senza curarsi di quale provider la fornisca) o, invece, specificare il provider desiderato.

AD ESEMPIO:

MessageDigest, Signature e KeyPairGenerator sono tre diverse engine class, che definiscono rispettivamente le funzionalità di digest (impronta digitale), signature (firma digitale), e di generatore di coppie di chiavi, secondo uno degli algoritmi a chiave pubblica disponibili.

La struttura "a livelli" della JCA

La struttura della JCA è a due livelli:

• la JCA "di base" che definisce la cornice generale per la crittografia, definendo le classi astratte ma fornendo solo alcune semplici implementazioni di funzionalità specifiche
• la Java Cryptography Extension (JCE) che definisce le API complete e fornisce l’implementazione delle funzionalità di cifratura e decifratura.

ATTENZIONE: a causa delle limitazioni all’esportazione di tecnologia crittografica fuori dagli Stati Uniti, la JCE della Sun non è esportabile.

Gli utenti europei devono quindi utilizzare un diverso provider scritto fuori dagli Stati Uniti, come IAIK-IJCE della IAIK (http://jcewww.iaik.tu-graz.ac.at/).

Funzionalità fornite dalla JCA "base"

La JCA base fornisce le seguenti classi:

• le classi Provider e Security
• le engine class MessageDigest, Signature e KeyPairGenerator
• la classe Key e le classi derivate.

ALGORITMI SUPPORTATI:

• MessageDigest supporta gli algoritmi SHA-1, MD2, MD5
• Signature supporta gli algoritmi DSA e RSA (quest’ultimo con SHA-1, MD2 o MD5)
• KeyPairGenerator supporta gli algoritmi di generazione chiavi per DSA e RSA.

JCA vs. JCE

Le classi fornite dalla JCA consentono di:

• calcolare impronte digitali di messaggi
• calcolare firme digitali di messaggi

usando coppie di chiavi pubblica/privata.

Le classi fornite dalla JCA non consentono di:

• cifrare un messaggio
• decifrare un messaggio

con algoritmi a piacere.

FUNZIONALITÀ DEFINITE DALLA JCE

La JCE definisce le API standard per la cifratura / decifratura:

• cifratura a chiave segreta con algoritmi DES, 3DES, RC2, IDEA (a bulk) e RC4 (a stream)
• cifratura a chiave pubblica con algoritmo RSA

con:

• modalità ECB (Electronic CodeBook mode), CBC (Cipher Block Chaining mode), CFB (Cipher FeedBack mode)
• schemi di padding PKCS #5 (Public Key Cryptography Standard 5) e PEM (Privacy Enhanced Mail).

Ogni provider può implementare solo alcune delle API definite dalla JCE. In particolare il provider standard SUN (jdk 1.1.x) fornisce:

• DES e 3DES, modalità ECB e CBC, padding PKCS#5

Il provider dell’IAIK fornisce invece una gamma più ampia di algoritmi, modalità e schemi di padding.

Esempi

Esempio 1
Calcolo dell’impronta digitale di un messaggio

• si crea un oggetto MessageDigest specializzato per un dato algoritmo (fra quelli supportati)
• si forniscono a tale oggetto i dati da "macinare" tramite il metodo update() (è possibile richiamare update()più volte per accodare diverse parti di messaggio)
• si fa produrre l’impronta chiamando il metodo digest().

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

class Esempio1 {

 public static void main(String args[]){

MessageDigest sha = null;
try {
  sha = MessageDigest.getInstance("SHA-1");
  //SHA = Secure Hash Algorithm
} catch (NoSuchAlgorithmException e) {
  System.out.println("Algoritmo non supportato");
}

byte[] messaggio = {10,20,30,40,50};

byte[] impronta = sha.digest(messaggio);

System.out.println("Impronta:");
for (int i=0; i<impronta.length; i++)
  System.out.print("" + impronta[i]
   + "\t");
System.out.println(""); }

}

Esempio 2
Verifica dell’impronta digitale di un messaggio

• si crea un oggetto MessageDigest specializzato per l'algoritmo prescelto (fra quelli supportati)
• si ricalcola l’impronta come nell'esempio precedente
• la si confronta con quella già disponibile: se è identica, il messaggio è integro, altrimenti è stato alterato.

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

class Esempio2 {

 public static void main(String args[]){

System.out.println("Verifica del digest"+ + "(impronta digitale) di un messaggio");

byte[] impronta1 = new byte[20];

BufferedReader in = new BufferedReader(
      new InputStreamReader(System.in));

System.out.println("Inserire l'impronta da verificare (un numero per riga):");
// nella realtà sarà letta da un file
// o scaricata via rete

try {

for(int i=0; i<20; i++) {
  String buf = in.readLine();
  impronta1[i] = Byte.parseByte(buf);
}

}
catch (IOException e) {
  System.out.println("Lettura da input fallita");
}

System.out.println("Impronta letta:");
for (int i=0; i<impronta.length; i++)
  System.out.print("" + improntaData[i]
   + "\t");
System.out.println("");

// ------- parte identica a Esempio0

MessageDigest sha = null;
try {
 sha = MessageDigest.getInstance("SHA-1");
}
catch (NoSuchAlgorithmException e) {
System.out.println("Algoritmo richiesto non supportato");
}

byte[] messaggio = {10,20,30,40,50};
// nella realtà sarà letto da file

byte[] impronta2 = sha.digest(messaggio);
// fine parte identica a Esempio0

// verifica impronta
if (MessageDigest.isEqual(impronta1,
   impronta2))
  System.out.println("MSG INTEGRO");
else
  System.out.println("MSG ALTERATO!");

 }

}

Esempio 3
Calcolo (e verifica) della firma digitale di un messaggio

Si procede in due fasi (tre se si include la verifica).

Fase 1 (generazione della coppia di chiavi)

• si crea un oggetto KeyPairGenerator specializzato per un dato algoritmo (fra quelli supportati)
• lo si inizializza con un seme casuale (un oggetto SecureRandom)
• gli si fa generare una coppia di chiavi (pubblica e privata)
• si recuperano singolarmente le due chiavi (due oggetti di tipo PublicKey e PrivateKey)

Fase 2 (generazione della firma)

• si crea un oggetto Signature specializzato per un dato algoritmo (fra quelli supportati)
• lo si inizializza con la chiave privata (con initSign())
• gli si forniscono i dati da firmare (tramite update())
• gli si fa generare la firma (con sign())

Fase 3 (verifica della firma)

• si re-inizializza l'oggetto Signature con la chiave
  pubblica (con initSign())
• gli si forniscono i dati da verificare (tramite update())
• gli si fa verificare la firma del messaggio (con verify())

import java.security.KeyPairGenerator;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.NoSuchAlgorithmException;
import java.security.InvalidKeyException;
import java.security.SignatureException;

class Esempio3 {

 public static void main(String args[]){

// FASE 1: GENERAZIONE DELLA COPPIA DI CHIAVI

KeyPairGenerator gen = null;
try {
  gen = KeyPairGenerator.getInstance("DSA");
  // DSA = Digital Signature Algorithm
} catch (NoSuchAlgorithmException e1) {
  System.out.println("Algoritmo non supportato");
  System.exit(1);
}

gen.initialize(1024, new SecureRandom( ));
// chiavi modulo 1024 bit, seme definito da Java
// (si potrebbe passare un seme definito dal-
// l'utente sotto forma di array di bytes)

KeyPair kp = gen.generateKeyPair();
PrivateKey kpriv = kp.getPrivate();
PublicKey kpub = kp.getPublic();

// FASE 2: GENERAZIONE DELLA FIRMA DIGITALE

Signature s = null;
try {
  s = Signature.getInstance("DSA");
}
catch (NoSuchAlgorithmException e2) {
  System.out.println("Algoritmo non supportato");
  System.exit(2);
}

try {
  s.initSign(kpriv);
  // .. inizializz. con la chiave privata
} catch (InvalidKeyException e3) {
  System.out.println("Chiave privata non valida");
  System.exit(3);
}

byte[] data = {10,20,30,40,50,60,70,80,90};
byte[] xxx = null;

try {
  s.update(data);
  xxx = s.sign();
  // xxx contiene la versione firmata di data
} catch (SignatureException e4) {
  System.out.println("Firma non valida");
  System.exit(4);
}

System.out.println("Dati: " + data);
System.out.println("Xxx: " + xxx);

// FASE 3: VERIFICA DELLA FIRMA DIGITALE

try {
  s.initVerify(kpub);
  // inserisce la chiave di decifratura
} catch (InvalidKeyException e5) {
  System.out.println("Chiave pubblica non valida");
  System.exit(5);
}

boolean res = false;

try {
  s.update(data);
  res = s.verify(xxx); // verifica la firma
} catch (SignatureException e6) {
  System.out.println("Firma non valida");
  System.exit(6);
}

if (res)
  System.out.println("Verifica positiva.");
else
  System.out.println("Verifica NEGATIVA!!");

 }

}

CIFRATURA DI MESSAGGI CON LA IAIK-JCE

Per cifrare o decifrare un messaggio le classi fondamentali sono Cipher (o CipherStream) e KeyGenerator, da utilizzare come segue:

• procurarsi un oggetto Cipher configurato in modo opportuno per l’algoritmo, la modalità e il padding desiderati
  ® metodo di classe Cipher.getInstance()
• procurarsi un oggetto KeyGenerator a cui far generare una chiave (Key) adatta
  ® metodo di classe KeyGenerator.getInstance()
• far generare al generatore un oggetto Key opportuno in relazione all’algoritmo, alla modalità e al padding desiderati
  ® metodo generateKey()
• inizializzare l’oggetto Cipher con tale chiave, precisando se si intende cifrare o decifrare
  ® metodo init() e costanti ENCRYPT / DECRYPT
• effettuare l’operazione effettiva (cifratura o decifratura a seconda dell’inizializzazione dell’oggetto Cipher)
  ® metodo doFinal()

Il metodo doFinal()

• si applica a un array di byte (che costituisce l'input)
• restituisce un altro array di byte (che costituisce l'output).

Per decifrare il risultato così ottenuto occorre re-inizializzare l'oggetto Cipher specificando il modo DECRYPT e la chiave di decifratura, quindi richiamarare nuovamente doFinal().

Esempio 4
Cifratura (e successiva decifratura) di un messaggio con DES

Fase 0 (creazione e installazione del provider IAIK)

• si crea un nuovo oggetto provider IAIK e lo si aggiunge all'elenco gestito dalla classe Security

Fase 1 (generazione della chiave segreta)

• si crea un oggetto KeyGenerator specifico per il DES, precisando il provider desiderato (IAIK)
• lo si inizializza con un seme casuale
• gli si fa generare la chiave
• si recupera tale chiave (un oggetto SecretKey)

Fase 2 (creazione del Cipher e del messaggio cifrato)

• si crea un oggetto Cipher specifico per il DES, precisando il provider desiderato (IAIK)
• lo si inizializza con la chiave segreta in modalità ENRCYPT
• gli si fa generare il messaggio cifrato (con doFinal())

Fase 3 (decifratura del messaggio e verifica del risultato)

• si re-inizializza l'oggetto Cipher con la stessa chiave segreta, ma in modalità DERCYPT
• gli si fa generare il messaggio decifrato (con doFinal())
• si controlla che quanto ottenuto sia il messaggio in chiaro originale.

import java.security.Security;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
import java.security.InvalidKeyException;
import java.security.NoSuchProviderException;
import java.security.Key;

import javax.crypto.*;
import iaik.security.provider.*;

class Esempio4 {

 static void printBytes(String name, byte[] b){

System.out.print(name + ": ");
for (int i=0; i<b.length; i++)
System.out.print(b[i] + " ");
System.out.println("");
System.out.println("-----------------------");

 }

 public static void main(String args[]){

// FASE 0: INSTALLAZIONE DEL PROVIDER IAIK

IAIK provider = new IAIK();
Security.addProvider(provider);

// FASE 1 (a): CREAZIONE DEL GENERATORE CHIAVI

KeyGenerator gen = null;
try {
  gen = KeyGenerator.getInstance("DES","IAIK");
} catch (NoSuchAlgorithmException e1) {
  System.out.println("Algoritmo non supportato");
  System.exit(1);
}
catch (NoSuchProviderException e1) {
  System.out.println("Provider non supportato");
  System.exit(1);
}

// FASE 1 (b): GENERAZIONE DELLA CHIAVE SEGRETA

gen.init(new SecureRandom());

Key k = gen.generateKey();
printBytes("chiave", k.getEncoded());

// il messaggio in chiaro (e due buffer)

byte[] data = {10,20,30,40,50,60,70,80};
printBytes("Dati", data);
byte[] xxx = null, newdata = null;

// FASE 2 (a): CREAZIONE E INIZIALIZZ. DEL Cipher

Cipher des = null;
try {
  des = Cipher.getInstance("DES","IAIK");
  des.init(Cipher.ENCRYPT_MODE, k);
  // Sun: des.initEncrypt(k);
  System.out.println("Cipher pronto per cifrare");

  // FASE 2 (b): CREAZIONE DEL MESSAGGIO CIFRATO

  xxx = des.doFinal(data);
  printBytes("xxx", xxx);

  // FASE 3 (a): REINIZIALIZZAZIONE DEL Cipher

  des.init(Cipher.DECRYPT_MODE, k);
  // Sun: des.initDecrypt(k);
  System.out.println("Cipher pronto a decifrare");

  // FASE 3 (b): DECIFRATURA DEL MESSAGGIO

  newdata = des.doFinal(xxx);
  printBytes("NewData", newdata);

  // FASE 3 (c): VERIFICA DEL RISULTATO

  boolean res = true;
  if (data.length != newdata.length) res = false;
  else
    for (int j=0; j<data.length; j++)
      if (data[j] != newdata[j]) {
          res = false; break;
      }
  if (res) System.out.println("Verifica positiva");
  else System.out.println("Verifica NEGATIVA!!");

} // chiude il try iniziale
catch (NoSuchProviderException e2) {
  System.out.println("Provider non supportato");
  System.exit(2);
}
catch (NoSuchAlgorithmException e2) {
  System.out.println("Algoritmo non supportato");
  System.exit(2);
}
catch (NoSuchPaddingException e2) {
  System.out.println("Padding non supportato");
  System.exit(2);
}
catch (BadPaddingException e3) {
  System.out.println("Bad Padding");
  System.exit(3);
}
catch (InvalidKeyException e3) {
  System.out.println("Chiave non valida");
  System.exit(3);
}
catch (IllegalBlockSizeException ex) {
  System.out.println("Dimensione blocco illegale");
  System.exit(3);
}

 }

}