import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.security.InvalidKeyException; 
import java.security.KeyFactory; 
import java.security.KeyPair; 
import java.security.KeyPairGenerator; 
import java.security.NoSuchAlgorithmException; 
import java.security.PrivateKey; 
import java.security.PublicKey; 
import java.security.Security; 
import java.security.spec.X509EncodedKeySpec; 
import java.util.Arrays; 
import javax.crypto.BadPaddingException; 
import javax.crypto.Cipher; 
import javax.crypto.IllegalBlockSizeException; 
import javax.crypto.NoSuchPaddingException; 

import org.bouncycastle.jce.provider.BouncyCastleProvider; 

public class Exemple { 

    public static void main(String argsd[]) throws Exception { 

        Security.addProvider(new BouncyCastleProvider()); 
        System.out.println("Inizio generazione chiavi RSA"); 
        // inizializza un generatore di coppie di chiavi usando RSA 
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC"); 
        kpg.initialize(1024); 
        KeyPair kp = kpg.generateKeyPair(); 
        System.out.println("Chiavi generate!\n"); 

        // SALVA CHIAVE PUBBLICA 
		String publicKeystore ="publicRSA.key";//path 
	    byte[] publicBytes;
        publicBytes= kp.getPublic().getEncoded(); 
        // salva nel keystore selezionato dall'utente 
        FileOutputStream fos = new FileOutputStream(publicKeystore); 
        fos.write(publicBytes); 
        fos.close(); 

        // SALVA CHIAVE PRIVATA 

        String privateKeystore ="privateRSA.key";// path 
        // ottieni la versione codificata in PKCS#8 
        byte[] privateBytes = kp.getPrivate().getEncoded(); 

        fos = new FileOutputStream(privateKeystore); 
        fos.write(privateBytes); 
        fos.close(); 

        // LEGGI CHIAVE PUBBLICA CODIFICATA IN X509 
        FileInputStream fis = new FileInputStream(publicKeystore); 
        byte[] publicKeyBytes = new byte[fis.available()]; 
         
        fis.read(publicKeyBytes); 
         
        fis.close();  
        // CONVERTI CHIAVE PUBBLICA DA X509 A CHIAVE UTILIZZABILE 

        // Inizializza convertitore da X.509 a chiave pubblica 
        X509EncodedKeySpec ks = new X509EncodedKeySpec(publicKeyBytes); 
        // Inizializza un KeyFactory per ricreare la chiave usando RSA 
        KeyFactory kf = KeyFactory.getInstance("RSA", "BC"); 
        // Crea una chiave pubblica usando generatePublic di KeyFactory in base
        // la chiave decodificata da ks 
        PublicKey publicKey = kf.generatePublic(ks); 
        // pubblica = publicKey; 
        byte[] temp = crypt(new String("Input message ... !!!!! ").getBytes("UTF8"), publicKey, 
                Cipher.ENCRYPT_MODE); 
        
        byte[] out = decrypt(temp,  kp.getPrivate()); 

        String risultato = new String(out,"UTF8");
        
        byte[] pp = risultato.getBytes("UTF8");

        System.out.println(Arrays.equals(pp, out)); 


    } 

    public static byte[] crypt(byte[] input, PublicKey publicKey, int mode) 
            throws InvalidKeyException, NoSuchAlgorithmException, 
            NoSuchPaddingException, IllegalBlockSizeException, 
            BadPaddingException { 
        System.out.print("\nInizio codifica"); 
        // Inizializzo un cifrario che usa come algoritmo RSA, come modalità ECB
        // e come padding PKCS1 
        Cipher cifrario = Cipher.getInstance("RSA/ECB/PKCS1Padding"); 
        System.out.print("."); 
        // Lo inizializzo dicendo modalità di codifica e chiave pubblica da 
        // usare 
        cifrario.init(mode, publicKey); 
        System.out.print("."); 
        // codifico e metto il risultato in encodeFile 
        byte[] encodeFile = cifrario.doFinal(input); 
        System.out.println(". Codifica terminata!"); 
        input = new byte[encodeFile.length]; 
        System.out.println("cifratura"); 
        return encodeFile; 
    } 

    public static byte[] decrypt(byte[] input, PrivateKey privateKey) 
            throws InvalidKeyException, NoSuchAlgorithmException, 
            NoSuchPaddingException, IllegalBlockSizeException, 
            BadPaddingException{ 

        System.out.print("\nInizio decodifica"); 
        Cipher cifrario = Cipher.getInstance("RSA/ECB/PKCS1Padding"); 
        System.out.print("."); 
        cifrario.init(Cipher.DECRYPT_MODE, privateKey); 
        System.out.print("."); 
        byte[] encodeFile = cifrario.doFinal(input); 
        System.out.println(". Decodifica terminata!"); 
        return encodeFile; 
    } 
}