浅谈常见的七种验签以及加密算法实现

前言
数字签名、信息加密是前后端开发都经常需要使用到的技术，应用场景包括了用户登入、交易、信息通讯、oauth 等等，不同的应用场景也会需要使用到不同的签名加密算法，或者需要搭配不一样的签名加密算法来达到业务目标。这里简单的给大家介绍几种常见的签名加密算法和一些典型场景下的应用。

正文

数字签名
数字签名，简单来说就是通过提供可鉴别的数字信息验证自身身份的一种方式。一套数字签名通常定义两种互补的运算，一个用于签名，另一个用于验证。分别由发送者持有能够代表自己身份的私钥 (私钥不可泄露),由接受者持有与私钥对应的公钥，能够在接受到来自发送者信息时用于验证其身份。

注意：图中加密过程有别于公钥加密，更多介绍戳这里。签名最根本的用途是要能够唯一证明发送方的身份，防止中间人攻击、CSRF 跨域身份伪造。基于这一点在诸如设备认证、用户认证、第三方认证等认证体系中都会使用到签名算法 (彼此的实现方式可能会有差异)。

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

2.2. 解密
加密的逆过程为解密，即将该编码信息转化为其原来数据的过程。

对称加密和非对称加密
加密算法分对称加密和非对称加密，其中对称加密算法的加密与解密密钥相同，非对称加密算法的加密密钥与解密密钥不同，此外，还有一类不需要密钥的散列算法。

常见的对称加密算法主要有 DES、3DES、AES 等，常见的非对称算法主要有 RSA、DSA 等，散列算法主要有 SHA-1、MD5 等。

3.1. 对称加密
对称加密算法是应用较早的加密算法，又称为共享密钥加密算法。在对称加密算法中，使用的密钥只有一个，发送和接收双方都使用这个密钥对数据进行加密和解密。这就要求加密和解密方事先都必须知道加密的密钥。

数据加密过程：在对称加密算法中，数据发送方将明文 (原始数据) 和加密密钥一起经过特殊加密处理，生成复杂的加密密文进行发送。

数据解密过程：数据接收方收到密文后，若想读取原数据，则需要使用加密使用的密钥及相同算法的逆算法对加密的密文进行解密，才能使其恢复成可读明文。

3.2. 非对称加密
非对称加密算法，又称为公开密钥加密算法。它需要两个密钥，一个称为公开密钥 (public key)，即公钥，另一个称为私有密钥 (private key)，即私钥。

因为加密和解密使用的是两个不同的密钥，所以这种算法称为非对称加密算法。

如果使用公钥对数据进行加密，只有用对应的私钥才能进行解密。

如果使用私钥对数据进行加密，只有用对应的公钥才能进行解密。

例子：甲方生成一对密钥并将其中的一把作为公钥向其它人公开，得到该公钥的乙方使用该密钥对机密信息进行加密后再发送给甲方，甲方再使用自己保存的另一把专用密钥 (私钥)，对加密后的信息进行解密。

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

public static final byte[] computeMD5(byte[] content) {
try {
MessageDigest md5 = MessageDigest.getInstance(“MD5”);
return md5.digest(content);
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}

4.2. SHA1算法
SHA1 是和 MD5 一样流行的消息摘要算法，然而 SHA1 比 MD5 的安全性更强。对于长度小于 2 ^ 64 位的消息，SHA1 会产生一个 160 位的消息摘要。基于 MD5、SHA1 的信息摘要特性以及不可逆 (一般而言)，可以被应用在检查文件完整性以及数字签名等场景。

public static byte[] computeSHA1(byte[] content) {
try {
MessageDigest sha1 = MessageDigest.getInstance(“SHA1”);
return sha1.digest(content);
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
}
}

4.3. HMAC算法
HMAC 是密钥相关的哈希运算消息认证码（Hash-based Message Authentication Code），HMAC 运算利用哈希算法 (MD5、SHA1 等)，以一个密钥和一个消息为输入，生成一个消息摘要作为输出。

HMAC 发送方和接收方都有的 key 进行计算，而没有这把 key 的第三方，则是无法计算出正确的散列值的，这样就可以防止数据被篡改。

package net.pocrd.util;
import net.pocrd.annotation.NotThreadSafe;
import net.pocrd.define.ConstField;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Arrays;

@NotThreadSafe
public class HMacHelper {
private static final Logger logger = LoggerFactory.getLogger(HMacHelper.class);
private Mac mac;

/**
 * MAC算法可选以下多种算法
 * HmacMD5/HmacSHA1/HmacSHA256/HmacSHA384/HmacSHA512
 */
private static final String KEY_MAC = "HmacMD5";
public HMacHelper(String key) {
    try {
        SecretKey secretKey = new SecretKeySpec(key.getBytes(ConstField.UTF8), KEY_MAC);
        mac = Mac.getInstance(secretKey.getAlgorithm());
        mac.init(secretKey);
    } catch (Exception e) {
        logger.error("create hmac helper failed.", e);
    }
}
public byte[] sign(byte[] content) {
    return mac.doFinal(content);
}

public boolean verify(byte[] signature, byte[] content) {
    try {
        byte[] result = mac.doFinal(content);
        return Arrays.equals(signature, result);
    } catch (Exception e) {
        logger.error("verify sig failed.", e);
    }
    return false;
}

}

测试结论：HMAC 算法实例在多线程环境下是不安全的。但是需要在多线程访问时，进行同步的辅助类，使用 ThreadLocal 为每个线程缓存一个实例可以避免进行锁操作。

4.4. AES/DES/3DES算法
AES、DES、3DES 都是对称的块加密算法，加解密的过程是可逆的。常用的有 AES128、AES192、AES256 (默认安装的 JDK 尚不支持 AES256，需要安装对应的 jce 补丁进行升级 jce1.7，jce1.8)。

4.4.1. DES算法
DES 加密算法是一种分组密码，以 64 位为分组对数据加密，它的密钥长度是 56 位，加密解密用同一算法。

DES 加密算法是对密钥进行保密，而公开算法，包括加密和解密算法。这样，只有掌握了和发送方相同密钥的人才能解读由 DES加密算法加密的密文数据。因此，破译 DES 加密算法实际上就是搜索密钥的编码。对于 56 位长度的密钥来说，如果用穷举法来进行搜索的话，其运算次数为 2 ^ 56 次。

4.4.2. 3DES算法
是基于 DES 的对称算法，对一块数据用三个不同的密钥进行三次加密，强度更高。

4.4.3. AES算法
AES 加密算法是密码学中的高级加密标准，该加密算法采用对称分组密码体制，密钥长度的最少支持为 128 位、 192 位、256 位，分组长度 128 位，算法应易于各种硬件和软件实现。这种加密算法是美国联邦政府采用的区块加密标准。

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

import net.pocrd.annotation.NotThreadSafe;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;

@NotThreadSafe
public class AesHelper {
private SecretKeySpec keySpec;
private IvParameterSpec iv;

public AesHelper(byte[] aesKey, byte[] iv) {
    if (aesKey == null || aesKey.length < 16 || (iv != null && iv.length < 16)) {
        throw new RuntimeException("错误的初始密钥");
    }
    if (iv == null) {
        iv = Md5Util.compute(aesKey);
    }
    keySpec = new SecretKeySpec(aesKey, "AES");
    this.iv = new IvParameterSpec(iv);
}

public AesHelper(byte[] aesKey) {
    if (aesKey == null || aesKey.length < 16) {
        throw new RuntimeException("错误的初始密钥");
    }
    keySpec = new SecretKeySpec(aesKey, "AES");
    this.iv = new IvParameterSpec(Md5Util.compute(aesKey));
}

public byte[] encrypt(byte[] data) {
    byte[] result = null;
    Cipher cipher = null;
    try {
        cipher = Cipher.getInstance("AES/CFB/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
        result = cipher.doFinal(data);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return result;
}

public byte[] decrypt(byte[] secret) {
    byte[] result = null;
    Cipher cipher = null;
    try {
        cipher = Cipher.getInstance("AES/CFB/NoPadding");
        cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
        result = cipher.doFinal(secret);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return result;
}

public static byte[] randomKey(int size) {
    byte[] result = null;
    try {
        KeyGenerator gen = KeyGenerator.getInstance("AES");
        gen.init(size, new SecureRandom());
        result = gen.generateKey().getEncoded();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return result;
}

}

4.5. RSA算法
RSA 加密算法是目前最有影响力的公钥加密算法，并且被普遍认为是目前最优秀的公钥方案之一。RSA 是第一个能同时用于加密和数字签名的算法，它能够抵抗到目前为止已知的所有密码攻击，已被 ISO 推荐为公钥数据加密标准。

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

import net.pocrd.annotation.NotThreadSafe;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.Security;
import java.security.Signature;
import java.security.interfaces.RSAPrivateCrtKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

@NotThreadSafe
public class RsaHelper {
private static final Logger logger = LoggerFactory.getLogger(RsaHelper.class);
private RSAPublicKey publicKey;
private RSAPrivateCrtKey privateKey;

static {
    Security.addProvider(new BouncyCastleProvider()); //使用bouncycastle作为加密算法实现
}

public RsaHelper(String publicKey, String privateKey) {
    this(Base64Util.decode(publicKey), Base64Util.decode(privateKey));
}

public RsaHelper(byte[] publicKey, byte[] privateKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        if (publicKey != null && publicKey.length > 0) {
            this.publicKey = (RSAPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
        }
        if (privateKey != null && privateKey.length > 0) {
            this.privateKey = (RSAPrivateCrtKey)keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public RsaHelper(String publicKey) {
    this(Base64Util.decode(publicKey));
}

public RsaHelper(byte[] publicKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        if (publicKey != null && publicKey.length > 0) {
            this.publicKey = (RSAPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public byte[] encrypt(byte[] content) {
    if (publicKey == null) {
        throw new RuntimeException("public key is null.");
    }

    if (content == null) {
        return null;
    }

    try {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int size = publicKey.getModulus().bitLength() / 8 - 11;
        ByteArrayOutputStream baos = new ByteArrayOutputStream((content.length + size - 1) / size * (size + 11));
        int left = 0;
        for (int i = 0; i < content.length; ) {
            left = content.length - i;
            if (left > size) {
                cipher.update(content, i, size);
                i += size;
            } else {
                cipher.update(content, i, left);
                i += left;
            }
            baos.write(cipher.doFinal());
        }
        return baos.toByteArray();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public byte[] decrypt(byte[] secret) {
    if (privateKey == null) {
        throw new RuntimeException("private key is null.");
    }

    if (secret == null) {
        return null;
    }

    try {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        int size = privateKey.getModulus().bitLength() / 8;
        ByteArrayOutputStream baos = new ByteArrayOutputStream((secret.length + size - 12) / (size - 11) * size);
        int left = 0;
        for (int i = 0; i < secret.length; ) {
            left = secret.length - i;
            if (left > size) {
                cipher.update(secret, i, size);
                i += size;
            } else {
                cipher.update(secret, i, left);
                i += left;
            }
            baos.write(cipher.doFinal());
        }
        return baos.toByteArray();
    } catch (Exception e) {
        logger.error("rsa decrypt failed.", e);
    }
    return null;
}

public byte[] sign(byte[] content) {
    if (privateKey == null) {
        throw new RuntimeException("private key is null.");
    }
    if (content == null) {
        return null;
    }
    try {
        Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initSign(privateKey);
        signature.update(content);
        return signature.sign();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public boolean verify(byte[] sign, byte[] content) {
    if (publicKey == null) {
        throw new RuntimeException("public key is null.");
    }
    if (sign == null || content == null) {
        return false;
    }
    try {
        Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initVerify(publicKey);
        signature.update(content);
        return signature.verify(sign);
    } catch (Exception e) {
        logger.error("rsa verify failed.", e);
    }
    return false;
}

}

4.6. ECC算法
ECC 也是一种非对称加密算法，主要优势是在某些情况下，它比其他的方法使用更小的密钥，比如 RSA 加密算法，提供相当的或更高等级的安全级别。不过一个缺点是加密和解密操作的实现比其他机制时间长 (相比 RSA 算法，该算法对 CPU 消耗严重)。

import net.pocrd.annotation.NotThreadSafe;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.Security;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

@NotThreadSafe
public class EccHelper {
private static final Logger logger = LoggerFactory.getLogger(EccHelper.class);
private static final int SIZE = 4096;
private BCECPublicKey publicKey;
private BCECPrivateKey privateKey;

static {
    Security.addProvider(new BouncyCastleProvider());
}

public EccHelper(String publicKey, String privateKey) {
    this(Base64Util.decode(publicKey), Base64Util.decode(privateKey));
}

public EccHelper(byte[] publicKey, byte[] privateKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
        if (publicKey != null && publicKey.length > 0) {
            this.publicKey = (BCECPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
        }
        if (privateKey != null && privateKey.length > 0) {
            this.privateKey = (BCECPrivateKey)keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));
        }
    } catch (ClassCastException e) {
        throw new RuntimeException("", e);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public EccHelper(String publicKey) {
    this(Base64Util.decode(publicKey));
}

public EccHelper(byte[] publicKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
        if (publicKey != null && publicKey.length > 0) {
            this.publicKey = (BCECPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public byte[] encrypt(byte[] content) {
    if (publicKey == null) {
        throw new RuntimeException("public key is null.");
    }
    try {
        Cipher cipher = Cipher.getInstance("ECIES", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int size = SIZE;
        ByteArrayOutputStream baos = new ByteArrayOutputStream((content.length + size - 1) / size * (size + 45));
        int left = 0;
        for (int i = 0; i < content.length; ) {
            left = content.length - i;
            if (left > size) {
                cipher.update(content, i, size);
                i += size;
            } else {
                cipher.update(content, i, left);
                i += left;
            }
            baos.write(cipher.doFinal());
        }
        return baos.toByteArray();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public byte[] decrypt(byte[] secret) {
    if (privateKey == null) {
        throw new RuntimeException("private key is null.");
    }
    try {
        Cipher cipher = Cipher.getInstance("ECIES", "BC");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        int size = SIZE + 45;
        ByteArrayOutputStream baos = new ByteArrayOutputStream((secret.length + size + 44) / (size + 45) * size);
        int left = 0;
        for (int i = 0; i < secret.length; ) {
            left = secret.length - i;
            if (left > size) {
                cipher.update(secret, i, size);
                i += size;
            } else {
                cipher.update(secret, i, left);
                i += left;
            }
            baos.write(cipher.doFinal());
        }
        return baos.toByteArray();
    } catch (Exception e) {
        logger.error("ecc decrypt failed.", e);
    }
    return null;
}

public byte[] sign(byte[] content) {
    if (privateKey == null) {
        throw new RuntimeException("private key is null.");
    }
    try {
        Signature signature = Signature.getInstance("SHA1withECDSA", "BC");
        signature.initSign(privateKey);
        signature.update(content);
        return signature.sign();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public boolean verify(byte[] sign, byte[] content) {
    if (publicKey == null) {
        throw new RuntimeException("public key is null.");
    }
    try {
        Signature signature = Signature.getInstance("SHA1withECDSA", "BC");
        signature.initVerify(publicKey);
        signature.update(content);
        return signature.verify(sign);
    } catch (Exception e) {
        logger.error("ecc verify failed.", e);
    }
    return false;
}

}

各种加密算法对比
5.1. 散列算法比较
名称安全性速度
SHA-1 高慢
MD5 中快
5.2. 对称加密算法比较
名称密钥名称运行速度安全性资源消耗
DES 56位较快低中
3DES 112位或168位慢中高
AES 128、192、256位快高低
5.3. 非对称加密算法比较
名称成熟度安全性运算速度资源消耗
RSA 高高中中
ECC 高高慢高
5.4. 对称算法与非对称加密算法
5.4.1. 对称算法
密钥管理：比较难，不适合互联网，一般用于内部系统

安全性：中

加密速度：快好几个数量级 (软件加解密速度至少快 100 倍，每秒可以加解密数 M 比特数据)，适合大数据量的加解密处理

5.4.2. 非对称算法
密钥管理：密钥容易管理

安全性：高

加密速度：比较慢，适合小数据量加解密或数据签名

小结
本文介绍了数字签名，加密和解密，对称加密和非对称加密，然后详细介绍了 MD5，SHA-1，HMAC，DES/AES，RSA 和 ECC 这几种加密算法和代码示例。
————————————————
版权声明：本文为CSDN博主「零壹技术栈」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/baidu_22254181/article/details/82594072

对称加密：密钥只有一个，解密、解密都是这个密码，加解密速度快，典型的对称加密有DES、AES、RC4等
非对称加密:密钥成对出现，分别为公钥和私钥，从公钥无法推知私钥，反之，从私钥也无法推知公钥，加密和解密使用不同的密钥，公钥加密需要私钥解密，反之，私钥加密需要公钥解密。非对称加密速度较慢，典型的非对称算法有：RSA,DSA,DSS.
Hash算法，这是一种不可逆的算法，它常用于验证数据的完整性。
对称加密：下面介绍AES：

AES是典型的对称加密算法，假设发送方要获取用户信息，如果没有任何加密算法，发送方发送的是一个明文信息"获取用户信息"，

未加密的情况下：

如果消息在网络传输中被人截获，即使无法篡改，也可以偷窥消息的内容，从而暴露了通信双方的私密。

加密的情况：

具体的工作的步骤如下：

发送方利用密钥123456，加密明文为"获取用户信息",加密结果为aaCURzhJGiOYIujQYwbocw==。
发送方把加密后的你内筒aaCURzhJGiOYIujQYwbocw传送给接收方。
接收方收到密文aaCURzhJGiOYIujQYwbocw，利用密钥123456还原为明文“获取用户信息”。
对称加密算法是可逆的，它的主要作用是保证私密信息不被泄露。

AES 算法的基本概念：密钥、填充、模式。

密钥：AES 支持三种长度的密钥：128位，192位，256位，位数越多，安全性越高
填充：
1.NoPadding:不做任何填充，但是要求明文必须是16字节的整数倍

          2.PKCS5PAdding(默认)：如果明文少于128bit,在明文末尾不足相应数量的字节，最后一个字符值等于缺少的自己数，其他字符填充随机数。

模式：ESB模式(默认)、CBC模式、CTR模式、CTR模式、CFB模式、OFB模式等
MD5算法：

MD5算法就是信息摘要的一种实现，它可以从任意长度的明文字符串生成128位的哈希值。

下面以支付宝转账为例：

不用MD5加密：

被篡改的情况下：

这种场景下就需要信息摘要技术了。信息摘要要把明文内容按某种规则生成一端哈希值，即使明文信息只改动了一点，生成的记过也完全不同。

信息摘要生成规则( secret+param+secret):可以任意添加，只要客户端和服务端加密规则一样就可以。

信息摘要的三个步骤：

1.收集相关业务参数，这里是金额和目标账户。

2.按照拼接规则拼接起来

3.利用MD5加密，生成128位的二进制

客户端使用MD5(secret+金额_10000+目标账户_12345678+secret)生成MD5

服务端收到后获取到用户发送的三处，也使用相同的拼接规则进行加密：然后比对客户端传过来的MD5和生成的MD5，如相同，则签名对比成功，信息没被篡改。

非对称加密：SHA

SHA也是一种生成信息摘要的算法，SHA有很多版本，最大的版本分类是SHA-1和SHA-2，SHA-2又分了很多子版本；

常用：
概述
md5及RSA加密算法是我们比较常见的两种加密算法，也是经常使用到的。我主要是利用md5的C Lib库实现md5加密功能，使用openssl库API实现RSA加密。这里做个笔记，下次用到就可以直接使用了。

MD5
MD5消息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。（摘自维基百科）

对于MD5加密，现在主要用于校验的一个功能，比如文件传输中，服务器预先给文件计算md5值，在客户下载时同时把md5值发送给客户，客户通过计算文件的md5值，比对两个值是否相等来判断文件下载是否成功。

这里是我的代码地址：https://github.com/dancersky/md5_demo.

RSA
RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。（摘自维基百科）

非对称加密需要两个密钥，一个公钥一个私钥。一般都是私钥是自己保管好不给任何人，公钥可以发布。对于明文，使用公钥加密则需用私钥解密，反之用私钥加密则需用公钥解密。

我这边主要是利用openssl的C库，实现了对明文的RSA加解密。主要环境在ubuntu14.04上。

这里是我代码地址以及公钥私钥生成的一些说明：https://github.com/dancersky/rsa_demo.
————————————————
版权声明：本文为CSDN博主「Dancer__Sky」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

————————————————
版权声明：本文为CSDN博主「IT_搬运工」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/fd2025/article/details/80035647

浅谈常见的七种验签以及加密算法实现

公司刚入职了一名 Java 中级开发，短短 4 行代码居然凑齐了 3 个 bug！我哭了~~

公众号5月C#/.NET热文一览

git 下载大陆镜像地址

Ubuntu-Yum方式的安裝

Python各進制轉換

UART SPI I2C 接口介紹轉載

Unistall Product

MarkDown 重新找回密碼 N久後再次登陸還是要多記錄

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結