java API接口签名授权安全认证问题—基于HMAC的rest api鉴权处理

已于 2022-02-08 10:33:31 修改
阅读量2.4k 收藏 6
点赞数
分类专栏： java springboot 文章标签： java hmac 鉴权
于 2022-01-26 18:18:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songkai558919/article/details/122706684
版权

如何利用对称加密实现简单的请求鉴权。

前期沟通

服务端与客户端需要在前期敲定以下内容：

  1. 秘钥对（apiKey和secretKey），由服务端通过安全的途径交给客户端，如邮件、IM等内部渠道。
  2. 头部名称，包括APIKey、时间戳、签名及业务相关的头部。
  3. 加签算法，即根据业务参数及secretKey如何生成加密签名，客户端与服务端需保持一致。由客户端加密后的内容，在服务端用同样的秘钥加密应该是一模一样的。

客户端

流程

客户端的加签过程如下图所示。

代码

创建一个拦截器

public class AkSkAuthInterceptor implements ClientHttpRequestInterceptor {

    private static final String HEADER_X_CONTENT_MD5 = "X-Content-MD5";
    private static final String HEADER_X_VERSION = "X-Sign-Version";
    private static final String HEADER_X_TIMESTAMP = "X-Timestamp";
    private static final String HEADER_X_NONCE = "X-Nonce";

    private final String accessKey;
    private final String secretKey;

    public AkSkAuthInterceptor(String accessKey, String secretKey) {
        this.accessKey = accessKey;
        this.secretKey = secretKey;
    }

    @Override
    public ClientHttpResponse intercept(
        HttpRequest request, byte[] body, ClientHttpRequestExecution execution
    ) throws IOException {
        request.getHeaders().set(HEADER_X_CONTENT_MD5, buildContentMD5(body));
        request.getHeaders().set(HEADER_X_VERSION, "1.0");
        request.getHeaders().set(HEADER_X_NONCE, UUID.randomUUID().toString().replace("-", ""));
        request.getHeaders().set(HEADER_X_TIMESTAMP, Long.toString(System.currentTimeMillis() / 1000));
        request.getHeaders().set("Authorization", "wayz " + accessKey + ":" + sign(request));
        return execution.execute(request, body);
    }

    private String sign(HttpRequest request) {

        byte[] sha = Hashing.hmacSha1(secretKey.getBytes())
            .hashString(buildStringToSign(request), StandardCharsets.UTF_8)
            .asBytes();
        return BaseEncoding.base64().encode(sha);
    }

   
    private String buildStringToSign(HttpRequest request) {

        return accessKey + "\r\n"
            + request.getMethodValue() + "\r\n"
            + request.getURI().getPath() + "\r\n"
            + sortedParamStr(request) + "\r\n"
            + getHeader(request, "Accept") + "\r\n"
            + getHeader(request, HEADER_X_CONTENT_MD5) + "\r\n"
            + getHeader(request, "Content-Type") + "\r\n"
            + getHeader(request, HEADER_X_TIMESTAMP) + "\r\n"
            + getHeader(request, HEADER_X_VERSION) + "\r\n"
            + getHeader(request, HEADER_X_NONCE);
    }

    private String sortedParamStr(HttpRequest request) {

        return splitQuery(request.getURI().getQuery()).entrySet().stream()
            .filter(e -> e.getValue() != null && !e.getValue().isEmpty())
            .sorted(Map.Entry.comparingByKey())
            .map(e -> e.getKey() + "=" + e.getValue().iterator().next())
            .collect(Collectors.joining("&"));
    }

    private Object getHeader(HttpRequest request, String key) {

        Collection<String> values = request.getHeaders().get(key);
        return values == null || values.isEmpty() ? "" : values.iterator().next();
    }

    // 此处的sign方法应与服务端的保持一致
    private String buildContentMD5(byte[] body) {

        if (body == null || body.length == 0) {
            return Hashing.md5().hashString("", StandardCharsets.UTF_8).toString();
        }

        return Hashing.md5().hashBytes(body).toString();
    }

    private Map<String, List<String>> splitQuery(String query) {
        if (Strings.isNullOrEmpty(query)) {
            return Collections.emptyMap();
        }
        return Arrays.stream(query.split("&"))
            .map(this::splitQueryParameter)
            .collect(Collectors.groupingBy(AbstractMap.SimpleImmutableEntry::getKey, LinkedHashMap::new, mapping(Map.Entry::getValue, toList())));
    }

    private AbstractMap.SimpleImmutableEntry<String, String> splitQueryParameter(String it) {
        final int idx = it.indexOf("=");
        final String key = idx > 0 ? it.substring(0, idx) : it;
        final String value = idx > 0 && it.length() > idx + 1 ? it.substring(idx + 1) : null;
        return new AbstractMap.SimpleImmutableEntry<>(key, value);
    }
}

测试类

@Slf4j
public class testSign {

    public static void main(String[] args) {

        // test ak & sk
        RestSdkClint client = new RestSdkClint("https://lbi-api.newayz.com",
            ImmutableList.of(new AkSkAuthInterceptor(
                "ASYUwavcj18gplEuxvnBO2QLJU", "dwsxhqW0YjnicMI3DeZqjH29emc"
            )));

        SdkResponse<POIListReply> response = client.execute(new POIListArgs());
        log.info("{}", response);
    }

    @Data
    public static class POIListArgs implements SdkRequest<POIListReply> {

        private int needOneFieldOtherwiseCannotSerializeByJackson;

        @Override
        public HttpMethod getHttpMethod() {
            return HttpMethod.POST;
        }

        @Override
        public String getPath() {
            return "/openapi/v1/poi";
        }

        @Override
        public TypeReference<POIListReply> getResponseType() {
            return new TypeReference<POIListReply>() {
            };
        }

        @Override
        public MultiValueMap<String, String> getHeaders() {
            return null;
        }
    }

    @Data
    static class POIListReply {
    }
}

服务端

验签流程

大致流程如下图所示。

在网关服务创建过滤器类

@Slf4j
@Component
/**
 * API签名认证
 * 依赖request path，需在会修改path的filter前面执行
 */
public class AuthorizationOpenApiFilterFactory extends AbstractGatewayFilterFactory<Config> {

    private static final String X_VERSION = "1.0";
    private static final long X_TIMESTAMP_EXPIRED_SEC = 30;
    private static final long NONCE_CACHE_PERIOD_MILLIS = TimeUnit.SECONDS.toMillis(X_TIMESTAMP_EXPIRED_SEC);
    private static final int MAX_NONCE_LENGTH = 32;

    private static final String HEADER_X_CONTENT_MD5 = "X-Content-MD5";
    private static final String HEADER_X_VERSION = "X-Sign-Version";
    private static final String HEADER_X_TIMESTAMP = "X-Timestamp";
    private static final String HEADER_X_NONCE = "X-Nonce";
    private static final String MISSING_MSG = "[MISSING]";

    // d41d8cd98f00b204e9800998ecf8427e
    private static final String EMPTY_BODY_MD5 = Hashing.md5()
        .hashString("", StandardCharsets.UTF_8).toString();
    private static final byte[] EMPTY_BODY = "".getBytes(StandardCharsets.UTF_8);

    private final NonceChecker nonceChecker;
    private final SecretKeyFinder secretKeyFinder;

    public AuthorizationOpenApiFilterFactory(
        final NonceChecker nonceChecker, final SecretKeyFinder secretKeyFinder
    ) {
        super(Config.class);

        Objects.requireNonNull(nonceChecker);
        Objects.requireNonNull(secretKeyFinder);

        this.nonceChecker = nonceChecker;
        this.secretKeyFinder = secretKeyFinder;
    }

    @Override
    public GatewayFilter apply(final Config config) {

        return (exchange, chain) -> verify(exchange, chain, VerifySignHelper.of(
                exchange.getRequest().getHeaders(), exchange.getRequest(),
                nonceChecker, secretKeyFinder
            ));
    }

    private Mono<Void> verify(
        ServerWebExchange exchange,
        GatewayFilterChain chain,
        VerifySignHelper verifySignHelper
    ) {

        return ServerRequest.create(exchange, HandlerStrategies.withDefaults().messageReaders())
            .bodyToMono(byte[].class)
            .defaultIfEmpty(EMPTY_BODY).flatMap(content -> {

                UserWithAkSk userWithAkSk = verifySignHelper.verify(content);

                String jwtToken = createUserToken(new User().setUserName(userWithAkSk.getName()).setUserType(userWithAkSk.getUserType()));

                ServerHttpRequest decorator =
                    new ServerHttpRequestDecorator(exchange.getRequest()) {
                        @Override
                        public HttpHeaders getHeaders() {
                            HttpHeaders httpHeaders = new HttpHeaders();
                            httpHeaders.putAll(super.getHeaders());
                            httpHeaders.set("jtoken", jwtToken);

                            return httpHeaders;
                        }

                        @Override
                        public Flux<DataBuffer> getBody() {
                            return Flux.defer(
                                () -> Mono.just(
                                    exchange.getResponse().bufferFactory().wrap(content)
                                ));
                        }
                    };

                return chain.filter(exchange.mutate().request(decorator).build());
            });
    }

    private String createUserToken(final User user) {
        try {
            return JwtUtils.createToken(user);
        } catch (final IllegalAccessException e) {
            log.error("", e);
            throw new IllegalStateException("BUG: cannot create user token");
        }
    }

    @Override
    public String name() {
        return "AuthorizationSignature";
    }

    static class Config {
        // empty
    }

    static class VerifySignHelper {

        private String method;
        private String accept;
        private String version;
        private String timestamp;
        private String nonce;
        private String contentMD5;
        private String accessKey;
        private String sign;
        private String path;
        private MultiValueMap<String, String> queries;
        private String contentType;

        private NonceChecker nonceChecker;
        private SecretKeyFinder secretKeyFinder;

        static VerifySignHelper of(
            final HttpHeaders headers, final ServerHttpRequest request,
            final NonceChecker nonceChecker, final SecretKeyFinder secretKeyFinder
        ) {

            Objects.requireNonNull(headers);
            Objects.requireNonNull(request);
            Objects.requireNonNull(nonceChecker);
            Objects.requireNonNull(secretKeyFinder);

            final String authorization = headers.getFirst(HttpHeaders.AUTHORIZATION);

            if (Strings.isNullOrEmpty(authorization)) {
                throw new ResultException(GatewayErrorCode.BAD_SIGN,
                    ImmutableMap.of(
                        HttpHeaders.AUTHORIZATION,
                        Objects.toString(authorization, MISSING_MSG)
                    ));
            }

            // wayz accessKey:sign
            final String prefix = "wayz ";
            if (!authorization.startsWith(prefix)) {
                throw new ResultException(GatewayErrorCode.BAD_SIGN,
                    ImmutableMap.of(HttpHeaders.AUTHORIZATION, authorization));
            }

            final String[] elts = authorization.substring(prefix.length()).split(":");
            if (elts.length != 2) {
                throw new ResultException(GatewayErrorCode.BAD_SIGN,
                    ImmutableMap.of(HttpHeaders.AUTHORIZATION, authorization));
            }

            String accessKey = elts[0];
            String sign = elts[1];

            String accept = "";
            final List<MediaType> mediaTypes = headers.getAccept();
            if (!mediaTypes.isEmpty()) {
                accept = mediaTypes.get(0).toString();
            }

            VerifySignHelper helper =  new VerifySignHelper();

            helper.method = request.getMethodValue();
            helper.accept = accept;
            helper.version = headers.getFirst(HEADER_X_VERSION);
            helper.timestamp = headers.getFirst(HEADER_X_TIMESTAMP);
            helper.nonce = headers.getFirst(HEADER_X_NONCE);
            helper.contentMD5 = headers.getFirst(HEADER_X_CONTENT_MD5);
            helper.accessKey = accessKey;
            helper.sign = sign;
            helper.path = request.getPath().value();
            helper.queries = request.getQueryParams();
            helper.contentType = Objects.toString(headers.getFirst(HttpHeaders.CONTENT_TYPE), "");

            helper.nonceChecker = nonceChecker;
            helper.secretKeyFinder = secretKeyFinder;

            return helper;
        }

        void checkVersion() {

            if (!X_VERSION.equals(version)) {
                throw new ResultException(GatewayErrorCode.BAD_SIGN_VERSION,
                    ImmutableMap.of(
                        HEADER_X_VERSION,
                        Objects.toString(version, MISSING_MSG)
                    ));
            }
        }

        void checkTimestamp() {

            if (Strings.isNullOrEmpty(timestamp)) {
                throw new ResultException(GatewayErrorCode.BAD_TIMESTAMP,
                    ImmutableMap.of(
                        HEADER_X_TIMESTAMP,
                        Objects.toString(timestamp, MISSING_MSG)
                    ));
            }

            try {
                final long now = System.currentTimeMillis() / 1000;
                if ((now - Long.parseLong(timestamp)) >= X_TIMESTAMP_EXPIRED_SEC) {
                    throw new ResultException(GatewayErrorCode.REQUEST_OUT_OF_DATE,
                        ImmutableMap.of(HEADER_X_TIMESTAMP, timestamp, "serverTimestamp", now));
                }
            } catch (final NumberFormatException e) {
                throw new ResultException(GatewayErrorCode.BAD_TIMESTAMP,
                    ImmutableMap.of(HEADER_X_TIMESTAMP, timestamp));
            }
        }

        void checkNonce() {

            if (Strings.isNullOrEmpty(nonce) || nonce.length() > MAX_NONCE_LENGTH) {

                throw new ResultException(GatewayErrorCode.BAD_NONCE,
                    ImmutableMap.of(
                        HEADER_X_NONCE, Objects.toString(nonce, MISSING_MSG)
                    )
                );
            }
            nonceChecker.check(nonce, NONCE_CACHE_PERIOD_MILLIS);
        }

        void checkContentMD5(final String contentMD5) {

            if (Strings.isNullOrEmpty(this.contentMD5) || !this.contentMD5
                .equalsIgnoreCase(contentMD5)) {

                throw new ResultException(GatewayErrorCode.BAD_CONTENT_MD5,
                    ImmutableMap.of(
                        HEADER_X_CONTENT_MD5,
                        Objects.toString(this.contentMD5, MISSING_MSG),
                        "calcContentMD5",
                        contentMD5
                    )
                );
            }
        }

        UserWithAkSk verify(final String contentMD5) {

            checkVersion();
            checkTimestamp();
            checkNonce();
            checkContentMD5(contentMD5);

            final UserWithAkSk userWithAkSk = secretKeyFinder.find(accessKey);

            final String sortedQueries = Objects.isNull(queries) ? "" :
                queries.toSingleValueMap().entrySet().stream().sorted(Entry.comparingByKey())
                    .map(e -> e.getKey() + "=" + Objects.toString(e.getValue(), ""))
                    .collect(Collectors.joining("&"));

            final String toSignStr = String.join("\r\n", accessKey, method, path,
                sortedQueries, accept, contentMD5, contentType, timestamp, version, nonce);

            final String secretKey = userWithAkSk.getSecretKey();
            final String calcSign = Base64.getEncoder().encodeToString(
                Hashing.hmacSha1(secretKey.getBytes(StandardCharsets.UTF_8))
                    .hashString(toSignStr, StandardCharsets.UTF_8).asBytes());
            if (!calcSign.equalsIgnoreCase(sign)) {
                log.error("verify sign failed: request:[{}], calc: [{}], secretKey:[{}], toSignStr: [{}]",
                    sign, calcSign, secretKey, toSignStr);
                throw new ResultException(GatewayErrorCode.INCORRECT_SIGN, ImmutableMap.of(
                    "requestSign", sign
                ));
            }

            return userWithAkSk;
        }

        UserWithAkSk verify(final byte[] content) {
            return verify(
                Objects.isNull(content) ?
                    EMPTY_BODY_MD5 :
                    Hashing.md5().hashBytes(content).toString());
        }

    }
}

就可以在相应的域名进行校验了！

雪中鱼01
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
API接签名验证
08-01
http Restful API接签名验证 ,防API接口进行在公网裸奔
python验证码识别接口 服务器_Python+selenium 第三方接口识别图文验证码
weixin_39640762的博客
11-30 433
以第三方斐斐打码接口为例(此方法只学习使用)#!/usr/bin/python3# coding=utf-8# Author: 文from re import matchfrom io import BytesIOfrom time import timeimport base64import hashlibimport requestsclass GetCode():def __init__(s...
winform项目——计算器程序02：计算逻辑实现
爱编程的小龙虾
01-02 367
上一篇文章我们根据VS文档上的教程搭建了计算器的界面，本篇文章就介绍如何实现它的计算逻辑。 逻辑分析 首先，我们要明白，实现计算逻辑，实际上就是在界面上按钮的点击事件中进行一些操作。我们可以将界面上的按钮分为两大类，一类是用于输入的数字按钮，一类是用于计算的运算按钮。这两类按钮要做的事情都是类似的，因此我们可以在编码时做一个公共的方法即可。 其次，计算器的本质是两个操作数A、B进行某种方式的...
API接口访问鉴权设计和实现的经验总结
最新发布
qq_33665793的博客
02-09 521
概述了OAuth 2.0鉴权框架的工作原理和四种角色（客户端、资源所有者、授权服务器、资源服务器），以及常见的授权类型（授权码模式、隐式授权模式、密码模式、客户端凭证模式）。总结：强调了设计和实现API接口访问鉴权时的综合考虑，需要根据具体场景选择适当的鉴权方法，并采取多种安全措施来确保API资源的安全性。- 引入了一些其他与API安全性相关的考虑因素，例如HTTPS的使用、敏感数据的保护、日志记录和监控等。- 解释了API接口访问鉴权的基本概念和作用，以及为什么需要对API进行鉴权。
ak sk认证java demo_AK-SK鉴权
weixin_29765215的博客
03-03 4117
插件名称类别名称描述属性服务插件AK/SK 鉴权gw-ak_sk_auth用户鉴权功能描述配置自己的AK/SK，或是使用网关自动生成的AK/SK，完成认证。客户端涉及的AK/SK签名以及请求发送的流程概述如下：(1)构造规范请求。将待发送的请求内容按照与API网关后台约定的规则组装，确保客户端签名、API网关后台认证时使用的请求内容一致。(2)使用规范请求和其他信息创建待签字符串。(3)使用AK/...
HTTP请求签名校验逻辑
ruangongtaotao的专栏
07-10 557
在签名算法中定义签名字符串有效期的一般做法是在请求参数中加入一个时间戳参数。客户端在生成签名字符串时，将时间戳参数和其他请求参数一起参与签名的计算，服务器端在接收到请求后，会根据相同的签名算法计算签名字符串并比对时间戳参数，如果时间戳过期，则拒绝请求。具体来说，签名算法的实现可以包含以下几个步骤：1在请求参数中加入一个时间戳参数，例如timestamp。2将时间戳参数和其他请求参数一起进行签名计算，得到签名字符串。3在请求中添加签名字符串和时间戳参数，发送给服务器。
支付宝 收款通知 mysql_基于支付宝微信通知的一种个人收款回调方案（转）
weixin_34584910的博客
01-20 646
最近闲来无事，看到网上有一些免签支付回调的服务商，当时感觉很新奇，于是自己动手看看怎么玩的，先看成果App上监听通知并向服务器POST支付信息服务端的支付订单表下面说原理及流程1.App上使用NotificationListenerService监听通知栏通知，一旦微信支付或者支付宝收款收到消息，读取消息的内容，然后使用正则匹配金额2.App读取到金额后，构造支付订单，支付订单包含：订单号(App...
HMAC API 接口签名 Message安全验证
心猿意码
05-21 1326
什么是HMAC？ HMAC 全称（Hash-based Message Authentication Code，即基于Hash的消息的认证码）。 - 基本过程为对某个消息，利用提前共享的对称密钥和Hash算法进行加密处理，得到HMAC值。 - 该HMAC值提供方可以证明自己拥有共享密钥的对称密钥，并且消息自身可以利用HMAC确保未经篡改。 为什么需要API接口签名？ 对外开放的 API 接口都会面临一些安全问题，例如伪装攻击、篡改攻击、重放攻击以及数据信息泄漏的风险。利用 API 接口签名能...
开放平台设计之接口签名认证
ybb_ymm的专栏
03-28 1608
当前时代，数据是王道！当我们自己的平台有了足够大的数据量，就有可能诞生一个开放平台宫第三方分析、使用。那么我们怎么去实现对外部调用接口的控制与鉴权呢？这是我们今天的重点——接口签名认证！！！
java反向认证接口,API接口身份验证方案设计
weixin_28721019的博客
03-15 468
Http Basic AuthenticationHttp Basic Authentication是一种比较简单的身份认证方式。在 Http 请求Header 中添加键值对 Authorization: Basic xxx，其中xxx 是 base64(username:passowrd)。例如 username 为 zmk ，password 为 123456，请求则如下GET /auth/...
拍拍API新版鉴权要用到的HMAC函数
04-27
拍拍API新版鉴权要用到的HMAC函数. Step 3. 生成签名值 1. 使用HMAC-SHA1加密算法，将Step1中的到的源串以及Step2中得到的密钥进行加密。 （注：一般程序语言中会内置HMAC-SHA1加密算法的函数，例如PHP5.1.2之后...
larsign:通过Web API服务器进行Laravel签名认证
04-19
Api授权的Laravel 5签名中间件关于larsign软件包授权的签名服务器。特征处理larsign请求安装Laravel需要havenshen/larsign包在你的composer.json和更新您的依赖关系： $ composer require havenshen/larsign 将...
腾讯云·短信·TC3-HMAC-SHA256API3.0签名V3算法带发送例子
12-30
腾讯云·短信·TC3-HMAC-SHA256API3.0签名V3算法带发送例子
simple-hmac-auth:旨在简化使用HMAC签名的构建API的协议规范和节点库
05-05
HTTP身份验证规范和Node库旨在简化使用HMAC签名的构建API。 规格 对于所有传入请求，应使用秘密对HTTP方法，路径，查询字符串，标头和正文进行签名，并将其作为请求的“签名”发送。 标头应包含用户的API密钥以及...
仿淘宝签名认证 HMAC加密
04-11
仿淘宝其中的一种签名认证方式，可以有效的防止参数网络篡改，实现统一接口调用，代码简单易懂，适合新手学习签名认证，本人接触签名认证的时间也不长，有什么问题可以发私信一起交流
mysql varchar能不能超过255个字节及产生的问题。
热门推荐
songkai558919的博客
08-23 1万+
项目里突然varchar字段设置255也不够用了，记得规定不能超过255，今天查了一下，现总结如下： MySQL要求一个行定义长度不能超过 65535 bytes（所有字符串类型字段包括其字段名称占用空间都计算在内， text、blob等大字段类型除外)。所有如果一个表有很多varchar字段的时候，不应该把varchar设置的特别大，会影响后面的字段 InnoDB存储引擎的表索引的前缀长度最长是767字节(bytes)(前缀长度适用于mysql5.6及以前，后续版本有变化) 你如果需要建索引，就
‘The client noticed that the server is not a supported distribution of Elasticsearch‘ 报错及解决办法
songkai558919的博客
08-11 6289
django项目运行的好好的，突然接口查询错误。 观察报错信息 { "code": 400102, "message": "请求错误", "data": { "detail": "The client noticed that the server is not a supported distribution of Elasticsearch" } } 搜索百度无果，随搜索谷歌 查询到新闻链接 链接如下： https://www.there
多用户并发操作的解决方案,同步锁的具体实施方法
songkai558919的博客
02-03 5758
一：并发操作出现的原因 原因：多个动作在一瞬间同时操作同一数据 现象： 多人在某一瞬间通过相同的方式操作同一条数据 多人在某一瞬间通过不同的方式操作同一条数据 在某一瞬间，同一动作，多次执行 二：并发举例及解决办法 针对上述的三种的情况，分别以实际情况进行举例。 【多人在某一瞬间通过相同的方式操作同一条数据】 1.某仓库系统有一品牌商品A，商品A在数据库中只允许存在一条记录，库存的数量是这条数据的一个字段，现有库存100件，在某一天到货了1000件。由于数量比较大，现在需要10名操作员去
java第三方开放api接口签名
07-12
在Java中，可以使用以下步骤对第三方开放API接口进行签名： 1. 获取API请求参数。 根据API接口文档，获取需要包含在请求中的参数。这些参数通常包括身份验证参数（如appKey、appSecret等）和业务参数（如请求方法、时间戳、随机数、数据等）。 2. 对参数进行排序。 将获取到的参数按照参数名进行字典排序，可以使用TreeMap或自定义比较器来实现。 3. 拼接参数字符串。 将排序后的参数按照key=value的形式拼接成字符串，不包括特殊字符，如空格、换行等。 4. 生成签名。 将拼接后的参数字符串与密钥（appSecret）进行加密生成签名。常见的加密算法有MD5、SHA1、HMAC等，具体使用哪种算法取决于API接口的要求。 5. 将签名加入请求参数。 将生成的签名添加到请求参数中，一般以sign或signature为参数名。 6. 发送请求。 将包含签名的请求参数发送到API接口地址。 请注意，以上步骤是一种通用的签名方式，具体的签名方法可能会因API接口的要求而有所不同。在使用第三方开放API接口时，建议参考具体的接口文档或开发者指南，以获取准确的签名方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值