per semplificare tutto potrei scrivere il codice in questo modo (spero di non scrivere scemenze):

codice:
 public static void codifica(String sorgenteFile,String destinazioneFile) throws Exception {
               
                // LEGGI CHIAVE PUBBLICA CODIFICATA IN X509
               
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                String publicKeystore = "C:\\Java Passwords\\chiavipubbliche.txt";
                FileInputStream fis = new FileInputStream(publicKeystore);
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                int i = 0;
                while((i = fis.read()) != -1) {
                        baos.write(i);
                }
                fis.close();
                byte[] publicKeyBytes = baos.toByteArray();
                baos.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");
                // Crea una chiave pubblica usando generatePublic di KeyFactory in base la chiave decodificata da ks
                PublicKey publicKey = kf.generatePublic(ks);
               
                // LEGGI FILE SORGENTE
               
                String sorgente = sorgenteFile;
                fis = new FileInputStream(sorgente);
                baos.reset();
                i=0;
                String dest = destinazioneFile;
                FileOutputStream fos = new FileOutputStream(dest);
                while(i!=-1){
                byte[] plainFile= new byte[64];
                while((i = fis.read()) != -1 && i<plainFile.length) {
                        baos.write(i);
                }
                
                plainFile = baos.toByteArray();
               
                // CODIFICA FILE SORGENTE
                System.out.print("\nInizio codifica");
                // Inizializzo un cifrario che usa come algoritmo RSA, come modalità ECB e come padding PKCS1
                Cipher c = Cipher.getInstance("RSA/ECB/PKCS1Padding");
                System.out.print(".");
                // Lo inizializzo dicendo modalità di codifica e chiave pubblica da usare
                c.init(Cipher.ENCRYPT_MODE, publicKey);
                System.out.print(".");
                // codifico e metto il risultato in encodeFile
                byte[] encodeFile = c.doFinal(plainFile);
                System.out.println(". Codifica terminata!");
               
                // SALVA FILE CODIFICATO

                fos.write(encodeFile);
                }
                fis.close();
                fos.close();
        }
        
        public static void decodifica(String Filecodificato,String FiledaSalvare) throws Exception {
        	 
            // LEGGI CHIAVE PRIVATA CODIFICATA IN PKCS#8
           
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
           
            String privateKeystore = "C:\\Java Passwords\\chiaviprivate.txt";
            FileInputStream fis = new FileInputStream(privateKeystore);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int i = 0;
            while((i = fis.read()) != -1) {
                    baos.write(i);
            }
            fis.close();
            byte[] privateKeyBytes = baos.toByteArray();
            baos.close();
           
            // CONVERTI CHIAVE PRIVATA PKCS8 IN CHIAVE NORMALE
           
            PKCS8EncodedKeySpec ks = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory kf = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = kf.generatePrivate(ks);
           
            // LEGGI FILE CODIFICATO
           
            
            String sorgente = Filecodificato;
            fis = new FileInputStream(sorgente);
            byte[] codFile = new byte[64];
            i = 0;
            String dest = FiledaSalvare;
            FileOutputStream fos = new FileOutputStream(dest);
            
            while(i!=-1){
            	 baos.reset();
            while((i = fis.read()) != -1 && i<codFile.length) {
                    baos.write(i);
            }
           
            codFile = baos.toByteArray();
           
    // DECODIFICA
           
            System.out.print("\nInizio decodifica");
            Cipher c = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            System.out.print(".");
            c.init(Cipher.DECRYPT_MODE, privateKey);
            System.out.print(".");
            byte[] plainFile = c.doFinal(codFile);
            System.out.println(". Decodifica terminata!");
           
            // SALVA FILE

            fos.write(plainFile);
            }
            fis.close();
            fos.close();
    }
}
l'errore che viene comunque fuori durante la decodifica è Data must start with zero O.o

e se al posto di RSA/ecc metto solo RSA in questo esempio il risultato non cambia