Blowfish auf Android-Studio für die Verschlüsselung/Entschlüsselung

Question

Ich habe fast alle Themen hier zu diesem Thema gesucht, aber ich kann immer noch nicht herausfinden, was los ist. Ich habe 3 EditText auf meiner Android-App erstellt: EditText, wo Sie den Schlüssel/das Passwort zum Verschlüsseln und Entschlüsseln einfügen; EditText2 wo es den verschlüsselten Text angezeigt wird; EditText3 wo der entschlüsselte Text angezeigt wird.

Da es sich noch um einen frühen Test handelt, habe ich die Nachricht oder die Zeichenfolge in der App als Variable an Crypt übergeben.

Das Problem ist, dass die Verschlüsselung so etwas wie einen Blowfish-Algorithmus gibt, also kein Problem (es endet mit 2 == also ich denke, es funktioniert richtig). Ich habe auch versucht, die Schnur vor der Entschlüsselung zu entschlüsseln oder die rohe byte[] von der Verschlüsselung ohne irgendein gutes Ergebnis zu verwenden. Die Entschlüsselung gibt nicht den ursprünglichen String-Text zurück, sondern gibt etwas größer als der verschlüsselte Text. Ich habe keine Vorliebe für den Modus von Blowfish, also fing ich einfach an wie Blowfish/CFB/NoPadding.

str_key, str2 und str3 werden für jetzt öffentlich erklärt. str2 setzt den Text für EditText2 Feld und str3 wird den Text für EditText3 Feld festlegen. Ein Beispiel für Ausgabe: Example of output generated from the app

Hier ist der Code:

public void encrypt(){ 
    //encrypt 
    EditText mEdit = (EditText)findViewById(R.id.editText); 
    str_key = (String) mEdit.getText().toString(); 

    int iterationCount = 1000; 
    int keyLength = 256; 
    int saltLength = keyLength/8; 

    SecureRandom random = new SecureRandom(); 
    byte[] salt = new byte[saltLength]; 
    random.nextBytes(salt); 
    KeySpec keySpec = new PBEKeySpec(str_key.toCharArray(), salt, 
      iterationCount, keyLength); 
    SecretKeyFactory keyFactory = null; 
    try { 
     keyFactory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1"); 
    } catch (NoSuchAlgorithmException e) { 
     e.printStackTrace(); 
    } 
    byte[] keyBytes = new byte[0]; 
    try { 
     keyBytes = keyFactory.generateSecret(keySpec).getEncoded(); 
    } catch (InvalidKeySpecException e) { 
     e.printStackTrace(); 
    } 
    SecretKey key = new SecretKeySpec(keyBytes, "Blowfish"); 

    Cipher cipher = null; 
    try { 
     cipher = Cipher.getInstance("Blowfish/CBC/PKCS5Padding"); 
    } catch (NoSuchAlgorithmException | NoSuchPaddingException e) { 
     e.printStackTrace(); 
    } 
    if (cipher == null || key == null) { 
     //throw new Exception("Invalid key or cypher"); 
     str2="error"; 
    } 
    else { 
     byte[] iv = new byte[cipher.getBlockSize()]; 
     random.nextBytes(iv); 
     IvParameterSpec ivParams = new IvParameterSpec(iv); 
     try { 
      cipher.init(Cipher.ENCRYPT_MODE, key,ivParams); 
     } catch (InvalidKeyException | InvalidAlgorithmParameterException e) { 
      e.printStackTrace(); 
     } 


     try { 
      raw = cipher.doFinal(message.getBytes("UTF-8")); 
     } catch (IllegalBlockSizeException | BadPaddingException | UnsupportedEncodingException e) { 
      e.printStackTrace(); 
     } 
     str2 = Base64.encodeToString(raw,Base64.DEFAULT); 

    } 


} 

Hier ist die Entschlüsselungsfunktion:

public void decrypt(){ 
      int iterationCount = 1000; 
      int keyLength = 256; 
      int saltLength = keyLength/8; 
      SecureRandom random = new SecureRandom(); 
      byte[] salt = new byte[saltLength]; 
      random.nextBytes(salt); 
      KeySpec keySpec = new PBEKeySpec(str_key.toCharArray(), salt, iterationCount, keyLength); 
      SecretKeyFactory keyFactory = null; 
      try { 
       keyFactory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1"); 
       } catch (NoSuchAlgorithmException e) { 
       e.printStackTrace(); 
       } 
       byte[] keyBytes = new byte[0]; 
       try { 
       keyBytes = keyFactory.generateSecret(keySpec).getEncoded(); 
       } catch (InvalidKeySpecException e) { 
        e.printStackTrace(); 
       } 
       SecretKey key = new SecretKeySpec(keyBytes, "Blowfish"); 



    Cipher cipher2 = null; 
    try { 
     cipher2 = Cipher.getInstance("Blowfish/CBC/PKCS5Padding"); 
    } catch (NoSuchAlgorithmException | NoSuchPaddingException e) { 
     e.printStackTrace(); 
    } 
    iv = new byte[cipher2.getBlockSize()]; 
    random.nextBytes(iv); 
    IvParameterSpec ivSpec = new IvParameterSpec(iv); 
    try { 
     cipher2.init(Cipher.DECRYPT_MODE, key, ivSpec); 
    } catch (InvalidKeyException | InvalidAlgorithmParameterException e) { 
     e.printStackTrace(); 
    } 
    byte[] decryptedBytes = null; 
    byte[] app= Base64.decode(str2,Base64.DEFAULT); 

    try { 
     decryptedBytes = cipher2.doFinal(app); 
    } catch (IllegalBlockSizeException | BadPaddingException e) { 
     e.printStackTrace(); 
    } 


    str3 = Base64.encodeToString(decryptedBytes,Base64.DEFAULT); 
} 

Answer 1

Sie das verschlüsselte Ergebnis base64 kodieren aber dann, wenn Sie zu entschlüsseln, Sie Nimm die einfachen Bytes dieser Base64. Sie sollten stattdessen base64 decodieren, um das tatsächliche Byte-Array des Chiffriertexts zu erhalten und dieses dann zu entschlüsseln.

Sie leiten Ihren Schlüssel auch direkt aus dem UTF8-Byte-Array ab, was ein sehr schlechter Weg ist. Sie sollten stattdessen eine KDF verwenden. PBKDF2 wird hier am häufigsten verwendet.

Die Art und Weise, wie Sie eine IV generieren (indem Sie überhaupt keine generieren), ist ebenfalls sehr schlecht. Es sollte zufällig erzeugt und dem Chiffretext vorangestellt werden. Es muss nicht geheim sein, nur unvorhersehbar.

Schließlich verwenden Sie überhaupt kein HMAC, also könnte jeder den Chiffretext ändern, und Sie würden nicht wissen.