ECCDSA加签验签工具类, base64编码

最新推荐文章于 2023-03-22 14:18:36 发布
最新推荐文章于 2023-03-22 14:18:36 发布
阅读量400 收藏
点赞数
文章标签： base64 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26412535/article/details/113251226
版权

对传入参数, 按照key首字母降序排序
json序列化后, 进行 sha256 加密, 结果使用base64编码获取hash
hash进行ECCDSA加密

package cn.box365.ipfs.utils;

import com.alibaba.fastjson.JSONObject;
import sun.misc.BASE64Decoder;

import javax.xml.bind.DatatypeConverter;
import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.security.*;
import java.security.spec.ECGenParameterSpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.*;

/**
 * ECCDSA加签验签工具类
 * @author Administrator
 *
 */
public class ECDSAUtil {
	
	 private static final String SIGNALGORITHMS = "SHA256withECDSA";
	 private static final String ALGORITHM = "EC";
	 private static final String SECP256K1 = "secp256k1";

    public static final String PRIVATE_KEY_PATH = "\\src\\main\\resources\\pem\\eccprivate_pkcs8.pem";
    public static final String PUBLIC_KEY_PATH = "\\src\\main\\resources\\pem\\eccpublic_pkcs8.pem";

    public static String HOST_URL;


    static {
        if (BlackBoxHttpUtil.IF_FORMAL) {
            //ipfs正式
            HOST_URL = "https://183.223.56.103:8080/send";
        } else {
            //测试地址
            HOST_URL = "https://183.223.56.103:8080/send";
        }
    }

    public static void main(String[] args) throws Exception {
        //1. 生成公钥私钥
        //生成公钥私钥
        KeyPair keyPair1 = getKeyPair();
        PublicKey publicKey1 = keyPair1.getPublic();
        PrivateKey privateKey1 = keyPair1.getPrivate();
        //密钥转16进制字符串
        String publicKey = Base64.getEncoder().encodeToString(publicKey1.getEncoded());
        String privateKey = Base64.getEncoder().encodeToString(privateKey1.getEncoded());
        System.out.println("生成公钥："+publicKey);
        System.out.println("生成私钥："+privateKey);
        //16进制字符串转密钥对象
        PrivateKey privateKey2 = getPrivateKey(privateKey);
        PublicKey publicKey2 = getPublicKey(publicKey);
        //加签验签
        String data="需要签名的数据";
        String signECDSA = signECDSA(privateKey2, data);
        System.out.println("signECDSA签名结果：" + signECDSA);
        signECDSA = signECDSA(privateKey2, data);
        boolean verifyECDSA = verifyECDSA(publicKey2, signECDSA, data);
        System.out.println("验签结果："+verifyECDSA);

        System.out.println();
        System.out.println();

        /**
         * 注意8是整形
         序列化:  {"address":"t1mq2zk4dtcxm42sx76djtezlgkyp3gbb4gdcidba","amount":"0.3","nonce":8}
         hash:  0lVEvbGmgdiWkkk4N4cGXMQiD2C6i00f8Hr0ggwZvpc=
         */
        Map<String,Object> map = new HashMap<>();
        map.put("address","t1mq2zk4dtcxm42sx76djtezlgkyp3gbb4gdcidba");
        map.put("amount","0.3");
        map.put("nonce",12);

        String jsonString = getDataSortJsonString(map);
        System.out.println("1.jsonString：" + jsonString);

        String signECDSA1 = signECDSAByPem(jsonString);
        System.out.println("2.签名结果：" + signECDSA1);

        boolean verifyECDSA1 = verifyECDSAByPem(signECDSA1, jsonString);
        System.out.println("验签结果："+verifyECDSA1);

        String result = sendPost(HOST_URL, BlackBoxHttpUtil.buildParamObj(map), signECDSA1);
        System.out.println("请求result："+result);
    }


    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url
     *            发送请求的 URL
     * @param param
     *            请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
     * @return 所代表远程资源的响应结果
     */
    public static String sendPost(String url, String param, String auth)  throws Exception{
        PrintWriter out = null;
        OutputStream os = null;
        BufferedReader in = null;
        String result = "";
        try {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("auth", auth);
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Content-Type", "application/json");

            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            // 获取URLConnection对象对应的输出流
            os = conn.getOutputStream();
            os.write(param.getBytes("utf-8"));

            // 定义BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(),"utf-8"));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 使用finally块来关闭输出流、输入流
        finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
                if (os != null) {
                    os.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 加签 通过PEM
     * @param data 数据
     * @return
     */
    public static String signECDSAByPem(String data) {
        String result = "";
        try {
            PrivateKey privateKey = getPrivateKeyByPem();
            //执行签名
            Signature signature = Signature.getInstance(SIGNALGORITHMS);
            signature.initSign(privateKey);
            signature.update(data.getBytes());
            byte[] sign = signature.sign();
            return Base64.getEncoder().encodeToString(sign);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 通过pemprivate key
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKeyByPem() throws Exception {

        File directory = new File("");//参数为空
        String courseFile = directory.getCanonicalPath() ;
        String privateKeyPath = courseFile + PRIVATE_KEY_PATH;

        BASE64Decoder base64decoder = new BASE64Decoder();
        BufferedReader br8 = new BufferedReader(new FileReader(privateKeyPath));
        String s = br8.readLine();
        String str = "";
        s = br8.readLine();
        while (s.charAt(0)!= '-'){
            str += s + "\r";
            s = br8.readLine();
        }
        byte[] buffer8 =base64decoder.decodeBuffer(str) ;
        br8.close();

        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer8);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * java 对字符串排序, 并返回json数据
     * @return
     * @throws Exception
     */
    public static String getDataSortJsonString(Map<String,Object> data) throws Exception {

        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[keySet.size()]);
        Arrays.sort(keyArray);

        JSONObject jsonObject = new JSONObject(true);
        for (String k : keyArray) {
            if (k.equals(BlackBoxHttpUtil.FIELD_SIGN) || k.equals(BlackBoxHttpUtil.FIELD_SUCCESS) ) {
                continue;
            }
            jsonObject.put(k,data.get(k));
        }

        return jsonObject.toJSONString();
    }


    /**
     * 加签
     * @param privateKey 私钥
     * @param data 数据
     * @return
     */
    public static String signECDSA(PrivateKey privateKey, String data) {
        String result = "";
        try {
            //执行签名
            Signature signature = Signature.getInstance(SIGNALGORITHMS);
            signature.initSign(privateKey);
            signature.update(data.getBytes());
            byte[] sign = signature.sign();
            return Base64.getEncoder().encodeToString(sign);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 验签
     * @param publicKey 公钥
     * @param signed 签名
     * @param data 数据
     * @return
     */
    public static boolean verifyECDSA(PublicKey publicKey, String signed, String data) {
        try {
            //验证签名
            Signature signature = Signature.getInstance(SIGNALGORITHMS);
            signature.initVerify(publicKey);
            signature.update(data.getBytes());
            byte[] hex = Base64.getDecoder().decode(signed);
            boolean bool = signature.verify(hex);
            // System.out.println("验证：" + bool);
            return bool;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 验签
     * @param signed 签名
     * @param data 数据
     * @return
     */
    public static boolean verifyECDSAByPem(String signed, String data) {
        try {
            PublicKey publicKey = getPublicKeyByPem();

            //验证签名
            Signature signature = Signature.getInstance(SIGNALGORITHMS);
            signature.initVerify(publicKey);
            signature.update(data.getBytes());
            byte[] hex = Base64.getDecoder().decode(signed);
            boolean bool = signature.verify(hex);
            // System.out.println("验证：" + bool);
            return bool;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }


    /**
     * 从string转private key
     * @param key 私钥的字符串
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String key) throws Exception {

        byte[] bytes = DatatypeConverter.parseBase64Binary(key);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 从string转publicKey
     * @param key 公钥的字符串
     * @return
     * @throws Exception
     */
    public static PublicKey getPublicKey(String key) throws Exception {

        byte[] bytes = DatatypeConverter.parseBase64Binary(key);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePublic(keySpec);
    }


    /**
     * 从string转publicKey
     * @return
     * @throws Exception
     */
    public static PublicKey getPublicKeyByPem() throws Exception {
        File directory = new File("");//参数为空
        String courseFile = directory.getCanonicalPath() ;
        String privateKeyPath = courseFile + PUBLIC_KEY_PATH;

        BASE64Decoder base64decoder = new BASE64Decoder();
        BufferedReader br8 = new BufferedReader(new FileReader(privateKeyPath));
        String s = br8.readLine();
        String str = "";
        s = br8.readLine();
        while (s.charAt(0)!= '-'){
            str += s + "\r";
            s = br8.readLine();
        }
        byte[] buffer8 =base64decoder.decodeBuffer(str) ;
        br8.close();

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer8);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePublic(keySpec);
    }


    /**
     * 生成密钥对
     * @return
     * @throws Exception
     */
    public static KeyPair getKeyPair() throws Exception {
        ECGenParameterSpec ecSpec = new ECGenParameterSpec(SECP256K1);
        KeyPairGenerator kf = KeyPairGenerator.getInstance(ALGORITHM);
        kf.initialize(ecSpec, new SecureRandom());
        KeyPair keyPair = kf.generateKeyPair();
        return keyPair;
    }

}

私钥
eccprivate_pkcs8.pem

-----BEGIN ecc private key-----
MIHuAgEAMBAGByqGSM49AgEGBSuBBAAjBIHWMIHTAgEBBEIAaCofgjFSk5g6UMzu
SRLkIKGYeHFAnVKgKIDS0UJUiNbqf7K/boAFsHAPurVp4h+nYxytlfGENeejrq3H
XO7kR4KhgYkDgYYABAFnxEML0ZCwXIXqAOUX3y1dta5b4gLoyQOAUC0W098Fy4Om
B9VF+Bv3TE/ovwKnmoulBlpbVPD8JBkWLuvQQAdKWwD8cuoGM/6EbOyS926ZJ33A
AZviVoY7y+dOf5QgjNKJfLQe9Uqam2h1J9DEVzEttAjr/91eJozihJvsvhVRVqML
Rw==
-----END ecc private key-----

公钥
eccpublic_pkcs8.pem

-----BEGIN ecc public key-----
MIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQBZ8RDC9GQsFyF6gDlF98tXbWuW+IC
6MkDgFAtFtPfBcuDpgfVRfgb90xP6L8Cp5qLpQZaW1Tw/CQZFi7r0EAHSlsA/HLq
BjP+hGzskvdumSd9wAGb4laGO8vnTn+UIIzSiXy0HvVKmptodSfQxFcxLbQI6//d
XiaM4oSb7L4VUVajC0c=
-----END ecc public key-----
voaycc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ECDSA签名算法
qq_41661056的博客
04-22 861
package main import ( "crypto/ecdsa" "crypto/elliptic" "crypto/rand" "crypto/sha256" "crypto/x509" "encoding/base64" "encoding/hex" "fmt" "math/big" "strings" ) // 生成公私钥 func GenKeyPair() (privateKey string, publicKey string, e error) { // Gen
ECC密钥生成、加密解密、签名验签工具
01-29
用VS2010基于C语言写的ECC密钥生成器，ECC加密解密小工具，ECC签名验签小工具，密钥生成、签名验签是基于OpenSSl写的，加密解密是自己写的，另外用到的还有大数库等
ECDSA签名+验签
andylau00j的专栏
08-14 9910
    ECDSA签名每次结果不同。      原因：ECDSA签名过程中混入随机值，生成签名结果不同。     公钥证书验签没问题。   1. 签名过程     假设要签名的消息是一个字符串：“Hello World!”。DSA签名的第一个步骤是对待签名的消息生成一个消息摘要。不同的签名算法使用不同的消息摘要算法。比如，DSS使用SHA1来生成160比特的摘要，而ECDSA256使用S...
ECDSA 验证签名
Jinglebin的博客
11-29 1726
ECDSA signature verify
JWT Token 使用 RS256 和 ES256 签名
热门推荐
yuanjian0814的博客
06-17 1万+
JWT Token 使用 RSA256 和 ES256 签名使用 RS256 签名创建 RSA256 密钥创建和验证 JWT Token使用 ES256 加密创建 ES256 密钥创建和验证 JWT Token 使用 RS256 签名 … 创建 RSA256 密钥 安装 openssl 服务，执行如下指令生成密钥对。 # 创建私钥 openssl genrsa -out rsa_private.pem 2048 # 创建公钥 openssl rsa -in rsa_private.pem -outform
数字签名验签 — ECC算法
Yang_Mao_Shan的博客
03-22 5919
数字签名与验签，使用 ECC 算法，基于 JCA 和 OpenSSL实现 ECC、 secp256r1曲率参数以及 SHA256摘要算法的验签过程
招行一网通支付 加签验签工具类
01-10
招行一网通支付 加签验签工具类 提供给做支付的小伙伴
RSA sha-256加密解密，加签验签工具类
01-14
spring框架中关于RSA sha-256加密解密，加签验签工具类
Java Base64加密解密方法工具类
04-22
Java Base64加密解密方法工具类
Base64编码解码工具.zip
12-01
基于VS开发的MFC界面Base64编码解码工具，使用方便，可以实现解码编码功能
ECC签名验签工具源码
04-27
之前上传的有ECC密钥生成、加密解密、签名验签工具，忘了放源码了，这个是源代码，VS2010的，由于上传大小有限制，所以分开了，这个是签名验签的，这里用到了OPENSSL库，OpenSSL源码网上可以找到
ecctool工具
11-13
ecctool工具
使用 OpenSSL 命令行进行 ECC 签名及验签
01-07
首先查看一下 OpenSSL 内建了哪些椭圆曲线，使用命令为： openssl ecparam -list_curves         选择一条椭圆曲线创建 ECC 公私钥对，这里使用 secp256k1，执行命令： openssl ecparam -name secp256k1 -genkey -out ec.key         可以用文本编辑器打开 ec.key 文件，其内容类似于： —–BEGIN EC PARAMETERS—– BgUrgQQACg== —–END EC PARAMETERS—– —–BEGIN EC PRIVATE KEY—– MHQCAQEEINMie6Xet
RSA加密解密签名加签验签RsaUtils工具类
最新发布
04-15
RSA加密解密签名加签验签RsaUtils工具类 RSA算法基于大数因子分解难题，提供了公钥加密和私钥解密的能力。公钥用于加密，私钥则负责解密。这种特性使得RSA成为保证数据传输安全的理想选择。 公钥加密私钥解密与...
DSA和ECC签名验签
自媒体软件
06-28 406
DSA DSA 是专业用于数字签名和验签，并且只有这个作用, 不能用于加密和解密。 在安全性上，DSA和RSA差不多，但是速度比RSA快很多。 DSA签名和验签 func main() { //设置私钥使用的参数 var param dsa.Parameters dsa.GenerateParameters(&param, rand.Reader...
各类编码加解密签名验签在线工具
qq19970496的博客
04-01 1179
在线签名工具 http://www.metools.info/code/c82.html RSA签名/验签 在线编码 https://www.sojson.com/md5/ 添加链接描述 各类哈希计算 在线加密 http://tool.chacuo.net/cryptaes/ http://www.jsons.cn/urlencode/
功能丰富的算法工具,支持RSA,ECC,SM2,AES,3DES,SM4,SHA等算法
l_z_h的博客
04-07 2243
一款功能强大的算法工具, 支持RSA, ECC, SM2, SM3, AES, 3DES, SM4, SHA-1, SHA-256，SHA-512等算法，并具有丰富的数据转换功能
web开发通用调试工具(含RSA,SM2,ECC,ECDsa等签名，验签，证书制作, 批量工具, RSA密钥格式转换, Http/Websocket请求调试等)
key12315的专栏
04-04 2703
【写在前面】本调试工具为纯客户端，且持续更新升级，永久免费。 【目标】简化开发人员的日常工作，包括不限于： 对称加密，RSA，ECC，国密SM２的加密，解密，签名，验签，证书制作．．． 　　　　http组包, websocket调试,cmd命令调试, 　　　　参数排序签名工具，批量生成工具，批量文件处理工具等等． 【作者技术博客】　企业研发，运维，运营必备的配置资源网.-分享关于互联网/软件研发和运维过程中遇到的各种环境，工具安装配置问题 ...
java base64加解密工具类
11-03
在Java中，可以使用Base64编码对数据进行加密和解密。以下是一个示例的Java Base64加解密工具类： ```java import java.util.Base64; public class Base64Utils { public static String encode(String data) { byte[] bytes = data.getBytes(); byte[] encodedBytes = Base64.getEncoder().encode(bytes); return new String(encodedBytes); } public static String decode(String data) { byte[] bytes = data.getBytes(); byte[] decodedBytes = Base64.getDecoder().decode(bytes); return new String(decodedBytes); } public static void main(String[] args) { String originalData = "Hello, World!"; String encodedData = encode(originalData); String decodedData = decode(encodedData); System.out.println("原始数据: " + originalData); System.out.println("加密后的数据: " + encodedData); System.out.println("解密后的数据: " + decodedData); } } ``` 在上面的示例中，`encode`方法用于将字符串进行Base64编码，而`decode`方法用于将Base64编码的字符串进行解码。两个方法的返回值均为字符串类型。 在`main`方法中，我们可以利用这两个方法来测试加解密的功能。首先，将原始数据字符串传入`encode`方法进行编码，得到加密后的数据字符串；然后，将加密后的数据字符串传入`decode`方法进行解码，得到解密后的数据字符串。 最后，通过使用`System.out.println()`方法将原始数据、加密后的数据和解密后的数据打印出来，以便观察加解密的效果。 需要注意的是，这里使用的是Java 8中的`java.util.Base64`类，该类提供了编码和解码的方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值