接口签名参数排序

已于 2024-07-10 11:23:51 修改
阅读量190 收藏
点赞数 1
文章标签： java
于 2024-07-09 14:45:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HJ_20210519/article/details/140294671
版权

1、待发送报文各字段的键（Key）按照字符串的字典顺序排序。如果字段为复合数据类型，按如下规则处理：如果数据类型是 List ，则对字段名按照字符串字典顺序排序

2、 从排序好的报文中依次取出各字段的值（Value），依次拼接起来；
3、计算整个拼接好的字符串的 MD5 值，转换为 16 进制的字符串，并赋值
给 sign 字段
  

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@SuppressWarnings("all")
public class ParameterOrdering {
	
	public static void main(String[] args) {
        // 测试数据
		School s = new School();
		s.setId("111122222");
		s.setAddress("北京");
		
		Section se = new Section();
		se.setId("33326666");
		se.setName("数学");
		se.setRs(86);
		List<Section> sectionList = new ArrayList<>();
		sectionList.add(se);
		s.setSectionList(sectionList);
        // 签名
		String paramOrder = generateSign(s);
	}
	
	public static String generateSign(Object data){
		Field[] fields = data.getClass().getDeclaredFields();
		List<Field> allFields = new ArrayList<>();
		Class supperclass = data.getClass().getSuperclass();
		while(supperclass != null){
			allFields.addAll(Arrays.asList(supperclass.getDeclaredFields()));
			supperclass =supperclass.getSuperclass();
		}
		allFields.addAll(Arrays.asList(fields));
		allFields.sort(new FieldComparator());
		StringBuilder stringBuilder =new StringBuilder();
		try{
			for(Field field:allFields){
				stringBuilder.append(getValue(field,data));
			}
		}catch(Exception e){
			e.printStackTrace();
			throw new RuntimeException(e);
		}
		System.out.println("Json 报文中各字段排序后取得的值拼接："+stringBuilder.toString());
		return Digestutils.md5Hex(stringBuilder.toString());
	}

	public static String getValue(Field field, Object o) throws Exception {
		field.setAccessible(true);
		if (o == null || field.get(o) == null) {
			return "";
		}
		Object value = field.get(o);
		if (value.getClass().getName().startsWith("java.lang")) {
			return String.valueOf(field.get(o));
		} else if (value instanceof List) {
			List list = (List) value;
			StringBuilder stringBuilder = new StringBuilder();
			for (Object object : list) {
				if (object.getClass().getName().startsWith("java.lang")) {
					stringBuilder.append(object);
				} else {
					Field[] fields = object.getClass().getDeclaredFields();
					List<Field> fieldList = Arrays.asList(fields);
					fieldList.sort(new FieldComparator());
					for (Field f : fieldList) {
						stringBuilder.append(getValue(f, object));
					}

				}
			}
			return stringBuilder.toString();
		} else {
			Field[] fields = field.get(o).getClass().getDeclaredFields();
			List<Field> allFields = Arrays.asList(fields);
			allFields.sort(new FieldComparator());
			StringBuilder stringBuilder = new StringBuilder();
			for (Field f : allFields) {
				f.setAccessible(true);
				if (f.get(field.get(o)) != null) {
					stringBuilder.append(getValue(f, field.get(o)));
				}
			}
			return stringBuilder.toString();
		}
	}
	
	private static class FieldComparator implements Comparator<Field> {
		public int compare(Field a, Field b) {
			 return a.getName().compareTo(b.getName());
		}
		
	}
}

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.codec.binary.StringUtils;

public class Digestutils {
	private static final int STREAM_BUFFER_LENGTH = 1024;
	private final MessageDigest messageDigest;

	public static byte[] digest(MessageDigest messageDigest, byte[] data) {
		return messageDigest.digest(data);
	}

	public static byte[] digest(MessageDigest messageDigest, ByteBuffer data) {
		messageDigest.update(data);
		return messageDigest.digest();
	}

	public static byte[] digest(MessageDigest messageDigest, File data) throws IOException {
		return updateDigest(messageDigest, data).digest();
	}

	public static byte[] digest(MessageDigest messageDigest, InputStream data) throws IOException {
		return updateDigest(messageDigest, data).digest();
	}

	public static MessageDigest getDigest(String algorithm) {
		try {
			return MessageDigest.getInstance(algorithm);
		} catch (NoSuchAlgorithmException var2) {
			throw new IllegalArgumentException(var2);
		}
	}

	public static MessageDigest getDigest(String algorithm, MessageDigest defaultMessageDigest) {
		try {
			return MessageDigest.getInstance(algorithm);
		} catch (Exception var3) {
			return defaultMessageDigest;
		}
	}

	public static MessageDigest getMd2Digest() {
		return getDigest("MD2");
	}

	public static MessageDigest getMd5Digest() {
		return getDigest("MD5");
	}

	public static MessageDigest getSha1Digest() {
		return getDigest("SHA-1");
	}

	public static MessageDigest getSha256Digest() {
		return getDigest("SHA-256");
	}

	public static MessageDigest getSha384Digest() {
		return getDigest("SHA-384");
	}

	public static MessageDigest getSha512Digest() {
		return getDigest("SHA-512");
	}

	/** @deprecated */
	@Deprecated
	public static MessageDigest getShaDigest() {
		return getSha1Digest();
	}

	public static byte[] md2(byte[] data) {
		return getMd2Digest().digest(data);
	}

	public static byte[] md2(InputStream data) throws IOException {
		return digest(getMd2Digest(), data);
	}

	public static byte[] md2(String data) {
		return md2(StringUtils.getBytesUtf8(data));
	}

	public static String md2Hex(byte[] data) {
		return Hex.encodeHexString(md2(data));
	}

	public static String md2Hex(InputStream data) throws IOException {
		return Hex.encodeHexString(md2(data));
	}

	public static String md2Hex(String data) {
		return Hex.encodeHexString(md2(data));
	}

	public static byte[] md5(byte[] data) {
		return getMd5Digest().digest(data);
	}

	public static byte[] md5(InputStream data) throws IOException {
		return digest(getMd5Digest(), data);
	}

	public static byte[] md5(String data) {
		return md5(StringUtils.getBytesUtf8(data));
	}

	public static String md5Hex(byte[] data) {
		return Hex.encodeHexString(md5(data));
	}

	public static String md5Hex(InputStream data) throws IOException {
		return Hex.encodeHexString(md5(data));
	}

	public static String md5Hex(String data) {
		return Hex.encodeHexString(md5(data));
	}

	/** @deprecated */
	@Deprecated
	public static byte[] sha(byte[] data) {
		return sha1(data);
	}

	/** @deprecated */
	@Deprecated
	public static byte[] sha(InputStream data) throws IOException {
		return sha1(data);
	}

	/** @deprecated */
	@Deprecated
	public static byte[] sha(String data) {
		return sha1(data);
	}

	public static byte[] sha1(byte[] data) {
		return getSha1Digest().digest(data);
	}

	public static byte[] sha1(InputStream data) throws IOException {
		return digest(getSha1Digest(), data);
	}

	public static byte[] sha1(String data) {
		return sha1(StringUtils.getBytesUtf8(data));
	}

	public static String sha1Hex(byte[] data) {
		return Hex.encodeHexString(sha1(data));
	}

	public static String sha1Hex(InputStream data) throws IOException {
		return Hex.encodeHexString(sha1(data));
	}

	public static String sha1Hex(String data) {
		return Hex.encodeHexString(sha1(data));
	}

	public static byte[] sha256(byte[] data) {
		return getSha256Digest().digest(data);
	}

	public static byte[] sha256(InputStream data) throws IOException {
		return digest(getSha256Digest(), data);
	}

	public static byte[] sha256(String data) {
		return sha256(StringUtils.getBytesUtf8(data));
	}

	public static String sha256Hex(byte[] data) {
		return Hex.encodeHexString(sha256(data));
	}

	public static String sha256Hex(InputStream data) throws IOException {
		return Hex.encodeHexString(sha256(data));
	}

	public static String sha256Hex(String data) {
		return Hex.encodeHexString(sha256(data));
	}

	public static byte[] sha384(byte[] data) {
		return getSha384Digest().digest(data);
	}

	public static byte[] sha384(InputStream data) throws IOException {
		return digest(getSha384Digest(), data);
	}

	public static byte[] sha384(String data) {
		return sha384(StringUtils.getBytesUtf8(data));
	}

	public static String sha384Hex(byte[] data) {
		return Hex.encodeHexString(sha384(data));
	}

	public static String sha384Hex(InputStream data) throws IOException {
		return Hex.encodeHexString(sha384(data));
	}

	public static String sha384Hex(String data) {
		return Hex.encodeHexString(sha384(data));
	}

	public static byte[] sha512(byte[] data) {
		return getSha512Digest().digest(data);
	}

	public static byte[] sha512(InputStream data) throws IOException {
		return digest(getSha512Digest(), data);
	}

	public static byte[] sha512(String data) {
		return sha512(StringUtils.getBytesUtf8(data));
	}

	public static String sha512Hex(byte[] data) {
		return Hex.encodeHexString(sha512(data));
	}

	public static String sha512Hex(InputStream data) throws IOException {
		return Hex.encodeHexString(sha512(data));
	}

	public static String sha512Hex(String data) {
		return Hex.encodeHexString(sha512(data));
	}

	/** @deprecated */
	@Deprecated
	public static String shaHex(byte[] data) {
		return sha1Hex(data);
	}

	/** @deprecated */
	@Deprecated
	public static String shaHex(InputStream data) throws IOException {
		return sha1Hex(data);
	}

	/** @deprecated */
	@Deprecated
	public static String shaHex(String data) {
		return sha1Hex(data);
	}

	public static MessageDigest updateDigest(MessageDigest messageDigest, byte[] valueToDigest) {
		messageDigest.update(valueToDigest);
		return messageDigest;
	}

	public static MessageDigest updateDigest(MessageDigest messageDigest, ByteBuffer valueToDigest) {
		messageDigest.update(valueToDigest);
		return messageDigest;
	}

	public static MessageDigest updateDigest(MessageDigest digest, File data) throws IOException {
		BufferedInputStream stream = new BufferedInputStream(new FileInputStream(data));

		MessageDigest var3;
		try {
			var3 = updateDigest(digest, (InputStream) stream);
		} finally {
			stream.close();
		}

		return var3;
	}

	public static MessageDigest updateDigest(MessageDigest digest, InputStream data) throws IOException {
		byte[] buffer = new byte[1024];

		for (int read = data.read(buffer, 0, 1024); read > -1; read = data.read(buffer, 0, 1024)) {
			digest.update(buffer, 0, read);
		}

		return digest;
	}

	public static MessageDigest updateDigest(MessageDigest messageDigest, String valueToDigest) {
		messageDigest.update(StringUtils.getBytesUtf8(valueToDigest));
		return messageDigest;
	}

	public static boolean isAvailable(String messageDigestAlgorithm) {
		return getDigest(messageDigestAlgorithm, (MessageDigest) null) != null;
	}

	/** @deprecated */
	@Deprecated
	public Digestutils() {
		this.messageDigest = null;
	}

	public Digestutils(MessageDigest digest) {
		this.messageDigest = digest;
	}

	public Digestutils(String name) {
		this(getDigest(name));
	}

	public MessageDigest getMessageDigest() {
		return this.messageDigest;
	}

	public byte[] digest(byte[] data) {
		return updateDigest(this.messageDigest, data).digest();
	}

	public byte[] digest(String data) {
		return updateDigest(this.messageDigest, data).digest();
	}

	public byte[] digest(ByteBuffer data) {
		return updateDigest(this.messageDigest, data).digest();
	}

	public byte[] digest(File data) throws IOException {
		return updateDigest(this.messageDigest, data).digest();
	}

	public byte[] digest(InputStream data) throws IOException {
		return updateDigest(this.messageDigest, data).digest();
	}

	public String digestAsHex(byte[] data) {
		return Hex.encodeHexString(this.digest(data));
	}

	public String digestAsHex(String data) {
		return Hex.encodeHexString(this.digest(data));
	}

	public String digestAsHex(ByteBuffer data) {
		return Hex.encodeHexString(this.digest(data));
	}

	public String digestAsHex(File data) throws IOException {
		return Hex.encodeHexString(this.digest(data));
	}

	public String digestAsHex(InputStream data) throws IOException {
		return Hex.encodeHexString(this.digest(data));
	}
}

方法generateSign中Object data为实体类

import java.util.List;

public class School {

	public String id;
	
	public String address;
	
	public List<Section> sectionList;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public List<Section> getSectionList() {
		return sectionList;
	}

	public void setSectionList(List<Section> sectionList) {
		this.sectionList = sectionList;
	}
	
	
}
public class Section {

	public String id;
	
	public String name;
	
	public int rs;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getRs() {
		return rs;
	}

	public void setRs(int rs) {
		this.rs = rs;
	}
	
	
}

星辰淼
关注
等级保护应用安全规范：对接口的请求参数进行签名校验（参数按照ASCII码从小到大排序、拼接、加密）
iOS逆向与安全
01-02 587
参数按照ASCII码从小到大排序、拼接、加密（采用递归的方式进行实现。如果添加 属性 记得 修改set get里面 map的 大小。
java排序签名
11-06
实现当前主流签名机制。 对请求参数进行排序 并添加协议key值 进行Md5加密
面试官爱问的 10 大经典排序算法，20+张图来搞定
程序员吴师兄的博客
09-29 269
点击上方“五分钟学算法”，选择“星标”公众号重磅干货，第一时间送达ID：技术让梦想更伟大作者:李肖遥冒泡排序简介冒泡排序是因为越小的元素会经由交换以升序或降序的方式慢慢浮到数列的顶端，就...
待签名参数按照字段名的ascii码从小到大排序
dgqvhtlwq472235338的博客
10-16 698
public static String getSign(Map<String, String> params) { Map<String, String> sortMap = new TreeMap<String, String>(); sortMap.putAll(params...
签名生成 参数名ASCII码从小到大排序（新）
qq_25330791的博客
11-05 2347
签名生成的通用步骤如下： 第一步，设所有发送或者接收到的数据为集合M，将集合M内非空参数值的参数按照参数名ASCII码从小到大排序（字典序），使用URL键值对的格式（即key1=value1&key2=value2…）拼接成字符串stringA。 特别注意以下重要规则： ◆ 参数名ASCII码从小到大排序（字典序）； ◆ 如果参数的值为空不参与签名； ◆ 参数名区分大小写； ◆ 接口可能增加字段，验证签名时必须支持增加的扩展字段 第二步，在stringA最后拼接上key得到str.
接口参数验签排序问题（map类型，通过key排序）
不吃肉肉的博客
11-17 1007
接口参数验签排序问题（map类型，通过key排序） 在设计对外的接口中，为了参数的安全性，经常会进行参数加密验签，以保证所传参数俩边一致，但是在生成签名时，如果参数的顺序不一致就会导致生成的签名不同，从而验签失败，因此参数排序成了重中之重。 public static String sign(Map<String, Object> data, String key) { if (data == null || data.isEmpty()) { retu
签名参数正序排列
cqx197988475的博客
09-19 279
Map treeMap = new TreeMap(); treeMap.put("deviceid" ,deviceid) ; treeMap.put("pcdeviceid" ,pcdeviceid) ; treeMap.put("userid" ,userid) ; String md5Sign = getMD...
签名算法 待签名参数按照字段名的ASCII码大小排序 Android、JS中实现
huch的博客
08-11 6097
验签是作为一个api接口避免裸奔的必要手段之一，原理就是前后端约定一套签名规则，首先前端在请求api接口时会增加一个sign参数，其值来源是对所提交的参数按照约定的签名规则去生成；接着后端同样会针对其接收到的参数(除sign外)按照约定的签名规则也生成一个sign，然后对2者进行比较，如果不一致则认为此次请求是未非法无效的，不予处理。 参考微信公众平台的签名算法： 签名生成规则如下：参与签名的字...
java 签名验证 body参数排序
最新发布
weixin_36823558的博客
07-13 49
Java签名验证与body参数排序 在网络开发中，签名验证是一种常见的安全机制，用于验证请求的合法性。在Java中，我们可以通过对请求的参数进行排序并生成签名来进行验证。同时，对于一些需要对请求的body参数进行排序的场景，我们也可以通过排序的方式来保证请求的有效性。 签名验证 在进行签名验证时，我们通常会使用一些加密算法...
java接口开发参数加密_常见开放接口签名简单实现-请求参数排序加密
weixin_28929351的博客
02-27 884
常见的签名方式实现一般分为以下几个步骤 :1 . 将所有(或者特殊)请求参数按特定规则排序；2 . 将请求参数按特定规则拼装为加密字符串；3 . 加密算法对加密字符串进行加密，得到签名。下面自己写了一个常见的实现方式，以便记录，这里只是示例说明基本常规实现，使用则还是根据项目的真实情况去选择。例如，下面我简单实现了一个restful接口，/signTest去验证签名。1.我这里使用了MD5加密方式...
PHP开发API接口签名生成及验证操作示例
01-21
本文实例讲述了PHP开发API接口签名生成及验证操作。...一、签名参数sign生成的方法 第1步: 将所有参数（注意是所有参数），除去sign本身，以及值是空的参数，按参数名字母升序排序。 第2步: 然后把排序后的
php 参数排序 计算sign_PHP开发API接口签名生成及验证
weixin_42365303的博客
01-17 617
开发过程中，我们经常会与接口打交道，有的时候是调取别人网站的接口，有的时候是为他人提供自己网站的接口，但是在这调取的过程中都离不开签名验证。我们在设计签名验证的时候，请注意要满足以下几点：可变性：每次的签名必须是不一样的。时效性：每次请求的时效，过期作废等。唯一性：每次的签名是唯一的。完整性：能够对传入数据进行验证，防止篡改。一、签名参数sign生成的方法第1步: 将所有参数(注意是所有参数)，除...
绕过接口参数签名验证
07-11 2756
在一些关键业务接口，系统通常会对请求参数进行签名验证，一旦篡改参数服务端就会提示签名校验失败。在黑盒渗透过程中，如果没办法绕过签名校验，那么就无法进一步深入。微信小程序的前端代码很容易被反编译，一旦签名加密算法和密钥暴漏，找到参数的排序规则，那么就可以篡改任意数据并根据算法伪造签名。下面我们将通过两个简单的小程序参数签名绕过的案例，来理解签名逆向的过程。01、常见签名算法...
接口报文中需包含签名字段，服务方对签名字段进行验签。
爱跳广场舞的熊的博客
07-23 1243
第一步：各接口中非空参数按照参数名ascii码从小到大排序，使用URL键值对的格式，拼接成待签名字符串，即key1=value1&key2=value2&key3=value3; public static String createSign(Map<String, String> params) { StringBuilder sb = new S...
java 参数排序_java学习-排序及加密签名时数据排序方式
weixin_34123023的博客
02-21 1858
排序有两种在java中一般实现集合排序的方式有两种。1. 类实现Comparable接口的compareTo(T o)接口方法2. 使用 Comparator接口的 compare(T o1, T o2)接口方法在具体的调用上。1. 类实现comparable接口调用List.sort(null)或Collections.sort(List)方法进行排序jdk内置的基本类型包装类等都实现了Comp...
(PHP对接接口的常用函数) 4. 将参数数组按字典排序
老刘Pro，PHPer
09-09 1386
最近因为业务需求总在对接和调试接口, 而接口文档给出的demo往往都是java或C#的. 为此, 我打算做一个系列, 将PHP对接接口常用的函数都整理出来. 今天送给大家的是该系列的第四个函数: "将参数数组按字典排序" /** * 将参数数组按字典排序 * @param array $array 参数数组 * @return string ...
调用接口时对参数的排序、生成签名、生成随机数，获取唯一标示符
dlzycoyz48995的博客
03-24 485
#pragma mark -- 参数的排序 + (NSMutableString*)postSignParamet:(NSString*)method privateParam:(NSMutableDictionary*)param { NSMutableString* lastParam = [[NSMutableString alloc]init];...
java 排序签名
猪头三
03-20 2358
在接入SDK时，通常需要签名和验签，而签名时，需要对url内容进行排序。
net生成微信支付接口签名
07-20
### 回答1： 微信支付接口签名是为了保证接口调用的安全性和完整性而生成的一串密文。下面是使用.Net生成微信支付接口签名的步骤： 1. 首先，需要准备以下参数：APPID（公众号或移动应用的唯一标识）、API密钥（微信商户平台设置的密钥）、随机字符串（用于防止重放攻击）、时间戳（接口调用的时间戳，10位的秒级时间戳即可）等。 2. 将上述参数按照字母顺序排序，并拼接成形如“key=value”的字符串，例如："appid=xxx&mch_id=xxx&nonce_str=xxx&timestamp=xxx"。 3. 在拼接的字符串末尾加上"&key=商户的API密钥"。 4. 使用Hash算法对拼接的字符串进行签名，常用的Hash算法有MD5和SHA1。使用.Net生成签名的代码示例如下： ```csharp using System.Security.Cryptography; using System.Text; string signStr = "拼接的字符串" + "&key=商户的API密钥"; MD5 md5 = MD5.Create(); byte[] signBytes = md5.ComputeHash(Encoding.UTF8.GetBytes(signStr)); StringBuilder sb = new StringBuilder(); foreach (byte b in signBytes) { sb.AppendFormat("{0:x2}", b); } string sign = sb.ToString().ToUpper(); ``` 5. 最后得到的sign就是生成的微信支付接口签名，可以将其加入到支付接口的请求参数中进行发送。 需要注意的是，每次请求的随机字符串和时间戳应该是不同的，以确保签名的唯一性和安全性。生成签名的代码可以根据具体的.Net版本进行调整，上述示例仅为参考。 ### 回答2： 微信支付接口签名是通过对发送的数据进行加密生成的一个字符串，用于校验数据的完整性和真实性。下面是一个基本的生成微信支付接口签名的流程： 1. 首先，将所有发送给微信支付接口的参数按照字母序排序，除了sign参数本身，将所有参数的参数名和参数值用key=value的形式拼接成一个字符串。 2. 在拼接的字符串末尾加上商户的支付密钥，并将密钥和字符串进行MD5加密，生成一个32位的字符串。这里需要注意，商户支付密钥是在微信商户平台进行配置的，需要在生成签名时正确配置使用。 3. 将生成的签名字符串赋值给sign参数，并将所有参数（包括sign参数）一起发送到微信支付接口。 4. 在接收到微信支付接口的响应时，需要对返回的数据进行校验。将返回的所有参数按照参数名的字母序排序，并按照key=value的形式拼接成一个字符串。 5. 同样地，在拼接的字符串末尾加上商户的支付密钥，进行MD5加密，生成一个32位的字符串。 6. 将生成的签名字符串与返回的sign参数进行比较，如果一致，则表示数据完整和真实；如果不一致，则表示数据可能被篡改了。 通过上述的流程，可以保证微信支付接口的安全和可靠性。需要注意的是，每个接口的签名算法可能会有所不同，具体的签名规则和参数配置可以参考微信支付开发文档。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值