Secret key getting corrupted

Question

Hi All,
Can anyone please help me in finding the possibilities of a secret key getting corrupted??
Encryption Algorithm used :- Blowfish
Instance of SecretKeyFactory :- PBEWithMD5AndDES
Also, are there any chances wherein, the secret key generated varies ( probably in length ); even though same data is used for key construction??
Thanks in advance!!!!

Answer 1

Hi Sabre,
Below is the CryptoWrapper class:
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
* A class to simplify doing encryption & decryption.
* <P>
* Note that it acts immediately; you <B>CANNOT</B> use this as a stream cipher wrapper.
public class CryptoWrapper{
    private static KeyGenerator keygen;
    private static Cipher cipher;
    private String transform;
     * Creates a crypto wrapper with sensible defaults; does <B>NOT</B> add a provider.
     * Default transformation is "Blowfish".
     * @return a wrapper for the required cipher.
    public CryptoWrapper() throws NoSuchAlgorithmException, NoSuchPaddingException{
        this("Blowfish", null);
     * Creates a crypto wrapper with sensible defaults; does <B>NOT</B> add a provider.
     * @param transformation the name of the transformation (e.g. <I>"Blowfish"</I>).
     * @return a wrapper for the required cipher.
    public CryptoWrapper(String transformation) throws NoSuchAlgorithmException,
                                                       NoSuchPaddingException{
        this(transformation, null);
     * Creates a CryptoWrapper with the given transformation name and crypto provider.
     * @param transformation the name of the transformation (e.g. <I>"Blowfish"</I>).
     * @param provider a crypto provider (e.g. <I>com.sun.crypto.provider.SunJCE</I>).  If null, no provider added.
     * @return a wrapper for the required cipher.
    public CryptoWrapper(String transformation, Provider provider) throws NoSuchAlgorithmException,
                                                                          NoSuchPaddingException{
        if (null != provider){
            Security.addProvider(provider);
        // can't happen until after the provider's loaded
        this.cipher = Cipher.getInstance(transformation);
        this.transform = transformation;
        if (null == this.keygen){
            this.keygen = KeyGenerator.getInstance(transformation);
     * Example to encrypt and decrypt a string.
     * <P>
     * Usage: <B>java CryptoWrapper <text to be encrypted></B>
    public static void main(String[] args){
        try{
            CryptoWrapper bw = new CryptoWrapper("Blowfish",
                                                 new com.sun.crypto.provider.SunJCE());
            SecretKey key = CryptoWrapper.generateSecretKey(128);
            String plaintext = "";
            String ciphertext;
            String outputtext;
            byte[] plaintext_bytes;
            byte[] ciphertext_bytes;
            byte[] outputtext_bytes;
            for (int i = 0; i < args.length; i++){
                plaintext = plaintext + " " + args;
plaintext_bytes = plaintext.getBytes();
ciphertext_bytes = bw.encrypt(plaintext_bytes, key);
ciphertext = new String(ciphertext_bytes);
outputtext_bytes = bw.decrypt(ciphertext_bytes, key);
outputtext = new String(outputtext_bytes);
catch (BadPaddingException bp){
catch (IllegalBlockSizeException ibs){
catch (InvalidKeyException ie){
catch (NoSuchAlgorithmException nsa){
catch (NoSuchPaddingException nsp){
* Creates a secret key of the given size.<BR>
* Note: synchronized against the key generator object.
* @param keysize The size (<B>in bits</B>) of the key.
* @return The secret key.
public static synchronized SecretKey generateSecretKey(int keysize)
throws InvalidParameterException{
keygen.init(keysize);
return keygen.generateKey();
* Decrypts the given byte array using the given cipher, with the given key.<BR>
* Note: synchronized against the cipher object.
* @param ciphertext An array of bytes to decode.
* @param key A secret key for use in decryption.
* @return The decrypted byte array.
public byte[] decrypt(byte[] ciphertext, SecretKey key) throws BadPaddingException,
IllegalBlockSizeException,
InvalidKeyException,
NoSuchAlgorithmException,
NoSuchPaddingException{
SecretKeySpec sks = new SecretKeySpec(key.getEncoded(),
this.transform);
synchronized (this.cipher){ // this resets the state of the cipher, so we must prevent concurrent access
this.cipher.init(Cipher.DECRYPT_MODE, sks);
return this.cipher.doFinal(ciphertext);
* Encrypts the given byte array using the given cipher, with the given key.<BR>
* Note: synchronized against the cipher object.
* @param plaintext An array of bytes to encode.
* @param key A secret key for use in encryption.
* @return The encrypted byte array.
public byte[] encrypt(byte[] plaintext, SecretKey key) throws NoSuchAlgorithmException,
NoSuchPaddingException,
BadPaddingException,
InvalidKeyException,
IllegalBlockSizeException{
SecretKeySpec sks = new SecretKeySpec(key.getEncoded(),
this.transform);
synchronized (this.cipher){ // this resets the state of the cipher, so must prevent concurrent access
this.cipher.init(Cipher.ENCRYPT_MODE, sks);
return this.cipher.doFinal(plaintext);
}Below is the hexStringToByteArrayConverter:public byte [] hexStringToByteArray(String hexStr) throws BadPasswordException{
     int length = hexStr.length();
     if(length%2!=0)
          throw new BadPasswordException("Bad hex string password!");
     int [] x = new int[length];
     int btLen = length/2;
     byte[] bt = new byte[btLen];
     for(int i=0;i<length;i++)
     x[i] = Character.getNumericValue(hexStr.charAt(i));
     if(i%2==1)
          int y = x[i-1]*16 + x[i];
          bt[(i-1)/2] = (byte)y;
     return bt;