Android与服务器交互的方式中的对称加密和非对称加密

对称加密

对称加密，就是加密和解密数据都是使用同一个key，这方面的算法有DES（64位），AES()。
高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。

public class AESUtil {

      private final static String HEX = "0123456789ABCDEF";
      private final static int JELLY_BEAN_4_2 = 17;

      /**
       * 加密
       * 
       * @param key
       *            密钥
       * @param src
       *            加密文本
       * @return
       * @throws Exception
       */
      public static String encrypt(String key, String src) throws Exception {
        byte[] rawKey = getRawKey(key.getBytes());
        byte[] result = encrypt(rawKey, src.getBytes());
        return toHex(result);
      }

      /**
       * 解密
       * 
       * @param key
       *            密钥
       * @param encrypted
       *            待揭秘文本
       * @return
       * @throws Exception
       */
      public static String decrypt(String key, String encrypted) throws Exception {
        byte[] rawKey = getRawKey(key.getBytes());
        byte[] enc = toByte(encrypted);
        byte[] result = decrypt(rawKey, enc);
        return new String(result);
      }

      /**
       * 获取256位的加密密钥
       * 
       * @param seed
       * @return
       * @throws Exception
       */
      @SuppressLint("TrulyRandom")
      private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        SecureRandom sr = null;
        // 在4.2以上版本中，SecureRandom获取方式发生了改变
        if (android.os.Build.VERSION.SDK_INT >= JELLY_BEAN_4_2) {
          sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
        } else {
          sr = SecureRandom.getInstance("SHA1PRNG");
        }
        sr.setSeed(seed);
        // 256 bits or 128 bits,192bits
        kgen.init(256, sr);
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return raw;
      }

      /**
       * 真正的加密过程
       * 
       * @param key
       * @param src
       * @return
       * @throws Exception
       */
      private static byte[] encrypt(byte[] key, byte[] src) throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(key, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal(src);
        return encrypted;
      }

      /**
       * 真正的解密过程
       * 
       * @param key
       * @param encrypted
       * @return
       * @throws Exception
       */
      private static byte[] decrypt(byte[] key, byte[] encrypted)
          throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(key, "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 < 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 < buf.length; i++) {
          appendHex(result, buf[i]);
        }
        return result.toString();
      }

      private static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
      }
    }

非对称加密

非对称加密，加密和解密是使用不同的key。发送数据之前要先和服务端约定生成公钥和私钥，使用公钥加密的数据可以用私钥解密，反之。这方面的算法有RSA。ssh 和 ssl都是典型的非对称加密。

RSA流程分析：
甲方构建密钥对儿，将公钥公布给乙方，将私钥保留。
甲方使用私钥加密数据，然后用私钥对加密后的数据签名，发送给乙方签名以及加密后的数据；乙方使用公钥、签名来验证待解密数据是否有效，如果有效使用公钥对数据解密。
乙方使用公钥加密数据，向甲方发送经过加密后的数据；甲方获得加密数据，通过私钥解密。