Conversion de bytes

Hola, estoy trabajando conencripcion y quiero guardar los datos encriptados en una bd, el problema es que al encriptar obtengo un arreglo de bytes y si lo convierto a string y luego lo guardo, cuando lo quiero desencriptar tengo problemas, ya que lo convierto de string a bytes y me dice que los bloques deben ser de 16 bytes, que puedo hacer para poder guardarlo sin modificar el tamaño de los bloques?
aqui les dejo mi codigo

package aes;
/**
 *
 * @author insi
 */

   import java.security.*;
   import javax.crypto.*;
   import javax.crypto.spec.*;
   import java.io.*;
import java.util.Arrays;
   /**
   * This program generates a AES key, retrieves its raw bytes, and
   * then reinstantiates a AES key from the key bytes.
   * The reinstantiated key is used to initialize a AES cipher for
   * encryption and decryption.
   */

   public class AES {
     /**
     * Turns array of bytes into string
     *
     * @param buf    Array of bytes to convert to hex string
     * @return    Generated hex string
     */

     public static String asHex (byte buf[]) {
      StringBuffer strbuf = new StringBuffer(buf.length * 2);
      int i;
      for (i = 0; i < buf.length; i++) {
       if (((int) buf[i] & 0xff) < 0x10)
        strbuf.append("0");
       strbuf.append(Long.toString((int) buf[i] & 0xff, 16));
      }
      return strbuf.toString();
     }
     public static void main(String[] args) throws Exception {
       String message="kljdklsfjkljfklsdj bla bla es una trama";
        char[] pass=new char[6];
        pass="1232a".toCharArray();
        byte[] pass16 = getClave16 (pass);
        Arrays.fill (pass, (char)0);
        byte[] iv = "2234598890193456".getBytes("UTF-8");
        IvParameterSpec extra = new IvParameterSpec(iv);
       
        SecretKeySpec key = new SecretKeySpec (pass16, "AES");
      // Instantiate the cipher
       Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
       cipher.init(Cipher.ENCRYPT_MODE, key,extra);
       byte[] encrypted =
         cipher.doFinal(message.getBytes());
       System.out.println(key+" "+extra+"encrypted string: " + asHex(encrypted));
//convierto a string, aqui es donde guardara en la bd
       String encriptada_string = new String(encrypted);

       
       pass="1232a".toCharArray();
        pass16 = getClave16 (pass);
        Arrays.fill (pass, (char)0);
       iv = "2234598890193456".getBytes("UTF-8");
       extra = new IvParameterSpec(iv);
        key = new SecretKeySpec (pass16, "AES");
       cipher.init(Cipher.DECRYPT_MODE, key,extra);
      byte[] encrypted2 =encriptada_string.getBytes();
      byte[] original =cipher.doFinal(encrypted2);
       String originalString = new String(original);
       System.out.println("Original string: " +
         originalString + " " + asHex(original));
     }
     public static byte[] getClave16 (char[] clave)
{
    MessageDigest md = null;
    try
    { md = MessageDigest.getInstance ("SHA-1"); }
    catch (Exception e) {}
    byte[] msg = new byte[clave.length];
    for (int i=0; i<clave.length; ++i)
        { msg[i] = (byte)clave[i]; }
    md.update(msg);
    byte[] msg2 = md.digest();
    Arrays.fill (msg, (byte)0);
    System.out.println (""+System.currentTimeMillis());
    for (int i=0; i<70000; ++i)
    {
        msg = new byte[msg2.length+1];
        System.arraycopy (msg2, 0, msg, 0, msg2.length);
        msg[msg2.length] = (byte)(i%128);
        md.update (msg);
        Arrays.fill (msg2, (byte)0);
        msg2 = md.digest();
        Arrays.fill (msg, (byte)0);
    }
    byte[] clave16 = new byte[16];
    for (int i=0; i<16; ++i)
        { clave16[i] = msg2[i]; }
    Arrays.fill (msg2, (byte)0);
    return clave16;
}
   }

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

Base64

Lo mejor será que uses Base64. Es un algoritmo para codificar datos binarios como cadenas de texto simple. Cada 3 bytes de datos se convierten en 4 bytes de texto.

O bien puedes codificar a hexadecimal, simplemente armas una cadena con la representación hexadecimal de cada byte, todo seguido.

La diferencia es que la cadena hexadecimal siempre va a medir el doble de los datos que estás codificando, mientras que con base64 la cadena solamente es entre 25% y 30% más grande que los datos que codificaste.

Es un algoritmo estándar, pero no hay una implementación pública en Java, aunque puedes encontrar un codec para base64 en los paquetes privados de com.sun.util.* o algo así (pero no están garantizados que van a seguir sirviendo, por eso es más recomendable que hagas tu propia implementación que es bastante simple, o que utilices alguna que seguro en Apache Commons debe haber algo).

gracias

ok, mejor haré mi propia implementacion, gracias por tu respuesta :D