JAVA AES加密 对应的 C# 方法

由于最近在项目中用到，之前在网上找了好多，来来回回，终于整出来了。 贴出来以后用起来方便

C#

#region AES加解密
       /// <summary>
       ///AES加密（加密步骤）
       ///1，加密字符串得到2进制数组；
       ///2，将2禁止数组转为16进制；
       ///3，进行base64编码
       /// </summary>
       /// <param name="toEncrypt">要加密的字符串</param>
       /// <param name="key">密钥</param>
       public String Encrypt(String toEncrypt, String key) 
       {
           Byte[] _Key = Encoding.ASCII.GetBytes(key);
           Byte[] _Source = Encoding.UTF8.GetBytes(toEncrypt);

           Aes aes = Aes.Create("AES");
           aes.Mode = CipherMode.ECB;
           aes.Padding = PaddingMode.PKCS7;
           aes.Key = _Key;
           ICryptoTransform cTransform = aes.CreateEncryptor();
           Byte[] cryptData = cTransform.TransformFinalBlock(_Source, 0, _Source.Length);
           String HexCryptString = Hex_2To16(cryptData);
           Byte[] HexCryptData = Encoding.UTF8.GetBytes(HexCryptString);
           String CryptString =Convert.ToBase64String(HexCryptData);
           return CryptString;
       }

       /// <summary>
       /// AES解密（解密步骤）
       /// 1，将BASE64字符串转为16进制数组
       /// 2，将16进制数组转为字符串
       /// 3，将字符串转为2进制数据
       /// 4，用AES解密数据
       /// </summary>
       /// <param name="encryptedSource">已加密的内容</param>
       /// <param name="key">密钥</param>
       public String Decrypt(string encryptedSource, string key)
       {
           Byte[] _Key = Encoding.ASCII.GetBytes(key);
           Aes aes = Aes.Create("AES");
           aes.Mode = CipherMode.ECB;
           aes.Padding = PaddingMode.PKCS7;
           aes.Key = _Key;
           ICryptoTransform cTransform = aes.CreateDecryptor();

           Byte[] encryptedData = Convert.FromBase64String(encryptedSource);
           String encryptedString = Encoding.UTF8.GetString(encryptedData);
           Byte[] _Source = Hex_16To2(encryptedString);
           Byte[] originalSrouceData = cTransform.TransformFinalBlock(_Source, 0, _Source.Length);
           String originalString = Encoding.UTF8.GetString(originalSrouceData);
           return originalString;
       }

       /// <summary>
       /// 2进制转16进制
       /// </summary>
       String Hex_2To16(Byte[] bytes)
       {
           String hexString = String.Empty;
           Int32 iLength = 65535;
           if (bytes != null)
           {
               StringBuilder strB = new StringBuilder();

               if (bytes.Length < iLength)
               {
                   iLength = bytes.Length;
               }

               for (int i = 0; i < iLength; i++)
               {
                   strB.Append(bytes[i].ToString("X2"));
               }
               hexString = strB.ToString();
           }
           return hexString;
       }

       /// <summary>
       /// 16进制转2进制
       /// </summary>
       Byte[] Hex_16To2(String hexString)
       {
           if ((hexString.Length % 2) != 0)
           {
               hexString += " ";
           }
           Byte[] returnBytes = new Byte[hexString.Length / 2];
           for (Int32 i = 0; i < returnBytes.Length; i++)
           {
               returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
           }
           return returnBytes;
       }
       #endregion

JAVA:

/**
	 * 加密--把加密后的byte数组先进行二进制转16进制在进行base64编码
	 * @param sSrc
	 * @param sKey
	 * @return
	 * @throws Exception
	 */
	public static String encrypt(String sSrc, String sKey) throws Exception {
		if (sKey == null) {
			throw new IllegalArgumentException("Argument sKey is null.");
		}
		if (sKey.length() != 16) {
			throw new IllegalArgumentException(
					"Argument sKey'length is not 16.");
		}
		byte[] raw = sKey.getBytes("ASCII");
		SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");

		Cipher cipher = Cipher.getInstance("AES");
		cipher.init(Cipher.ENCRYPT_MODE, skeySpec);

		byte[] encrypted = cipher.doFinal(sSrc.getBytes("UTF-8"));
		String tempStr = parseByte2HexStr(encrypted);

		Base64Encoder encoder = new Base64Encoder();
		return encoder.encode(tempStr.getBytes("UTF-8"));
	}

	/**
	 *解密--先 进行base64解码，在进行16进制转为2进制然后再解码
	 * @param sSrc
	 * @param sKey
	 * @return
	 * @throws Exception
	 */
	public static String decrypt(String sSrc, String sKey) throws Exception {

		if (sKey == null) {
			throw new IllegalArgumentException("499");
		}
		if (sKey.length() != 16) {
			throw new IllegalArgumentException("498");
		}

		byte[] raw = sKey.getBytes("ASCII");
		SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");

		Cipher cipher = Cipher.getInstance("AES");
		cipher.init(Cipher.DECRYPT_MODE, skeySpec);

		Base64Encoder encoder = new Base64Encoder();
		byte[] encrypted1 = encoder.decode(sSrc);

		String tempStr = new String(encrypted1, "utf-8");
		encrypted1 = parseHexStr2Byte(tempStr);
		byte[] original = cipher.doFinal(encrypted1);
		String originalString = new String(original, "utf-8");
		return originalString;
	}

	/**
	 * 将二进制转换成16进制
	 * 
	 * @param buf
	 * @return
	 */
	public static String parseByte2HexStr(byte buf[]) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < buf.length; i++) {
			String hex = Integer.toHexString(buf[i] & 0xFF);
			if (hex.length() == 1) {
				hex = '0' + hex;
			}
			sb.append(hex.toUpperCase());
		}
		return sb.toString();
	}

	/**
	 * 将16进制转换为二进制
	 * 
	 * @param hexStr
	 * @return
	 */
	public static byte[] parseHexStr2Byte(String hexStr) {
		if (hexStr.length() < 1)
			return null;
		byte[] result = new byte[hexStr.length() / 2];
		for (int i = 0; i < hexStr.length() / 2; i++) {
			int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
			int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),
					16);
			result[i] = (byte) (high * 16 + low);
		}
		return result;
	}