Schlechte Polsterung Ausnahme :pad-block beschädigt beim Aufruf dofinal

Alles, was Sie brauchen, ist, um präzise den charset. Hier gehen Sie :

import org.bouncycastle.crypto.BufferedBlockCipher;
import org.bouncycastle.crypto.DataLengthException;
import org.bouncycastle.crypto.InvalidCipherTextException;
import org.bouncycastle.crypto.engines.AESFastEngine;
import org.bouncycastle.crypto.paddings.PaddedBufferedBlockCipher;
import org.bouncycastle.crypto.params.KeyParameter;

public class Main
{
    private BufferedBlockCipher cipher;
    private final KeyParameter key = setEncryptionKey("testinggtestingg");
    private static final String CHARSET = "ISO-8859-1";

    public static void main(String[] argv)
    {
        Main main = new Main();

        String plain = "trallalla";
        System.out.println("initial : " + plain);

        String encrypted = main.encryptString(plain);
        System.out.println("after encryption : " + encrypted);

        String decrypted = main.decryptString(encrypted);
        System.out.println("after decryption : " + decrypted);
    }

    public KeyParameter setEncryptionKey(String keyText)
    {
        //adding in spaces to force a proper key
        keyText += "                ";

        //cutting off at 128 bits (16 characters)
        keyText = keyText.substring(0, 16);

        byte[] keyBytes = keyText.getBytes();
        //key = new KeyParameter(keyBytes);
        AESFastEngine engine = new AESFastEngine();
        cipher = new PaddedBufferedBlockCipher(engine);
        return new KeyParameter(keyBytes);

    }

    public String encryptString(String plainText)
    {
        try
        {
            byte[] plainArray = plainText.getBytes();
            cipher.init(true, key);
            byte[] cipherBytes = new byte[cipher.getOutputSize(plainArray.length)];
            int cipherLength = cipher.processBytes(plainArray, 0, plainArray.length, cipherBytes, 0);
            cipher.doFinal(cipherBytes, cipherLength);

            return (new String(cipherBytes, CHARSET));
        }
        catch (DataLengthException e)
        {
            e.printStackTrace();
        }
        catch (IllegalArgumentException e)
        {
            e.printStackTrace();
        }
        catch (IllegalStateException e)
        {
            e.printStackTrace();
        }
        catch (InvalidCipherTextException e)
        {
            e.printStackTrace();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        //else
        return null;
    }

    public String decryptString(String encryptedText)
    {
        try
        {
            byte[] cipherBytes = encryptedText.getBytes(CHARSET);
            cipher.init(false, key);
            byte[] decryptedBytes = new byte[cipher.getOutputSize(cipherBytes.length)];
            int decryptedLength = cipher.processBytes(cipherBytes, 0, cipherBytes.length, decryptedBytes, 0);
            cipher.doFinal(decryptedBytes, decryptedLength);
            String decryptedString = new String(decryptedBytes);

            //crop accordingly
            int index = decryptedString.indexOf("\u0000");
            if (index >= 0)
            {
                decryptedString = decryptedString.substring(0, index);
            }
            return decryptedString;
        }
        catch (DataLengthException e)
        {
            e.printStackTrace();
        }
        catch (IllegalArgumentException e)
        {
            e.printStackTrace();
        }
        catch (IllegalStateException e)
        {
            e.printStackTrace();
        }
        catch (InvalidCipherTextException e)
        {
            e.printStackTrace();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        //else
        return null;
    }
}

Aber warum sind Sie über diese externe Bibliothek ? Hier ist der code, den ich verwenden und was nicht, müssen alle externen Bibliotheken:

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.*;
import javax.crypto.spec.*;


public class Encryption 
{
    private static final String ALGORITHME = "Blowfish";
    private static final String TRANSFORMATION = "Blowfish/ECB/PKCS5Padding";
    private static final String SECRET = "kjkdfjslm";
    private static final String CHARSET = "ISO-8859-1";


    public static void main(String[] argv) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, UnsupportedEncodingException, IllegalBlockSizeException, BadPaddingException
    {
        Encryption main = new Encryption();

        String plain = "trallalla";
        System.out.println("initial : " + plain);

        String encrypted = main.encrypt(plain);
        System.out.println("after encryption : " + encrypted);

        String decrypted = main.decrypt(encrypted);
        System.out.println("after decryption : " + decrypted);
    }

    public String encrypt(String plaintext) 
    throws NoSuchAlgorithmException, 
    NoSuchPaddingException, 
    InvalidKeyException, 
    UnsupportedEncodingException, 
    IllegalBlockSizeException, 
    BadPaddingException
    {

            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(SECRET.getBytes(CHARSET), ALGORITHME));
            return new String(cipher.doFinal(plaintext.getBytes()), CHARSET);    
    }

    public String decrypt(String ciphertext) 
    throws NoSuchAlgorithmException, 
    NoSuchPaddingException, 
    InvalidKeyException, 
    UnsupportedEncodingException, 
    IllegalBlockSizeException, 
    BadPaddingException 
    {
      Cipher cipher = Cipher.getInstance(TRANSFORMATION);
      cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(SECRET.getBytes(), ALGORITHME));
      return new String(cipher.doFinal(ciphertext.getBytes(CHARSET)), CHARSET);
    }
}

InformationsquelleAutor restricteur