JAVA AES加密 对应的 C# 方法

于 2014-06-30 15:32:35 发布
阅读量540 收藏
点赞数
文章标签： java AES 加密 C#
C# 
       // 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; 
       } 
       

       // 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;
       }

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; 
    } 

  /**
  * 加密--把加密后的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;
 }



yang_gs
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值