Encryt with a String

Question

Hi all
This is the first time that I'm trying to use de cryto api, but my purpose is to encrip a object with a String of my, and then serialize it.
I've found the following example on the net:
try {
// Generate a temporary key. In practice, you would save this key.
// See also e464 Encrypting with DES Using a Pass Phrase.
SecretKey key = KeyGenerator.getInstance("DES").generateKey();
// Prepare the encrypter
Cipher ecipher = Cipher.getInstance("DES");
ecipher.init(Cipher.ENCRYPT_MODE, key);
// Seal (encrypt) the object
SealedObject so = new SealedObject(new MySecretClass(), ecipher);
// Get the algorithm used to seal the object
String algoName = so.getAlgorithm(); // DES
// Prepare the decrypter
Cipher dcipher = Cipher.getInstance("DES");
dcipher.init(Cipher.DECRYPT_MODE, key);
// Unseal (decrypt) the class
MySecretClass o = (MySecretClass)so.getObject(dcipher);
} catch (java.io.IOException e) {
} catch (ClassNotFoundException e) {
} catch (javax.crypto.IllegalBlockSizeException e) {
} catch (javax.crypto.BadPaddingException e) {
} catch (javax.crypto.NoSuchPaddingException e) {
} catch (java.security.NoSuchAlgorithmException e) {
} catch (java.security.InvalidKeyException e) {
But i like to use it with my own key (String object), anyone knows which changes need to be performed?

Answer 1

This is my standard DES example -
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;
import sun.misc.*;
public class DESEncryptDataString
    static public class EncryptionException extends Exception
        private EncryptionException(String text, Exception chain)
            super(text, chain);
    public DESEncryptDataString(byte[] keyBytes, byte[] ivBytes, String characterEncoding) throws EncryptionException
        assert (keyBytes != null) && (keyBytes.length == 8);
        assert (ivBytes != null) && (ivBytes.length == 8);
        assert (characterEncoding != null);
        try
            SecretKey key1 = new SecretKeySpec(keyBytes, "DES");
            // To demonstrate that the least significant bit is the parity bit and can be ignored.
            keyBytes[0] ^=0x01;
            SecretKey key2 = new SecretKeySpec(keyBytes, "DES");
            IvParameterSpec iv = new IvParameterSpec(ivBytes);
            this.characterEncoding = characterEncoding;
            this.encryptCipher = Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
            this.encryptCipher.init(javax.crypto.Cipher.ENCRYPT_MODE, key1, iv);
            this.decryptCipher = Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
            this.decryptCipher.init(javax.crypto.Cipher.DECRYPT_MODE, key2, iv);
        catch (Exception e)
            throw new EncryptionException("Problem constucting " + this.getClass().getName(), e);
    synchronized public byte[] encrypt(String dataString) throws EncryptionException
        assert dataString != null;
        try
            byte[] dataStringBytes = dataString.getBytes(characterEncoding);
            byte[] encryptedDataStringBytes = encryptCipher.doFinal(dataStringBytes);
            return encryptedDataStringBytes;
        catch (Exception e)
            throw new EncryptionException("Problem encrypting string", e);
    synchronized public String decrypt(byte[] encryptedDataStringBytes) throws EncryptionException
        assert encryptedDataStringBytes != null;
        try
            byte[] dataStringBytes = this.decryptCipher.doFinal(encryptedDataStringBytes);
            String dataString = new String(dataStringBytes, characterEncoding);
            return dataString;
        catch (Exception e)
            throw new EncryptionException("Problem decrypting string", e);
    public static void main(String[] args)
        try
            // Make sure SUN are a valid provider
            Security.addProvider(new com.sun.crypto.provider.SunJCE());
            // The DES Key - any 8 bytes will do though beware of weak keys.
            // This could be read from a file.
            final byte[] keyBytes = "01234567".getBytes("ASCII");
            // IV For CBC mode
            // Again, could be read from a file.
            final byte[] IVBytes = "ABCDEFGH".getBytes("ASCII");
            // Data string encrypt agent that assumes the data string is only ASCII characters
            DESEncryptDataString dataStringEncryptAgent = new DESEncryptDataString(keyBytes, IVBytes, "UTF-8");
            // Get the data string to encrypt from the command line
            String dataString = (args.length == 0)? "The quick brown fox jumps over the lazy dog." : args[0];
            System.out.println("Data string ....................[" + dataString + "]");
            byte[] encryptedDataStringBytes = dataStringEncryptAgent.encrypt(dataString);
            BASE64Encoder base64Encoder = new BASE64Encoder();
            System.out.println("Encoded encrypted data string ..[" + base64Encoder.encode(encryptedDataStringBytes) + "]");
            String recoveredDataString = dataStringEncryptAgent.decrypt(encryptedDataStringBytes);
            System.out.println("Recovered data string ..........[" + recoveredDataString + "]");
        catch (Exception e)
            e.printStackTrace(System.out);
    private String characterEncoding;
    private Cipher encryptCipher;
    private Cipher decryptCipher;
}Please note, DO NOT TRY TO CONVERT THE ENCRYPTED DATA TO A STRING USING
String encryptedDataAsString = new String(encryptedDataStringBytes)
as not all bytes and byte sequences can be recovered from teh resulting String. The result depends on the encoding.
If you need a String representation then use Base64 or Hex encoding.