常用加解密及摘要算法介绍及使用场景–MD5,SHA1,AES,DES,3DES,RSA,ECC

 加解密  常用加解密及摘要算法介绍及使用场景–MD5,SHA1,AES,DES,3DES,RSA,ECC已关闭评论
10月 292020
 

网上看到的一篇常用加解密算法、摘要算法的介绍文章,转载来自CSDN

数字签名信息加密是前后端开发经常使用的技术。应用场景包括:用户登录,交易,信息通讯等。

1、数字签名

数字签名 简单来说就是通过提供可鉴别 的数字信息 验证自身身份的一种方式。

一套 数字签名 通常定义两种 互补的运算,一个用于签名,另一个用于验证,分别  发送者持有能够代表自己的私钥,由接受者持有的与私钥对应的公钥,能够在接受到来自发送者信息时候用于验证其身份。

2、加密和解密

2.1 加密: 数据加密 基本过程,就是对来的铭文的文件或者数据 按照 某种算法 进行处理,使其成为不可读的一段代码,通常成为 “密文”。通过这样的途径,来达到保护数据 不被别人 非法窃取,阅读的目的。

2.2 解密:加密的逆过程为解密,将 编码的信息 转为为 原有的数据 的过程。

3、对称加密和非对称加密

面试相关问题:举例说一下有哪些常用的对称算法?及其使用场景。
常见的对称加密算法:DES3DESAES

常见的非对称加密算法:RSADSA

散列算法:SHA-1MD5等,其应用场景?

3.1、对称加密(共享密钥加密算法)

在对称加密算法中,使用的密钥只有一个,发送者  接受者 双方都是用这一个密钥进行 加密  解密。这就要求通信双方都必须事先知道这个密钥。

  • 数据加密过程:在对称加密算法中,数据发送方  明文 和加密密钥 一起经过特殊加密处理,生成 密文 进行发送。
  • 数据解密过程:数据接收方,收到密文后,若想读取原数据,则需要使用加密使用的密钥 即相同算法的 逆算法 对密文进行解密,才可以恢复到 可读的明文。

3.2、非对称加密算法(公开密钥加密算法)

在非对称加密算法中,她需要两个密钥,一个称为公开密钥,另一个为私有密钥。因为加密和解密使用的密钥不同,所以称为非对称加密算法。

  • 如果使用公钥对数据进行加密,只有用对应的私钥才可以对其进行解密。
  • 如果使用私钥对数据进行加密,只有用对应的公钥才可以对其进行解密。

4、常用的签名加密算法

4.1MD5算法 (相比于SHA1 安全性低,但是 速度快)

MD5算法用的是哈希函数,他的典型应用是对于一段信息产生信息摘要,以防止被篡改。严格来说MD5不算一种加密算法,而是一种 摘要算法。无论多长的输入,MD5都会输出长度为128bits的一个串(通常用16进制表示32个字符)。


public class MD5 {

    public static final byte[] computeMD5(byte[] content) {

        try {

            MessageDigest md5 = MessageDigest.getInstance(“MD5”);

            return md5.digest(content);

        } catch (NoSuchAlgorithmException e) {

            throw new RuntimeException(e);

        }

    }



    public static void main(String[] args) {

        String s1 = “hello world”;

        byte[] bytes = s1.getBytes();

        System.out.println(s1 +加密后的密文为:+computeMD5(bytes));

    }

}


// 输出结果:hello world经过MD5加密后的密文为:[[email protected]

 

4.2 SHA1算法 (相比于MD5 安全性高,但是 速度慢)

SHA1算法和MD5算法是一样流行 消息摘要算法,然而SHA1的安全性会高于MD5。对于长度小于2^64位的消息,SHA1会产生一个160位的消息摘要。


public class SHA1 {
    public static byte[] computeSHA1(byte[] content) {

        try {

            MessageDigest sha1 = MessageDigest.getInstance(“SHA1”);

            return sha1.digest(content);

        } catch (NoSuchAlgorithmException e) {

            throw new RuntimeException(e);

        }

    }



    public static void main(String[] args) {

        String s1 = “hello world”;

        byte[] bytes = s1.getBytes();

        System.out.println(s1 +加密后的密文为:+computeSHA1(bytes));

    }

}


// 输出结果:hello world经过SHA1加密后的密文为:[[email protected]

 

根据MD5SHA1的信息摘要及不可逆的特性,应用场景有 

  • 密码验证:服务器端存储用户密码加密后的内容,每次密码校验比较的是密文是否相同,确保服务器管理员也无法获取到用户使用的密码。
  • 文件的完整性比较:当下载一个文件时,服务器返回的信息中包括这个文件的MD5(或者SHA1),在本地下载完毕将其进行MD5加密,之后比较两个MD5只进行比较,如果一直则说明文件完整不存在丢包现象。
  • 文件上传:在上传文件信息的时候,将该文件的MD5同时上传给服务器。服务器中存储了这个文件MD5,并存储这个MD5只对应的已上传的字节长度,比如未上传为0,已完成为-1,已上传200自己,则值为200。可以用于匹配该文件在服务器中的状态,方便断点再传。只要源文件没有改,就算文件改了名字,换个账户都可以在服务器中找到对应的文件,避免存储多份相同文件,并可以提高二次上传时的速度。
  • 版权验证:当一个视频或者音创作出来的时候他的MD5是唯一的,翻录过后的版本的MD5会不同,可以用于版权验证。

4.3 HMAC算法

是一个密钥相关的 哈希运算消息认证码,HMAC运算利用 哈希算法(MD5SHA1等),以一个密钥  一个消息作为输入,生成一个消息摘要 作为输出。HMAC 发送方和接收方都有这个key进行计算,而没有这个key的第三方,则无法计算出正确的散列值,这样就可以防止数据被篡改。 该算法在多线程环境下是不安全的。

对称算法和非对称算法:

4.4 对称算法——AES/DES/3DES算法

AES/DES/3DES 都是对称的块加密算法,加解密过程是可逆的,

4.4.1 AES算法

AES加密算法是密码学中的高级加密标准,该加密算法采用的是 对称分组密码体制,密钥长度最少支持 128位,192位,256位,因而有AES128AES192AES256等常用的加密方式。分组长度为128位,算法更易于各种硬件和软件的实现。

AES本身就是为了取代DES的,AES具有更好的安全性,效率和灵活性。

4.4.2 DES算法

DES加密算法是一种 分组密码,以64位位 分组对数据加密,他的密钥长度是56位,加密和解密用同一个算法。
DES加密算法对于密钥进行保密,而公开算法,包括加密和解密算法。这样只有掌握了和发送方 相同密钥的人才能来解读由DES进行加密的密文数据。

4.4.3 3DES算法

是基于DES的对称算法,对 一块数据  三个不同的密钥 进行三次加密,安全性更高。
 

4.5 非对称算法——RSAECC算法

4.5.1 RSA算法

RSA算法是目前最具影响力的公钥加密算法。RSA是第一个同事用于加密和数字签名的算法,它能够抵抗到目前为止已知的所有密码攻击

RSA算法基于一个十分简单的数论试试,将两个大素数相乘十分容易,但是想要对乘积进行因式分解确十分困难,因此可以将乘积公开作为加密密钥。

4.5.2 ECC算法

ECC算法的主要优势是,在某一些情况下,它可以生成比其他方法更小的密钥,比如RSA算法,并提供相当或者更高级别的安全等级。不过他的缺点是 加密和解密操作的实现会比其他机制时间要长,对于CPU的消耗严重。

utm   详细X
基本翻译
abbr. 统一威胁管理(Unified Threat Management);通用横墨卡托投影(Universal Transverse Mercator projection)
网络释义
UTM: 统一威胁管理
UTM UTM: 统一威胁管理
UTM-: 通用横向墨卡托图

Java 环境下使用 AES 密钥长度限制等特殊情况处理及 PKCS5 和 PKCS7 填充说明( Illegal key size or default parameters问题解决)

 java, 加解密  Java 环境下使用 AES 密钥长度限制等特殊情况处理及 PKCS5 和 PKCS7 填充说明( Illegal key size or default parameters问题解决)已关闭评论
12月 182015
 

补充下AES 加密问题及PKCS5 和 PKCS7 填充说明

近些年DES使用越来越少,原因就在于其使用56位密钥,比较容易被破解,近些年来逐渐被AES替代,AES已经变成目前对称加密中最流行算法之一;AES可以使用128、192、和256位密钥,并且用128位分组加密和解密数据.

 在 Java 环境下使用 AES 加密,在密钥长度和字节填充方面有一些比较特殊的处理。

1. 密钥长度问题

    默认 Java 中仅支持 128 位密钥,当使用 256 位密钥的时候,会报告密钥长度错误(或者 Illegal key size or default parameters)

Invalid AES key length

   你需要下载一个支持更长密钥的包。这个包叫做 Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 6,可以从这里下载,下载地址:http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html

   下载之后,解压后,可以看到其中包含两个包:

    local_policy.jar

    US_export_policy.jar

    看一下你的 JRE 环境,将 JRE 环境中 lib\lib\security 中的同名包替换掉。

2. Base64 问题

     Apache 提供了 Base64 的实现,可以从这里下载。

    下载地址:http://commons.apache.org/proper/commons-codec/download_codec.cgi

     编码

// 编码 String asB64 = new Base64().encodeToString("some string".getBytes("utf-8"));
System.out.println(asB64); // 输出为: c29tZSBzdHJpbmc=

     解码   

// 解码 byte[] asBytes = new Base64().getDecoder().decode("c29tZSBzdHJpbmc=");
System.out.println(new String(asBytes, "utf-8")); // 输出为: some string

 

     如果你已经使用 Java 8,那么就不需要再选用第三方的实现了,在 java.util 包中已经包含了 Base64 的处理。

     编码的方式

// 编码 String asB64 = Base64.getEncoder().encodeToString("some string".getBytes("utf-8"));
System.out.println(asB64); // 输出为: c29tZSBzdHJpbmc=

     解码处理

// 解码 byte[] asBytes = Base64.getDecoder().decode("c29tZSBzdHJpbmc=");
System.out.println(new String(asBytes, "utf-8")); // 输出为: some string

 

3. 关于 PKCS5 和 PKCS7 填充问题

PKCS #7 填充字符串由一个字节序列组成,每个字节填充该填充字节序列的长度。

假定块长度为 8,数据长度为 9,
          数据: FF FF FF FF FF FF FF FF FF
PKCS7 填充: FF FF FF FF FF FF FF FF FF 07 07 07 07 07 07 07

简单地说, PKCS5, PKCS7和SSL3, 以及CMS(Cryptographic Message Syntax)

有如下相同的特点:
1)填充的字节都是一个相同的字节
2)该字节的值,就是要填充的字节的个数

如果要填充8个字节,那么填充的字节的值就是0×8;
要填充7个字节,那么填入的值就是0×7;

如果只填充1个字节,那么填入的值就是0×1;

这种填充方法也叫PKCS5, 恰好8个字节时还要补8个字节的0×08

正是这种即使恰好是8个字节也需要再补充字节的规定,可以让解密的数据很确定无误的移除多余的字节。

pkcs7_padding

 

在PKCS# Padding中说:

  1. 因为恢复的明文的最后一个字节 告诉你 存在多少个填充字节, 用PKCS#5 填充 的加密方法, 即使在输入的明文长度 恰好是 块大小(Block Size)整数倍 , 也会增加一个完整的填充块. 否则,恢复出来的明文的最后一个字节可能是实际的消息字节.
  2. 因为第1个因素限制了 使用PKCS#填充的 对称加密算法的 输入块大小(Block Size, 注意不是输入的明文的总长度 total input length), 最大只能是256个字节.   因为大多数对称块加密算法 通常使用8字节或者16字节的块, 所以,这不是一个问题
  3. 使用ECB模式填充可能会有安全问题.
  4. 使用PKCS#5填充 可以很方便地检测明文中的错误.

标准

PKCS #7: Cryptographic Message Syntax

在 10.3节中讲到了上面提到的填充算法,  对Block Size并没有做规定

PKCS #5: Password-Based Cryptography Specification

在6.1.1 中对 填充做了说明
但是因为该标准 只讨论了 8字节(64位) 块的加密, 对其他块大小没有做说明
其 填充算法跟 PKCS7是一样的

后来 AES 等算法, 把BlockSize扩充到 16个字节

比如, Java中
Cipher.getInstance(“AES/CBC/PKCS5Padding”)
这个加密模式
跟C#中的
RijndaelManaged cipher = new RijndaelManaged();
cipher.KeySize = 128;
cipher.BlockSize = 128;
cipher.Mode = CipherMode.CBC;
cipher.Padding = PaddingMode.PKCS7;
的加密模式是一样的

因为AES并没有64位的块, 如果采用PKCS5, 那么实质上就是采用PKCS7

12月 082015
 

DES使用越来越少,原因就在于其使用56位密钥,比较容易被破解,近些年来逐渐被AES替代,AES已经变成目前对称加密中最流行算法之一;AES可以使用128、192、和256位密钥,并且用128位分组加密和解密数据(目前默认java仅支持128位密钥,需下载扩展包支持256位,见java扩展算法与辅助工具)。本文就简单介绍如何通过JAVA实现AES加密。

网上很多java 实现AES的代码都有这样那样问题,现摘录《java加密与解密的艺术》中关于AES的代码, 简单明了,关键是有效!!!

JAVA实现

package test.rsa;

import java.security.Key;
import java.util.Arrays;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;

public class AESCoder {
public static final String KEY_ALGORITHM = “AES”;

public static final String CIPHER_ALGORITHM = “AES/ECB/PKCS5Padding”;

private static Key toKey(byte[] key) throws Exception {
SecretKey secretKey = new SecretKeySpec(key, KEY_ALGORITHM);
return secretKey;
}

public static byte[] decrypt(byte[] data, byte[] key) throws Exception{
Key k = toKey(key);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, k);
return cipher.doFinal(data);
}

public static byte[] encrypt(byte[] data, byte[] key) throws Exception{
Key k = toKey(key);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, k);
return cipher.doFinal(data);
}

public static byte[] initKey() throws Exception {
KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);
kg.init(128);
SecretKey secretKey = kg.generateKey();
return secretKey.getEncoded();

}

public static void main(String[] args) throws Exception {
String inputStr=”测试 AES 密钥密钥密钥密钥”;
byte[] inputData = inputStr.getBytes();
System.out.println(“原文[arrays]:\t” + Arrays.toString(inputData));
System.out.println(“原文:\t” + inputStr);

byte[] key = initKey();
System.out.println(“密钥[arrays]:\t” + Arrays.toString(key));
System.out.println(“密钥[base64]:\t” + Base64.encodeBase64String(key));

inputData = encrypt(inputData, key);
System.out.println(“加密后[arrays]:\t” + Arrays.toString(inputData));
System.out.println(“加密后[base64]:\t” + Base64.encodeBase64String(inputData));

byte[] outputData= decrypt(inputData, key);
System.out.println(“解密后[arrays]:\t” + Arrays.toString(outputData));
System.out.println(“解密后[base64]:\t” + new String(outputData));

}

}

密钥的合成及base64转码方式,给我们保存及传输提供了想象空间。

5月 292015
 

网上找到到一个加解密内容的系列文章,强烈推荐:

DES 
DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。 
DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。 

 

通过java代码实现如下:Coder类见 Java加密技术(一) 

Java代码  收藏代码

  1. import java.security.Key;  
  2. import java.security.SecureRandom;  
  3.   
  4. import javax.crypto.Cipher;  
  5. import javax.crypto.KeyGenerator;  
  6. import javax.crypto.SecretKey;  
  7. import javax.crypto.SecretKeyFactory;  
  8. import javax.crypto.spec.DESKeySpec;  
  9.   
  10.   
  11. /** 
  12.  * DES安全编码组件 
  13.  *  
  14.  * <pre> 
  15.  * 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR) 
  16.  * DES                  key size must be equal to 56 
  17.  * DESede(TripleDES)    key size must be equal to 112 or 168 
  18.  * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available 
  19.  * Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive) 
  20.  * RC2                  key size must be between 40 and 1024 bits 
  21.  * RC4(ARCFOUR)         key size must be between 40 and 1024 bits 
  22.  * 具体内容 需要关注 JDK Document http://…/docs/technotes/guides/security/SunProviders.html 
  23.  * </pre> 
  24.  *  
  25.  * @author 梁栋 
  26.  * @version 1.0 
  27.  * @since 1.0 
  28.  */  
  29. public abstract class DESCoder extends Coder {  
  30.     /** 
  31.      * ALGORITHM 算法 <br> 
  32.      * 可替换为以下任意一种算法,同时key值的size相应改变。 
  33.      *  
  34.      * <pre> 
  35.      * DES                  key size must be equal to 56 
  36.      * DESede(TripleDES)    key size must be equal to 112 or 168 
  37.      * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available 
  38.      * Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive) 
  39.      * RC2                  key size must be between 40 and 1024 bits 
  40.      * RC4(ARCFOUR)         key size must be between 40 and 1024 bits 
  41.      * </pre> 
  42.      *  
  43.      * 在Key toKey(byte[] key)方法中使用下述代码 
  44.      * <code>SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);</code> 替换 
  45.      * <code> 
  46.      * DESKeySpec dks = new DESKeySpec(key); 
  47.      * SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM); 
  48.      * SecretKey secretKey = keyFactory.generateSecret(dks); 
  49.      * </code> 
  50.      */  
  51.     public static final String ALGORITHM = “DES”;  
  52.   
  53.     /** 
  54.      * 转换密钥<br> 
  55.      *  
  56.      * @param key 
  57.      * @return 
  58.      * @throws Exception 
  59.      */  
  60.     private static Key toKey(byte[] key) throws Exception {  
  61.         DESKeySpec dks = new DESKeySpec(key);  
  62.         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);  
  63.         SecretKey secretKey = keyFactory.generateSecret(dks);  
  64.   
  65.         // 当使用其他对称加密算法时,如AES、Blowfish等算法时,用下述代码替换上述三行代码  
  66.         // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);  
  67.   
  68.         return secretKey;  
  69.     }  
  70.   
  71.     /** 
  72.      * 解密 
  73.      *  
  74.      * @param data 
  75.      * @param key 
  76.      * @return 
  77.      * @throws Exception 
  78.      */  
  79.     public static byte[] decrypt(byte[] data, String key) throws Exception {  
  80.         Key k = toKey(decryptBASE64(key));  
  81.   
  82.         Cipher cipher = Cipher.getInstance(ALGORITHM);  
  83.         cipher.init(Cipher.DECRYPT_MODE, k);  
  84.   
  85.         return cipher.doFinal(data);  
  86.     }  
  87.   
  88.     /** 
  89.      * 加密 
  90.      *  
  91.      * @param data 
  92.      * @param key 
  93.      * @return 
  94.      * @throws Exception 
  95.      */  
  96.     public static byte[] encrypt(byte[] data, String key) throws Exception {  
  97.         Key k = toKey(decryptBASE64(key));  
  98.         Cipher cipher = Cipher.getInstance(ALGORITHM);  
  99.         cipher.init(Cipher.ENCRYPT_MODE, k);  
  100.   
  101.         return cipher.doFinal(data);  
  102.     }  
  103.   
  104.     /** 
  105.      * 生成密钥 
  106.      *  
  107.      * @return 
  108.      * @throws Exception 
  109.      */  
  110.     public static String initKey() throws Exception {  
  111.         return initKey(null);  
  112.     }  
  113.   
  114.     /** 
  115.      * 生成密钥 
  116.      *  
  117.      * @param seed 
  118.      * @return 
  119.      * @throws Exception 
  120.      */  
  121.     public static String initKey(String seed) throws Exception {  
  122.         SecureRandom secureRandom = null;  
  123.   
  124.         if (seed != null) {  
  125.             secureRandom = new SecureRandom(decryptBASE64(seed));  
  126.         } else {  
  127.             secureRandom = new SecureRandom();  
  128.         }  
  129.   
  130.         KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);  
  131.         kg.init(secureRandom);  
  132.   
  133.         SecretKey secretKey = kg.generateKey();  
  134.   
  135.         return encryptBASE64(secretKey.getEncoded());  
  136.     }  
  137. }  

延续上一个类的实现,我们通过MD5以及SHA对字符串加密生成密钥,这是比较常见的密钥生成方式。 
再给出一个测试类: 

Java代码  收藏代码

  1. import static org.junit.Assert.*;  
  2.   
  3.   
  4. import org.junit.Test;  
  5.   
  6. /** 
  7.  *  
  8.  * @author 梁栋 
  9.  * @version 1.0 
  10.  * @since 1.0 
  11.  */  
  12. public class DESCoderTest {  
  13.   
  14.     @Test  
  15.     public void test() throws Exception {  
  16.         String inputStr = “DES”;  
  17.         String key = DESCoder.initKey();  
  18.         System.err.println(“原文:t” + inputStr);  
  19.   
  20.         System.err.println(“密钥:t” + key);  
  21.   
  22.         byte[] inputData = inputStr.getBytes();  
  23.         inputData = DESCoder.encrypt(inputData, key);  
  24.   
  25.         System.err.println(“加密后:t” + DESCoder.encryptBASE64(inputData));  
  26.   
  27.         byte[] outputData = DESCoder.decrypt(inputData, key);  
  28.         String outputStr = new String(outputData);  
  29.   
  30.         System.err.println(“解密后:t” + outputStr);  
  31.   
  32.         assertEquals(inputStr, outputStr);  
  33.     }  
  34. }  

得到的输出内容如下: 

Console代码  收藏代码

  1. 原文: DES  
  2. 密钥: f3wEtRrV6q0=  
  3.   
  4. 加密后:    C6qe9oNIzRY=  
  5.   
  6. 解密后:    DES  

    由控制台得到的输出,我们能够比对加密、解密后结果一致。这是一种简单的加密解密方式,只有一个密钥。 
    其实DES有很多同胞兄弟,如DESede(TripleDES)、AES、Blowfish、RC2、RC4(ARCFOUR)。这里就不过多阐述了,大同小异,只要换掉ALGORITHM换成对应的值,同时做一个代码替换SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);就可以了,此外就是密钥长度不同了。 

Java代码  收藏代码

  1. /** 
  2.  * DES          key size must be equal to 56 
  3.  * DESede(TripleDES) key size must be equal to 112 or 168 
  4.  * AES          key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available 
  5.  * Blowfish     key size must be multiple of 8, and can only range from 32 to 448 (inclusive) 
  6.  * RC2          key size must be between 40 and 1024 bits 
  7.  * RC4(ARCFOUR) key size must be between 40 and 1024 bits 
  8.  **/  



转自:http://snowolf.iteye.com/blog/380034