手写区块链（二）：区块链开发中的密码学知识

手写区块链中会采用各种密码学知识

对称加密-加密秘钥和解密秘钥是同一个，缺点是秘钥无法被安全传递，常用的对称加密算法有

DES,3DES（TripleDES），AES

非对称加密-公钥加密，私钥解密

公钥由私钥生成，私钥可以推导出公钥，公钥无法推导出私钥。优点：解决秘钥传输中的安全行问题。

常用算法RSA,ECC

如何验证发送方是正确的

哈希：将一段数据经过计算转换成一段定长数据

不可逆性：几乎无法通过哈希推导出原文

无碰撞性：两个不同的原文hash后值一定不一样

常用算法MD5,SHA256

数字签名

公私钥对，私钥签名，公钥解签名

下面是这几个签名算法的具体java实现

package com.fj.blockchainmy.security;

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;import java.security.MessageDigest;

/** * @author: yangchun * @description: * @date: Created in 2019-11-12 15:38 */public class Coder {    public static final String KEY_SHA = "SHA";    public static final String KEY_MD5 = "MD5";

    /**     * MAC算法可选以下多种算法     *     * <pre>     * HmacMD5     * HmacSHA1     * HmacSHA256     * HmacSHA384     * HmacSHA512     * </pre>     */    public static final String KEY_MAC = "HmacMD5";

    /**     * BASE64解密     *     * @param key     * @return     * @throws Exception     */    public static byte[] decryptBASE64(String key) throws Exception {        return (new BASE64Decoder()).decodeBuffer(key);    }

    /**     * BASE64加密     *     * @param key     * @return     * @throws Exception     */    public static String encryptBASE64(byte[] key) throws Exception {        return (new BASE64Encoder()).encodeBuffer(key);    }

    /**     * MD5加密     *     * @param data     * @return     * @throws Exception     */    public static byte[] encryptMD5(byte[] data) throws Exception {

        MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);        md5.update(data);

        return md5.digest();

    }

    /**     * SHA加密     *     * @param data     * @return     * @throws Exception     */    public static byte[] encryptSHA(byte[] data) throws Exception {

        MessageDigest sha = MessageDigest.getInstance(KEY_SHA);        sha.update(data);

        return sha.digest();

    }

    /**     * 初始化HMAC密钥     *     * @return     * @throws Exception     */    public static String initMacKey() throws Exception {        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);

        SecretKey secretKey = keyGenerator.generateKey();        return encryptBASE64(secretKey.getEncoded());    }

    /**     * HMAC加密     *     * @param data     * @param key     * @return     * @throws Exception     */    public static byte[] encryptHMAC(byte[] data, String key) throws Exception {

        SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);        Mac mac = Mac.getInstance(secretKey.getAlgorithm());        mac.init(secretKey);

        return mac.doFinal(data);

    }}

package com.fj.blockchainmy.security;

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

import javax.crypto.Cipher;import java.security.*;import java.security.interfaces.RSAPrivateKey;import java.security.interfaces.RSAPublicKey;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.HashMap;import java.util.Map;

/** * @author: yangchun * @description: * @date: Created in 2019-11-12 15:24 */public class RSACoder extends Coder{    public static final String KEY_ALGORITHM = "RSA";    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    private static final String PUBLIC_KEY = "RSAPublicKey";    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**     * 用私钥对信息生成数字签名     *     * @param data     *            加密数据     * @param privateKey     *            私钥     *     * @return     * @throws Exception     */    public static String sign(byte[] data, String privateKey) throws Exception {        // 解密由base64编码的私钥        byte[] keyBytes = decryptBASE64(privateKey);

        // 构造PKCS8EncodedKeySpec对象        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

        // KEY_ALGORITHM 指定的加密算法        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        // 取私钥匙对象        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 用私钥对信息生成数字签名        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);        signature.initSign(priKey);        signature.update(data);

        return encryptBASE64(signature.sign());    }

    /**     * 校验数字签名     *     * @param data     *            加密数据     * @param publicKey     *            公钥     * @param sign     *            数字签名     *     * @return 校验成功返回true 失败返回false     * @throws Exception     *     */    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {

        // 解密由base64编码的公钥        byte[] keyBytes = decryptBASE64(publicKey);

        // 构造X509EncodedKeySpec对象        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

        // KEY_ALGORITHM 指定的加密算法        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        // 取公钥匙对象        PublicKey pubKey = keyFactory.generatePublic(keySpec);

        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);        signature.initVerify(pubKey);        signature.update(data);

        // 验证签名是否正常        return signature.verify(decryptBASE64(sign));    }

    /**     * 解密<br>     * 用私钥解密     *     * @param data     * @param key     * @return     * @throws Exception     */    public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {        // 对密钥解密        byte[] keyBytes = decryptBASE64(key);

        // 取得私钥        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 对数据解密        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        return cipher.doFinal(data);    }

    /**     * 解密<br>     * 用公钥解密     *     * @param data     * @param key     * @return     * @throws Exception     */    public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception {        // 对密钥解密        byte[] keyBytes = decryptBASE64(key);

        // 取得公钥        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        Key publicKey = keyFactory.generatePublic(x509KeySpec);

        // 对数据解密        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.DECRYPT_MODE, publicKey);

        return cipher.doFinal(data);    }

    /**     * 加密<br>     * 用公钥加密     *     * @param data     * @param key     * @return     * @throws Exception     */    public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception {        // 对公钥解密        byte[] keyBytes = decryptBASE64(key);

        // 取得公钥        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        Key publicKey = keyFactory.generatePublic(x509KeySpec);

        // 对数据加密        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        return cipher.doFinal(data);    }

    /**     * 加密<br>     * 用私钥加密     *     * @param data     * @param key     * @return     * @throws Exception     */    public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception {        // 对密钥解密        byte[] keyBytes = decryptBASE64(key);

        // 取得私钥        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 对数据加密        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.ENCRYPT_MODE, privateKey);

        return cipher.doFinal(data);    }

    /**     * 取得私钥     *     * @param keyMap     * @return     * @throws Exception     */    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {        Key key = (Key) keyMap.get(PRIVATE_KEY);

        return encryptBASE64(key.getEncoded());    }

    /**     * 取得公钥     *     * @param keyMap     * @return     * @throws Exception     */    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {        Key key = (Key) keyMap.get(PUBLIC_KEY);

        return encryptBASE64(key.getEncoded());    }

    /**     * 初始化密钥     *     * @return     * @throws Exception     */    public static Map<String, Object> initKey() throws Exception {        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);        keyPairGen.initialize(1024);

        KeyPair keyPair = keyPairGen.generateKeyPair();

        // 公钥        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

        // 私钥        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        Map<String, Object> keyMap = new HashMap<String, Object>(2);

        keyMap.put(PUBLIC_KEY, publicKey);        keyMap.put(PRIVATE_KEY, privateKey);        return keyMap;    }}

package com.blockchain.security;

import java.security.MessageDigest;import java.util.UUID;

import org.eclipse.jetty.util.security.Credential.MD5;

/** * 加密工具类 *  * @author aaron.rao * */public class CryptoUtil {   private CryptoUtil() {   }

   public static String SHA256(String str) {      MessageDigest messageDigest;      String encodeStr = "";      try {         messageDigest = MessageDigest.getInstance("SHA-256");         messageDigest.update(str.getBytes("UTF-8"));         encodeStr = byte2Hex(messageDigest.digest());      } catch (Exception e) {         System.out.println("getSHA256 is error" + e.getMessage());      }      return encodeStr;   }

   public static String MD5(String str) {      String resultStr = MD5.digest(str);      return resultStr.substring(4, resultStr.length());   }

   public static String UUID() {      return UUID.randomUUID().toString().replaceAll("\\-", "");   }

   private static String byte2Hex(byte[] bytes) {      StringBuilder builder = new StringBuilder();      String temp;      for (int i = 0; i < bytes.length; i++) {         temp = Integer.toHexString(bytes[i] & 0xFF);         if (temp.length() == 1) {            builder.append("0");         }         builder.append(temp);      }      return builder.toString();   }

}

原文地址：https://www.cnblogs.com/xiaofeiyang/p/11842509.html