bloque de almohadilla dañado durante el descifrado (Android)

Question

estoy cifrar un archivo en Java y enviar el archivo cifrado y la clave privada en el dispositivo androide. Pero al descifrar el archivo en Android, da error bloqueado pad pad. Por cierto, mismo código de descifrado funciona en PC

Aquí está el cifrado:

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"); 
} 

Aquí está la parte de descifrado:

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

También nos enfrentamos a la misma cuestión, se resolvió sólo en hacer la parte cifrar también en el lado androide (El uso de Android SDK) y luego descifrarlos en el dispositivo. No se encontraron otras razones correctas para el problema ..

Answer 2

La razón más probable es el código que están utilizando para enviar el archivo al dispositivo es incorrecto. Tal vez está truncando, rellenando o corrompiendo los datos por lo que no se descifra correctamente. Intente probar con un archivo estático y vea si puede aislar el problema.

Answer 3

La PC donde está encriptando el archivo está usando un proveedor de seguridad diferente (principalmente SunJCE) y el android usa el proveedor de seguridad "BC" (Bouncy Castle anterior a 4.2, AndroidOpenssl después de 4.2) para descifrar el archivo. Por lo tanto, el descifrado no es exitoso en el dispositivo Android. Utilice el contenedor de castillo hinchable correspondiente a su tipo de PC desde esta ubicación Bouncy castle jar download.

Cifrar utilizando el proveedor de "BC" en el código de Java en el PC.

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

Decyption no tendrán ningún problema en el lado androide :)