blocco pad corrotto durante la decrittazione (Android)

Question

Sto crittografando un file in java e invio il file crittografato e la chiave privata al dispositivo Android. Ma mentre decodifica il file in Android, dà errore pad pad danneggiato. A proposito, stesso codice di decrittazione funziona su PC

Ecco la crittografia:

public void encrypt(File inf, File outf, File publicKey, int userId, int resourceId) throws ArServerConnectionException { 
    // ENCRYPTION BEGIN 
    try { 
     pkCipher = Cipher.getInstance("RSA"); 
    } catch (NoSuchAlgorithmException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } catch (NoSuchPaddingException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    // create AES shared key cipher 
    try { 
     aesCipher = Cipher.getInstance("AES"); 
    } catch (NoSuchAlgorithmException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } catch (NoSuchPaddingException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 

    try { 
     makeKey(); 
    } catch (NoSuchAlgorithmException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
      // File operation 

      try { 
     saveKey(new File(System.getProperty("user.home") + "/" + userId 
       + "/keyfile"), publicKey); 
    } catch (IOException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } catch (GeneralSecurityException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    // File operation 

    try { 
     encryptFiles(inf, outf); 
    } catch (InvalidKeyException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } catch (IOException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 

    // /ENCRYPTION END 
} 

    public void saveKey(File out, File publicKeyFile) throws IOException, 
     GeneralSecurityException { 
    // read public key to be used to encrypt the AES key 
    byte[] encodedKey = new byte[(int) publicKeyFile.length()]; 
    new FileInputStream(publicKeyFile).read(encodedKey); 

    // create public key 
    X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedKey); 
    KeyFactory kf = KeyFactory.getInstance("RSA"); 
    PublicKey pk = kf.generatePublic(publicKeySpec); 

    // write AES key 
    pkCipher.init(Cipher.ENCRYPT_MODE, pk); 
    CipherOutputStream os = new CipherOutputStream(
      new FileOutputStream(out), pkCipher); 
    os.write(aesKey); 
    os.close(); 
} 
    public void makeKey() throws NoSuchAlgorithmException { 
    KeyGenerator kgen = KeyGenerator.getInstance("AES"); 
    kgen.init(AES_Key_Size); 
    SecretKey key = kgen.generateKey(); 
    aesKey = key.getEncoded(); 
    aeskeySpec = new SecretKeySpec(aesKey, "AES"); 
} 

Qui viene la parte decrittazione:

public class FileDecrypt { 
    public static final int AES_Key_Size = 256; 

    Cipher pkCipher, aesCipher; 
    byte[] aesKey; 
    SecretKeySpec aeskeySpec; 
    private String pubKeyPath=null; 
    private String prvKeyPath=null; 
    private String keyFilePath=null; 
    private String encFilePath=null; 
    private String unencFilePath=null; 


    public String getEncFilePath() { 
     return encFilePath; 
    } 

    public void setEncFilePath(String encFilePath) { 
     this.encFilePath = encFilePath; 
    } 

    public String getUnencFilePath() { 
     return unencFilePath; 
    } 

    public void setUnencFilePath(String unencFilePath) { 
     this.unencFilePath = unencFilePath; 
    } 

    public String getPubKeyPath() { 
     return pubKeyPath; 
    } 

    public void setPubKeyPath(String pubKeyPath) { 
     this.pubKeyPath = pubKeyPath; 
    } 

    public String getPrvKeyPath() { 
     return prvKeyPath; 
    } 

    public void setPrvKeyPath(String prvKeyPath) { 
     this.prvKeyPath = prvKeyPath; 
    } 

    public String getKeyFilePath() { 
     return keyFilePath; 
    } 

    public void setKeyFilePath(String keyFilePath) { 
     this.keyFilePath = keyFilePath; 
    } 
    public void decrypt() { 
     Log.i("DECRYPT","**************************************************DECRYPT&*******************"); 
     Log.i("encFilePath",encFilePath); 
     Log.i("pubKeyPath",pubKeyPath); 
     Log.i("prvKeyPath",prvKeyPath); 
     Log.i("keyFilePath",keyFilePath); 
     Log.i("unencFilePath",unencFilePath); 
     Log.i("DECRYPT","********************************************DECRYPT&*******************"); 
     try { 
      pkCipher = Cipher.getInstance("RSA"); 
     } catch (NoSuchAlgorithmException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (NoSuchPaddingException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
     try { 
      aesCipher = Cipher.getInstance("AES"); 
     } catch (NoSuchAlgorithmException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (NoSuchPaddingException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
     //DECRYPTION BEGIN 

     File pkf=new File(pubKeyPath); 
     byte[] encodedKey = new byte[(int) pkf.length()]; 
     try { 
      new FileInputStream(pkf).read(encodedKey); 
      // create public key 
      X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedKey); 
      KeyFactory kf = KeyFactory.getInstance("RSA"); 
      PublicKey pk = kf.generatePublic(publicKeySpec); 

      // write AES key 
      pkCipher.init(Cipher.ENCRYPT_MODE, pk); 
     } catch (FileNotFoundException e1) { 
      // TODO Auto-generated catch block 
      e1.printStackTrace(); 
     } catch (IOException e1) { 
      // TODO Auto-generated catch block 
      e1.printStackTrace(); 
     } catch (NoSuchAlgorithmException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (InvalidKeyException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (InvalidKeySpecException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
     try { 
      loadKey(new File(keyFilePath), new File(prvKeyPath)); 
     } catch (GeneralSecurityException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

     try { 
      decrypt(new File(encFilePath), new File(unencFilePath)); 
     } catch (IOException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

     //DECRYPTION END 
    } 

    /** 
    * Decrypts an AES key from a file using an RSA private key 
    */ 
    public void loadKey(File in, File privateKeyFile) 
      throws GeneralSecurityException, IOException { 
     // read private key to be used to decrypt the AES key 
     byte[] encodedKey = new byte[(int) privateKeyFile.length()]; 
     new FileInputStream(privateKeyFile).read(encodedKey); 

     // create private key 
     PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(encodedKey); 
     KeyFactory kf = KeyFactory.getInstance("RSA"); 
     PrivateKey pk = kf.generatePrivate(privateKeySpec); 

     // read AES key 
     pkCipher.init(Cipher.DECRYPT_MODE, pk); 
     aesKey = new byte[AES_Key_Size/8]; 
     CipherInputStream is = new CipherInputStream(new FileInputStream(in), 
       pkCipher); 
     is.read(aesKey); 
     aeskeySpec = new SecretKeySpec(aesKey, "AES"); 
    } 

    /** 
    * Decrypts and then copies the contents of a given file. 
    */ 
    public void decrypt(File in, File out) throws IOException 
     { 
     try { 
      aesCipher.init(Cipher.DECRYPT_MODE, aeskeySpec); 
     } catch (InvalidKeyException e) { 
      Log.i("EXCEPTION","INVALID KEY EXCEPTION"); 
      e.printStackTrace(); 
     } 

     CipherInputStream is = new CipherInputStream(new FileInputStream(in), 
       aesCipher); 
     FileOutputStream os = new FileOutputStream(out); 

     copy(is, os); 

     is.close(); 
     os.close(); 
    } 

    /** 
    * Copies a stream. 
    */ 
    private void copy(InputStream is, OutputStream os) throws IOException { 
     int i; 
     byte[] b = new byte[2048]; 
     while ((i = is.read(b)) != -1) { 
      os.write(b, 0, i); 
     } 
    } 
} 

Answer 1

Abbiamo anche affrontato lo stesso problema, è stato risolto solo eseguendo la parte di crittografia anche sul lato Android (utilizzando Android SDK) e quindi decrittandolo sul dispositivo. Nessun altro motivo corretto è stato trovato per il problema.

Answer 2

La ragione più probabile è il codice che stanno usando per inviare il file al dispositivo non è corretto. Forse sta troncando, riempendo o corrompendo in altro modo i dati in modo che non decifri correttamente. Prova a testare con un file statico e vedi se riesci a isolare il problema.

Answer 3

Il PC su cui si sta crittografando il file utilizza un altro provider di sicurezza (principalmente SunJCE) e l'androide utilizza il provider di sicurezza "BC" (Bouncy Castle precedente alla 4.2, AndroidOpenssl dopo 4.2) per decrittografare il file. Quindi la decodifica non ha successo sul dispositivo Android. Utilizzare il vaso rimbalzante del castello corrispondente al tipo di PC da questa posizione Bouncy castle jar download.

Criptare utilizzando il provider "BC" nel codice java nel PC.

Cipher cipher = Cipher.getInstance("AES", "BC"); 

Decyption funzionerà benissimo al fianco di Android :)