各种算法的集合

最新推荐文章于 2023-04-17 10:43:56 发布
置顶 最新推荐文章于 2023-04-17 10:43:56 发布
阅读量1.5k 收藏 4
点赞数 1
分类专栏： rsa，aes，des，MD5；base64；算法 文章标签： android rsa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianshideyouhuo1/article/details/78048624
版权


AES算法

美国国家标准和技术研究所（NIST）经过三轮候选算法筛选，从众多的分组密码中选中Rijndael算法作为高级加密标准（AES）。Rijndael密码是一个迭代型分组密码，分组长度和密码长度都是可变的，分组长度和密码长度可以独立的指定为128比特，192比特或者256比特。AES的加密算法的数据处理单位是字节，128位的比特信息被分成16个字节，按顺序复制到一个4*4的矩阵中，称为状态（state），AES的所有变换都是基于状态矩阵的变换。

用Nr表示对一个数据分组加密的轮数（加密轮数与密钥长度的关系如表1所示）。在轮函数的每一轮迭代中，包括四步变换，分别是字节代换运算(ByteSub())、行变换(ShiftRows())、列混合(MixColumns())以及轮密钥的添加变换AddRoundKey()[3]，其作用就是通过重复简单的非线形变换、混合函数变换，将字节代换运算产生的非线性扩散，达到充分的混合，在每轮迭代中引入不同的密钥，从而实现加密的有效性。

下面是三种不同类型的AES加密密钥分组大小与相应的加密轮数的对照表。加密开始时，输入分组的各字节按表2 的方式装入矩阵state中。如输入ABCDEFGHIJKLMNOP，则输入块影射到如表2的状态矩阵中。
表1：

AES类型 密钥长度 分组长度 加密轮数
AES-128 4字 4字 10
AES-192 6字 4字 12
AES-256 8字 4字 14

A E I M
B F J N
C G K O
D H L P

1、字节代换运算(ByteSub())

字节代换运算是一个可逆的非线形字节代换操作，对分组中的每个字节进行，对字节的操作遵循一个代换表，即S盒。S盒由有限域 GF（28）上的乘法取逆和GF（2）上的仿射变换两步组成。
2、行变换ShiftRows()

行变换是一种线性变换，其目的就是使密码信息达到充分的混乱，提高非线形度。行变换对状态的每行以字节为单位进行循环右移，移动字节数根据行数来确定，第0行不发生偏移，第一行循环右移一个字节，第二行移两个，依次类推。
3、 列混合变换MixColumns()

列变换就是从状态中取出一列，表示成多项式的形式后，用它乘以一个固定的多项式a(x)，然后将所得结果进行取模运算，模值为 x4+1。其中a(x)={03}x3+{02}x2+{01}x+{02},
这个多项式与x4+1互质，因此是可逆的。列混合变换的算术表达式为：s’(x)= a(x) s(x)，其中， s(x)表示状态的列多项式。
4、轮密钥的添加变换AddRoundKey()
在这个操作中，轮密钥被简单地异或到状态中，轮密钥根据密钥表获得，其长度等于数据块的长度Nb。
AES算法流程

对于发送方，它首先创建一个AES私钥，并用口令对这个私钥进行加密。然后把用口令加密后的AES密钥通过Internet发送到接收方。发送方解密这个私钥，并用此私钥加密明文得到密文，密文和加密后的AES密钥一起通过Internet发送到接收方。接收方收到后再用口令对加密密钥进行解密得到AES密钥，最后用解密后的密钥把收到的密文解密成明文。图7中是这个过程的实现流程。
AES算法流程

这里写图片描述

RSA算法

RSA算法基本原理及流程

RSA是在1977年发明RSA密码系统的三个人的名字的首字母的缩写，他们是：Ron Rivest、Adi Shamir和Leonard Adleman。它是第一个公钥加密算法，在很多密码协议中都有应用，如SSL和S/MIME。RSA算法是基于大质数的因数分解的公匙体系。简单的讲，就是两个很大的质数，一个作为公钥，另一个作为私钥，如用其中一个加密，则用另一个解密。密钥长度从40到2048位可变，密钥越长，加密效果越好，但加密解密的开销也大。RSA算法可简单描述如下：

公开密钥：n=pq，（p，q为两个不同的很大的质数，p和q必须保密）
将(p-1)和(q-1)相乘得到φ(n)
选择一个整数e (1<e<φ(n))与φ(n)互质
秘密密钥：d=e-1modφ(n)，即计算一个数字d，使得它满足公式 de=1 modφ(n)
加密：c=mc(mod n) 
解密：m=cd(mod n)，m为明文，c为密文。

RSA算法实现流程

首先，接收方创建RSA密匙对，即一个公钥和一个私钥，公钥被发送到发送方,私钥则被保存在接收方。发送方在接收到这个公钥后,用该公钥对明文进行加密得到密文，然后把密文通过网络传输给接收方。接收方在收到它们后，用RSA私钥对收到的密文进行解密，最后得到明文 下面 是整个过程的实现流程。

这里写图片描述

AES与RSA相结合数据加密方案

RSA算法是公开密钥系统的代表，其安全性建立在具有大素数因子的合数，其因子分解困难这一法则之上的。Rijndael算法作为新一代的高级加密标准，运行时不需要计算机有非常高的处理能力和大的内存，操作可以很容易的抵御时间和空间的攻击，在不同的运行环境下始终能保持良好的性能。这使AES将安全，高效，性能，方便，灵活性集于一体，理应成为网络数据加密的首选。相比较，因为AES密钥的长度最长只有256比特，可以利用软件和硬件实现高速处理，而RSA算法需要进行大整数的乘幂和求模等多倍字长处理，处理速度明显慢于AES[5]；所以AES算法加解密处理效率明显高于RSA算法。在密钥管理方面，因为AES算法要求在通信前对密钥进行秘密分配，解密的私钥必须通过网络传送至加密数据接收方，而RSA采用公钥加密，私钥解密（或私钥加密，公钥解密），加解密过程中不必网络传输保密的密钥；所以RSA算法密钥管理要明显优于AES算法。

从上面比较得知，由于RSA加解密速度慢，不适合大量数据文件加密，因此在网络中完全用公开密码体制传输机密信息是没有必要，也是不太现实的。AES加密速度很快，但是在网络传输过程中如何安全管理AES密钥是保证AES加密安全的重要环节。这样在传送机密信息的双方，如果使用AES对称密码体制对传输数据加密，同时使用RSA不对称密码体制来传送AES的密钥，就可以综合发挥AES和RSA的优点同时避免它们缺点来实现一种新的数据加密方案。

Android端 AES+RSA结合实践

基本要求

保证传输数据的安全性
保证数据的完整性
能够验证客户端的身份
基本流程

Android端

  1. 服务器端(server)分别生成自己的RSA密钥对,并提供接口给Android客户端获取RSA公钥(rsaPublicKey)
  2. client生成AES密钥(aesKey)
  3. client使用自己的AES密钥(aesKey)对转换为json格式的请求明文数据(data)进行加密，得到加密后的请求数据encryptData
  4. client提供server提供的接口获取RSA公钥(rsaPublicKey)
  5. client使用获取RSA公钥(rsaPublicKey)对AES密钥(aesKey)进行加密，得到encryptAesKey

  6. client将encryptAesKey作为http请求头参数，将加密后的请求数据encryptData作为请求体一起传输给服务器端
    服务器端

    1. server 响应client的http请求，读取http请求头。获得client传过来的加密后的AES密钥(encryptAesKey)，读取http请求体，获得client传过来的加密后的请求数据(encryptData)。
    2. server使用自己的RSA私钥(rsaPrivateKey)对加密后的AES密钥(encryptAesKey)进行RSA解密，得到AES密钥(aesKey)
    3. 使用解密后的AES密钥(aesKey)对加密后的请求数据(encryptData),进行AES解密操作，得到解密后的请求数据(data)，该数据为json格式
    4. 对解密后的请求数据(data)进行json解析，然后做相关的响应操作。

这里写图片描述

<一>. MD5加密算法：
消息摘要算法第五版(Message Digest Algorithm)，是一种单向加密算法，只能加密、无法解密。然而MD5加密算法已经被中国山东大学王小云教授成功破译哭，但是在安全性要求不高的场景下，MD5加密算法仍然具有应用价值。
1. 创建md5对象：

MessageDigest md5 = MessageDigest.getInstance(“md5”);
2. 进行加密操作：
byte[] cipherData = md5.digest(plainText.getBytes());

  1. 将其中的每个字节转成十六进制字符串：byte类型的数据最高位是符号位，通过和0xff进行与操作，转换为int类型的正整数。
    Java代码
    String toHexStr = Integer.toHexString(cipher & 0xff);
  2. 如果该正数小于16(长度为1个字符)，前面拼接0占位：确保最后生成的是32位字符串。
    Java代码
    builder.append(toHexStr.length() == 1 ? “0” + toHexStr : toHexStr);
  3. 加密转换之后的字符串为：c0bb4f54f1d8b14caf6fe1069e5f93ad
  4. 完整的MD5算法应用如下所示： 
Java代码 
/** 
 * 功能简述: 测试MD5单向加密. 
 * @throws Exception 
 */  
@Test  
public void test01() throws Exception {  
    String plainText = "Hello , world !";  
    MessageDigest md5 = MessageDigest.getInstance("md5");  
    byte[] cipherData = md5.digest(plainText.getBytes());  
    StringBuilder builder = new StringBuilder();  
    for(byte cipher : cipherData) {  
        String toHexStr = Integer.toHexString(cipher & 0xff);  
        builder.append(toHexStr.length() == 1 ? "0" + toHexStr : toHexStr);  
    }  
    System.out.println(builder.toString());  
    //c0bb4f54f1d8b14caf6fe1069e5f93ad  
}

<二>. 使用BASE64进行加密/解密：
使用BASE64算法通常用作对二进制数据进行加密，加密之后的数据不易被肉眼识别。严格来说，经过BASE64加密的数据其实没有安全性可言保密，因为它的加密解密算法都是公开的，典型的防菜鸟不防程序猿的呀。 经过标准的BASE64算法加密后的数据， 通常包含/、+、=等特殊符号，不适合作为url参数传递，幸运的是Apache的Commons Codec模块提供了对BASE64的进一步封装。 (参见最后一部分的说明)
1. 使用BASE64加密：
Java代码
BASE64Encoder encoder = new BASE64Encoder();
String cipherText = encoder.encode(plainText.getBytes());
2. 使用BASE64解密：
Java代码
BASE64Decoder decoder = new BASE64Decoder();
plainText = new String(decoder.decodeBuffer(cipherText));
3. 完整代码示例：
Java代码 

/** 
 * 功能简述: 使用BASE64进行双向加密/解密. 
 * @throws Exception 
 */  
@Test  
public void test02() throws Exception {  
    BASE64Encoder encoder = new BASE64Encoder();  
    BASE64Decoder decoder = new BASE64Decoder();  
    String plainText = "Hello , world !";  
    String cipherText = encoder.encode(plainText.getBytes());  
    System.out.println("cipherText : " + cipherText);  
    //cipherText : SGVsbG8gLCB3b3JsZCAh  
    System.out.println("plainText : " +   
        new String(decoder.decodeBuffer(cipherText)));  
    //plainText : Hello , world !

<三>. 使用DES对称加密/解密：
数据加密标准算法(Data Encryption Standard)，和BASE64最明显的区别就是有一个工作密钥，该密钥既用于加密、也用于解密，并且要求密钥是一个长度至少大于8位的字符串。使用DES加密、解密的核心是确保工作密钥的安全性。叫
1. 根据key生成密钥：
Java代码 

DESKeySpec keySpec = new DESKeySpec(key.getBytes());  
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("des");  
SecretKey secretKey = keyFactory.generateSecret(keySpec);
  1. 加密操作：
    Java代码 
Cipher cipher = Cipher.getInstance("des");  
cipher.init(Cipher.ENCRYPT_MODE, secretKey, new SecureRandom());  
byte[] cipherData = cipher.doFinal(plainText.getBytes());
  1. 为了便于观察生成的加密数据，使用BASE64再次加密： 
String cipherText = new BASE64Encoder().encode(cipherData);  
 生成密文如下：PtRYi3sp7TOR69UrKEIicA==

4. 解密操作：
Java代码 

cipher.init(Cipher.DECRYPT_MODE, secretKey, new SecureRandom());  
byte[] plainData = cipher.doFinal(cipherData);  
String plainText = new String(plainData);
  1. 完整的代码demo：
    Java代码 
/** 
 * 功能简述: 使用DES对称加密/解密. 
 * http://hello-nick-xu.iteye.com/blog/2103781
 * @throws Exception 
 */  
@Test  
public void test03() throws Exception {  
    String plainText = "Hello , world !";  
    String key = "12345678";    //要求key至少长度为8个字符  

    SecureRandom random = new SecureRandom();  
    DESKeySpec keySpec = new DESKeySpec(key.getBytes());  
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("des");  
    SecretKey secretKey = keyFactory.generateSecret(keySpec);  

    Cipher cipher = Cipher.getInstance("des");  
    cipher.init(Cipher.ENCRYPT_MODE, secretKey, random);  
    byte[] cipherData = cipher.doFinal(plainText.getBytes());  
    System.out.println("cipherText : " + new BASE64Encoder().encode(cipherData));  
    //PtRYi3sp7TOR69UrKEIicA==  

    cipher.init(Cipher.DECRYPT_MODE, secretKey, random);  
    byte[] plainData = cipher.doFinal(cipherData);  
    System.out.println("plainText : " + new String(plainData));  
    //Hello , world !  
}

<四>. 使用RSA非对称加密/解密：
RSA算法是非对称加密算法的典型代表，既能加密、又能解密。和对称加密算法比如DES的明显区别在于用于加密、解密的密钥是不同的。使用RSA算法，只要密钥足够长(一般要求1024bit)，加密的信息是不能被破解的。天真用户通过https协议访问服务器时，就是使用非对称加密算法进行数据的加密、解密操作的。
服务器发送数据给客户端时使用私钥（private key）进行加密，并且使用加密之后的数据和私钥生成数字签名（digital signature）并发送给客户端。客户端接收到服务器发送的数据会使用公钥（public key）对数据来进行解密，并且根据加密数据和公钥验证数字签名的有效性，防止加密数据在传输过程中被第三方进行了修改。
客户端发送数据给服务器时使用公钥进行加密，服务器接收到加密数据之后使用私钥进行解密。
1. 创建密钥对KeyPair：
Java代码 

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("rsa");  
keyPairGenerator.initialize(1024);  //密钥长度推荐为1024位.  
KeyPair keyPair = keyPairGenerator.generateKeyPair();
  1. 获取公钥/私钥：
    Java代码 
PublicKey publicKey = keyPair.getPublic();  
PrivateKey privateKey = keyPair.getPrivate();
  1. 服务器数据使用私钥加密：
    Java代码 
Cipher cipher = Cipher.getInstance("rsa");  
cipher.init(Cipher.ENCRYPT_MODE, privateKey, new SecureRandom());  
byte[] cipherData = cipher.doFinal(plainText.getBytes());
  1. 用户使用公钥解密：
    Java代码 
cipher.init(Cipher.DECRYPT_MODE, publicKey, new SecureRandom());  
byte[] plainData = cipher.doFinal(cipherData);
  1. 服务器根据私钥和加密数据生成数字签名：
    Java代码 
Signature signature  = Signature.getInstance("MD5withRSA");  
signature.initSign(privateKey);  
signature.update(cipherData);  
byte[] signData = signature.sign();
  1. 用户根据公钥、加密数据验证数据是否被修改过：
    Java代码 
signature.initVerify(publicKey);  
signature.update(cipherData);  
boolean status = signature.verify(signData);
  1. RSA算法代码demo
Java代码 
/** 
 * 功能简述: 使用RSA非对称加密/解密. 
 * @throws Exception 
 */  
@Test  
public void test04() throws Exception {  
    String plainText = "Hello , world !";  

    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("rsa");  
    keyPairGenerator.initialize(1024);  
    KeyPair keyPair = keyPairGenerator.generateKeyPair();  

    PublicKey publicKey = keyPair.getPublic();  
    PrivateKey privateKey = keyPair.getPrivate();  

    Cipher cipher = Cipher.getInstance("rsa");  
    SecureRandom random = new SecureRandom();  

    cipher.init(Cipher.ENCRYPT_MODE, privateKey, random);  
    byte[] cipherData = cipher.doFinal(plainText.getBytes());  
    System.out.println("cipherText : " + new BASE64Encoder().encode(cipherData));  
    //gDsJxZM98U2GzHUtUTyZ/Ir/NXqRWKUJkl6olrLYCZHY3RnlF3olkWPZ35Dwz9BMRqaTL3oPuyVq  
    //sehvHExxj9RyrWpIYnYLBSURB1KVUSLMsd/ONFOD0fnJoGtIk+T/+3yybVL8M+RI+HzbE/jdYa/+  
    //yQ+vHwHqXhuzZ/N8iNg=  

    cipher.init(Cipher.DECRYPT_MODE, publicKey, random);  
    byte[] plainData = cipher.doFinal(cipherData);  
    System.out.println("plainText : " + new String(plainData));  
    //Hello , world !  

    Signature signature  = Signature.getInstance("MD5withRSA");  
    signature.initSign(privateKey);  
    signature.update(cipherData);  
    byte[] signData = signature.sign();  
    System.out.println("signature : " + new BASE64Encoder().encode(signData));  
    //ADfoeKQn6eEHgLF8ETMXan3TfFO03R5u+cQEWtAQ2lRblLZw1DpzTlJJt1RXjU451I84v3297LhR  
    //co64p6Sq3kVt84wnRsQw5mucZnY+jRZNdXpcbwh2qsh8287NM2hxWqp4OOCf/+vKKXZ3pbJMNT/4  
    ///t9ewo+KYCWKOgvu5QQ=  

    signature.initVerify(publicKey);  
    signature.update(cipherData);  
    boolean status = signature.verify(signData);  
    System.out.println("status : " + status);  
    //true  
}

下面给出工具类

package com.excelsoft.common.crypto;  

import java.io.IOException;  
import java.security.Key;  
import java.security.KeyPair;  
import java.security.KeyPairGenerator;  
import java.security.MessageDigest;  
import java.security.NoSuchAlgorithmException;  
import java.security.PrivateKey;  
import java.security.PublicKey;  
import java.security.SecureRandom;  
import java.security.Signature;  

import javax.crypto.Cipher;  
import javax.crypto.SecretKey;  
import javax.crypto.SecretKeyFactory;  
import javax.crypto.spec.DESKeySpec;  

import org.apache.commons.logging.Log;  
import org.apache.commons.logging.LogFactory;  

import sun.misc.BASE64Decoder;  
import sun.misc.BASE64Encoder;  

/** 
 * 功能简述: 加密解密工具类，对MD5/BASE64/DES/RSA等算法提供了包装. 
 * @author Nick Xu 
 * @version 1.0 
 */  
public class EncryptUtil {  
    private static Log logger = LogFactory.getLog(EncryptUtil.class);  

    private static final int KEY_SIZE = 1024;  
    private static final String  MD5_ALGORITHM= "md5";  
    private static final String  DES_ALGORITHM= "des";  
    private static final String  RSA_ALGORITHM= "rsa";  
    private static final String  SIGNATURE_ALGORITHM= "MD5withRSA";  

    private static MessageDigest md5;  
    private static BASE64Encoder encoder;  
    private static BASE64Decoder decoder;  
    private static SecureRandom random;  
    private static KeyPair keyPair;  

    private EncryptUtil() {  
    }  

    static {  
        try {  
            md5 = MessageDigest.getInstance(MD5_ALGORITHM);  

            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM);  
            keyPairGenerator.initialize(KEY_SIZE);  
            keyPair = keyPairGenerator.generateKeyPair();  
        }  
        catch (NoSuchAlgorithmException e) {  
            // Exception handler  
            logger.error(e);  
        }  
        encoder = new BASE64Encoder();  
        decoder = new BASE64Decoder();  
        random = new SecureRandom();  
    }  

    /** 
     * 功能简述: 使用md5进行单向加密. 
     */  
    public static String encryptMD5(String plainText) {  
        byte[] cipherData = md5.digest(plainText.getBytes());  
        StringBuilder builder = new StringBuilder();  
        for(byte cipher : cipherData) {  
            String toHexStr = Integer.toHexString(cipher & 0xff);  
            builder.append(toHexStr.length() == 1 ? "0" + toHexStr : toHexStr);  
        }  
        return builder.toString();  
    }  

    /** 
     * 功能简述: 使用BASE64进行加密. 
     * @param plainData 明文数据 
     * @return 加密之后的文本内容 
     */  
    public static String encryptBASE64(byte[] plainData) {  
        return encoder.encode(plainData);  
    }  

    /** 
     * 功能简述: 使用BASE64进行解密. 
     * @param cipherText 密文文本 
     * @return 解密之后的数据 
     */  
    public static byte[] decryptBASE64(String cipherText) {  
        byte[] plainData = null;  
        try {  
            plainData =  decoder.decodeBuffer(cipherText);  
        }  
        catch (IOException e) {  
            // Exception handler  
            logger.error(e);  
        }  
        return plainData;  
    }  

    /** 
     * 功能简述: 使用DES算法进行加密. 
     * @param plainData 明文数据 
     * @param key   加密密钥 
     * @return   
     */  
    public static byte[] encryptDES(byte[] plainData, String key) {  
        return processCipher(plainData, createSecretKey(key), Cipher.ENCRYPT_MODE, DES_ALGORITHM);  
    }  

    /** 
     * 功能简述: 使用DES算法进行解密. 
     * @param cipherData    密文数据 
     * @param key   解密密钥 
     * @return 
     */  
    public static byte[] decryptDES(byte[] cipherData, String key) {  
        return processCipher(cipherData, createSecretKey(key), Cipher.DECRYPT_MODE, DES_ALGORITHM);  
    }  

    /** 
     * 功能简述: 根据key创建密钥SecretKey. 
     * @param key  
     * @return 
     */  
    private static SecretKey createSecretKey(String key) {  
        SecretKey secretKey = null;  
        try {  
            DESKeySpec keySpec = new DESKeySpec(key.getBytes());  
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES_ALGORITHM);  
            secretKey = keyFactory.generateSecret(keySpec);  
        }  
        catch (Exception e) {  
            // Exception handler  
            logger.error(e);  
        }  
        return secretKey;  
    }  

    /** 
     * 功能简述: 加密/解密处理流程. 
     * @param processData   待处理的数据 
     * @param key   提供的密钥 
     * @param opsMode   工作模式 
     * @param algorithm   使用的算法 
     * @return   
     */  
    private static byte[] processCipher(byte[] processData, Key key, int opsMode, String algorithm) {  
        try{   
            Cipher cipher = Cipher.getInstance(algorithm);  
            cipher.init(opsMode, key, random);  
            return cipher.doFinal(processData);  
        }  
        catch (Exception e) {  
            // Exception handler  
            logger.error(e);  
        }  
        return null;  
    }  

    /** 
     * 功能简述: 创建私钥，用于RSA非对称加密. 
     * @return 
     */  
    public static PrivateKey createPrivateKey() {  
        return keyPair.getPrivate();  
    }  

    /** 
     * 功能简述: 创建公钥，用于RSA非对称加密. 
     * @return 
     */  
    public static PublicKey createPublicKey() {  
        return keyPair.getPublic();  
    }  

    /** 
     * 功能简述: 使用RSA算法加密. 
     * @param plainData 明文数据 
     * @param key   密钥 
     * @return 
     */  
    public static byte[] encryptRSA(byte[] plainData, Key key) {  
        return processCipher(plainData, key, Cipher.ENCRYPT_MODE, RSA_ALGORITHM);  
    }  

    /** 
     * 功能简述: 使用RSA算法解密. 
     * @param cipherData    密文数据 
     * @param key   密钥 
     * @return 
     */  
    public static byte[] decryptRSA(byte[] cipherData, Key key) {  
        return processCipher(cipherData, key, Cipher.DECRYPT_MODE, RSA_ALGORITHM);  
    }  

    /** 
     * 功能简述: 使用私钥对加密数据创建数字签名. 
     * @param cipherData     已经加密过的数据 
     * @param privateKey    私钥 
     * @return 
     */  
    public static byte[] createSignature(byte[] cipherData, PrivateKey privateKey) {  
        try {  
            Signature signature  = Signature.getInstance(SIGNATURE_ALGORITHM);  
            signature.initSign(privateKey);  
            signature.update(cipherData);  
            return signature.sign();  
        }  
        catch (Exception e) {  
            // Exception handler  
            logger.error(e);   
        }  
        return null;  
    }  

    /** 
     * 功能简述: 使用公钥对数字签名进行验证. 
     * @param signData  数字签名 
     * @param publicKey 公钥 
     * @return 
     */  
    public static boolean verifySignature(byte[] cipherData, byte[] signData, PublicKey publicKey) {  
        try {  
            Signature signature  = Signature.getInstance(SIGNATURE_ALGORITHM);  
            signature.initVerify(publicKey);  
            signature.update(cipherData);  
            return signature.verify(signData);  
        }  
        catch (Exception e) {  
            // Exception handler  
            logger.error(e);  
        }  
        return false;  
    }  
}
不在的诱惑
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java版本大数据各种算法集合
09-23
18大数据挖掘的经典算法以及代码实现，涉及到了决策分类，聚类，链接挖掘，关联挖掘，模式挖掘等等方面,后面都是相应算法。
基础夯实：基础数据结构与算法(二)
熊泽-学习中的苦与乐
01-19 3455
基础夯实：基础数据结构与算法（二）常见的10种算法1、递归算法例题1：计算n！例题2：斐波那契数列例题3：递归将整形数字转换为字符串例题4：汉诺塔例题5：猴子吃桃例题6：N皇后问题2、排序算法冒泡排序：快速排序：3、二分查找算法4、搜索算法5、哈希算法6、贪心算法7、分治算法求x的n次幂归并排序8、回溯算法9、动态规划(DP)算法10、字符串匹配算法参考文献 上一章我们说了常见的10种数据结构，接下来我们说常见的10种算法。 上一章地址：基础夯实：基础数据结构与算法(一)，不怎么清楚的可以去瞅瞅。 常见的1
非对称性密钥加密 java 实例_JAVA加密算法（4）- 非对称加密算法（DH，RSA）
weixin_36330518的博客
02-13 235
非对称密码概念发送者使用接收者的公钥加密，接收者使用自己的私钥解密。需要两个密钥进行加密或解密，分为公钥和私钥特点：安全性高，速度慢常用算法DH密钥交换算法RSA算法ElGamal算法那用途密钥交换(DH)双方在没有确定共同密钥的情况下，生成密钥，不提供加密工作，加解密还需要其他对称加密算法实现加密/解密(RSA)数字签名(RSA)DH算法示例import javax.crypto.KeyAgre...
常见算法大全
G_GUi的博客
07-30 1万+
要找到撒列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。在机器学习中，基于基本的梯度下降法发展了两种梯度下降方法，分别为随机梯度下降法和批量梯度下降法。在求解损失函数的最小值时，可以通过梯度下降法来一步步的迭代求解，得到最小化的损失函数和模型参数值。堆是一个近似完全二叉树的结构，并同时满足堆积的性质即子结点的键值或索引总是小于（或者大于）它的父节点。22.最大流量算法、......
常见的10种算法(经典)
gb4215287的博客
04-17 1万+
经典算法
Zookeeper的Paxos算法，（2P/3P/CAP/BASE）一致性协议简单介绍
cxw0的博客
10-24 1766
2P/3P提交（为了保证事务的ACID） 2P 就是二段提交（RDBMS经常就这种机制，保证强一致性），3P就是三段提交； 2P提交 -- 1阶段：提交事务请求（投票阶段）               2P提交 -- 2阶段：执行事务的提交（commit、rollback的情况）              3P提交- 阶段1：是否提交 3P提交- 阶段2：预先提交 3P提交-...
java 各种算法集合
07-06
里面写了 很多种java排序算法 希望可以帮到需要的人呢
各种算法大集合
10-21
里面集合了各种排序算法、控制算法、查找算法、压缩算法等等。
Python算法集合
10-10
Python算法集合，Python用实现了所有算法，排序、等等
C# 算法集源代码C# 实现的各种算法的集合
最新发布
03-07
用于教育目的，C# 实现的各种算法的集合。存储库是用 C# 实现的各种算法的集合。这些算法涵盖各种主题 从计算机科学、数学和统计学、数据科学、机器学习、工程学等。实现 及其相关文档旨在为教育工作者和学生提供...
经典算法集合
07-10
里面包含了<br>费式数列 、巴斯卡三角形 、三色棋 、老鼠走迷官（一） 、老鼠走迷官（二） 、八个皇后 、八枚银币、 生命游戏 字串核对、 <br>双色、三色河内塔 等经典的算法。<br>
超级经典算法大集合
03-02
超级经典算法大集合：老掉牙 河内塔 费式数列 巴斯卡三角形 三色棋 老鼠走迷官（一） 老鼠走迷官（二） 骑士走棋盘 八个皇后 八枚银币 生命游戏 字串核对
十大基本算法介绍
热门推荐
_陌默
05-17 8万+
转载地址：https://www.cnblogs.com/onepixel/articles/7674659.html 一、算法概述： 1.算法分类： 十种常见算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能超过Q(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下限， 以...
十种常用的算法
Juwenile的博客
02-29 888
分治算法 一：分治算法介绍 1）：分治算法是一种很重的算法，在字面上解释就是“分而治之”，就是将一个复杂的问题先分成两个或者更多的相同或者是相似的子问题，再把子问题分成更小的子问题。。。。直到最后的子问题可以简单直接求解，原问题的解即子问题的解的合并。这个技巧 是很多高效算法的基础，如排序算法（快速排序，归并排序等）。傅里叶变换等 2）：分治算法可以求解一些经典问题： 二分搜索 大整数乘法 棋盘...
Zookeeper 系统学习二--Base理论、2P、3P、Paxos 算法、ZAB协议
qq_16681279的博客
03-12 513
ZAB 协议 其他理论原谅我没耐心看下去~后续补充，祝 心情愉快~后续会写接手的电商+金融类两个分布式项目的架构和设计思想。以及各个环节的优化。
常考算法总结
u010006156的博客
05-21 613
文章目录 前言 分而治之 动态规划 贪心算法 回溯算法 分支限界 前言 本篇介绍算法的五大算法思想，如果还不了解算法的基础概念请看一下这篇文章： 初识数据结构和算法 分而治之 把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题，直到最后子问题小到可 以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序， 归并排序)，傅立叶变换(快速傅立叶变换)，大数据中的MR，现实中如汉诺塔游戏。 分治法对问题有一定的要求: 该问题缩小到一定
密钥生成器KeyPairGenerator
kimi
02-22 2799
密钥生成器KeyPairGenerator
20.6 常用集合算法
qq_32513033的博客
08-20 303
20.6 常用集合算法 算法简介： set_intersection//求两个容器的交集 set_union//求两个容器的并集 set_difference//求两个容器的差集 1、set_intersection 功能描述： 求两个容器的交集 函数原型：I set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest); //求两个集合的交集 //注意：两个集合必须是有序序列
【算法系列（五）】：集合
wxplol的博客
09-08 303
集合技术在解题中主要用于处理有数据重复出现的问题。这里直接看leetcode题库的实例来感受下吧。。。 一、算法应用 349. 两个数组的交集 题目描述 给定两个数组，编写一个函数来计算它们的交集。 示例 1： 输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2] 示例 2： 输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[9,4] 解题思路 直接利用集合这种结构 c++代码实现 vector<int> i
python 贪心算法集合覆盖的近似算法
11-14
以下是Python中贪心算法集合覆盖的近似算法的实现： ```python # 创建广播台清单 stations = {} stations['KONE'] = set(['ID', 'NV', 'UT']) stations['KTWO'] = set(['WA', 'ID', 'MT']) stations['KTHREE'] = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值