如何设计安全可靠的开放接口---对请求参加密保护

已于 2022-06-07 08:09:12 修改
阅读量1.1k 收藏 4
点赞数 2
分类专栏： 经验分享 文章标签： java 开发语言
于 2022-05-25 21:45:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_WYL2016/article/details/124974277
版权

文章目录

【如何设计安全可靠的开放接口】系列

1. 如何设计安全可靠的开放接口—之Token
2. 如何设计安全可靠的开放接口—之AppId、AppSecret
3. 如何设计安全可靠的开放接口—之签名(sign)
4. 如何设计安全可靠的开放接口【番外篇】—关于MD5应用的介绍
5. 如何设计安全可靠的开放接口—还有哪些安全保护措施
6. 如何设计安全可靠的开放接口—对请求参加密保护
7. 如何设计安全可靠的开放接口【番外篇】— 对称加密算法

前言

前面提到过，到目前为止我们已经基本上实现了一个安全可靠的开放接口设计，本节我们再来完善最后一块拼图：对业务参数的加密。
有些时候，如果有些参数比较敏感，你不希望以明文的方式在网络中传输，那么就可以使用加解密的方式。

AES加解密

一般来说，要完成对业务参数的加解密，最常用的算法就是AES了，它是一种对称加密算法，也是当前公认的即安全，又兼顾性能的对称加密算法，加解密双方通过约定好的密钥来分别对明文加密，和密文解密，基本常见主流的工具包中都有其实现的API，可以直接拿来使用，非常方便。

代码实现

具体代码实现方式，就继续接着前面的案例，添加了clientCallWithEncryption和serverVerifyWithDecryption(string)两个方法，分别是接口请求方对请求的业务参数进行加密，和接口提供方对请求参数进行解密的版本。

import com.alibaba.fastjson.JSONObject;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.collect.Maps;
import lombok.SneakyThrows;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.lang3.RandomStringUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
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.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;


public class AppUtils {

    /**
     * key:appId、value:appSecret
     */
    static Map<String, String> appMap = Maps.newConcurrentMap();

    /**
     * key:appId、value:appAESSecret
     */
    static Map<String, String> appAesMap = Maps.newConcurrentMap();

    /**
     * 分别保存生成的公私钥对
     * key:appId，value:公私钥对
     */
    static Map<String, Map<String, String>> appKeyPair = Maps.newConcurrentMap();


    static Cache<String, String> cache = CacheBuilder.newBuilder()
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .build();

    private static final String AES_ALG = "AES";

    private static final String AES_CBC_PCK_ALG = "AES/CBC/PKCS5Padding";

    private static final byte[] AES_IV = initIv();


    public static void main(String[] args) throws Exception {
        // 模拟生成appId、appSecret
        String appId = initAppInfo();

        // 根据appId生成公私钥对
        initKeyPair(appId);

        // 模拟请求方
        String requestParam = clientCall();

        // 模拟提供方验证
        serverVerify(requestParam);

        System.out.println("***************************业务参数加密版本***************************");

        // 以下是带加密业务参数的版本
        String encryptionContent = clientCallWithEncryption();

        serverVerifyWithDecryption(encryptionContent);
    }

    private static void serverVerifyWithDecryption(String encryptionContent) throws Exception {
        APIRequestEntity apiRequestEntity = JSONObject.parseObject(encryptionContent, APIRequestEntity.class);
        Header header = apiRequestEntity.getHeader();

        // AES解密
        Object body = apiRequestEntity.getBody();
        String content = decrypt(body.toString(), appAesMap.get(header.getAppId()), "UTF-8");
        System.out.println();
        System.out.println("【业务参数解密后内容】：" + content);

        UserEntity userEntity = JSONObject.parseObject(content, UserEntity.class);

        // 首先，拿到参数后同样进行签名
        String sign = getSHA256Str(JSONObject.toJSONString(userEntity));
        if (!sign.equals(header.getSign())) {
            throw new Exception("数据签名错误！");
        }

        // 从header中获取相关信息，其中appSecret需要自己根据传过来的appId来获取
        String appId = header.getAppId();
        String appSecret = getAppSecret(appId);
        String nonce = header.getNonce();
        String timestamp = header.getTimestamp();

        // 请求时间有效期校验
        long now = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
        if ((now - Long.parseLong(timestamp)) / 1000 / 60 >= 5) {
            throw new Exception("请求过期！");
        }

        // nonce有效性判断
        String str = cache.getIfPresent(appId + "_" + nonce);
        if (Objects.nonNull(str)) {
            throw new Exception("请求失效！");
        }
        cache.put(appId + "_" + nonce, "1");


        // 按照同样的方式生成appSign，然后使用公钥进行验签
        Map<String, String> data = Maps.newHashMap();
        data.put("appId", appId);
        data.put("nonce", nonce);
        data.put("sign", sign);
        data.put("timestamp", timestamp);
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[0]);
        Arrays.sort(keyArray);
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
        }
        sb.append("appSecret=").append(appSecret);


        if (!rsaVerifySignature(sb.toString(), appKeyPair.get(appId).get("publicKey"), header.getAppSign())) {
            throw new Exception("验签错误！");
        }

        System.out.println();
        System.out.println("【提供方】验证通过！");
    }

   
    private static byte[] initIv() {

        try {
            Cipher cipher = Cipher.getInstance(AppUtils.AES_CBC_PCK_ALG);
            int blockSize = cipher.getBlockSize();
            byte[] iv = new byte[blockSize];
            for (int i = 0; i < blockSize; ++i) {
                iv[i] = 0;
            }
            return iv;
        } catch (Exception e) {
            int blockSize = 16;
            byte[] iv = new byte[blockSize];
            for (int i = 0; i < blockSize; ++i) {
                iv[i] = 0;
            }
            return iv;
        }
    }

    public static String decrypt(String content, String key, String charset) throws Exception {
        Cipher cipher = Cipher.getInstance(AES_CBC_PCK_ALG);
        IvParameterSpec iv = new IvParameterSpec(initIv());
        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(Base64.decodeBase64(key.getBytes()),
                AES_ALG), iv);
        byte[] cleanBytes = cipher.doFinal(Base64.decodeBase64(content.getBytes()));
        return new String(cleanBytes, charset);
    }

    public static String encrypt(String content, String aesKey, String charset) throws Exception {
        Cipher cipher = Cipher.getInstance(AES_CBC_PCK_ALG);
        IvParameterSpec iv = new IvParameterSpec(AES_IV);
        cipher.init(Cipher.ENCRYPT_MODE,
                new SecretKeySpec(Base64.decodeBase64(aesKey.getBytes()), AES_ALG), iv);
        byte[] encryptBytes = cipher.doFinal(content.getBytes(charset));
        return new String(Base64.encodeBase64(encryptBytes));
    }

    private static String clientCallWithEncryption() throws Exception {
        // 假设接口请求方与接口提供方，已经通过其他渠道，确认了双方交互的appId、appSecret
        String appId = "123456";
        String appSecret = appMap.get(appId);
        String timestamp = String.valueOf(System.currentTimeMillis());

        // 随机数
        String nonce = RandomStringUtils.randomAlphanumeric(10);

        // 业务请求参数
        UserEntity userEntity = new UserEntity();
        userEntity.setUserId("1");
        userEntity.setPhone("13912345678");

        // 使用sha256的方式生成签名
        String sign = getSHA256Str(JSONObject.toJSONString(userEntity));

        Map<String, String> data = Maps.newHashMap();
        data.put("appId", appId);
        data.put("nonce", nonce);
        data.put("sign", sign);
        data.put("timestamp", timestamp);
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[0]);
        Arrays.sort(keyArray);
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
        }
        sb.append("appSecret=").append(appSecret);

        System.out.println("【请求方】拼接后的参数：" + sb.toString());
        System.out.println();

        // 使用sha256withRSA的方式对header中的内容加签
        String appSign = sha256withRSASignature(appKeyPair.get(appId).get("privateKey"), sb.toString());
        System.out.println("【请求方】appSign：" + appSign);
        System.out.println();

        // 请求参数组装
        Header header = Header.builder()
                .appId(appId)
                .nonce(nonce)
                .sign(sign)
                .timestamp(timestamp)
                .appSign(appSign)
                .build();
        APIRequestEntity apiRequestEntity = new APIRequestEntity();
        apiRequestEntity.setHeader(header);
        apiRequestEntity.setBody(encrypt(JSONObject.toJSONString(userEntity), appAesMap.get(appId), "UTF-8"));

        String requestParam = JSONObject.toJSONString(apiRequestEntity);
        System.out.println("【请求方】接口请求参数: " + requestParam);

        return requestParam;
    }

    private static String initAppInfo() {
        // appId、appSecret生成规则，依据之前介绍过的方式，保证全局唯一即可
        String appId = "123456";
        String appSecret = "654321";

        // AES密钥，同样每个appId分别对应一个AES密钥。
        String encryptionKey = "50AHsYx7H3OHVMdF123456";

        appMap.put(appId, appSecret);
        appAesMap.put(appId, encryptionKey);

        return appId;
    }

    private static void serverVerify(String requestParam) throws Exception {
        APIRequestEntity apiRequestEntity = JSONObject.parseObject(requestParam, APIRequestEntity.class);
        Header header = apiRequestEntity.getHeader();
        UserEntity userEntity = JSONObject.parseObject(JSONObject.toJSONString(apiRequestEntity.getBody()), UserEntity.class);

        // 首先，拿到参数后同样进行签名
        String sign = getSHA256Str(JSONObject.toJSONString(userEntity));
        if (!sign.equals(header.getSign())) {
            throw new Exception("数据签名错误！");
        }

        // 从header中获取相关信息，其中appSecret需要自己根据传过来的appId来获取
        String appId = header.getAppId();
        String appSecret = getAppSecret(appId);
        String nonce = header.getNonce();
        String timestamp = header.getTimestamp();

        // 请求时间有效期校验
        long now = LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
        if ((now - Long.parseLong(timestamp)) / 1000 / 60 >= 5) {
            throw new Exception("请求过期！");
        }

        // nonce有效性判断
        String str = cache.getIfPresent(appId + "_" + nonce);
        if (Objects.nonNull(str)) {
            throw new Exception("请求失效！");
        }
        cache.put(appId + "_" + nonce, "1");


        // 按照同样的方式生成appSign，然后使用公钥进行验签
        Map<String, String> data = Maps.newHashMap();
        data.put("appId", appId);
        data.put("nonce", nonce);
        data.put("sign", sign);
        data.put("timestamp", timestamp);
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[0]);
        Arrays.sort(keyArray);
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
        }
        sb.append("appSecret=").append(appSecret);


        if (!rsaVerifySignature(sb.toString(), appKeyPair.get(appId).get("publicKey"), header.getAppSign())) {
            throw new Exception("验签错误！");
        }

        System.out.println();
        System.out.println("【提供方】验证通过！");

    }

    public static String clientCall() {
        // 假设接口请求方与接口提供方，已经通过其他渠道，确认了双方交互的appId、appSecret
        String appId = "123456";
        String appSecret = appMap.get(appId);
        String timestamp = String.valueOf(System.currentTimeMillis());

        // 随机数
        String nonce = RandomStringUtils.randomAlphanumeric(10);

        // 业务请求参数
        UserEntity userEntity = new UserEntity();
        userEntity.setUserId("1");
        userEntity.setPhone("13912345678");

        // 使用sha256的方式生成签名
        String sign = getSHA256Str(JSONObject.toJSONString(userEntity));

        Map<String, String> data = Maps.newHashMap();
        data.put("appId", appId);
        data.put("nonce", nonce);
        data.put("sign", sign);
        data.put("timestamp", timestamp);
        Set<String> keySet = data.keySet();
        String[] keyArray = keySet.toArray(new String[0]);
        Arrays.sort(keyArray);
        StringBuilder sb = new StringBuilder();
        for (String k : keyArray) {
            if (data.get(k).trim().length() > 0) // 参数值为空，则不参与签名
                sb.append(k).append("=").append(data.get(k).trim()).append("&");
        }
        sb.append("appSecret=").append(appSecret);

        System.out.println("【请求方】拼接后的参数：" + sb.toString());
        System.out.println();

        // 使用sha256withRSA的方式对header中的内容加签
        String appSign = sha256withRSASignature(appKeyPair.get(appId).get("privateKey"), sb.toString());
        System.out.println("【请求方】appSign：" + appSign);
        System.out.println();

        // 请求参数组装
        Header header = Header.builder()
                .appId(appId)
                .nonce(nonce)
                .sign(sign)
                .timestamp(timestamp)
                .appSign(appSign)
                .build();
        APIRequestEntity apiRequestEntity = new APIRequestEntity();
        apiRequestEntity.setHeader(header);
        apiRequestEntity.setBody(userEntity);

        String requestParam = JSONObject.toJSONString(apiRequestEntity);
        System.out.println("【请求方】接口请求参数: " + requestParam);

        return requestParam;
    }


    /**
     * 私钥签名
     *
     * @param privateKeyStr
     * @param dataStr
     * @return
     */
    public static String sha256withRSASignature(String privateKeyStr, String dataStr) {
        try {
            byte[] key = Base64.decodeBase64(privateKeyStr);
            byte[] data = dataStr.getBytes();
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(key);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            Signature signature = Signature.getInstance("SHA256withRSA");
            signature.initSign(privateKey);
            signature.update(data);
            return new String(Base64.encodeBase64(signature.sign()));
        } catch (Exception e) {
            throw new RuntimeException("签名计算出现异常", e);
        }
    }

    /**
     * 公钥验签
     *
     * @param dataStr
     * @param publicKeyStr
     * @param signStr
     * @return
     * @throws Exception
     */
    public static boolean rsaVerifySignature(String dataStr, String publicKeyStr, String signStr) throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKeyStr));
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initVerify(publicKey);
        signature.update(dataStr.getBytes());
        return signature.verify(Base64.decodeBase64(signStr));
    }

    /**
     * 生成公私钥对
     *
     * @throws Exception
     */
    public static void initKeyPair(String appId) throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, String> keyMap = Maps.newHashMap();
        keyMap.put("publicKey", new String(Base64.encodeBase64(publicKey.getEncoded())));
        keyMap.put("privateKey", new String(Base64.encodeBase64(privateKey.getEncoded())));
        appKeyPair.put(appId, keyMap);
    }

    private static String getAppSecret(String appId) {
        return String.valueOf(appMap.get(appId));
    }


    @SneakyThrows
    public static String getSHA256Str(String str) {
        MessageDigest messageDigest;
        messageDigest = MessageDigest.getInstance("SHA-256");
        byte[] hash = messageDigest.digest(str.getBytes(StandardCharsets.UTF_8));
        return Hex.encodeHexString(hash);
    }

}

对比带加密和不带加密版本的执行效果。

【请求方】拼接后的参数：appId=123456&nonce=TWDo7kxIkE&sign=c630885277f9d31cf449697238bfc6b044a78545894c83aad2ff6d0b7d486bc5&timestamp=1653486151381&appSecret=654321

【请求方】appSign：N9QZEUvaK6HrzGlg2tnry4BoqWpuvy9UnXw2UBmJIyc6kDwrofCwnJs1Djc6+m619vVNbsrM8/EOHFnROrxVeNwD0n3hCDAlYgZ4uZVI/d3ZAFQqbl9qiNJKp0UgyB/Za6oyT+xdtihwwZb6qH5J/UOeGBJLel61kxk7/tIgtQsZ9s2Akk4epjsLEYbGhlHzBT7Misq7Ij60ODr21eKtzdEj6NQeM+3mLkAF/O27BOcjBcOdExRYwtmwvHRtYUnBuapVcnLtDif+7oauHJDnEFCt5+n8P5Q0lGSf5kD7sVz9rviqGV271n8R/P3rIc0Y/g1rm5jm42uy0j7fwIIj7Q==

【请求方】接口请求参数: {"body":{"phone":"13912345678","userId":"1"},"header":{"appId":"123456","appSign":"N9QZEUvaK6HrzGlg2tnry4BoqWpuvy9UnXw2UBmJIyc6kDwrofCwnJs1Djc6+m619vVNbsrM8/EOHFnROrxVeNwD0n3hCDAlYgZ4uZVI/d3ZAFQqbl9qiNJKp0UgyB/Za6oyT+xdtihwwZb6qH5J/UOeGBJLel61kxk7/tIgtQsZ9s2Akk4epjsLEYbGhlHzBT7Misq7Ij60ODr21eKtzdEj6NQeM+3mLkAF/O27BOcjBcOdExRYwtmwvHRtYUnBuapVcnLtDif+7oauHJDnEFCt5+n8P5Q0lGSf5kD7sVz9rviqGV271n8R/P3rIc0Y/g1rm5jm42uy0j7fwIIj7Q==","nonce":"TWDo7kxIkE","sign":"c630885277f9d31cf449697238bfc6b044a78545894c83aad2ff6d0b7d486bc5","timestamp":"1653486151381"}}

【提供方】验证通过！
***************************业务参数加密版本***************************
【请求方】拼接后的参数：appId=123456&nonce=5haU5Ltbm5&sign=c630885277f9d31cf449697238bfc6b044a78545894c83aad2ff6d0b7d486bc5&timestamp=1653486151555&appSecret=654321

【请求方】appSign：ytqqV+llqbpRBzzO2Kr/gEyLgmBnQHQ5iLDdEGvU2Rq6HhahC46i3hV85LI392Yduh98EvC9x2i8Vve6IHY4Gsp6pch4gw6DxvndB9Gk84NYBMYnsXc9+/ddKD44CbDMd7BzHB+A5zNcuXyJqFYQLxV+5GpHXFYtmqHB+jVUYK2ZnPxMi2PXkKENlsSYUdNh8xp2gM1OX+gB9T/yCoVTAN3itHAzBCAS5c52vTGbz9qKw7oUx4L5Hs5OkxAw8q3t8H+srX2pi/F9+1KOAIbw6Y7V4YggMXq3WtXTlPLnx7z+YJu9DsoevDKDdJPkiq86liUMmUFyXlAViW2bx26RYQ==

【请求方】接口请求参数: {"body":"RLdUZ42CyRpUAzu9CsDS8Q0X1ARoM0dynwSmF66bfkDxpWBDQC0xYFDjBJWk13WK","header":{"appId":"123456","appSign":"ytqqV+llqbpRBzzO2Kr/gEyLgmBnQHQ5iLDdEGvU2Rq6HhahC46i3hV85LI392Yduh98EvC9x2i8Vve6IHY4Gsp6pch4gw6DxvndB9Gk84NYBMYnsXc9+/ddKD44CbDMd7BzHB+A5zNcuXyJqFYQLxV+5GpHXFYtmqHB+jVUYK2ZnPxMi2PXkKENlsSYUdNh8xp2gM1OX+gB9T/yCoVTAN3itHAzBCAS5c52vTGbz9qKw7oUx4L5Hs5OkxAw8q3t8H+srX2pi/F9+1KOAIbw6Y7V4YggMXq3WtXTlPLnx7z+YJu9DsoevDKDdJPkiq86liUMmUFyXlAViW2bx26RYQ==","nonce":"5haU5Ltbm5","sign":"c630885277f9d31cf449697238bfc6b044a78545894c83aad2ff6d0b7d486bc5","timestamp":"1653486151555"}}

业务参数解密后内容：{"phone":"13912345678","userId":"1"}

【提供方】验证通过！
码拉松
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
通用接口开放平台设计与实现——（1）整体介绍
学海无涯，行者无疆
01-25 6281
首先简单聊下背景，大概是几年前，工作中遇到这么一个复杂的应用场景，大型企业中的物流系统，需要跟众多的内外部系统交互，对接的系统达到十几个，接口数量在50个左右，并且后续还会大量增加新的对接方，并且很多对接方是类似的，例如跟汽运物流厂商的运输管理系统TMS，进行运输委托、运力反馈、运费结算、签收回传等交互。API服务：物流接口平台对外提供统一的数据接口服务，其他应用系统通过调用API服务，一方面，可以查询权限范围内的物流数据，另一方面，可以将自身系统产生的数据推送至物流系统。
接口参数加密
yarbrough
08-15 2767
最近，公司有一些接口需要对合作方开放，需要做参数加密以及合作方身份认证，下面是我的做法： 思想：因为部分接口需要加密，所以通过自定义注解，加上注解的接口才进行校验。 我们会为合作方下发 partnerId 和 privateKey ，客户端和服务端保留这两个信息。 加密方式： 1.必须提交的参数 POST提交 signature: 签名 //必填 partnerId： 合作者ID //必填 t...
Postman通用接口加密解决方案_postman对字段进行smrsa解密
最新发布
m0_60691292的博客
04-17 838
如果不想在环境变量夹中显示动态生成的环境变量可以将下方tests中的脚本加入到tests中。// ------------ AES 加密 ------------// ------------ RSA 加密 ------------(img-36Y6dA2L-1713344907557)]// ------ 存储所有未加密环境变量 ------// ------ 导入RSA ------// ------ 通用方法 ------// 获取当前请求中的加密变量。// 提取{{}}中内容。
实战！接口数据加解密应该如何设计？
竹林幽深
04-15 248
江苏。
java接口开发参数加密_常见开放接口签名简单实现-请求参数排序加密
weixin_28929351的博客
02-27 866
常见的签名方式实现一般分为以下几个步骤 :1 . 将所有(或者特殊)请求参数按特定规则排序；2 . 将请求参数按特定规则拼装为加密字符串；3 . 加密算法对加密字符串进行加密，得到签名。下面自己写了一个常见的实现方式，以便记录，这里只是示例说明基本常规实现，使用则还是根据项目的真实情况去选择。例如，下面我简单实现了一个restful接口，/signTest去验证签名。1.我这里使用了MD5加密方式...
太强了！看看别人设计的安全好用的OpenApi！
竹林幽深
10-26 185
在提到对于开放接口的安全设计时，一定少不了对于摘要算法的应用（MD5算法是其实现方式之一），在接口设计方面它可以帮助我们完成数据签名的功能，也就是说用来防止请求或者返回的数据被他人篡改。本节我们单从安全的角度出发，看看到底哪些场景下的需求可以借助MD5的方式来实现。其入口参数有三个：key、data、mode。key为加密解密使用的密钥，data为加密解密的数据，mode为其工作模式。当模式为加密模式时，明文按照64位进行分组，形成明文组，key用于对数据加密，当模式为解密模式时，key用于对数据解密。
java -加密安全的java即时通信系统设计
10-06
在设计一个加密安全的Java即时通信系统时，我们需要考虑多个关键方面，确保用户数据的隐私和安全性。以下是一些核心知识点： 1. **Java平台**：Java是一种跨平台的编程语言，适合开发分布式网络应用程序，如即时...
优选第四章-电子商务支付安全技术PPT文档.ppt
12-01
2. 支付的条件问题：电子支付的条件问题是指在支付过程中可能遇到的各种技术和法律问题，如支付系统的可靠性、支付工具的安全性等。 六、电子支付系统基本体系构成 电子支付系统的基本结构可以分为四个部分： 1. ...
Go-一个开放的文件下载服务
08-13
1. **基础架构设计**：一个开放的文件下载服务通常需要包含以下几个关键组件： - **路由处理**：使用http.HandleFunc注册路由，处理不同的HTTP请求，如GET请求用于文件下载。 - **文件存储**：服务需要一个文件...
Qi-API 接口开放平台开发者调用工具.zip
03-07
开发工具在软件开发生命周期中扮演着至关重要的角色，它们旨在简化和加速从概念设计到产品部署的各个环节。以下是开发工具的主要作用： 代码编写与编辑： 提供集成开发环境（IDE），如Visual Studio、Eclipse、...
alipay-sdk-java20170307171631.jar
12-09
《支付宝Java SDK 20170307171631详解》 ...通过合理的配置和调用，开发者可以为自己的应用程序添加安全可靠的支付选项，提升用户体验。同时，对于开发者来说，理解和掌握SDK的使用技巧以及安全规范至关重要。
开放平台的Open API设计
07-31
开放平台的Open API设计 开发者的抱怨 • 加密算法从没有听过！ • 从其他平台迁移过来好难啊！ • 说明文档看不懂
设计一个安全的对外开放接口+实现案例
十指演绎悲伤的博客
06-19 2158
对外开放接口
保证接口数据安全的10种方案
m0_71777195的博客
07-05 1092
我们日常开发中，如何保证接口数据的安全性呢？个人觉得，接口数据安全的保证过程，主要体现在这几个方面：一个就是数据传输过程中的安全，还有就是数据到达服务端，如何识别数据，最后一点就是数据存储的安全性。今天跟大家聊聊保证接口数据安全的10个方案。正在上传…重新上传取消我们都知道，数据在网络传输过程中，很容易被抓包。如果使用的是http协议，因为它是明文传输的，用户的数据就很容易被别人获取。所以需要对数据加密。常见的实现方式，就是对关键字段加密。比如，你一个登录的接口，你可以对密码加密。一般用什么加密算法呢？简单
get和post接口加密
只为成功找方法 不为失败找借口
05-03 2538
这日，刚撸完2两代码，正准备掏出手机摸鱼放松放松，只见老大朝我走过来，并露出一个”善意“的微笑，兴伟呀，xx项目有于安全问题，需要对接口整体进行加密处理，你这方面比较有经验，就给你安排上了哈，看这周内提测行不...，额，摸摸头上飘摇着而稀疏的长发，感觉我爱了。 和产品、前端同学对外需求后，梳理了相关技术方案， 主要的需求点如下： 尽量少改动，不影响之前的业务逻辑； 考虑到时间紧迫性，可采用对称性加密方式，服务需要对接安卓、IOS、H5三端，另外考虑到H5端存储密钥安全性相对来说会低一些，故分针对H5和
如何实现接口加密？
yanghang520520的博客
12-31 6999
如何实现接口加密？ 为什么要使用接口加密？ 系统明文传输的数据会被不明身份的人用抓包工具抓取，从而威胁系统和数据的安全性 我这里采用非对称加密算法： 非对称加密算法是一种密钥的保密方法，加密和解密使用两个不同的密钥，公开密钥（publickey:简称公钥）和私有密钥（privatekey:简称私钥）。公钥与私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。 非对称加密算法的特点： 算法强度复杂 加密解密速度没有对称密钥算法的速度快 经典应用场景：数字签名（私钥加密，公钥验证） 常用的算法：
Postman进阶篇（三）-实战：pre-request script加密接口请求参数（AES、MD5）
做测试多少要会点的技能
08-29 4435
接口请求加密是放在接口请求前，所以Pre-request Script的运行机制适合用来解决接口请求加密的问题。
如何保证HTTP接口请求的安全呢？
热门推荐
MIYAOW
03-19 1万+
在二家公司负责后台开发与APP接口开发。 那我们要如何对接口请求进行一个安全校验或者拦截非法请求呐？ 1、选择拦截过滤器。 在请求的时候对请求方法进行一次拦截处理。比如非正常访问的方法已经注入插入可执行语句参数验证等在拦截中进行一次安全校验保证 请求不是非法请求。 2、数据加密。我们知道目前大部分APP接口都是通过Http协议进行调用的容易被抓包拦截。 我们可以对客户端和服务端都对数据
413 (Request Entity Too Large)
zzw_17600691357的博客
03-02 2384
报错 POST http://ccsoms-dev.aixin-ins.net/prod-api/doublerecord/uploadFile 413 (Request Entity Too Large) 操作 docker发布vue项目文件上传 问题原因 默认情况下，Nginx请求体大小是1M，超过这个限制就会出现413错误 可以在Nginx配置中的http节点中设置大小 client_max_body_size 10m; # 当前处理的项目发布在docker容器中，使用的nginx # Tem
Quectel-BC260Y-CN-QuecOpen-API-参考手册-V1.0
01-09
QuecOpen是一个开放的嵌入式平台，为开发者提供了丰富的API接口，以便于进行应用程序的开发和设备的集成。 手册内容包括API的详细说明，涵盖了初始化、网络连接管理、数据传输、AT命令控制、电源管理、系统设置等多...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码拉松

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值