精华内容
下载资源
问答
  • 主要介绍了Java实现的AES256加密解密功能,结合完整实例形式分析了Java实现AES256加密解密功能的步骤与相关操作技巧,需要的朋友可以参考下
  • 主要介绍了Java AES256加密解密示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java写的AES256加密文件

    2017-12-09 11:43:16
    Java写的AES256加密文件,可对电脑本地文件进行加密解密
  • AES加密算法java)实现

    热门讨论 2015-01-15 16:32:38
    AES高级加密标准,在密码学中又称Rijndael加密法,是美国联邦政府采用的一种...本软件是用java语言开发,实现了AES算法对文件的加密和解密,并在界面上加了进度条,来提示用户加密解密的进度。如果不足之处,欢迎留言。
  • 北京交通大学密码学作业,第三次实验源码及实验报告,包括工程文件和测试用例
  • AES加密算法JAVA实现

    2015-12-27 02:30:59
    AES加密算法JAVA实现(只有加密)
  • 主要介绍了Java实现的对称加密算法AES,结合实例形式分析了对称加密算法AES的定义、特点、用法及使用场景,需要的朋友可以参考下
  • Java AES256加密解密实现

    万次阅读 2017-09-20 18:06:58
    http://blog.csdn.net/liyuming0000/article/details/48395139 不说别的,直接上代码: [java] view plain copy import it.sauronsoftware.base64.Base64;...import java.security.Mes

    http://blog.csdn.net/liyuming0000/article/details/48395139


    不说别的,直接上代码:

    [java]  view plain  copy
    1. import it.sauronsoftware.base64.Base64;  
    2.   
    3. import java.security.MessageDigest;  
    4. import java.security.NoSuchAlgorithmException;  
    5. import java.security.SecureRandom;  
    6. import java.security.Security;  
    7.   
    8. import javax.crypto.Cipher;  
    9. import javax.crypto.KeyGenerator;  
    10. import javax.crypto.SecretKey;  
    11. import javax.crypto.spec.SecretKeySpec;  
    12.   
    13. import org.bouncycastle.jce.provider.BouncyCastleProvider;  
    14.   
    15. /** 
    16.  * java实现AES256加密解密 
    17.  * 依赖说明: 
    18.  * bcprov-jdk15-133.jar:PKCS7Padding 
    19.  * javabase64-1.3.1.jar:base64 
    20.  * local_policy.jar 和 US_export_policy.jar需添加到%JAVE_HOME%\jre\lib\security中(lib中版本适合jdk1.7) 
    21.  */  
    22.   
    23. public class AES256 {  
    24.   
    25.     public static byte[] encrypt(String content, String password) {  
    26.         try {  
    27.             //"AES":请求的密钥算法的标准名称  
    28.             KeyGenerator kgen = KeyGenerator.getInstance("AES");  
    29.             //256:密钥生成参数;securerandom:密钥生成器的随机源  
    30.             SecureRandom securerandom = new SecureRandom(tohash256Deal(password));  
    31.             kgen.init(256, securerandom);  
    32.             //生成秘密(对称)密钥  
    33.             SecretKey secretKey = kgen.generateKey();  
    34.             //返回基本编码格式的密钥  
    35.             byte[] enCodeFormat = secretKey.getEncoded();  
    36.             //根据给定的字节数组构造一个密钥。enCodeFormat:密钥内容;"AES":与给定的密钥内容相关联的密钥算法的名称  
    37.             SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
    38.             //将提供程序添加到下一个可用位置  
    39.             Security.addProvider(new BouncyCastleProvider());  
    40.             //创建一个实现指定转换的 Cipher对象,该转换由指定的提供程序提供。  
    41.             //"AES/ECB/PKCS7Padding":转换的名称;"BC":提供程序的名称  
    42.             Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding""BC");  
    43.   
    44.             cipher.init(Cipher.ENCRYPT_MODE, key);  
    45.             byte[] byteContent = content.getBytes("utf-8");  
    46.             byte[] cryptograph = cipher.doFinal(byteContent);  
    47.             return Base64.encode(cryptograph);  
    48.         } catch (Exception e) {  
    49.             e.printStackTrace();  
    50.         }  
    51.         return null;  
    52.     }  
    53.   
    54.     public static String decrypt(byte[] cryptograph, String password) {  
    55.         try {  
    56.             KeyGenerator kgen = KeyGenerator.getInstance("AES");  
    57.             SecureRandom securerandom = new SecureRandom(tohash256Deal(password));  
    58.             kgen.init(256, securerandom);  
    59.             SecretKey secretKey = kgen.generateKey();  
    60.             byte[] enCodeFormat = secretKey.getEncoded();  
    61.             SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
    62.             Security.addProvider(new BouncyCastleProvider());  
    63.             Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding""BC");  
    64.   
    65.             cipher.init(Cipher.DECRYPT_MODE, key);  
    66.             byte[] content = cipher.doFinal(Base64.decode(cryptograph));  
    67.             return new String(content);  
    68.         } catch (Exception e) {  
    69.             e.printStackTrace();  
    70.         }  
    71.         return null;  
    72.     }  
    73.   
    74.     private static String parseByte2HexStr(byte buf[]) {  
    75.         StringBuffer sb = new StringBuffer();  
    76.         for (int i = 0; i < buf.length; i++) {  
    77.             String hex = Integer.toHexString(buf[i] & 0xFF);  
    78.             if (hex.length() == 1) {  
    79.                 hex = '0' + hex;  
    80.             }  
    81.             sb.append(hex.toUpperCase());  
    82.         }  
    83.         return sb.toString();  
    84.     }  
    85.   
    86.     /*private static byte[] parseHexStr2Byte(String hexStr) { 
    87.         if (hexStr.length() < 1) 
    88.             return null; 
    89.         byte[] result = new byte[hexStr.length()/2]; 
    90.         for (int i = 0;i< hexStr.length()/2; i++) { 
    91.             int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16); 
    92.             int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16); 
    93.             result[i] = (byte) (high * 16 + low); 
    94.         } 
    95.         return result; 
    96.     }*/  
    97.       
    98.     private static byte[] tohash256Deal(String datastr) {  
    99.         try {  
    100.             MessageDigest digester=MessageDigest.getInstance("SHA-256");  
    101.             digester.update(datastr.getBytes());  
    102.             byte[] hex=digester.digest();  
    103.             return hex;   
    104.         } catch (NoSuchAlgorithmException e) {  
    105.             throw new RuntimeException(e.getMessage());    
    106.         }  
    107.     }  
    108.       
    109.     public static void main(String[] args) {  
    110.   
    111.         String content = "0f607264fc6318a92b9e13c65db7cd3c";  
    112.         String password = "zsyy";  
    113.         System.out.println("明文:" + content);  
    114.         System.out.println("key:" + password);  
    115.           
    116.         byte[] encryptResult = AES256.encrypt(content, password);  
    117.         System.out.println("密文:" + AES256.parseByte2HexStr(encryptResult));  
    118.           
    119.         String decryptResult = AES256.decrypt(encryptResult, password);  
    120.         System.out.println("解密:" + decryptResult);  
    121.     }  
    122. }  


    运行截图:




    展开全文
  • aes256加密java 总览 由于最近爱德华·斯诺登 ( Edward Snowden)发布了文件,以及针对JC Penny , Sony和Target等在线商业商店的黑客攻击激增,安全性已成为近年来讨论的重要话题。 尽管本文不会为您提供帮助防止...

    aes256加密java

    总览

    由于最近爱德华·斯诺登Edward Snowden)发布了文件,以及针对JC PennySonyTarget等在线商业商店的黑客攻击激增,安全性已成为近年来讨论的重要话题。 尽管本文不会为您提供帮助防止使用非法来源数据的所有工具,但本文将为构建一套工具和策略提供起点,以帮助防止其他方使用数据。

    这篇文章将展示如何在Java环境中对字符串采用AES加密。 它将讨论如何创建AES密钥以及以JCEKS密钥库格式存储AES密钥。 此博客中的代码的工作示例位于https://github.com/mike-ensor/aes-256-encryption-utility

    建议按顺序阅读每个部分,因为每个部分都是前一部分的基础,但是,您可能希望快速跳转到特定部分。

    什么是JCEKS?

    JCEKS代表的J avaçryptographyËxtensionķEY 小号扯了下来,这是针对Java平台的替代密钥库格式。 将密钥存储在KeyStore中可以作为一种措施,以防止暴露您的加密密钥。 Java密钥库安全地包含可以由别名引用以在Java程序中使用的各个证书和密钥。 Java KeyStore通常是使用Java JDK随附的“ keytool ”创建的。

    注意:强烈建议为KeyStore创建复杂的密码,以确保内容安全。 KeyStore是一个被认为是公共文件,但是建议不要轻易访问该文件。

    建立

    所有加密均受每个国家/地区的法律管辖,并且通常会对加密强度进行限制。 一个例子是在美国,如果数据在边界外传输,则所有128位以上的加密都受到限制。 默认情况下,Java JCE实施强度策略以遵守这些规则。 如果首选更强的加密并遵守国家/地区的法律,则JCE需要访问更强的加密策略。 简而言之,如果您打算使用AES 256位加密,则必须安装Unlimited Strength Jurisdiction Policy Files 。 如果没有适当的策略,则无法进行256位加密。

    安装JCE无限强度政策

    这篇文章的重点是密钥,而不是JCE的安装和设置。 安装非常简单, 可以在此处找到明确的说明(注意:这是针对JDK7的,如果使用其他JDK,则搜索适当的JCE策略文件)。

    密钥库设置

    使用KeyTool时,操作密钥库很简单。 必须使用指向新密钥的链接或在导入现有密钥库的过程中创建密钥库。 为了创建一个新的密钥和密钥库,只需键入:

    keytool -genseckey -keystore aes-keystore.jck -storetype jceks -storepass mystorepass -keyalg AES -keysize 256 -alias jceksaes -keypass mykeypass

    重要标志

    在上面的示例中,这里是有关keytool参数的说明:

    密钥库参数

    genseckey :生成SecretKey。 这是表示创建同步密钥的标志,它将成为我们的AES密钥 keystore密钥库的位置。 如果密钥库不存在,该工具将创建一个新的存储器。 路径可以是相对的或绝对的,但必须是局部的 storetype :这是商店的类型(JCE,PK12,JCEKS等)。 JCEKS用于存储证书中不包含的对称密钥(AES)。 storepass :与密钥库相关的密码。 强烈建议为密钥库创建一个强大的密码短语

    关键参数

    keyalg :用于创建密钥的算法(AES / DES / etc) keysize密钥的大小(128、192、256等) alias :给新创建的密钥的别名,使用该密钥时要在其中引用 keypass :保护密钥使用的密码

    加密

    由于它涉及Java中的数据,并且在最基本的级别上,加密是一种算法过程,用于通过可逆过程以编程方式混淆数据,双方都拥有与该数据有关的信息以及该算法的使用方式。 在Java加密中,这涉及使用密码。 JCE中的Cipher对象是通常由算法选择的加密提供程序的通用入口点。 此示例使用默认的Java提供程序,但也可以与Bouncy Castle一起使用。

    生成密码对象

    获取Cipher的实例非常容易,并且加密和解密都需要相同的过程。 (注意:加密和解密需要相同的算法,但不需要相同的对象实例)

    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");

    一旦有了密码实例,就可以根据算法对数据进行加密和解密。 通常,该算法将需要其他信息,以便对数据进行加密/解密。 在此示例中,我们将需要向算法传递包含密钥和初始向量的字节(如下所述)。

    初始化

    为了使用密码,我们必须首先初始化密码。 此步骤是必需的,因此我们可以为算法提供其他信息,例如AES密钥和Initial Vector(又名IV)。

    cipher.init(Cipher.ENCRYPT_MODE, secretKeySpecification, initialVector);

    参量

    SecretKeySpecification是一个对象,其中包含对构成AES密钥的字节的引用。 AES密钥无非是由密钥工具生成的(见上文)的特定大小的字节阵列(256位的AES 256或32个字节)。

    替代参数

    有多种创建密钥的方法,例如包含盐,用户名和密码(或类似名称)的哈希。 此方法将利用连接字符串的SHA1哈希,转换为字节,然后将结果截断为所需大小。 这篇文章不会显示使用此方法生成密钥或使用使用密码和密码的PBE密钥方法。 对于键输入密码和/或盐的使用是通过创建新的密钥的过程中使用的输入密钥工具处理。

    初始化向量

    AES算法还需要第二个参数,称为I信息V扇区。 该过程中使用IV来使加密的消息随机化,并防止密钥容易猜测。 IV被认为是公开共享的信息,但同样,不建议公开共享信息(例如,将其发布在您公司的网站上是不明智的)。 在加密消息时,通常会在消息前加上IV,因为基于算法,​​IV的大小将为设定值/已知大小。 注意:如果使用相同的IV,密钥和消息,则AES算法将输出相同的结果。 建议每次加密随机创建IV。

    使用新初始化的密码,加密消息很简单。 只需致电:

    byte[] encryptedMessageInBytes = Cipher.doFinal((message.getBytes("UTF-8"));
    String base64EncodedEncryptedMsg = BaseEncoding.base64().encode(encryptedMessageInBytes);
    String base32EncodedEncryptedMsg = BaseEncoding.base32().encode(encryptedMessageInBytes);

    编码结果

    字节数组很难可视化,因为它们通常不会在任何字符集中形成字符。 解决此问题的最佳建议是以HEX(base-16)Double HEX(base-32)Base64格式表示字节。 如果将通过URL或POST参数传递消息,请确保使用网络安全的Base64编码。 Google Guava库提供了出色的BaseEncoding实用程序 。 注意:请记住在解密之前对编码的消息进行解码。

    解密

    解密消息几乎与加密过程相反,只有少数例外。 与生成随机IV的加密过程不同,解密需要一个已知的初始化向量作为参数。

    解密

    解密时,请使用与加密方法相同的过程获得一个密码对象。 密码对象将需要利用完全相同的算法,包括方法和填充选择。 一旦代码获得对Cipher对象的引用,下一步就是初始化用于解密的密码,并将对密钥和初始化向量的引用传递给它。

    // key is the same byte[] key used in encryption
    SecretKeySpec secretKeySpecification = new SecretKeySpec(key, "AES");
    cipher.init(Cipher.DECRYPT_MODE, secretKeySpecification, initialVector);

    注意: 密钥存储在密钥库中,并通过使用别名获得 。 有关从密钥库获取密钥的详细信息,请参见下文

    一旦提供了密钥IV并初始化了解密密码,密码就可以执行解密了。

    byte[] encryptedTextBytes = BaseEncoding.base64().decode(message);
    byte[] decryptedTextBytes = cipher.doFinal(encryptedTextBytes);
    String origMessage = new String(decryptedTextBytes);

    保持静脉输液的策略

    用于加密消息的IV对于解密消息很重要,因此提出了一个问题,即它们如何保持在一起。 一种解决方案是对IV进行基本编码(请参见上文),并将其添加到经过加密和编码的消息之前:Base64UrlSafe(myIv)+分隔符+ Base64UrlSafe(encryptedMessage)。 其他可能的解决方案可能是上下文相关的,例如,在具有IV的XML文件中包括一个属性,并为所使用的密钥提供别名。

    从密钥库获取密钥

    这篇文章的开头显示了创建引用密钥库数据库内部别名的新AES-256密钥有多么容易。 然后,该帖子继续介绍如何在给定密钥的情况下对消息进行加密和解密,但是还显示了如何在密钥库中获取对该密钥的引用。

    // for clarity, ignoring exceptions and failures
    InputStream keystoreStream = new FileInputStream(keystoreLocation);
    
    KeyStore keystore = KeyStore.getInstance("JCEKS");
    keystore.load(keystoreStream, keystorePass.toCharArray());
    
    if (!keystore.containsAlias(alias)) {
        throw new RuntimeException("Alias for key not found");
    }
    
    Key key = keystore.getKey(alias, keyPass.toCharArray());

    参量

    keystoreLocation :字符串–本地密钥库文件位置的位置 keypass :字符串–使用keytool创建或修改密钥库文件时使用的密码(请参见上文) alias :String –使用keytool创建新密钥时使用的别名(请参见上文)

    结论

    这篇文章展示了如何使用AES-256加密算法对基于字符串的消息进行加密和解密。 加密和解密这些消息的密钥保存在使用JDK提供的“ keytool”实用程序创建的JCEKS格式的KeyStore数据库中。 这篇文章中的示例应被视为加密/解密对称密钥(例如AES)的坚实起点。 加密消息(例如密钥旋转)时,这不应被视为唯一的防线。 密钥轮换是一种减轻数据泄露事件风险的方法。 如果入侵者获取数据并设法破解单个密钥,则多个文件中包含的数据应已使用多个密钥对数据进行加密,从而降低了总暴露损失的风险。

    该博客文章中的所有示例都已简化为一个简单的工具,允许查看密钥库中的密钥,而JDK密钥工具不支持开箱即用的操作。 这篇文章中概述的步骤和主题的各个方面都可以在以下网址获得: https : //github.com/mike-ensor/aes-256-encryption-utility 。 注意:示例,示例代码和任何参考资料均由实施者自担风险,没有任何默示的保证或责任,您承担所有风险。

    参考:来自Mike站点博客上的JCG合作伙伴 Mike Ensor 提供的Java和JCEKS的AES-256加密

    翻译自: https://www.javacodegeeks.com/2014/02/aes-256-encryption-with-java-and-jceks.html

    aes256加密java

    展开全文
  • java Aes256 加密算法的实现

    千次阅读 2015-01-01 09:57:16
    如果希望进行AES256位的加密解密,需要事先从java官网下载 local_policy.jar与US_export_policy.jar替换%JAVA_HOME%/jre/lib/security的两个policy文件,local_policy.jar与US_export_policy .jar。 主要是为了突破...

    如果希望进行AES256位的加密解密,需要事先从java官网下载 local_policy.jar与US_export_policy.jar替换%JAVA_HOME%/jre/lib/security的两个policy文件,local_policy.jar与US_export_policy .jar。 主要是为了突破AES算法只能支持到128位的限制。如果未替换,可能会得到如下错误: *

     

    java.security.InvalidKeyException: Illegal key
     
     
     
    package com.jlins;
     
    import java.io.UnsupportedEncodingException;
     
    import javax.crypto.Cipher;
     
    import javax.crypto.spec.IvParameterSpec;
     
    import javax.crypto.spec.SecretKeySpec;
     
    import com.jlins.util.Hex;
     
    /**
     
    * java Aes256 加密
     
    *
     
    * @author jlins
     
    *
     
    */
     
    public class Aes256Encryptor {
     
    // 说明 key 需要大家自己去设定加密解密的key,key牵涉到安全信息,所以这里无法公布
     
        private static final byte[] key = {};
     
        private static final String transform = "AES/CBC/NoPadding";
     
        private static final String algorithm = "AES";
     
        private static final SecretKeySpec keySpec = new SecretKeySpec(key, algorithm);
     
        public static void main(String[] args) throws Exception {
     
             String pwds[] = { "123", "0123456789012345", "01234567890123456", "123", "123", "0123456789012345678",
     
                                "012345678901234567890123456789", "b", "0123456789012345", "01234567890123456", "012345678901234567" };
     
            String ivss[] = { "test", "test", "test", "test0123456789012", "test01234567890123", "test", "test", "a",
     
                            "test", "test", "test" };
     
            String rr[] = new String[ivss.length];
     
             for (int i = 0; i < ivss.length; i++) {
     
                String en = encrypt(pwds[i], ivss[i]);
     
                String decy = decrypt(en, ivss[i]);
     
                rr[i] = "[" + ivss[i] + "],[" + decy + "]-->[" + en + "]";
     
                System.out.println(rr[i]);
     
               }
     
               System.out.println("---------");
     
               for (int i = 0; i < rr.length; i++) {
     
                   System.out.println(rr[i]);
     
                }
     
    }
     
    /**
     
    */
     
    public static String decrypt(String pHexText, String pIv) throws Exception {
     
            Cipher cipher = Cipher.getInstance(transform);
     
            byte[] encryptedBytes = Hex.decode(pHexText);
     
            byte[] iv = createIV(pIv);
     
            cipher.init(Cipher.DECRYPT_MODE, keySpec, new IvParameterSpec(iv));
     
            byte[] decryptedBytes = cipher.doFinal(encryptedBytes);
     
            System.arraycopy(decryptedBytes, 0, encryptedBytes, 0, encryptedBytes.length);
     
            String result = new String(encryptedBytes);
     
            return result.trim();
     
    }
     
    /**
     
    */
     
    public static String encrypt(String pData, String pIv) throws Exception {
     
             Cipher cipher = Cipher.getInstance(transform);
     
             byte[] iv = createIV(pIv);
     
             cipher.init(Cipher.ENCRYPT_MODE, keySpec, new IvParameterSpec(iv));
     
             byte[] output = cipher.doFinal(paddingData(pData));
     
             byte[] encryptedContent = new byte[output.length];
     
             System.arraycopy(output, 0, encryptedContent, 0, encryptedContent.length);
     
             String result = new String(Hex.encode(encryptedContent)).toUpperCase();
     
             return result;
     
    }
     
    /**
     
    * 补齐的16位的整数倍
     
    *
     
    * @param pData
     
    * @return
     
    */
     
    private static byte[] paddingData(String pData) {
     
           byte[] bytes = pData.getBytes();
     
           int length = bytes.length / 16;
     
           if (length * 16 < bytes.length) {
     
              length++;
     
            }
     
           byte[] result = new byte[length * 16];
     
           System.arraycopy(bytes, 0, result, 0, bytes.length);
     
           for (int i = bytes.length; i < result.length; i++) {
     
             result[i] = 0x00;
     
            }
     
            return result;
     
            }
     
    /**
     
    * 初始化向量到16位
     
    * */
     
           private static byte[] createIV(String pIv) throws UnsupportedEncodingException {
     
           byte[] bytes = pIv.getBytes("US-ASCII");
     
           int length = bytes.length / 16;
     
           if (length * 16 < bytes.length) {
     
           length++;
     
           }
     
           byte[] result = new byte[16];
     
           System.arraycopy(bytes, 0, result, 0, bytes.length > 16 ? 16 : bytes.length);
     
           for (int i = bytes.length; i < result.length; i++) {
     
           result[i] = 0x00;
     
          }
     
          return result;
     
    }
     
    }

     

    原文地址:http://www.itmmd.com/201411/98.html
    该文章由 android开发 整理发布,转载须标明出处。

    展开全文
  • Java AES128加密解密

    2019-01-19 20:53:59
    Java AES128加密解密 示例源码(AES-ECB-PKCS7Padding)
  • 实现功能 已知明文为0123456789ABCDEF的ASCII码表示的128比特 * 密钥是0101101100001110的12次重复构成的192比特密钥 * 编写AES的加解密程序对明文进行加密并进行解密验证 1.程序结构 2.运行结果 源代码 <1.AESclass...
  • 本人实测可以使用,基于C的AES算法代码,希望能帮到有需要的。以下是相关模式调用的函数。 void AES_init_ctx(struct AES_ctx* ctx, const uint8_t* key); void AES_init_ctx_iv(struct AES_ctx* ctx, const uint8_t...
  • Java实现AES加密算法

    万次阅读 2019-10-02 12:00:27
    高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥,具体的加密流程如下图: 下面简单介绍下各个部分的...

    最近恶补了一些关于加密算法的知识,然后用编程语言来实现

    AES简介

    高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥,具体的加密流程如下图:

    下面简单介绍下各个部分的作用与意义:

    • 明文P

    没有经过加密的数据

    • 密钥K

    用来加密明文的密码,在对称加密算法中,加密与解密的密钥是相同的,密钥为接收方与发送方协商产生,但不可以直接在网络上传输,否则会导致密钥泄露,通常是通过非对称加密算法加密密钥,然后再通过网络传输给对方,或者直接面对面商量密钥。密钥绝对不能泄露,否则会被攻击者还原密钥,窃取数据

    • AES加密函数

    设AES加密函数为E,则C = E(K,P).其中P为明文,K为密钥,C为密文。也就是说,把明文P和密钥K作为加密函数的参数输入,则加密函数E会输出密文C

    • 密文C

    经过加密函数处理后的数据

    • AES解密函数

    设AES解密函数为D,则P = D().其中C为密文,K为密钥,P为明文。也就是说,把密文C和密钥K作为解密函数的参数输入,则解密函数会输出明文P

    这里简单解释下对称加密算法非对称加密算法

    • 对称加密算法

    加密和解密使用的密钥是相同的,这种加密方式加密速度非常快,适合经常发送数据的场合。缺点是密钥的传输比较麻烦

    • 非对称加密算法

    加密和解密使用的密钥是不同的,这种加密方式是用数学定理或者公式构造的,通常加密解密的速度比较慢,适合偶尔发送数据的场合。优点是密钥传输方便。常见的非对称加密算法为RSA、ECC和EIGamal

    实际中,一般是通过RSA加密AES的密钥,传输到接收方,接收方解密得到AES密钥

    AES的基本结构

    AES为分组密码,分组密码也就是把明文分成一组一组的,每组长度相等,每次加密一组数据,直到加密完所有组。在AES标准规范中,分组长度只能是128位,也就是说,每个分组为16个字节。密钥的长度可以使用128位、192位或256位。密钥的长度不同,推荐加密轮数也不同。如下表所示:

    AES密钥长度(32bit)分组长度(32bit)加密轮数
    AES-1284410
    AES-1926412
    AES-2568414

    上面说到,AES的加密公式为C = E(K,P),在加密函数E种,会执行一个轮函数,并且执行n(n为加密轮数)次这个轮函数,这个轮函数的前n-1次执行的操作是一样的,只有第n次有所不同

    AES的处理单位是字节,128位的输入明文分组P和输入密钥K都被分成16字节,分别记为 P = P 0 , P 1 , . . . , P 15 P = P_0,P_1,...,P_{15} P=P0,P1,...,P15 K = K 0 , K 1 , . . . , K 15 K = K_0,K_1,...,K_{15} K=K0,K1,...,K15。如明文分组为P=abcdefghijklmnop,其中字符a对应 P 0 P_0 P0,p对应 P 15 P_{15} P15。一般地,明文分组用字节为单位地正方形矩阵描述,称为状态矩阵。在算法地每一轮中,状态矩阵地内容不断发生变化,最后的结果作为密文输出。该矩阵中字节地排列顺序为从上到下、从左至右依次排列,如下图所示:

    现在假设明文分组P=abcdefghijklmnop,则对应上面生成地状态矩阵图如下:

    上图中,0x61为a字符的十六进制表示,可以看到,明文经过AES加密后,已经面目全非了

    类似地,128位密钥也是用以字节为单位的矩阵表示,矩阵的每一列被称为1个32为比特字。通过密钥编排函数可以将该密钥矩阵扩展成一个44字组成的序列W[0],W[1],…,W[43]。该序列的前4个元素W[0],W[1],W[2],W[3]是原始密钥,用于加密运算中的初始密钥。后面40个字分为10组,每组4个字(128bit)分别用于10轮加密运算中的轮密钥加,如下图所示:

    上图中,设K=abcdefghijklmnop,则 K 0 = a , K 15 = p K_0=a,K_{15}=p K0=a,K15=p,w[0] = K 0 k 1 K 2 K 3 = a b c d =K_0k_1K_2K_3=abcd =K0k1K2K3=abcd

    AES整体的结构如下图所示,其中W[0,3]是指W[0]、W[1]、W[2]和W[3]串联组成的128位密钥。加密的第一轮到第9轮的轮函数一样,包括4个操作,字节代换、行位移、列混合和轮密钥加。最后一轮迭代不执行列混合。另外,在第一轮迭代之前,先将明文和原始密钥进行一次异或加密操作

    上图也展示了AES的解密过程,解密过程仍为10轮,每一轮的操作是加密操作的逆操作。由于AES的4个轮操作都是可逆的,因此,解密操作的每一轮就是顺序执行逆行移位、逆字节代换、轮密钥加和逆列混合。同加密操作类似,最后一轮不执行逆列混合,在第1轮解密之前,要执行1次密钥加操作

    下面分别介绍AES中一轮的4个操作阶段,这4分操作阶段使输入位得到充分的混淆

    字节代换

    1.字节代换操作

    AES的字节代换其实就是一个简单的查表操作。AES定义了一个S盒和一个逆S盒

    AES的S盒:

    把该字节的高4位作为行值,低4位作为列值,取出S盒或者逆S盒中对应的行的元素作为输出。例如,加密时,输出的字节S1为0x12,则查S盒的第0x01行和0x02列,得到值0xc9,然后替换S1原有的0x12为0xc9。状态矩阵经字节代换后的图如下:

    2.字节代换逆操作

    逆字节代换也就是查逆S盒来变换,逆S盒如下:

    行位移

    1.行位移变换

    行移位是一个简单的左循环移位操作。当密钥长度为128比特时,状态矩阵的第0行左移0字节,第1行左移1字节,第2行左移2字节,第3行左移3字节,如下图所示:

    2.行位移逆变换

    行移位的逆变换是将状态矩阵中的每一行执行相反的移位操作,例如AES-128中,状态矩阵的第0行右移0字节,第1行右移1字节,第2行右移2字节,第3行右移3字节

    列混合

    1.列混合预算

    列混合变换是通过矩阵相乘来实现的,经行移位后的状态矩阵与固定的矩阵相乘,得到混淆后的状态矩阵,如下图的公式所示:

    状态矩阵中的第j列(0 ≤j≤3)的列混合可以表示为:
    KaTeX parse error: Expected 'EOF', got '&' at position 16: S'_{0,j} = (2 &̲#042; S_{0,j}) …

    2.列混合逆运算

    逆向列混合变换可由下图的矩阵乘法定义:

    可以验证,逆变换矩阵同正变换矩阵的乘积恰好为单位矩阵

    轮密钥加

    轮密钥加是将128位轮密钥 K i K_i Ki同状态矩阵中的数据进行逐位异或操作,如下图所示。其中,密钥 K i K_i Ki中每个字W[4i],W[4i+1],W[4i+2],W[4i+3]为32位比特字,包含4个字节,他们的生成算法下面在下面介绍。轮密钥加过程可以看成是字逐位异或的结果,也可以看成字节级别或者位级别的操作。也就是说,可以看成S0 S1 S2 S3 组成的32位字与W[4i]的异或运算

    轮密钥加的逆运算同正向的轮密钥加运算完全一致,这是因为异或的逆操作是其自身。轮密钥加非常简单,但却能够影响S数组中的每一位

    密钥扩展


    这个4*4矩阵的每一列的4个字节组成一个字,矩阵4列的4个字依次命名为W[0]、W[1]、W[2]和W[3],它们构成一个以字为单位的数组W。例如,设密钥K=abcdefghijklmnop,则 K 0 = a , K 1 = b , K 2 = c , K 3 = d K_0 = a,K_1 = b,K_2 = c,K_3 = d K0=a,K1=b,K2=c,K3=d,W[0] = abcd

    接着,对W数组扩充40个新列,构成总共44列的扩展密钥数组。新列以如下的递归方式产生:

    1. 如果i不是4的倍数,那么第i列由如下等式确定:W[i]=W[i-4]⨁W[i-1]
    2. 如果i是4的倍数,那么第i列由如下等式确定:W[i]=W[i-4]⨁T(W[i-1])

    其中,函数T由3部分组成:字循环、字节代换和轮常量异或,这3部分的作用分别如下:

    • 字循环:将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]
    • 字节代换:对字循环的结果使用S盒进行字节代换
    • 轮常量异或:将前两步的结果同轮常量Rcon[j]进行异或,其中j表示轮数

    轮常量Rcon[j]是一个字,其值见下表:

    j12345
    Rcon[j]01 00 00 0002 00 00 0004 00 00 0008 00 00 0010 00 00 00
    j678910
    Rcon[j]20 00 00 0040 00 00 0080 00 00 001B 00 00 0036 00 00 00

    举个例子,设初始的128为密钥为:3C A1 0B 21 57 F0 19 16 90 2E 13 80 AC C1 07 BD,那么4个初始值为

    W[0] = 3C A1 0B 21 
    W[1] = 57 F0 19 16 
    W[2] = 90 2E 13 80 
    W[3] = AC C1 07 BD 
    

    下面求扩展的第1轮的子密钥(W[4],W[5],W[6],W[7])

    由于4是4的倍数,所以:W[4] = W[0] ⨁ T(W[3]),T(W[3])的计算步骤如下:

    1. 循环地将W[3]的元素移位:AC C1 07 BD变成C1 07 BD AC
    2. C1 07 BD AC作为S盒的输入,输出为78 C5 7A 91
    3. 78 C5 7A 91与第一轮轮常量Rcon[1]进行异或运算,将得到79 C5 7A 91,因此,T(W[3]) = 79 C5 7A 91,故W[4] = 3C A1 0B 21 ⨁ 79 C5 7A 91 = 45 64 71 B0

    其余3个子密钥段的计算如下:

    W[5] = W[1] ⨁ W[4] = 57 F0 19 16 ⨁ 45 64 71 B0 = 12 94 68 A6 
    W[6] = W[2] ⨁ W[5] =90 2E 13 80 ⨁ 12 94 68 A6 = 82 BA 7B 26 
    W[7] = W[3] ⨁ W[6] = AC C1 07 BD ⨁ 82 BA 7B 26 = 2E 7B 7C 9B 
    

    所以,第一轮的密钥为45 64 71 B0 12 94 68 A6 82 BA 7B 26 2E 7B 7C 9B

    Java实现AES算法

    由于Java有自带的函数,因此可以直接调用

    首先生成密钥,密钥是SecretKey类型的对象

    static final String ALGORITHM = "AES";
    
    public static SecretKey generateKey() throws NoSuchAlgorithmException { // 生成密钥
    	KeyGenerator secretGenerator = KeyGenerator.getInstance(ALGORITHM);
    	SecureRandom secureRandom = new SecureRandom();
    	secretGenerator.init(secureRandom);
    	SecretKey secretKey = secretGenerator.generateKey();
    	return secretKey;
    }
    

    首先创建密钥生成器KeyGenerator对象,产生的是AES算法的密钥,因此传入参数AES。这里使用安全的随机数SecureRandom作为参数传入密钥生成器的init()函数中,最后调用密钥生成器的generateKey()方法产生密钥对象secretKey

    然后实现加密方法和解密方法

    static Charset charset = Charset.forName("UTF-8");
    public static byte[] encrypt(String content, SecretKey secretKey) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { // 加密
    	return aes(content.getBytes(charset),Cipher.ENCRYPT_MODE,secretKey);
    }
    
    public static String decrypt(byte[] contentArray, SecretKey secretKey) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { // 解密
    	byte[] result =  aes(contentArray,Cipher.DECRYPT_MODE,secretKey);
    	return new String(result,charset);
    }
    

    加密方法传入的是需要加密的明文content以及密钥;解密方法传入的是密文contentArray以及密钥

    最后实现aes函数

    private static byte[] aes(byte[] contentArray, int mode, SecretKey secretKey)
    		throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
    	Cipher cipher = Cipher.getInstance(ALGORITHM);
    	cipher.init(mode, secretKey);
    	byte[] result = cipher.doFinal(contentArray);
    	return result;
    }
    

    完整代码如下:

    import java.nio.charset.Charset;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.KeyGenerator;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    
    public class Aes {
    
    	
    	static final String ALGORITHM = "AES";
    
    	public static SecretKey generateKey() throws NoSuchAlgorithmException { // 生成密钥
    		KeyGenerator secretGenerator = KeyGenerator.getInstance(ALGORITHM);
    		SecureRandom secureRandom = new SecureRandom();
    		secretGenerator.init(secureRandom);
    		SecretKey secretKey = secretGenerator.generateKey();
    		return secretKey;
    	}
    
    	static Charset charset = Charset.forName("UTF-8");
    	public static byte[] encrypt(String content, SecretKey secretKey) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { // 加密
    		return aes(content.getBytes(charset),Cipher.ENCRYPT_MODE,secretKey);
    	}
    
    	public static String decrypt(byte[] contentArray, SecretKey secretKey) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { // 解密
    		byte[] result =  aes(contentArray,Cipher.DECRYPT_MODE,secretKey);
    		return new String(result,charset);
    	}
    
    	private static byte[] aes(byte[] contentArray, int mode, SecretKey secretKey)
    			throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
    		Cipher cipher = Cipher.getInstance(ALGORITHM);
    		cipher.init(mode, secretKey);
    		byte[] result = cipher.doFinal(contentArray);
    		return result;
    	}
    
    	public static void main(String[] args) {
    		String content = "你好,我很喜欢加密算法";
    		SecretKey secretKey;
    		try {
    			long timeStart = System.currentTimeMillis();
    			secretKey = generateKey();
    			byte[] encryptResult = encrypt(content, secretKey);
    			long timeEnd = System.currentTimeMillis();
    			System.out.println("加密后的结果为:" + new String(encryptResult,charset));
    			String decryptResult = decrypt(encryptResult,secretKey);
    			System.out.println("解密后的结果为:" + decryptResult);
    			System.out.println("加密用时:" + (timeEnd - timeStart));
    		} catch (NoSuchAlgorithmException | InvalidKeyException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException e) {
    			e.printStackTrace();
    		}
    	}
    }
    

    运行GIF图如下所示:

    展开全文
  • //加密 public String encryyptstr(byte[] iv,String key,String text){ String algorithm = "AES"; String transform = "AES/CBC/PKCS5Padding";// Cipher cipher = null; String result =
  • java aes128/256 对称加密解密,rsa对称加密解密验签实现,php java通用aes加密 支持任何形式的aes加密,文件,字符,字节等,内含php代码,可以与php平台实现aes加密,而且包含rsa非对称加密签名验签实现,都是对...
  • JAVA中使用AES256加密

    千次阅读 2019-07-06 12:49:38
    前言:java默认支持128位加密规范,如果想支持256加密规范,就需要使用无限制JCE策略文件,而现在Android端AES256加密填充方式一般是PKCS7Padding,JAVA支持PKCS5Padding,虽然PKCS7Padding和PKCS5Padding除了...
  • 本文就简单介绍如何通过JAVA实现AES加密: /** * 测试AES加密和解密 * @param args */ public static void main(String[] args) { /**数据初始化**/ String content = "http://www.mbaike.net"; String...
  • C# JAVA nodejs通用的AES加密解密算法,考虑到实际使用过程中由于客户端和服务端使用的语言不一样而又需要对数据进行加密和解密的情况,特此总结了C# JAVA nodejs通用的AES加密解密算法,供需要者参考。
  • RSA与AES混合加密算法的实现http://blog.csdn.net/jkxqj/article/details/25228707
  • 该文件是AES加密算法C语言的实现,在STM32平台验证通过,ECB加密方式,方便移植。
  • 一、AES对称加密算法简介随着对称密码的发展,DES数据加密标准算法由于密钥长度较小(56位),已经不适应当今分布式开放网络对数据加密安全性的要求,因此1997年NIST公开征集新的数据加密标准,即AES[1]。经过三轮的筛选,...
  • AES/DES 对称加密算法

    2018-12-25 14:04:55
    DES、AES对称加密算法,之前从网上找的,但是在MAC上运行发现每次加密出来的结果都不一样,后来查了一些博客,最后确认是SecureRandom的随机算法问题,需要设置setSeed.
  • Java AES 256加密解密

    千次阅读 2019-05-27 14:38:09
    Java AES解密加密算法默认是支持128位的,但是,最近,做了登录练习,是从数据库里的用户表提取用户账号和密码来进行验证登录,因为用户表里的密码是经过256位加密进行储存的,而且是用PKCS7Padding的填充方式来存储...
  • AES对称加密java工具类

    2020-12-30 19:48:10
    适用于java开发者使用,用于对称加密的数据。进行加密
  • 这个是我之前在网上看到一个大神做的基于Java语言实现AES算法加密解密文件的应用,希望对于一些有志于密码学同学有点用处。zip文件包括AES算法原理以及详解还有实现的源代码(Eclipse直接导入使用就好)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,725
精华内容 7,490
关键字:

aes256加密算法java

java 订阅