轻松实现开放接口的签名和验签

最新推荐文章于 2024-04-02 15:12:29 发布
最新推荐文章于 2024-04-02 15:12:29 发布
阅读量600 收藏 3
点赞数
文章标签： java 前端 数据库
原文链接：https://mp.weixin.qq.com/s/cmpnLamK3wFbgmTZAWNpOw
版权

原创 一安 一安未来 2023-12-01 08:00 发表于北京

收录于合集#干货分享集191个

图片

大家好，我是一安~

介绍

开放接口

开放接口是指不需要登录凭证就允许被第三方系统调用的接口，这个时候肯定要考虑接口数据的安全性问题，比如数据是否被篡改，数据是否已经过时，数据是否可以重复提交等问题，为了防止开放接口被恶意调用，开放接口一般都需要验签才能被调用。

验签

验签是指第三方系统在调用接口之前，需要按照接口提供方的规则根据所有请求参数生成一个签名（字符串），在调用接口时携带该签名。接口提供方会验证签名的有效性，只有签名验证有效才能正常调用接口，否则请求会被驳回。

大致流程

图片

实战

这里只是演示，未真正区分开客户端和服务端

导入依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.7.13</version>
    </dependency>
    <dependency>
        <groupId>commons-codec</groupId>
        <artifactId>commons-codec</artifactId>
        <version>1.15</version>
    </dependency>

自定义配置

私钥和公钥直接保存在文件中

spring:
  redis:
    host: localhost
    port: 6379
    password: root
    database: 2

signature:
  enable: true
  key-pair:
    # 调用方ID
    test-1:
      # 算法
      algorithm: SHA256withRSA
      # 私钥
      private-key-path: classpath:signature/private
      # 公钥
      public-key-path: classpath:signature/public
      # 生效时间(分钟)
      effective-time: 3

加载配置信息

@Data
@ConditionalOnProperty(value = "signature.enable", havingValue = "true")
@Component
@ConfigurationProperties("signature")
public class SignatureProps {

    private Boolean enable;
    private Map<String, KeyPairProps> keyPair;

    @Data
    public static class KeyPairProps {
        private SignAlgorithm algorithm;
        private String publicKeyPath;
        private String publicKey;
        private String privateKeyPath;
        private String privateKey;
        private Integer effectiveTime;
    }
}

签名管理类

@ConditionalOnBean(SignatureProps.class)
@Component
public class SignatureManager {

    private final SignatureProps signatureProps;
    public SignatureManager(SignatureProps signatureProps) {
        this.signatureProps = signatureProps;
        loadKeyPairByPath();
    }
    
    public SignatureProps.KeyPairProps getKeyPairPropsByClientID(String clientID) {
        return signatureProps.getKeyPair().get(clientID);
    }   
    

    /**
     * 验签。验证不通过可能抛出运行时异常CryptoException
     *
     * @param clientID  调用方的唯一标识
     * @param rawData   原数据
     * @param signature 待验证的签名(十六进制字符串)
     * @return 验证是否通过
     */
    public boolean verifySignature(String clientID, String rawData, String signature) {
        Sign sign = getSignByClientID(clientID);
        if (ObjectUtils.isEmpty(sign)) {
            return false;
        }
        // 使用公钥验签
        return sign.verify(rawData.getBytes(StandardCharsets.UTF_8), HexUtil.decodeHex(signature));
    }

    /**
     * 生成签名
     *
     * @param clientID 调用方的唯一标识
     * @param rawData  原数据
     * @return 签名(十六进制字符串)
     */
    public String sign(String clientID, String rawData) {
        Sign sign = getSignByClientID(clientID);
        if (ObjectUtils.isEmpty(sign)) {
            return null;
        }
        return sign.signHex(rawData);
    }

    private Sign getSignByClientID(String clientID) {
        SignatureProps.KeyPairProps keyPairProps = signatureProps.getKeyPair().get(clientID);
        if (ObjectUtils.isEmpty(keyPairProps)) {
            return null; // 无效的、不受信任的调用方
        }
        return SecureUtil.sign(keyPairProps.getAlgorithm(), keyPairProps.getPrivateKey(), keyPairProps.getPublicKey());
    }

    /**
     * 加载非对称密钥对
     */
    private void loadKeyPairByPath() {
        // 支持类路径配置，形如：classpath:signature/public
        // 公钥和私钥都是base64编码后的字符串
        signatureProps.getKeyPair()
                .forEach((key, keyPairProps) -> {
                    keyPairProps.setPublicKey(loadKeyByPath(keyPairProps.getPublicKeyPath()));
                    keyPairProps.setPrivateKey(loadKeyByPath(keyPairProps.getPrivateKeyPath()));
                    if (ObjectUtils.isEmpty(keyPairProps.getPublicKey()) ||
                            ObjectUtils.isEmpty(keyPairProps.getPrivateKey())) {
                        throw new RuntimeException("No public and private key files configured");
                    }
                });
    }

    private String loadKeyByPath(String path) {
        if (ObjectUtils.isEmpty(path)) {
            return null;
        }
        return IoUtil.readUtf8(ResourceUtil.getStream(path));
    }
}

自定义验签注解

自定义验签注解，控制哪些接口需要验签

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface VerifySignature {
    boolean resubmit() default true;//允许重复请求
}

切面验签

@ConditionalOnBean(SignatureProps.class)
@Component
@Slf4j
@Aspect
public class RequestSignatureAspect {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Resource
    private SignatureManager signatureManager;

    @Pointcut("@annotation(org.example.sign.anno.VerifySignature)")
    public void signPointCut() {
    }

    @Before("signPointCut()")
    public void verifySignature(JoinPoint joinPoint) {
    
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        String clazz = joinPoint.getTarget().getClass().getName();
        String name = method.getName();

        VerifySignature verifySignature = method.getAnnotation(VerifySignature.class);
        if(!verifySignature.resubmit()&&!redisTemplate.opsForValue().setIfAbsent(clazz+":"+name,"1",10, TimeUnit.SECONDS)){
            throw new RuntimeException("不可重复提交");
        } 
    
        HttpServletRequest request = getHttpServletRequest();
        // 从请求头中提取调用法ID，不存在直接驳回
        String clientID = request.getHeader("clientID");
        if (ObjectUtils.isEmpty(clientID)) {
            throw new RuntimeException("不受信任的调用方");
        }

        // 从请求头中提取签名，不存在直接驳回
        String signature = request.getHeader("sign");
        if (ObjectUtils.isEmpty(signature)) {
            throw new RuntimeException("无效的签名");
        }
        
         // 从请求头中提取时间戳，不存在或者过期直接驳回
        String timestamp = request.getHeader("timestamp");
        if (ObjectUtils.isEmpty(timestamp) ||
                ChronoUnit.MINUTES.between(
                        LocalDateTime.ofInstant(Instant.ofEpochMilli(Long.parseLong(timestamp)), ZoneOffset.ofHours(8)),
                        LocalDateTime.now()
                ) > signatureManager.getKeyPairPropsByClientID(clientID).getEffectiveTime()) {
            throw new RuntimeException("签名已过期");
        }


        // 提取请求参数
        String requestParamsStr = extractRequestParams(request);

        // 验签。验签不通过抛出业务异常
        verifySignature(clientID, requestParamsStr, signature);
    }

    /**
     * 由于body输入流只能读取一次，所以拦截器中不能直接读取body的输入流，否则会造成后续@RequestBody的参数解析器读取不到body，因此需要使用ContentCachingRequestWrapper包装请求，缓存body内容
     **/
    private String extractRequestParams(HttpServletRequest request) {
        // @RequestBody
        String body = null;
        if (request instanceof ContentCachingRequestWrapper) {
            ContentCachingRequestWrapper requestWrapper = (ContentCachingRequestWrapper) request;
            body = new String(requestWrapper.getContentAsByteArray(), StandardCharsets.UTF_8);
        }

        // @RequestParam
        Map<String, String[]> paramMap = request.getParameterMap();

        // @PathVariable
        ServletWebRequest webRequest = new ServletWebRequest(request, null);
        Map<String, String> uriTemplateVarNap = (Map<String, String>) webRequest.getAttribute(
                HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);

        return CommonUtils.extractRequestParams(body, paramMap, uriTemplateVarNap);
    }


    /**
     * 验证请求参数的签名
     */
    public void verifySignature(String clientID, String requestParamsStr, String signature) {
        try {
            boolean verified = signatureManager.verifySignature(clientID, requestParamsStr, signature);
            if (!verified) {
                throw new RuntimeException("The signature verification result is false.");
            }
        } catch (Exception ex) {
            log.error("Failed to verify signature", ex);
            throw new RuntimeException("业务异常");
        }
    }

    private HttpServletRequest getHttpServletRequest() {
        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) ra;
        return sra.getRequest();
    }
}

工具类

@Configuration
public class RedisConfig {
    @Autowired
    private RedisConnectionFactory factory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

public class CommonUtils {
    /**
     * 提取所有的请求参数，按照固定规则拼接成一个字符串
     *
     * @param body              post请求的请求体
     * @param paramMap          路径参数(QueryString)。形如：name=zhangsan&age=18&label=A&label=B
     * @param uriTemplateVarNap 路径变量(PathVariable)。形如：/{name}/{age}
     * @return 所有的请求参数按照固定规则拼接成的一个字符串
     */
    public static String extractRequestParams(String body, Map<String, String[]> paramMap, Map<String, String> uriTemplateVarNap) {
        String paramStr = null;
        if (!ObjectUtils.isEmpty(paramMap)) {
            paramStr = paramMap.entrySet().stream()
                    .sorted(Map.Entry.comparingByKey())
                    .map(entry -> {
                        // 拷贝一份按字典序升序排序
                        String[] sortedValue = Arrays.stream(entry.getValue()).sorted().toArray(String[]::new);
                        return entry.getKey() + "=" + joinStr(",", sortedValue);
                    })
                    .collect(Collectors.joining("&"));
        }

        String uriVarStr = null;
        if (!ObjectUtils.isEmpty(uriTemplateVarNap)) {
            uriVarStr = joinStr(",", uriTemplateVarNap.values().stream().sorted().toArray(String[]::new));
        }

        // { userID: "xxx" }#name=zhangsan&age=18&label=A,B#zhangsan,18
        return joinStr("#", body, paramStr, uriVarStr);
    }

    /**
     * 使用指定分隔符，拼接字符串
     *
     * @param delimiter 分隔符
     * @param strs      需要拼接的多个字符串，可以为null
     * @return 拼接后的新字符串
     */
    public static String joinStr(String delimiter,String... strs) {
        if (ObjectUtils.isEmpty(strs)) {
            return StrUtil.EMPTY;
        }
        StringBuilder sbd = new StringBuilder();
        for (int i = 0; i < strs.length; i++) {
            if (ObjectUtils.isEmpty(strs[i])) {
                continue;
            }
            sbd.append(strs[i].trim());
            if (!ObjectUtils.isEmpty(sbd) && i < strs.length - 1 && !ObjectUtils.isEmpty(strs[i + 1])) {
                sbd.append(delimiter);
            }
        }
        return sbd.toString();
    }
}

request流只能获取一次

如果接口是用@RequestBody来接受数据，在拦截器中需要使用读取request的输入流 ，但ServletRequest中getReader()和getInputStream()只能调用一次

@ConditionalOnBean(SignatureProps.class)
@Component
public class RequestCachingFilter extends OncePerRequestFilter {


    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        boolean isFirstRequest = !isAsyncDispatch(request);
        HttpServletRequest requestWrapper = request;
        if (isFirstRequest && !(request instanceof ContentCachingRequestWrapper)) {
            requestWrapper = new ContentCachingRequestWrapper(request);
        }
        filterChain.doFilter(requestWrapper, response);
    }
}

测试类

@RestController
public class controller {

    @Resource
    private SignatureManager signatureManager;


    /**
     * 数据验签
    * 参数：{"name":"一安未来"}
    **/
    @VerifySignature(resubmit = false)
    @PostMapping("/sign1")
    public String sign1(@RequestBody Map<String,String> map){
        System.out.println(map);
        return "success";
    }

    /**
     *  数据签名
     * 参数：{"name":"一安未来"}
     **/
    @PostMapping("/sign2")
    public String sign2(@RequestBody Map<String,String> map, HttpServletRequest httpRequest){
        String clientID = httpRequest.getHeader("clientID");
        String mapToJsonString = String.format("{%s}", String.join(",", map.entrySet().stream()
                .map(e -> String.format("\"%s\":\"%s\"", e.getKey(), e.getValue()))
                .collect(Collectors.toList())));
        return signatureManager.sign(clientID,mapToJsonString);
    }
}

一安未来

致力于Java，大数据；心得交流，技术分享；

122篇原创内容

公众号

竹林幽深
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spring Boot实现接口签名验证
04-23
包括配置签名密钥、定义签名算法、拦截器或过滤器实现、测试接口、模拟第三方调用 博客：https://blog.csdn.net/u011974797/article/details/138123261 开放接口是指不需要登录凭证就允许被第三方系统调用的接口。为了防止开放接口被恶意调用，开放接口一般都需要验签才能被调用。 在Spring Boot中实现接口校验签名通常是为了保证接口请求的安全性和数据的完整性。签名校验通常涉及对请求参数的签名计算和验证，以确保请求是由可信的发送方发送，并且在传输过程中没有被篡改。
Java Http接口加签、验签操作
qq_33409823的博客
04-11 9152
1.业务背景： 一些加积分，兑换奖品等接口，为了确保数据参数在传输过程中未经过篡改，都需要对接口数据进行加签，然后在接口服务器端对接口参数进行验签，确保两个签名是一样的，验签通过之后再进行业务逻辑处理。 2.实现思路： ​ 双方约定好，参数按特定顺序排列，比如按首字母的顺序排列，如url:http://xxx/xxx.do?a=wersd&b=sd2354&c=4&sign...
接口安全设计之接口验签
最新发布
xlj_bear的博客
04-02 377
最近接到一个需求，在海外客户还款之前，都是通过一个还款链接去还款，但是还款链接内没有任何的客户信息，所以需要还款之前，进入一个前置信息确认页面，就需要后端先提供一个查询接口给前端，但是需要参数明文传递给前端，其中包含订单号，金额及还款类型。在原本的请求链接不变的情况下，加一个sign参数，针对当前参数进行签名，在请求后端的时候，需要先验证签名，如果验签不通过，则直接返回error，否则认定参数没有被修改，继续生成还款链接。当请求到达后端之后，去查询当次请求的参数，然后去生成真实的还款链接给客户还款。
【JAVA】实现API 接口参数签名
小朋友的博客
08-27 711
使用sa-token+SpringBoot+拦截器实现API 接口参数签名
java/springboot服务第三方接口安全签名(Signature)实现方案
Mervin
11-03 1685
springboot服务第三方接口安全签名(Signature)实现方案
Java对外接口签名(Signature)实现方案
学习学习学习
07-04 1万+
对外接口加密验签功能
【java】java接口安全之接口签名
YuChen
11-28 2895
自定义的接口签名解签工具类
最易于使用的java接口签名实现
weixin_38387358的博客
08-03 3309
最易于使用的java对外接口签名实现
程序员必备基础：加签验签
竹林幽深
03-02 936
https://mp.weixin.qq.com/s/LH4D7hOTXcyhYRCLdgQwRw
API 接口签名验签
热门推荐
javaTalk
06-23 1万+
目录 一、为什么需要 API 接口签名 二、API 接口签名验签实现机制 一、为什么需要 API 接口签名 对外开放的 API 接口都会面临一些安全问题，例如伪装攻击、篡改攻击、重放攻击以及数据信息泄漏的风险。利用 API 接口签名能方便的防范这些安全问题和风险。在设计 API 接口签名时主要考虑以下几点： 保证请求数据正确 当请求中的某一个字段的值变化时，原...
【国密SM2】基于Hutool的SM2公私钥生成、签名验签、加密解密（30行代码搞定）
Java全栈开发者
10-11 8997
由于在公司项目中需要用到国密SM2秘钥生成、签名、验签功能，找了网上很多的资料，发现其工具类都异常复杂，最终找到了hutool工具包，但其官网的示例也不尽人意。于是，对Hutool提供的SM2类进行封装，封装成了自己使用的Sm2Util工具类，代码量在20行以内，尽可能做到简单易懂。
springboot实现接口签名
06-06
为了保证数据传输的安全性，跟其他系统进行数据交互时，双方应该约定好密钥，把数据进行加密，接口签名，这样双方调用接口时，验证接口签名一致时就表明数据传输过程中没有被修改。
使用微软CSP接口进行签名验签
09-06
测试Demo改自网上一位大佬，在此基础上进行了一些改动，支持默认的CSP签名验签，也支持具有自己的CSP签名验签
证书签名和验签Demo JAVA版.zip
09-26
银联云闪付证书签名和验签Demo JAVA版+RSA签名 接口参数RSA签名工具类和Demo，可直接使用。privateKey 证书信息进行签名 签名，验签都有
php 通过CFCA证书实现RSA的PKCS7格式的签名和验签步骤
07-09
php 通过CFCA证书实现RSA的PKCS7格式的签名和验签步骤demo文件和扩展文件，php通过.pfx和.cer结尾证书进行CFCA签名 通过具体可以查看https://blog.csdn.net/weixin_39934453/article/details/125695880 你是不是遇到...
Java实战指南｜玩转接口验签-你和高手只差俩个自定义注解
xxsiyao的博客
07-12 417
前言： 一些个很朴素的功能【 登陆功能+接口验签+登陆用户信息共享 】这三个功能想必是大家在日常开发中基本上大都碰到过的吧，如果你还在使用拦截器给接口加白名单来进行过滤那些接口需要验签，如果你还在每次需要拿用户信息的时候都得去查一遍db，那么你就值得看下去，小编教你如何花式玩转接口登陆验签功能????????????【参考资料】 正文 技术设计流程【参考资料】 我们先看一下实现流程图哈，我们主要使用的技术包括： HandlerMethodArgumentResolver （参数解析器）， Handler
接口验签规则
上善若水
12-01 445
加签验签，发送消息方，对消息加签名；接受消息方，验证签名是否正确。
java接口签名框架
qq_29768197的博客
10-21 206
java接口签名框架，考虑接口数据的安全问题。例如：数据是否被篡改，数据是否已经过时，数据是否可以重复提交等问题。
Java实现rsa数字签名代码和验签
06-06
RSA数字签名是非常重要的加密算法之一，以下是Java实现RSA数字签名的代码示例： ## 数字签名 ```java import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.security.Key; import java.security.KeyFactory; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Signature; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; public class RSAUtil { private static final String ALGORITHM = "RSA"; private static final String SIGNATURE_ALGORITHM = "SHA1WithRSA"; /** * 从文件中加载私钥 * * @param privateKeyFile 私钥文件 * @return 私钥 * @throws Exception */ public static PrivateKey loadPrivateKeyFromFile(File privateKeyFile) throws Exception { FileInputStream fis = new FileInputStream(privateKeyFile); ByteArrayOutputStream bos = new ByteArrayOutputStream(); byte[] buffer = new byte[1024]; int len; while ((len = fis.read(buffer)) != -1) { bos.write(buffer, 0, len); } fis.close(); bos.close(); byte[] privateKeyBytes = bos.toByteArray(); PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKeyBytes); KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); return keyFactory.generatePrivate(pkcs8KeySpec); } /** * 从文件中加载公钥 * * @param publicKeyFile 公钥文件 * @return 公钥 * @throws Exception */ public static PublicKey loadPublicKeyFromFile(File publicKeyFile) throws Exception { FileInputStream fis = new FileInputStream(publicKeyFile); ByteArrayOutputStream bos = new ByteArrayOutputStream(); byte[] buffer = new byte[1024]; int len; while ((len = fis.read(buffer)) != -1) { bos.write(buffer, 0, len); } fis.close(); bos.close(); byte[] publicKeyBytes = bos.toByteArray(); X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKeyBytes); KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); return keyFactory.generatePublic(x509KeySpec); } /** * 对数据进行数字签名 * * @param data 数据 * @param privateKey 私钥 * @return 数字签名 * @throws Exception */ public static byte[] sign(byte[] data, PrivateKey privateKey) throws Exception { Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM); signature.initSign(privateKey); signature.update(data); return signature.sign(); } /** * 验证数字签名 * * @param data 数据 * @param publicKey 公钥 * @param signedData 数字签名 * @return 是否验证通过 * @throws Exception */ public static boolean verify(byte[] data, PublicKey publicKey, byte[] signedData) throws Exception { Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM); signature.initVerify(publicKey); signature.update(data); return signature.verify(signedData); } } ``` ## 使用示例 ```java import java.io.File; import java.nio.charset.StandardCharsets; import java.security.PrivateKey; import java.security.PublicKey; public class Main { public static void main(String[] args) throws Exception { // 加载私钥 File privateKeyFile = new File("private_key.txt"); PrivateKey privateKey = RSAUtil.loadPrivateKeyFromFile(privateKeyFile); // 加载公钥 File publicKeyFile = new File("public_key.txt"); PublicKey publicKey = RSAUtil.loadPublicKeyFromFile(publicKeyFile); // 待签名数据 String data = "Hello, World!"; byte[] dataBytes = data.getBytes(StandardCharsets.UTF_8); // 数字签名 byte[] signedData = RSAUtil.sign(dataBytes, privateKey); // 验证数字签名 boolean verified = RSAUtil.verify(dataBytes, publicKey, signedData); System.out.println("Verified: " + verified); } } ``` 以上代码示例中，我们使用了`RSAUtil`类中的`loadPrivateKeyFromFile`方法和`loadPublicKeyFromFile`方法分别从私钥文件和公钥文件中加载私钥和公钥。然后我们使用`sign`方法对待签名数据进行数字签名，使用`verify`方法对签名结果进行验证。 切记，要使用自己的密钥对，不要使用他人的密钥对。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值