精华内容
下载资源
问答
  • 从这一篇起整理一下常见的加密算法以及在java中使用的demo,首先从最简单的开始.简单了解Base64严格来说并不是一种加密算法,而是一种编码/解码的实现方式.我们都知道,数据在计算机网络之间是使用字节流的方式进行传递...

    从这一篇起整理一下常见的加密算法以及在java中使用的demo,首先从最简单的开始.

    简单了解

    Base64严格来说并不是一种加密算法,而是一种编码/解码的实现方式.

    我们都知道,数据在计算机网络之间是使用字节流的方式进行传递的,所有的信息都要最终转换为0101的二进制,这本身就涉及到编码,解码的应用.

    Base64,顾名思义,是使用了64个基本的字符来对任意数据进行编码的一种实现方式,那既然有Base64,是不是也有Base32,Base16呢? 答案是没错,有.

    下面先看一下Base64的编码表:

    ab42140ef008e8d98c37e9ccd11e910b.png

    由图可见,Base64使用了26个字母的大小写,也就是52个字符,再加上10个数字和两个特殊的"+","/"组成,一共64个字符,其中最后两个字符选取不一定总是这两个.

    java代码实现

    首先看代码,然后再细说Base64实现的原理和应用:

    1 packagecom.wang.encryption;2 importcom.sun.org.apache.xerces.internal.impl.dv.util.Base64;3 importsun.misc.BASE64Decoder;4 importsun.misc.BASE64Encoder;5 importjava.io.IOException;6 /**

    7 *@authoryogo.wang8 * @date 2016/11/03-下午3:58.9 */

    10 public classBase64Test {11

    12 public static void main(String[] args) throwsIOException {13

    14 String msg="wang";15 byte[] bys=msg.getBytes("utf-8");16

    17 /**

    18 * 使用BASE64 加密(编码)19 */

    20 //第一种方式

    21 BASE64Encoder base64Encoder=newBASE64Encoder();22 String s =base64Encoder.encodeBuffer(bys);23 System.out.println(s);24 System.out.println("---------------------");25 //第二种方式

    26 String s1 =Base64.encode(bys);27 System.out.println(s1);28 System.out.println("---------------------");29 /**

    30 * 使用BASE64 解密(解码)31 */

    32 //第一种方式

    33 BASE64Decoder base64Decoder=newBASE64Decoder();34 byte[] bys2 =base64Decoder.decodeBuffer(s);35 System.out.println(newString(bys2));36 System.out.println("---------------------");37 //第二种方式

    38 byte[] bys3 =Base64.decode(s);39 System.out.println(newString(bys3));40

    41

    42 }43 }

    输出结果如下:

    d2FuZw==

    ---------------------

    d2FuZw==

    ---------------------

    wang

    ---------------------

    wang

    原理和应用

    根据代码,可以看到,字符"wang"通过Base64的编码转化成了一个字符串"d2FuZw==",那么到底内部是怎么实现的呢?

    Base64使用了64的字符,那么只需要6个二进制位就可以表示,但是一个Base64字符是8个二进制位的,即8Bit,也就是说Base64在6Bit的基础上在左边加了俩0,所有它的左边两位永远为0.

    我们知道,一个字符是占了8位的,那怎么用6Bit表示8Bit的数呢,这好办,因为8和6的最小公倍数是24,那么,我用4个Base64的字符来表示3个常规的字符就可以了.

    知道了这些,我们就可以来看看"wang"这个字符串是怎么被编码成"d2FuZw=="的了.

    第一步:把常规字符转换为ASCII.

    第二步:把ASCII码转为8位2进制

    第三步:每6位2进制数划为一组

    第四步:将2进制转为10进制

    第五步:根据Base64编码表对应找出相应的字符

    对应下面的图:

    93b38295175551cc5a363e04b92085e6.png

    因为每三个常规字符,对应四个Base64字符,如果不够的话,会在后边补0,这里的"wang"是4个字符,不是3的整数倍,所以需要补0,那为什么编码的结果是"d2FuZw==",而不是"d2FuZwAA"呢?

    原因其实也很简单,因为最后两个AA是没有实际意义的,并不携带有效信息,为了解码方便,Base64编码选择了使用"="来代替最后的"A",所以就是我们看到的"d2FuZw=="了.

    通过以上的过程我们可以发现,其实Base64是一种编码方式而非加密方式,因为它的编码解码过程是完全可逆的,且不需要额外信息,你只要有一张Base64的编码表就可以了,所以,不要将他用于对数据的加密.

    Base64的应用

    说了这么多,好像还是不太明白这种编码有什么必须存在的理由.....

    我们知道在计算机中任何数据都是按ascii码存储的,而ascii码的128~255之间的值是不可见字符。而在网络上交换数据时,比如说从A地传到B地,往往要经过多个路由设备,由于不同的设备对字符的处理方式有一些不同,这样那些不可见字符就有可能被处理错误,这是不利于传输的。所以就先把数据先做一个Base64编码,统统变成可见字符,这样出错的可能性就大降低了(这段来自知乎)。

    不仅如此,比如说我们可以使用HTML来内嵌Base64编码的图片,这样就避免了不必要的外部资源加载,不过还是要量力而为,这种场景一般适用于尺寸比较小的图片,如果是高清图片,用这种方式会导致Base64编码后的字符串很大,反而影响加载速度.

    展开全文
  • 今天来给大家讲解一下,java如何进行加密解密的,这里面包含java单向加密解密比如MD5等等,也包含java的双向加密解密方式,比如base64格式的等等,首先先给大家介绍一下大体的加密方法,然后再对具体的给出一些实例...

    今天来给大家讲解一下,java如何进行加密解密的,这里面包含java的单向加密解密比如MD5等等,也包含java的双向加密解密方式,比如base64格式的等等,首先先给大家介绍一下大体的加密方法,然后再对具体的给出一些实例:
    1.md5/hash加密算法(单向加密)
    2.单匙密码体制:DES
    3.数字签名
    4.非对称密匙密码体制(公匙体系)
    5.base64式双向加密解密法:
    例如:
     

    / * 编码原理:将3个字节转换成4个字节( (3 X 8) = 24 = (4 X 6) )
          * 先读入3个字节,每读一个字节,左移8位,再右移四次,每次6位,这样就有4个字节了
          *
          * @param data
          * @return 编码后的Base64字符串
          */
         public static String Base64Encode(byte[] data) {
             StringBuilder builder = new StringBuilder();
             int[] temp = new int[4];
             int len = data.length - data.length % 3;
             for (int i = 0; i < len; i += 3) {
                 int goal = 0;
                 for (int j = 0; j < 3; j++) {
                     goal <<= 8;
                     goal |= (data[i + j] & 0xff);
                 }
                 for (int k = 0; k < 4; k++) {
                     temp[k] = goal & 0x3f;
                    goal >>= 6;
                 }
                 for (int k = 3; k >= 0; k--) {
                     builder.append(base64_alphabet.charAt(temp[k]));
                 }
             }
             int index;
             switch (data.length % 3) {
             case 1:
                 index = data[data.length - 1] >> 2;
                 builder.append(base64_alphabet.charAt(index));
                 index = (data[data.length - 1] & 0x03) << 4;
                 builder.append(base64_alphabet.charAt(index));
                 builder.append("==");
                 break;
             case 2:
                 index = data[data.length - 1 - 1] >> 2;
                 builder.append(base64_alphabet.charAt(index));
                 index = (data[data.length - 1 - 1] & 0x03) << 4
                         | data[data.length - 1] >> 4;
                 builder.append(base64_alphabet.charAt(index));
                 index = (data[data.length - 1] & 0x0f) << 2;
                 builder.append(base64_alphabet.charAt(index));
                 builder.append('=');
                 break;
             }
             return builder.toString();
         }
     
         /**
          * 解码原理:将4个字节转换成3个字节. 先读入4个6位(用或运算),每次左移6位,再右移3次,每次8位.
          *
          * @param data
          *            需解码的Base64字符串。
          * @return byte[]-解码出的字节数组
          */
         public static byte[] Base64Decode(String data) {
             char[] chArray = data.toCharArray();
             int len = chArray.length;
             byte[] result = new byte[len * 3 / 4];
             for (int i = 0, res_i = 0; i < len; i += 4, res_i += 3) {
                 int goal = 0;
                 int index = 0;
                 for (int k = 0; k < 4; k++) {
                     index = base64_alphabet.indexOf(chArray[i + k]);
                     goal <<= 6;
                     goal |= index;
                 }
                 for (int j = 2; j >= 0; j--) {
                     result[res_i + j] = (byte) goal;
                     goal >>= 8;
                 }
             }
             // 等号=的处理
             if (chArray[len - 1] != '=')
                 return result;
             else if (chArray[len - 2] == '=')
                 return Arrays.copyOf(result, result.length - 2);
             else
                 return Arrays.copyOf(result, result.length - 1);
     
         }
     // 将 s 进行 BASE64 编码
         public static String getBASE64(String s) {
             if (s == null)
                 return null;
             return Base64Encode(s.getBytes());
         }
     
         // 将 BASE64 编码的字符串 s 进行解码
         public static String getFromBASE64(String s) {
             if (s == null)
                 return null;
             try {
                 byte[] b = Base64Decode(s);
                 return new String(b);
             } catch (Exception e) {
                 return null;
             }
         }

     

    6.URLEncoder双向加密解密方式
    好了,具体的就先给大家如果大家想看具体的更多的加密方法推荐大家可以去59biye网,查看java加密解密的方法总结

    展开全文
  • 本篇文章主要介绍了Java实现常用加密算法——单向加密算法MD5和SHA,信息加密后数据更安全,需要的朋友可以参考下。
  • 1、Java的安全体系架构1.1 Java的安全体系架构介绍Java中为安全框架提供类和接口。JDK 安全 API 是 Java 编程语言的核心 API,位于 java....JDK 1.1 中第一次发布的 JDK 安全中引入了“Java 加密体系结构”(JCA)

    1、Java的安全体系架构

    1.1 Java的安全体系架构介绍

    Java中为安全框架提供类和接口。JDK 安全 API 是 Java 编程语言的核心 API,位于 java.security 包(及其子包),以及sun.securityAPI包(及其子包)中。设计用于帮助开发人员在程序中同时使用低级和高级安全功能。

    JDK 1.1 中第一次发布的 JDK 安全中引入了“Java 加密体系结构”(JCA),指的是用于访问和开发 Java 平台密码功能的构架。在 JDK 1.1 中,JCA 包括用于数字签名报文摘要的 API。
    JDK 1.2 大大扩展了 Java 加密体系结构,它还对证书管理基础结构进行了升级以支持 X.509 v3 证书,并为划分细致、可配置性强、功能灵活、可扩展的访问控制引入了新的 Java 安全体系结构。

    Java 加密体系结构包含 JDK 1.2 安全 API 中与密码有关的部分,以及本文档中提供的一组约定和规范。为实现多重、可互操作的密码,它还提供了“提供者”体系结构。

    Java 密码扩展 (JCE))扩展了 JCA API,包括用于加密、密钥交换和信息认证码(MAC)的 API。JCE 和 JDK 密码共同提供了一个与平台无关的完整密码 API。JCE 作为 JDK 的扩展将独立发布,以符合美国的出口控制约束。

    1.2 JDK中MD5和SHA加密的主要类

    在JDK6.0中,与MD5与SHA密切相关的几个类的类图如下:

    这里写图片描述

    其中“MessageDigestSpi”为顶层抽象类,同一个包下的“MessageDigest”和“DigestBase”为子抽象类。

    在上面的类图中,使用了Delegate(委托)设计模式

    这种模式的原理为类B(在此处为Delegage内部类)和类A(在此处为MessageDigestSpi类)是两个互相没有什么关系的类,B具有和A一模一样的方法和属性;并且调用B中的方法和属性就是调用A中同名的方法和属性。B好像就是一个受A授权委托的中介。第三方的代码不需要知道A及其子类的存在,也不需要和A及其子类发生直接的联系,通过B就可以直接使用A的功能,这样既能够使用到A的各种功能,又能够很好的将A及其子类保护起来了。

    MD5和SHA的相关代码都在MD5和SHA等类中,但是面向客户的MessageDigest抽象类不需要跟各个实现类打交道,只要通过委托类与其打交道即可。

    2、MD5加密

    2.1 概述

    Message Digest Algorithm MD5(中文名为消息摘要算法第五版)为计算机安全领域广泛使用的一种散列函数,用以提供消息的完整性保护。该算法的文件号为RFC 1321(R.Rivest,MIT Laboratory for Computer Science and RSA Data Security Inc. April 1992).

    MD5的全称是Message-Digest Algorithm 5(信息-摘要算法),在90年代初由MIT Laboratory for Computer Science和RSA Data Security Inc的Ronald L. Rivest开发出来,经MD2、MD3和MD4发展而来。

    MD5用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一(又译摘要算法、哈希算法),主流编程语言普遍已有MD5实现。

    将数据(如汉字)运算为另一固定长度值,是杂凑算法的基础原理,MD5的前身有MD2、MD3和MD4。

    MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩“成一种保密的格式(就是把一个任意长度的字节串变换成一定长的十六进制数字串)。

    2.2 算法原理

    对MD5算法简要的叙述可以为:MD5以512位分组来处理输入的信息,且每一分组又被划分为16个32位子分组,经过了一系列的处理后,算法的输出由四个32位分组组成,将这四个32位分组级联后将生成一个128位散列值。

    在MD5算法中,首先需要对信息进行填充,使其位长对512求余的结果等于448。因此,信息的位长(Bits Length)将被扩展至N*512+448,N为一个非负整数,N可以是零。

    填充的方法如下:

    • 1.在信息的后面填充一个1无数个0,直到满足上面的条件时才停止用0对信息的填充。
    • 2.然后,在这个结果后面附加一个以64位二进制表示的填充前信息长度

    经过这两步的处理,信息的位长=N*512+448+64=(N+1)*512,即长度恰好是512的整数倍。这样做的原因是为满足后面处理中对信息长度的要求。

    2.3 Java中的MD5实现

    package encrypt.md5;
    
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    /**
     * MD5Util
     * Created by heqianqian on 2017/5/17.
     */
    public class MD5Util {
    
        /**
         * MD5加密
         * 生成32位md5码
         *
         * @param inStr 待加密字符串
         * @return 2位md5码
         */
        public static String md5Encode(String inStr) throws Exception {
            MessageDigest md5 = null;
            try {
                md5 = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
                return "";
            }
            byte[] byteArray = inStr.getBytes("UTF-8");
            byte[] md5Bytes = md5.digest(byteArray);
            StringBuffer hexValue = new StringBuffer();
            for (int i = 0; i < md5Bytes.length; i++) {
                int val = ((int) md5Bytes[i]) & 0xff;
                if (val < 16) {
                    hexValue.append("0");
                }
                hexValue.append(Integer.toHexString(val));
            }
            return hexValue.toString();
        }
    
        public static void main(String[] args) throws Exception {
            String s = "ahhasdasd";
            System.out.println("Before:"+s);
            System.out.println("After:"+MD5Util.md5Encode(s));
        }
    }
    

    测试结果:

    Before:ahhasdasd
    After:f6060a6c081e6b620e73adfc85d37182

    MD算法具有以下特点:
    - 压缩性:任意长度的数据,算出的MD值长度都是固定的。
    - 容易计算:从原数据计算出MD值很容易。
    - 抗修改性:对原数据进行任何改动,哪怕只修改个字节,所得到的MD值都有很大区别。
    - 弱抗碰撞:已知原数据和其MD值,想找到一个具有相同MD值的数据(即伪造数据)是非常困难的。
    - 强抗碰撞:想找到两个不同的数据,使它们具有相同的MD值,是非常困难的。

    MD的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式(就是把一个任意长度的字节串变换成一定长的十六进制数字串)。除了MD以外,其中比较有名的还有sha-、RIPEMD以及Haval等。

    3、SHA加密

    3.1 概述

    SHA是一种数据加密算法,该算法经过加密专家多年来的发展和改进已日益完善,现在已成为公认的最安全的散列算法之一,并被广泛使用。该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

    安全散列算法SHA(Secure Hash Algorithm,SHA)是美国国家标准技术研究所发布的国家标准FIPS PUB 180,最新的标准已经于2008年更新到FIPS PUB 180-3。其中规定了SHA-1,SHA-224,SHA-256,SHA-384,和SHA-512这几种单向散列算法。SHA-1,SHA-224和SHA-256适用于长度不超过2^64二进制位的消息。SHA-384和SHA-512适用于长度不超过2^128二进制位的消息。

    3.2 原理

    SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。

    单向散列函数的安全性在于其产生散列值的操作过程具有较强的单向性。如果在输入序列中嵌入密码,那么任何人在不知道密码的情况下都不能产生正确的散列值,从而保证了其安全性。SHA将输入流按照每块512位(64个字节)进行分块,并产生20个*字节*的被称为信息认证代码或信息摘要的输出。

    该算法输入报文的长度不限,产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突,并具有良好的雪崩效应。

    通过散列算法可实现数字签名实现,数字签名的原理是将要传送的明文通过一种函数运算(Hash)转换成报文摘要(不同的明文对应不同的报文摘要),报文摘要加密后与明文一起传送给接受方,接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较,比较结果一致表示明文未被改动,如果不一致表示明文已被篡改。

    MAC (信息认证代码)就是一个散列结果,其中部分输入信息是密码,只有知道这个密码的参与者才能再次计算和验证MAC码的合法性。

    3.3 Java中的SHA实现

    package encrypt.sha;
    
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    /**
     * SHAUtil
     * Created by heqianqian on 2017/5/17.
     */
    public class SHAUtil {
    
        public static String shaEncode(String inStr) throws Exception {
            MessageDigest sha = null;
            try {
                sha = MessageDigest.getInstance("SHA");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
                return "";
            }
            byte[] byteArray = inStr.getBytes("UTF-8");
            byte[] md5Bytes = sha.digest(byteArray);
            StringBuffer hexValue = new StringBuffer();
            for (int i = 0; i < md5Bytes.length; i++) {
                int val = ((int) md5Bytes[i]) & 0xff;
                if (val < 16) {
                    hexValue.append("0");
                }
                hexValue.append(Integer.toHexString(val));
            }
            return hexValue.toString();
        }
    
        public static void main(String[] args) throws Exception {
            String str = new String("heqian");
            System.out.println("Before:" + str);
            System.out.println("After:" + shaEncode(str));
        }
    }
    

    测试结果:
    Before:heqian
    After:acc3a85f726578e72aa15fe54351aed2495edbc1

    3、SHA-1和MD5的比较

    因为二者均由MD4导出,SHA-1和MD5彼此很相似。相应的,他们的强度和其他特性也是相似,但还有以下几点不同:

    1)对强行攻击的安全性:最显著和最重要的区别是SHA-1摘要比MD5摘要长32 位。使用强行技术,产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2^128数量级的操作,而对SHA-1则是2^160数量级的操作。这样,SHA-1对强行攻击有更大的强度。

    2)对密码分析的安全性:由于MD5的设计,易受密码分析的攻击,SHA-1显得不易受这样的攻击。

    3)速度:在相同的硬件上,SHA-1的运行速度比MD5慢

    4、BASE加密

    Base是网络上最常见的用于传输Bit字节代码的编码方式之一,大家可以查看RFC~RFC,上面有MIME的详细规范。

    Base编码可用于在HTTP环境下传递较长的标识信息。例如,在Java Persistence系统Hibernate中,就采用了Base来将一个较长的唯一标识符(一般为-bit的UUID)编码为一个字符串,用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中,也常常需要把二进制数据编码为适合放在URL(包括隐藏表单域)中的形式。此时,采用Base编码具有不可读性,即所编码的数据不会被人用肉眼所直接看到。

    严格地说,属于编码格式,而非加密算法

    实现:

    package encrypt.base;
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    import java.io.IOException;
    
    /**
     * BaseUtil
     * Created by heqianqian on 2017/5/17.
     */
    public class BaseUtil {
        /**
         * BASE解密
         */
        public static byte[] decryptBASE(String inStr) throws IOException {
            return new BASE64Decoder().decodeBuffer(inStr);
        }
    
        /**
         * BASE加密
         */
        public static String encryptBASE(byte[] key){
            return new BASE64Encoder().encodeBuffer(key);
        }
    
        /**
         * 测试方法
         */
        public static void main(String[] args) throws IOException {
            String s = "heqian";
            String encryptBASE = BaseUtil.encryptBASE(s.getBytes());
            System.out.println("加密后:"+encryptBASE);
            String decryptBASE = new String(BaseUtil.decryptBASE(encryptBASE));
            System.out.println("解密后:"+decryptBASE);
        }
    }
    

    输出结果:

    加密后:aGVxaWFu
    解密后:heqian
    

    5、HMAC加密

    HMAC(Hash Message Authentication Code散列消息鉴别码,基于密钥Hash算法的认证协议。消息鉴别码实现鉴别的原理是,用公开函数密钥产生一个固定长度的值作为认证标识,用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块,即MAC,并将其加入到消息中,然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。

    实现:

    package encrypt.hmac;
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    import javax.crypto.KeyGenerator;
    import javax.crypto.Mac;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    /**
     * HMACExample
     * Created by heqianqian on 2017/5/17.
     */
    public class HMACExample {
    
        public static final String KEY_MAC = "HmacMD5";
    
        /**
         * 初始化HMAX密钥
         */
        public static String initMacKey() throws Exception {
            KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
            SecretKey secretKey = keyGenerator.generateKey();
            return new BASE64Encoder().encode(secretKey.getEncoded());
        }
    
        /**
         * HMAC加密
         */
        public static String encryptHMAC(byte[] data, String key) throws Exception {
            SecretKey secretKey = new SecretKeySpec(new BASE64Decoder().decodeBuffer(key), KEY_MAC);
            Mac mac = Mac.getInstance(secretKey.getAlgorithm());
            mac.init(secretKey);
            return new String(mac.doFinal(data));
        }
    
        public static void main(String[] args) throws Exception {
            String sendStr = "heqianqian";
            String key = HMACExample.initMacKey();
            System.out.println(HMACExample.encryptHMAC(sendStr.getBytes(), key));
            System.out.println(HMACExample.encryptHMAC(sendStr.getBytes(), key));
        }
    
    
    }
    

    展开全文
  • 一,双向加密AES 1.创建Util类 ​ package com.rtsm.zhjs.background.util; import java.security.Key; import java.security.SecureRandom; import java.util.Base64; import javax.crypto.Cipher; import ...

    一,双向加密AES

    1.创建Util类

    ​
    package com.rtsm.zhjs.background.util;
    
    import java.security.Key;
    import java.security.SecureRandom;
    import java.util.Base64;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    
    public class AESUtils {
    
         //实例化密钥
         private static Key key;
    
         //原始密钥
         private static String KEY_STR = "my-springmvc-2019-04-17";
    
         //编码
        private static String CHARSETNAME = "UTF-8";
    
         //密钥算法
         private static String KEY_ALGORITHM = "AES";
    
         //加密-解密算法 / 工作模式 / 填充方式
         private static String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
    
             /**
         * 初始化key
         */
         static {
            try {
                 KeyGenerator kgen = KeyGenerator.getInstance(KEY_ALGORITHM);
                 SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
                 random.setSeed(KEY_STR.getBytes());
                 kgen.init(128, random);
                 key = kgen.generateKey();
                 kgen = null;
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
         }
    
         public static String getEncryptString(String str) {
             try {
                     byte[] bytes = str.getBytes(CHARSETNAME);
                     Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                     cipher.init(Cipher.ENCRYPT_MODE, key);
                     byte[] doFinal = cipher.doFinal(bytes);
             return Base64.getEncoder().encodeToString(doFinal);
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
         }
    
        /**
         * @description: 对AES加密字符串进行解密
         * @param str
         * @return
         */
        public static String getDecryptString(String str) {
                 try {
                     byte[] bytes = Base64.getDecoder().decode(str);
                         Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                         cipher.init(Cipher.DECRYPT_MODE, key);
                     byte[] doFinal = cipher.doFinal(bytes);
                 return new String(doFinal, CHARSETNAME);
                 } catch (Exception e) {
             throw new RuntimeException(e);
            }
         }
    }
    
    ​

    2.编写测试类

    
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class GcglDmpzTest {
       
        @Test
        public void jiamiTest() {
            String password = "123456";
            String pass = AESUtils.getEncryptString(password);
            System.out.println("加密:"+pass);
            System.out.println("解密:"+ AESUtils.getDecryptString(pass));
    
        }
    
    
    
    }
    

    3.输出结果:

    加密:Db9BY4b58pQm6eZ4pwVccg==
    解密:123456

    二,SHA256单向加密

    1.util类

    package com.rtsm.zhjs.background.util;
    
    import java.io.UnsupportedEncodingException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    /**
    * SHA256 摘要算法工具类
    * @author Administrator
    *
    */
    public class SHA256Util {
    
        /**
      * 利用java原生的摘要实现SHA256加密
      * @param str 加密后的报文
      * @return
      */
    
        public static String getSHA256StrJava(String str){
        MessageDigest messageDigest;
        String encodeStr = "";
        try {
            messageDigest = MessageDigest.getInstance("SHA-256");
            messageDigest.update(str.getBytes("UTF-8"));
            encodeStr = byte2Hex(messageDigest.digest());
            } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
            }
            return encodeStr;
        }
    
        /**
      * 将byte转为16进制
      * @param bytes
      * @return
      */
        private static String byte2Hex(byte[] bytes){
            StringBuffer stringBuffer = new StringBuffer();
            String temp = null;
            for (int i=0;i<bytes.length;i++){
                temp = Integer.toHexString(bytes[i] & 0xFF);
            if (temp.length()==1){
                //1得到一位的进行补0操作
                stringBuffer.append("0");
                }
                stringBuffer.append(temp);
            }
            return stringBuffer.toString();
        }
    
    }

    2.测试

    /**
     * @author syx
     * @date 2019/3/2015:54
     */
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class GcglDmpzTest {
        
        @Test
        public void jiamiTest() {
            String password = "123456";
            String pass = SHA256Util.getSHA256StrJava(password);
            System.out.println("加密:"+pass);
        }
    
    
    
    }
    

    3.输出结果

    加密:8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92

     

    展开全文
  • Java学习资料,心得,其中包括单向加密算法、jsp实现分页的步骤、Hibernate、Spring和Struts工作原理及使用理由.txt
  • 主要介绍了Java 详解单向加密--MD5、SHA和HMAC及简单实现实例的相关资料,需要的朋友可以参考下
  • 我有以下代码 –import org.jasypt.util.text.BasicTextEncryptor;public static void main(String[] args) {BasicTextEncryptor textEncryptor = new BasicTextEncryptor();textEncryptor.setPassword("kshitiz");...
  • JAVA几种简单的单向加密方式

    千次阅读 2018-10-17 16:28:53
    本问只简要讲解在JAVA中如何使用几种加密的代码示例,关于加密算法和数学知识不在本文讨论范围。 package com.util; import java.io.UnsupportedEncodingException; import java.math.BigInteger; import java....
  • java加密之单向加密算法:MD5,SHA,HMAC。 一、MD5加密算法: /** * MD5加密算法 * * @param data 要加密的数据 */ public static byte[] MD5Encrypt(byte[] data) { byte[] b = null; try {
  • 转自:http://fcm915.javaeye.com/blog/401562JAVA单向加密(MD5,SHA,MAC) 具体代码如下: <br />import java.security.MessageDigest; import javax.crypto.KeyGenerator; import javax...
  • 单向加密双向加密简要汇总

    千次阅读 2020-02-04 16:16:47
    常用的编码方式 BASE64,一种基于64个可打印字符来表示二进制数据的表示方法,主要特点是将二进制数据转换为可视字符来...MD5(Message Algorithm(消息摘要算法第五版),最常用的单向加密算法,可将原文加密为固...
  • 单向加密

    千次阅读 2016-09-16 23:29:24
     MD5、SHA、HMAC这三种加密算法,可谓是非可逆加密,就是不可解密的加密方法,我们称之为单向加密算法。我们通常只把他们作为加密的基础。单纯的以上三种的加密并不可靠。  BASE64  按照RFC2045的定义,Base...
  • 加密,是以某种特殊的算法改变原有的信息数据,使得未授权的用户即使获得了已加密的信息,但因不知解密的方法,仍然无法了解...而单向加密只是对信息进行了摘要计算,不能通过算法生成明文,单向加密从严格意思上说不能
  • 一提到加密,就会联想到数字签名,这两个经常被混淆的概念到底是什么呢? 加密加密是一种以密码方式发送信息的方法。只有拥有正确密钥的人才能解开这个信息的密码。对于其他人来说,这个信息看起来就像是一系列...
  • 单向加密算法

    千次阅读 2016-03-30 14:51:00
    MD5,SHA算法是单向加密算法的代表,单向加密算法是数据完整性验证的常用算法。对称加密算法: DES算法是典型的对称加密算法的代表,对称加密算法是数据存储加密的常用算法非对称算法: RSA算法是典型的非对称
  • java加密技术

    2018-08-31 10:59:17
    java加密技术 与单向加密算法MD5&SHA;&MAC; 对称加密算法DES&AES; PBE 算法
  • Java加密算法

    2021-02-28 19:16:27
    Java加密算法有三种:1、单向加密算法2、对错加密算法3、非对称加密算法单向加密算法单向加密是不可逆的加密算法,加密的密文不能解密,常见的算法有MD5、SHA、HMAC。MD5(信息摘要算法)无论多长数据最后都编码成128...
  • Java常用加密算法

    千次阅读 2020-03-23 10:42:26
    可以对数据编码和解码,是可逆的,安全度较低,不过,也可以作为最基础最简单的加密算法用于加密要求较弱的情况。 Base64可以使用JDk中自带的类实现,还可以使用Bouncy Castle(简称bc)或Commons Codec(简称cc)...
  • java加密工具类

    2021-02-25 20:13:52
    }/*** 使用MessageDigest进行单向加密(无密码) *@paramres 被加密的文本 *@paramalgorithm 加密算法名称 *@return */ privateString messageDigest(String res,String algorithm){try{ MessageDigest md=...
  • 一提到加密,就会联想到数字签名,这两个经常被混淆的概念到底是什么呢?加密加密是一种以密码方式发送信息的方法。只有拥有正确密钥的人才能解开这个信息的密码。对于其他人来说,这个信息看起来就像是一系列随机...
  • aes-javaJava 编写的 ECB 模式下的 128 位 AES 加密。 不解密文件。 也可在。 用法 从stdin读取二进制文件并在stdout上stdout加密字节。
  • 感谢微博原著:Snowolf ...加密解密,曾经是我一个毕业设计的重要组件。在工作了多年以后回想当时那个加密、解密算法,实在是太单纯了。... 如基本的单向加密算法: BASE64 严格地说,属于编码格式,而非加密算法
  • import java.security.MessageDigest;public class PasswordEncoder {private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5","6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };private Obj...
  • 加密解密,曾经是我一个毕业设计的重要组件。在工作了多年以后回想当时... 如基本的单向加密算法:  BASE64 严格地说,属于编码格式,而非加密算法MD5(Message Digest algorithm 5,信息摘要算法)SHA(Secure Hash
  • java--加密解密

    2021-03-06 06:18:33
    加 密算法通常分为对称性加密算法和非对称性加密算法,对于对称性加密算法,信息接收双方都需事先知道密匙和加解密算法且其密匙是相同的,之后便是对数据进行 加解密了。非对称算法与之不同,发送双方A,B事先均生成...
  • Java常见加密方式

    2021-03-09 13:53:55
    下文主要对Java常见的加密算法概述以及具体示例 BASE64:严格地说,属于编码格式,而非加密算法 BASE的加密解密是双向的,可以求反解. BASEEncoder和BASEDecoder是非官方JDK实现类。虽然可以在JDK里能找到并使用,...
  •   SHA是一种数据加密算法, 该算法经过加密专家多年来的发展和改进已日益完善,现在已成为公认的最安全的散列算法之一,并被广泛使用。该算法的思想是接收一段明文,然后以一种不可逆 的方式将它转换成一段(通常...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,732
精华内容 5,892
关键字:

java单向加密

java 订阅