title: Android 4.2 broke my AES encrypt/decrypt code
body: <p>It's my first time asking for help in here, my department (a Government), have published some app on the market (Google Play), and the encryption and description was working really well up to yesterday when I got the Jelly Bean 4.2 on my Nexus. 
  The encrypt works fine, it's in fact encrypt the information to be stored. Though when decrypt it, I'm getting an exception exactly like this : <strong>pad block corrupted</strong>.
  I've checked the string and it's consistent with it on others devices (using the same key for test purposes), meaning it's exactly the same.
  The problem is that we need keep the back compatibility with previous versions, meaning that if I change something in the code, it's should be able to read the old encrypted information. The encrypted information it's stored on SQLite, due that I need encode it to Base64. The exception happen on this line <strong>byte[] decrypted = cipher.doFinal(encrypted);</strong></p>
  
  <p>Here is my class:</p>
  
  <pre><code>import java.security.SecureRandom;
  
  import javax.crypto.Cipher;
  import javax.crypto.KeyGenerator;
  import javax.crypto.SecretKey;
  import javax.crypto.spec.SecretKeySpec;
  
  import android.util.Base64;
  
  public class EncodeDecodeAES {
  
      private final static String HEX = "0123456789ABCDEF";
  
      public static String encrypt(String seed, String cleartext) throws Exception {
          byte[] rawKey = getRawKey(seed.getBytes());
          byte[] result = encrypt(rawKey, cleartext.getBytes());
          String fromHex = toHex(result);
          String base64 = new String(Base64.encodeToString(fromHex.getBytes(), 0));
          return base64;
      }
  
  
      public static String decrypt(String seed, String encrypted) throws Exception {
          String base64 = new String(Base64.decode(encrypted, 0));
          byte[] rawKey = getRawKey(seed.getBytes());
          byte[] enc = toByte(base64);
          byte[] result = decrypt(rawKey, enc);
          return new String(result);
      }
  
  
      public static byte[] encryptBytes(String seed, byte[] cleartext) throws Exception {
          byte[] rawKey = getRawKey(seed.getBytes());
          byte[] result = encrypt(rawKey, cleartext);
          return result;
      }
  
  
      public static byte[] decryptBytes(String seed, byte[] encrypted) throws Exception {
          byte[] rawKey = getRawKey(seed.getBytes());
          byte[] result = decrypt(rawKey, encrypted);
          return result;
      }
  
  
  
      private static byte[] getRawKey(byte[] seed) throws Exception {
          KeyGenerator kgen = KeyGenerator.getInstance("AES");
          SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
          sr.setSeed(seed);
          try {
              kgen.init(256, sr);
          } catch (Exception e) {
      //      Log.w(LOG, "This device doesn't suppor 256bits, trying 192bits.");
              try {
                  kgen.init(192, sr);
              } catch (Exception e1) {
      //          Log.w(LOG, "This device doesn't suppor 192bits, trying 128bits.");
                  kgen.init(128, sr);
              }
          }
          SecretKey skey = kgen.generateKey();
          byte[] raw = skey.getEncoded();
          return raw;
      }
  
  
      private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {
          SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
          Cipher cipher = Cipher.getInstance("AES");
          cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
          byte[] encrypted = cipher.doFinal(clear);
          return encrypted;
      }
  
  
      private static byte[] decrypt(byte[] raw, byte[] encrypted) throws Exception {
          SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
          Cipher cipher = Cipher.getInstance("AES");
          cipher.init(Cipher.DECRYPT_MODE, skeySpec);
          byte[] decrypted = cipher.doFinal(encrypted);
          return decrypted;
      }
  
  
      public static String toHex(String txt) {
          return toHex(txt.getBytes());
      }
  
  
      public static String fromHex(String hex) {
          return new String(toByte(hex));
      }
  
  
      public static byte[] toByte(String hexString) {
          int len = hexString.length() / 2;
          byte[] result = new byte[len];
          for (int i = 0; i &lt; len; i++)
              result[i] = Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16).byteValue();
          return result;
      }
  
  
      public static String toHex(byte[] buf) {
          if (buf == null)
              return "";
          StringBuffer result = new StringBuffer(2 * buf.length);
          for (int i = 0; i &lt; buf.length; i++) {
              appendHex(result, buf[i]);
          }
          return result.toString();
      }
  
  
      private static void appendHex(StringBuffer sb, byte b) {
          sb.append(HEX.charAt((b &gt;&gt; 4) &amp; 0x0f)).append(HEX.charAt(b &amp; 0x0f));
      }
  
  }
  </code></pre>
  
  <p>I would like to know (if somebody help me), what 'm I doing wrong with this code, or if it's a issue with Android 4.2 and if it's a issue with 4.2 if has any workaround?</p>
  
  <p>Thank you</p>