AES加密php,java,.net三种语言同步实现加密、解密

最新推荐文章于 2024-05-14 15:38:31 发布
最新推荐文章于 2024-05-14 15:38:31 发布
阅读量953 收藏 1
点赞数 1
分类专栏： php解密 php 文章标签： java aes加密解密 php aes加密解密 asp.net aes加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zimumanbu/article/details/81660970
版权

因工作需要，在使用aes解密时，因客户开发语言有多种，现在基本就是java,php,asp.net三种语言是主流，笔者对三种语言也算是研究多年了，有时客户总是问这问那的，就调试好了三种不同语言的AES加密工具类，这样也确保客户加密过来的数据服务器端可以正常解密。闲话少说了，贴出代码。：）

1、java版

    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    package com.totcms.api.util;
     
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
     
    import java.io.FileInputStream;
    import java.io.UnsupportedEncodingException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
     
     
    public class AES {
        // /** 算法/模式/填充 **/
        private static final String CipherMode = "AES/ECB/PKCS5Padding";
        // private static final String CipherMode = "AES";
     
        /**
         * 生成一个AES密钥对象
         * @return
         */
        public static SecretKeySpec generateKey(){
            try {
                KeyGenerator kgen = KeyGenerator.getInstance("AES");
                kgen.init(128, new SecureRandom());
                SecretKey secretKey = kgen.generateKey();  
                byte[] enCodeFormat = secretKey.getEncoded();  
                SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
                return key;
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            return null;
        }
     
        /**
         * 生成一个AES密钥字符串
         * @return
         */
        public static String generateKeyString(){
            return byte2hex(generateKey().getEncoded());
        }
     
        /**
         * 加密字节数据
         * @param content
         * @param key
         * @return
         */
        public static byte[] encrypt(byte[] content,byte[] key) {
            try {
                Cipher cipher = Cipher.getInstance(CipherMode);
                cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "AES"));
                byte[] result = cipher.doFinal(content);
                return result;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
     
        /**
         * 通过byte[]类型的密钥加密String
         * @param content
         * @param key
         * @return 16进制密文字符串
         */
        public static String encrypt(String content,byte[] key) {
            try {
                Cipher cipher = Cipher.getInstance(CipherMode);
                cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "AES"));
                byte[] data = cipher.doFinal(content.getBytes("UTF-8"));
                String result = byte2hex(data);
                return result;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
     
        /**
         * 通过String类型的密钥加密String
         * @param content
         * @param key
         * @return 16进制密文字符串
         */
        public static String encrypt(String content,String key) {
            byte[] data = null;
            try {
                data = content.getBytes("UTF-8");
            } catch (Exception e) {
                e.printStackTrace();
            }
            data = encrypt(data,new SecretKeySpec(hex2byte(key), "AES").getEncoded());
            String result = byte2hex(data);
            return result;
        }
     
        /**
         * 通过byte[]类型的密钥解密byte[]
         * @param content
         * @param key
         * @return
         */
        public static byte[] decrypt(byte[] content,byte[] key) {
            try {
                Cipher cipher = Cipher.getInstance(CipherMode);
                cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "AES"));
                byte[] result = cipher.doFinal(content);
                return result;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
     
        /**
         * 通过String类型的密钥 解密String类型的密文
         * @param content
         * @param key
         * @return
         */
        public static String decrypt(String content, String key) {
            byte[] data = null;
            try {
                data = hex2byte(content);
            } catch (Exception e) {
                e.printStackTrace();
            }
            data = decrypt(data, hex2byte(key));
            if (data == null)
                return null;
            String result = null;
            try {
                result = new String(data, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return result;
        }
     
        /**
         * 通过byte[]类型的密钥 解密String类型的密文
         * @param content
         * @param key
         * @return
         */
        public static String decrypt(String content,byte[] key) {
            try {
                Cipher cipher = Cipher.getInstance(CipherMode);
                cipher.init(Cipher.DECRYPT_MODE,new SecretKeySpec(key, "AES"));
                byte[] data = cipher.doFinal(hex2byte(content));
                return new String(data, "UTF-8");
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
     
        /**
         * 字节数组转成16进制字符串
         * @param b
         * @return
         */
        public static String byte2hex(byte[] b) { // 一个字节的数，
            StringBuffer sb = new StringBuffer(b.length * 2);
            String tmp;
            for (int n = 0; n < b.length; n++) {
                // 整数转成十六进制表示
                tmp = (Integer.toHexString(b[n] & 0XFF));
                if (tmp.length() == 1) {
                    sb.append("0");
                }
                sb.append(tmp);
            }
            return sb.toString().toUpperCase(); // 转成大写
        }
     
        /**
         * 将hex字符串转换成字节数组
         * @param inputString
         * @return
         */
        private static byte[] hex2byte(String inputString) {
            if (inputString == null || inputString.length() < 2) {
                return new byte[0];
            }
            inputString = inputString.toLowerCase();
            int l = inputString.length() / 2;
            byte[] result = new byte[l];
            for (int i = 0; i < l; ++i) {
                String tmp = inputString.substring(2 * i, 2 * i + 2);
                result[i] = (byte) (Integer.parseInt(tmp, 16) & 0xFF);
            }
            return result;
        }
        
        public static void main(String[] args) {
            try{
                // 加载RSA
                //RSAPublicKey publicKey = RSA.loadPublicKey(new FileInputStream("E:\\2016\\9\\19\\cert\\apiclient_cert.p12"));
                //RSAPrivateKey privateKey = RSA.loadPrivateKey(new FileInputStream("E:\\2016\\9\\19\\cert\\apiclient_cert.p12"));
            
                // 生成AES密钥
                 String key=AES.generateKeyString();
                 //                String key = "1234567890123456";
                System.out.println("AES-KEY:" + key);
            
                // 内容
    //            String content = "{\"mobile\":\"18660803982\",\"amount\":\"100\",\"companyId\":\"8\",\"orderNum\":\"123456789\",\"bussissId\":\"18154568754\",\"notifyUrl\":\"\"}";
                String content = "{\"mobile\":\"15005414383\",\"amount\":\"10\",\"companyId\":\"8\",\"orderNum\":\"123456789\",\"notifyUrl\":\"\",\"bussissId\":\"1101\"}";
                
                // 用RSA公钥加密AES-KEY
                //String miKey = RSA.encryptByPublicKey(key, publicKey);
                //System.out.println("加密后的AES-KEY:" + miKey);
                //System.out.println("加密后的AES-KEY长度:" + miKey.length());
            
                // 用RSA私钥解密AES-KEY
                //String mingKey = RSA.decryptByPrivateKey(miKey, privateKey);
                //System.out.println("解密后的AES-KEY:" + mingKey);
                //System.out.println("解密后的AES-KEY长度:" + mingKey.length());
            
                // 用AES加密内容
                //String miContent = AES.encrypt(content, mingKey);
                String miContent = AES.encrypt(content, "6369BE91F580F990015D709D4D69FA41");            
                System.out.println("AES加密后的内容:" + miContent);        
                // 用AES解密内容
                String mingContent = AES.decrypt(miContent, "6369BE91F580F990015D709D4D69FA41");
                System.out.println("AES解密后的内容:" + mingContent);        
            }catch (Exception e) {
                e.printStackTrace();
                // TODO: handle exception
            }
     
        }
    }

 

2、asp.net版

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.IO;
    using System.Net;
    using System.Web;
    using System.Text.RegularExpressions;
    using System.Security.Cryptography;  
     
    namespace PostDemo
    {
      public partial class Form1 : Form
      {
        public Form1()
        {
          InitializeComponent();
        }
     
       
        public static string AESEncrypts(String Data, String Key)
        {
          // 256-AES key      
          byte[] keyArray = HexStringToBytes(Key);//UTF8Encoding.ASCII.GetBytes(Key);
          byte[] toEncryptArray = UTF8Encoding.ASCII.GetBytes(Data);
     
          RijndaelManaged rDel = new RijndaelManaged();
          rDel.Key = keyArray;
          rDel.Mode = CipherMode.ECB;
          rDel.Padding = PaddingMode.PKCS7;
     
          ICryptoTransform cTransform = rDel.CreateEncryptor();
          byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0,
                  toEncryptArray.Length);
     
          return BytesToHexString(resultArray);
        }
     
        
        /// <summary>
        /// Byte array to convert 16 hex string
        /// </summary>
        /// <param name="bytes">byte array</param>
        /// <returns>16 hex string</returns>
        public static string BytesToHexString(byte[] bytes)
        {
          StringBuilder returnStr = new StringBuilder();
          if (bytes != null || bytes.Length == 0)
          {
            for (int i = 0; i < bytes.Length; i++)
            {
              returnStr.Append(bytes[i].ToString("X2"));
            }
          }
          return returnStr.ToString();
        }
     
        /// <summary>
        /// 16 hex string converted to byte array
        /// </summary>
        /// <param name="hexString">16 hex string</param>
        /// <returns>byte array</returns>
        public static byte[] HexStringToBytes(String hexString)
        {
          if (hexString == null || hexString.Equals(""))
          {
            return null;
          }
          int length = hexString.Length / 2;
          if (hexString.Length % 2 != 0)
          {
            return null;
          }
          byte[] d = new byte[length];
          for (int i = 0; i < length; i++)
          {
            d[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
          }
          return d;
        }
     
        private void button2_Click(object sender, EventArgs e)
        {
          String Content = tbContent.Text;//要加密的字符串
          //接口密钥，替换成您的密钥（32位）
          String k = "6D6A39C7078F6783E561B0D1A9EB2E68";
          String s = AESEncrypts(Content, k);
          tbLog.AppendText("encript:"+s);
        }  
      }
    }

 

3、php版

    <?php
    class CryptAES
    {
        protected $cipher = MCRYPT_RIJNDAEL_128;
        protected $mode = MCRYPT_MODE_ECB;
        protected $pad_method = NULL;
        protected $secret_key = '';
        protected $iv = '';
     
        public function set_cipher($cipher)
        {
            $this->cipher = $cipher;
        }
     
        public function set_mode($mode)
        {
            $this->mode = $mode;
        }
     
        public function set_iv($iv)
        {
            $this->iv = $iv;
        }
     
        public function set_key($key)
        {
            $this->secret_key = $key;
        }
     
        public function require_pkcs5()
        {
            $this->pad_method = 'pkcs5';
        }
     
        protected function pad_or_unpad($str, $ext)
        {
            if ( is_null($this->pad_method) )
            {
                return $str;
            }
            else
            {
                $func_name = __CLASS__ . '::' . $this->pad_method . '_' . $ext . 'pad';
                if ( is_callable($func_name) )
                {
                    $size = mcrypt_get_block_size($this->cipher, $this->mode);
                    return call_user_func($func_name, $str, $size);
                }
            }
            return $str;
        }
     
        protected function pad($str)
        {
            return $this->pad_or_unpad($str, '');
        }
     
        protected function unpad($str)
        {
            return $this->pad_or_unpad($str, 'un');
        }
     
        public function encrypt($str)
        {
            $str = $this->pad($str);
            $td = mcrypt_module_open($this->cipher, '', $this->mode, '');
     
            if ( empty($this->iv) )
            {
                $iv = @mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
            }
            else
            {
                $iv = $this->iv;
            }
     
            mcrypt_generic_init($td, hex2bin($this->secret_key), $iv);
            $cyper_text = mcrypt_generic($td, $str);
            $rt = strtoupper(bin2hex($cyper_text));
            mcrypt_generic_deinit($td);
            mcrypt_module_close($td);
     
            return $rt;
        }
     
        public function decrypt($str){
            $td = mcrypt_module_open($this->cipher, '', $this->mode, '');
     
            if ( empty($this->iv) )
            {
                $iv = @mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
            }
            else
            {
                $iv = $this->iv;
            }
     
            mcrypt_generic_init($td, $this->secret_key, $iv);
            //$decrypted_text = mdecrypt_generic($td, self::hex2bin($str));
            $decrypted_text = mdecrypt_generic($td, base64_decode($str));
            $rt = $decrypted_text;
            mcrypt_generic_deinit($td);
            mcrypt_module_close($td);
     
            return $this->unpad($rt);
        }
     
        public static function hex2bin($hexdata) {
            $bindata = '';
            $length = strlen($hexdata);
            for ($i=0; $i< $length; $i += 2)
            {
                $bindata .= chr(hexdec(substr($hexdata, $i, 2)));
            }
            return $bindata;
        }
     
        public static function pkcs5_pad($text, $blocksize)
        {
            $pad = $blocksize - (strlen($text) % $blocksize);
            return $text . str_repeat(chr($pad), $pad);
        }
     
        public static function pkcs5_unpad($text)
        {
            $pad = ord($text{strlen($text) - 1});
            if ($pad > strlen($text)) return false;
            if (strspn($text, chr($pad), strlen($text) - $pad) != $pad) return false;
            return substr($text, 0, -1 * $pad);
        }
    }
     
    //密钥
    $keyStr = '6D6A39C7078F6783E561B0D1A9EB2E68';
    //加密的字符串
    $plainText = 'test';
     
    $aes = new CryptAES();
    $aes->set_key($keyStr);
    $aes->require_pkcs5();
    $encText = $aes->encrypt($plainText);
     
    echo $encText;
     
    ?>


上面三种语言，使用相当的密钥(key)，对同样字符串加密后的结果是一样的。加密过程通过上面代码也好理解，将先key转成16进制传递给加密函数对内容加密，然后将加密后的结果转成16进制字符串返回结果（要注意大小写，这里我统一返回大写的结果）。

小人物9527
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP语言实现的AES加密、解密
云客的技术博客【云游天下 做客四方】
04-27 3726
&lt;?php /** * Class AES * 用于AES加解密数据 * by:云客 【云游天下，做客四方】,微信号：php-world，欢迎转载，但须注明出处，讨论请加qq群203286137 * time:2018-04-27 */ class AES { protected $cipher = MCRYPT_RIJNDAEL_256; //AES加密算法 p...
php AES加密解密 和 java 加密解密 互通
adminyan的博客
04-12 488
1，废话不多说直接上代码，先写一个类 class Crypt { /** * [$cipher 加密模式] * @var [type] */ private $cipher = MCRYPT_RIJNDAEL_128; private $mode = MCRYPT_MODE_CBC; /** * [$key 密匙] * @var string */ private $secret_key = 'dc1
ASP微信公众号消息加密解密 asp AES CBC模式加密
09-09
ASP公众号消息加解密EncodingAESKey，在网上这方面的知识也很少，官网上也没有给出示例，花了一些时间整理了下分享。 ASP的AES加密，采用的CBC模式，PACS7填充。调用.net framework的API接口加密 v2.0修复原来有些密钥存在的BUG问题
文件加密与解密技术实战：使用Java实现AES/CBC/PKCS5Padding加密算法
csdn466412618的博客
05-14 1212
使用Java实现AES/CBC/PKCS5Padding加密解密文件，保护数据安全。本文通过详细解析FileEncryptDecryptUtil类，展示了加密解密过程，强调了密钥管理、初始化向量(IV)使用的重要性，以及文件I/O操作的实现。提醒生产环境应采用安全密钥存储，优化大文件处理，并实施全面错误管理。掌握此工具，为文件安全保驾护航。
还不会参数加密？快来学学AES加密的方法
Bummon的学习随笔
09-24 1324
在实际工作中为了安全，会将参数进行密文传输，这里使用的是对称加密的加密方式，在此记录并学习一下，技术不精望大家谅解。AES加密是一种对称加密，有对称加密自然也有非对称加密。对称加密对称加密是一种简单快速的加密方式，它在加密和解密的时候使用的密钥是同一个，并且通常不会超过256bit，密钥越小，在加解密的时候耗时越短，但是同样的，对于数据的加密会稍弱一些。本文使用的加密方式正是对称加密非对称加密非对称加密提供了一种更为安全的加解密解决方案，它使用了一对密钥，也就是一个公钥和一个私钥。
php退款req_info乱码,退款结果通知解密req_info失败，麻烦看看代码有错误吗？
weixin_31082779的博客
04-01 121
/*** 对微信的返回数据进行解密 做AES-256-ECB解密(PKCS7Padding)* @param encrypted 目标密文* @param aesKey 解密密钥* @param* @throws Exception*/public static String decryptWXReturn(String encrypted, String aesKey){try {Cipher ...
C#, Java, PHP, Python和Javascript几种语言的AES加密解密实现
free_journey的博客
02-16 245
参考地址：https://www.cnblogs.com/mao2080/p/10500612.html 解决跨平台之后aes加密之后内容不一致的情况。 跨语言加解密的要求是：AES/CBC/ZeroPadding 128位模式，key和iv一样，编码统一用utf-8。不支持ZeroPadding的就用NoPadding. ...
AES加密解密,iOS,Android,Java,.Net通用
08-28
AES加密有多种算法模式，下面提供两套模式的可用源码: 一、CBC（Cipher Block Chaining，加密块链）模式 二、ECB（Electronic Code Book，电子密码本）模式 其中CBC模式下，有.NET的源码。而ECB模式的，大家在网上找...
Java使用Hutool实现AES、DES加密解密的方法
08-29
Java 使用 Hutool 实现 AES、DES 加密解密的方法 Java 中使用 Hutool 实现 AES、DES 加密解密的方法主要介绍了如何使用 Hutool 库来实现 AES 和 DES 加密解密。Hutool 库对 Java 中的 Cipher 对象进行了封装，简化...
Java实现的AES256加密解密功能示例
08-31
以下是对Java实现AES256加密解密功能的详细解析： 1. **密钥生成**： 在提供的代码中，`initkey()` 方法使用`KeyGenerator`类生成AES256密钥。`KeyGenerator.getInstance(KEY_ALGORITHM, "BC")`初始化一个密钥生成...
asp AES加密
04-23
asp版的AES加密源码，支持中英文加密。望采纳。
VB.NET实现AES加密解密
08-22
VB.NET实现AES加密解密代码，可直接使用
JAVA实现AES加密和解密
08-15
1.采用秘钥为16位长度的加密字符 2.加密算法为AES/ECB/PKCS5Padding 3.解决加解密乱码问题 4.完整的线上可运行代码及各方法及步骤注释 5.无任何插件，java环境直接运行
Java AES256加密解密实现
热门推荐
liyuming0000的专栏
09-12 4万+
Java AES256加密解密实现
C# AES 加密结果与Java 不同的解决办法
Tenderness104的博客
03-07 1038
C# AES 加密结果与Java 不同的解决办法
Atitit.加密算法 des  aes 各个语言不同的原理与解决方案java php c#
weixin_33909059的博客
08-23 169
Atitit.加密算法 des  aes 各个语言不同的原理与解决方案java php c#   1. 加密算法的参数：：算法/模式/填充  1 2. 标准加密api使用流程 1 2.1. Md5——16bit 填充key，使其长度达到128（或其他规定的长度） 2 2.2. 生成key 2 2.3. 运算 2 3. Aes加密原理架构图 2 4. Key的算法不一致 4 5. 加密模式 4 ...
java的ase加密不对_C#和JAVA AES加密解密遇到的问题,发现Java的AES加密出来的结果跟C#的AES加密出来的结果不一致...
weixin_42124497的博客
02-27 1207
先上java的加解密方法:packagecom.uns.unspay.common;importjava.io.UnsupportedEncodingException;importjava.security.InvalidKeyException;importjava.security.NoSuchAlgorithmException;importjava.security.Secur...
Node.js中AES加密和其它语言不一致问题解决办法
abcdefg367的博客
01-22 860
例子一： 这几天被一个问题困扰着。Nodejs的AES加密和Java，C#加密出来的不一致。当然，这样就不能解密了。纠结了许久：后来还是实在不行了，看了下源代码，要不然还得继续纠结下去。网上说，通常的nodejs AES和其他语言实现不一样。好吧~~或许吧。nodejs的crypto模块。 var crypto = require('crypto'); var data = ...
AES加密解密 java
最新发布
06-12
在Java中，你可以使用`javax.crypto`包中的`Cipher`类来实现AES的加密和解密操作。 **AES加密步骤**: 1. **初始化**：创建一个`Cipher`实例，并指定其模式（ENCRYPT_MODE或DECRYPT_MODE）和填充模式（例如`PKCS5...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值