sound-force/sign-doc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

✨ 添加Java和Kotlin实现的API签名工具，包括核心库、命令行工具和使用文档，支持多种签名算法和环境变量配置。

Browse Source
This commit is contained in:
SF-bytebytebrew
2025-05-21 18:44:37 +08:00
parent f6186868b7
commit d1fdcfa7e7
21 changed files with 2130 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
java/README.md Normal file
View File

@@ -0,0 +1,165 @@
# API签名工具 - Java实现
## 项目结构
根据实际项目文件结构：
```plaintext
java/
├── pom.xml # Maven项目配置
├── src/
│ ├── main/
│ │ └── java/
│ │ └── com/
│ │ └── soundforce/
│ │ └── apisign/
│ │ ├── ApiSigner.java # 签名工具实现
│ │ ├── Main.java # 命令行入口
│ │ ├── SignOptions.java # 签名配置
│ │ └── SignatureAlgorithm.java # 签名算法
│ └── test/
│ └── java/ # 测试代码目录
└── target/ # 构建输出目录
```
## 使用方法
### 构建项目
```bash
mvn clean package
```
### 运行命令行工具
```bash
java -jar target/apisign-1.0.0.jar [选项]
```
### 命令行选项
| 选项 | 描述 |
|------|------|
| `-a, --algorithm` | 签名算法: MD5, SHA1, SHA256, HMAC-SHA256 |
| `-u, --url` | API基础URL |
| `-p, --param` | 请求参数，格式为key=value，可多次使用 |
| `-k, --key` | 访问密钥ID |
| `-s, --secret` | 密钥 |
| `-c, --channel` | 合作渠道方ID |
| `-h, --help` | 显示帮助信息 |
### 常用命令示例
**基本用法**
```bash
java -jar target/apisign-1.0.0.jar
```
**自定义参数**
```bash
java -jar target/apisign-1.0.0.jar \
-u "https://api.example.com/user/info" \
-p "userId=12345" -p "action=getInfo" \
-k "YOUR_ACCESS_KEY" \
-s "YOUR_SECRET_KEY" \
-c "3"
```
**指定签名算法**
```bash
java -jar target/apisign-1.0.0.jar -a SHA256
```
**帮助信息**
```bash
java -jar target/apisign-1.0.0.jar --help
```
### API接口测试实例
使用真实API接口进行测试：
```bash
# 未签名的API调用测试 - 返回错误
curl "https://api-v1.sound-force.com:8443/p/album/single/media-url?channelId=3&singleId=381980"
# 返回: {"code":400,"data":null,"msg":"Missing AccessKeyId","success":false}
# 生成访问https://api-v1.sound-force.com:8443/p/album/single/media-url的签名URL
java -jar target/apisign-1.0.0.jar \
-a MD5 \
-u "https://api-v1.sound-force.com:8443/p/album/single/media-url" \
-p "singleId=381980" \
-k "YOUR_ACCESS_KEY" \
-s "YOUR_SECRET_KEY" \
-c "3"
# 使用curl测试API接口
signed_url=$(java -jar target/apisign-1.0.0.jar \
-a MD5 \
-u "https://api-v1.sound-force.com:8443/p/album/single/media-url" \
-p "singleId=381980" \
-k "YOUR_ACCESS_KEY" \
-s "YOUR_SECRET_KEY" \
-c "3" | grep -A 1 "签名后的URL:" | tail -n 1)
curl -v "$signed_url"
```
请注意：
- 替换`YOUR_ACCESS_KEY`为实际的访问密钥ID
- 替换`YOUR_SECRET_KEY`为实际的密钥
- 示例使用的渠道ID为`3`，请根据实际情况调整
使用有效的密钥和签名后，API接口将返回成功响应(状态码200)并提供媒体URL数据。
### 代码集成
```java
import com.soundforce.apisign.ApiSigner;
import com.soundforce.apisign.SignOptions;
import com.soundforce.apisign.SignatureAlgorithm;
import java.util.HashMap;
import java.util.Map;
// 创建签名选项
SignOptions options = new SignOptions(SignatureAlgorithm.MD5);
// 创建签名工具
ApiSigner signer = new ApiSigner(options);
// 准备请求参数
Map<String, String> params = new HashMap<>();
params.put("singleId", "381980");
// 执行签名
Map<String, String> signedParams = signer.signRequest(
params,
"YOUR_ACCESS_KEY",
"YOUR_SECRET_KEY",
"3"
);
// 或签名URL
String signedUrl = signer.signUrl(
"https://api-v1.sound-force.com:8443/p/album/single/media-url",
params,
"YOUR_ACCESS_KEY",
"YOUR_SECRET_KEY",
"3"
);
```
### 环境变量
该工具支持从`.env`文件加载以下配置：
- `ACCESS_KEY_ID`: 访问密钥ID
- `SECRET_KEY`: 密钥
- `CHANNEL_ID`: 渠道ID
- `SIGN_ALGORITHM`: 签名算法
- `API_BASE_URL`: API基础URL

70
java/pom.xml Normal file
View File

@@ -0,0 +1,70 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.soundforce</groupId>
<artifactId>api-signer</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<name>API Signer</name>
<description>API签名工具，提供请求签名与验证功能</description>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>21</java.version>
<maven.compiler.source>${java.version}</maven.compiler.source>
<maven.compiler.target>${java.version}</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.2.0</version>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>com.soundforce.apisign.Main</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.4</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

331
java/src/main/java/com/soundforce/apisign/ApiSigner.java Normal file
View File

@@ -0,0 +1,331 @@
package com.soundforce.apisign;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
import java.util.UUID;
import java.util.regex.Pattern;
/**
* API签名工具
*/
public record ApiSigner(SignOptions options) {
private static final Pattern ALPHANUMERIC_PATTERN = Pattern.compile("^[a-zA-Z0-9]*$");
/**
* 创建API签名工具
*
* @param options 签名选项，如为null则使用默认选项
*/
public ApiSigner(SignOptions options) {
this.options = options != null ? options : new SignOptions();
}
/**
* 生成随机字符串
*
* @return 一个基于当前时间的随机字符串
*/
public String generateNonce() {
return System.currentTimeMillis() + UUID.randomUUID().toString().substring(0, 8);
}
/**
* 获取当前时间戳（毫秒）
*
* @return 当前的Unix时间戳（毫秒）
*/
public long getTimestamp() {
return System.currentTimeMillis();
}
/**
* 对请求进行签名
*
* @param params 请求参数
* @param accessKeyId 访问密钥ID
* @param secretKey 密钥
* @param channelId 合作渠道方ID
* @return 添加了签名的完整参数
*/
public Map<String, String> signRequest(Map<String, String> params, String accessKeyId, String secretKey, String channelId) {
Map<String, String> signParams = new HashMap<>(params);
long timestamp = getTimestamp();
signParams.put(options.getKeyName(), accessKeyId);
signParams.put(options.getChannelIdName(), channelId);
signParams.put(options.getTimestampName(), String.valueOf(timestamp));
signParams.put(options.getNonceName(), generateNonce());
String signature = calculateSignature(signParams, secretKey);
signParams.put(options.getSignatureName(), signature);
return signParams;
}
/**
* 对URL进行签名
*
* @param baseUrl 基础URL地址
* @param params 请求参数
* @param accessKeyId 访问密钥ID
* @param secretKey 密钥
* @param channelId 合作渠道方ID
* @return 添加了签名的完整URL
*/
public String signUrl(String baseUrl, Map<String, String> params, String accessKeyId, String secretKey, String channelId) {
Map<String, String> signedParams = signRequest(params, accessKeyId, secretKey, channelId);
String queryString = buildQueryString(signedParams);
if (baseUrl.contains("?")) {
return baseUrl + "&" + queryString;
} else {
return baseUrl + "?" + queryString;
}
}
/**
* 构建URL查询字符串
*
* @param params 参数
* @return 查询字符串
*/
private String buildQueryString(Map<String, String> params) {
StringBuilder result = new StringBuilder();
boolean first = true;
Map<String, String> sortedParams = new TreeMap<>(params);
for (Entry<String, String> entry : sortedParams.entrySet()) {
if (first) {
first = false;
} else {
result.append("&");
}
result.append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8)).append("=").append(URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8));
}
return result.toString();
}
/**
* 计算签名
*
* @param params 请求参数
* @param secretKey 密钥
* @return 签名字符串
*/
public String calculateSignature(Map<String, String> params, String secretKey) {
String signingString = createSigningString(params);
signingString = signingString + "&key=" + secretKey;
try {
return switch (options.getAlgorithm()) {
case SHA1 -> sha1(signingString);
case SHA256 -> sha256(signingString);
case HMAC_SHA256 -> hmacSha256(signingString, secretKey);
default -> md5(signingString);
};
} catch (NoSuchAlgorithmException | InvalidKeyException e) {
throw new RuntimeException("计算签名时发生错误", e);
}
}
/**
* 创建用于签名的规范化字符串
*
* @param params 请求参数
* @return 按键名排序并拼接的字符串
*/
public String createSigningString(Map<String, String> params) {
Map<String, String> sortedParams = new TreeMap<>();
for (Entry<String, String> entry : params.entrySet()) {
if (!entry.getKey().equals(options.getSignatureName())) {
sortedParams.put(entry.getKey(), entry.getValue());
}
}
List<String> parts = new ArrayList<>();
for (Entry<String, String> entry : sortedParams.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
if (needsUrlEncode(value)) {
value = URLEncoder.encode(value, StandardCharsets.UTF_8);
}
parts.add(key + "=" + value);
}
return String.join("&", parts);
}
/**
* 判断是否需要对字符串进行URL编码
*
* @param s 需要判断的字符串
* @return 如果包含非字母数字字符，返回true，否则返回false
*/
private boolean needsUrlEncode(String s) {
return !ALPHANUMERIC_PATTERN.matcher(s).matches();
}
/**
* 验证签名结果
*/
public record SignVerifyResult(boolean valid, String error) {
/**
* 签名是否有效
*
* @return 如果签名有效，返回true，否则返回false
*/
@Override
public boolean valid() {
return valid;
}
/**
* 获取错误信息
*
* @return 错误信息，如果没有错误则返回null
*/
@Override
public String error() {
return error;
}
}
/**
* 验证签名
*
* @param params 所有请求参数，包括签名
* @param secretKey 密钥
* @param maxAgeMs 允许的最大时间差（毫秒）
* @return 验证结果
*/
public SignVerifyResult verifySignature(Map<String, String> params, String secretKey, long maxAgeMs) {
if (!params.containsKey(options.getKeyName()))
return new SignVerifyResult(false, "缺少参数: " + options.getKeyName());
if (!params.containsKey(options.getChannelIdName())) {
return new SignVerifyResult(false, "缺少参数: " + options.getChannelIdName());
}
if (!params.containsKey(options.getTimestampName())) {
return new SignVerifyResult(false, "缺少参数: " + options.getTimestampName());
}
try {
long timestamp = Long.parseLong(params.get(options.getTimestampName()));
long now = getTimestamp();
if (Math.abs(now - timestamp) > maxAgeMs) {
return new SignVerifyResult(false, "时间戳过期");
}
} catch (NumberFormatException e) {
return new SignVerifyResult(false, "无效的时间戳");
}
if (!params.containsKey(options.getNonceName())) {
return new SignVerifyResult(false, "缺少参数: " + options.getNonceName());
}
if (!params.containsKey(options.getSignatureName())) {
return new SignVerifyResult(false, "缺少参数: " + options.getSignatureName());
}
String providedSignature = params.get(options.getSignatureName());
String expectedSignature = calculateSignature(params, secretKey);
if (expectedSignature.equals(providedSignature)) {
return new SignVerifyResult(true, null);
} else {
return new SignVerifyResult(false, "签名不匹配");
}
}
/**
* 计算MD5签名
*
* @param content 内容
* @return MD5签名
* @throws NoSuchAlgorithmException 如果算法不存在
*/
private String md5(String content) throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] digest = md.digest(content.getBytes(StandardCharsets.UTF_8));
return bytesToHex(digest);
}
/**
* 计算SHA1签名
*
* @param content 内容
* @return SHA1签名
* @throws NoSuchAlgorithmException 如果算法不存在
*/
private String sha1(String content) throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("SHA-1");
byte[] digest = md.digest(content.getBytes(StandardCharsets.UTF_8));
return bytesToHex(digest);
}
/**
* 计算SHA256签名
*
* @param content 内容
* @return SHA256签名
* @throws NoSuchAlgorithmException 如果算法不存在
*/
private String sha256(String content) throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[] digest = md.digest(content.getBytes(StandardCharsets.UTF_8));
return bytesToHex(digest);
}
/**
* 计算HMAC-SHA256签名
*
* @param content 内容
* @param key 密钥
* @return HMAC-SHA256签名
* @throws NoSuchAlgorithmException 如果算法不存在
* @throws InvalidKeyException 如果密钥无效
*/
private String hmacSha256(String content, String key) throws NoSuchAlgorithmException, InvalidKeyException {
Mac hmac = Mac.getInstance("HmacSHA256");
SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
hmac.init(keySpec);
byte[] digest = hmac.doFinal(content.getBytes(StandardCharsets.UTF_8));
return bytesToHex(digest);
}
/**
* 将字节数组转换为十六进制字符串
*
* @param bytes 字节数组
* @return 十六进制字符串
*/
private String bytesToHex(byte[] bytes) {
StringBuilder sb = new StringBuilder();
for (byte b : bytes) {
sb.append(String.format("%02x", b & 0xff));
}
return sb.toString();
}
}

272
java/src/main/java/com/soundforce/apisign/Main.java Normal file
View File

@@ -0,0 +1,272 @@
package com.soundforce.apisign;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* API签名工具命令行实现
*/
public class Main {
private static final String ENV_FILE = ".env";
private static final String ENV_ACCESS_KEY_ID = "ACCESS_KEY_ID";
private static final String ENV_SECRET_KEY = "SECRET_KEY";
private static final String ENV_CHANNEL_ID = "CHANNEL_ID";
private static final String ENV_API_BASE_URL = "API_BASE_URL";
private static final String ENV_SIGN_ALGORITHM = "SIGN_ALGORITHM";
private static final String DEFAULT_ACCESS_KEY_ID = "test-access-key-id";
private static final String DEFAULT_SECRET_KEY = "test-secret-key";
private static final String DEFAULT_CHANNEL_ID = "test-channel-id";
private static final String DEFAULT_API_BASE_URL = "https://api.example.com/v1/data";
private static final String DEFAULT_ALGORITHM = "MD5";
private static final String DEFAULT_MODE = "url";
/**
* 应用程序入口点
*
* @param args 命令行参数
*/
public static void main(String[] args) {
// 加载环境变量
Properties env = loadEnvFile();
// 解析命令行参数
CommandLineArgs cmdArgs = parseArgs(args, env);
// 创建签名工具
SignOptions options = new SignOptions();
options.setAlgorithm(SignatureAlgorithm.fromString(cmdArgs.algorithm));
ApiSigner signer = new ApiSigner(options);
// 打印配置信息
System.out.println("===================== API签名示例 =====================");
System.out.println("AccessKeyId: " + cmdArgs.accessKeyId);
System.out.println("ChannelId: " + cmdArgs.channelId);
System.out.println("SecretKey: " + cmdArgs.secretKey);
System.out.println("签名算法: " + options.getAlgorithm());
System.out.println("基础URL: " + cmdArgs.url);
System.out.println("请求参数: " + cmdArgs.params);
// 根据操作模式执行不同操作
switch (cmdArgs.mode) {
case "url":
// 签名URL
String signedUrl = signer.signUrl(cmdArgs.url, cmdArgs.params, cmdArgs.accessKeyId, cmdArgs.secretKey, cmdArgs.channelId);
System.out.println("\n签名后的URL:");
System.out.println(signedUrl);
break;
case "params":
// 获取签名后的参数
Map<String, String> signedParams = signer.signRequest(cmdArgs.params, cmdArgs.accessKeyId, cmdArgs.secretKey, cmdArgs.channelId);
System.out.println("\n签名后的参数:");
for (Map.Entry<String, String> entry : signedParams.entrySet()) {
System.out.println(" " + entry.getKey() + ": " + entry.getValue());
}
break;
case "verify":
// 验证签名
ApiSigner.SignVerifyResult result = signer.verifySignature(cmdArgs.params, cmdArgs.secretKey, 300000);
System.out.println("\n签名验证结果:");
if (result.valid()) {
System.out.println(" 验证成功");
} else {
System.out.println(" 验证失败: " + result.error());
}
break;
default:
System.err.println("未知操作模式: " + cmdArgs.mode);
System.exit(1);
}
// 演示不同算法的签名结果
demonstrateAlgorithms(cmdArgs.params, cmdArgs.accessKeyId, cmdArgs.secretKey);
}
/**
* 加载.env文件
*
* @return 环境变量属性
*/
private static Properties loadEnvFile() {
Properties properties = new Properties();
// 首先尝试当前目录
File envFile = new File(ENV_FILE);
if (!envFile.exists()) {
// 尝试父目录
envFile = new File(".." + File.separator + ENV_FILE);
}
if (envFile.exists()) {
try (FileInputStream fis = new FileInputStream(envFile)) {
properties.load(fis);
} catch (IOException e) {
System.err.println("警告: 无法加载.env文件: " + e.getMessage());
}
}
return properties;
}
/**
* 演示不同算法的签名结果
*
* @param params 参数
* @param accessKeyId 访问密钥ID
* @param secretKey 密钥
*/
private static void demonstrateAlgorithms(Map<String, String> params, String accessKeyId, String secretKey) {
System.out.println("\n不同算法的签名结果:");
SignatureAlgorithm[] algorithms = {SignatureAlgorithm.MD5, SignatureAlgorithm.SHA1, SignatureAlgorithm.SHA256, SignatureAlgorithm.HMAC_SHA256};
for (SignatureAlgorithm alg : algorithms) {
SignOptions options = new SignOptions();
options.setAlgorithm(alg);
ApiSigner signer = new ApiSigner(options);
// 添加必要的参数用于签名
Map<String, String> signParams = new HashMap<>(params);
signParams.put(options.getKeyName(), accessKeyId);
String signature = signer.calculateSignature(signParams, secretKey);
System.out.println(" " + alg + ": " + signature);
}
}
/**
* 命令行参数
*/
private static class CommandLineArgs {
String algorithm = DEFAULT_ALGORITHM;
String mode = DEFAULT_MODE;
String url = DEFAULT_API_BASE_URL;
String accessKeyId = DEFAULT_ACCESS_KEY_ID;
String secretKey = DEFAULT_SECRET_KEY;
String channelId = DEFAULT_CHANNEL_ID;
Map<String, String> params = new HashMap<>();
}
/**
* 解析命令行参数
*
* @param args 命令行参数
* @param env 环境变量
* @return 解析后的参数对象
*/
private static CommandLineArgs parseArgs(String[] args, Properties env) {
CommandLineArgs result = new CommandLineArgs();
// 从环境变量加载默认值
result.accessKeyId = getEnvOrDefault(env, ENV_ACCESS_KEY_ID, DEFAULT_ACCESS_KEY_ID);
result.secretKey = getEnvOrDefault(env, ENV_SECRET_KEY, DEFAULT_SECRET_KEY);
result.channelId = getEnvOrDefault(env, ENV_CHANNEL_ID, DEFAULT_CHANNEL_ID);
result.url = getEnvOrDefault(env, ENV_API_BASE_URL, DEFAULT_API_BASE_URL);
result.algorithm = getEnvOrDefault(env, ENV_SIGN_ALGORITHM, DEFAULT_ALGORITHM);
// 解析命令行参数
for (int i = 0; i < args.length; i++) {
String arg = args[i];
if ("-h".equals(arg) || "--help".equals(arg)) {
printHelp();
System.exit(0);
} else if ("-a".equals(arg) || "--algorithm".equals(arg)) {
if (i + 1 < args.length) {
result.algorithm = args[++i];
}
} else if ("-m".equals(arg) || "--mode".equals(arg)) {
if (i + 1 < args.length) {
result.mode = args[++i];
}
} else if ("-u".equals(arg) || "--url".equals(arg)) {
if (i + 1 < args.length) {
result.url = args[++i];
}
} else if ("-k".equals(arg) || "--key".equals(arg)) {
if (i + 1 < args.length) {
result.accessKeyId = args[++i];
}
} else if ("-s".equals(arg) || "--secret".equals(arg)) {
if (i + 1 < args.length) {
result.secretKey = args[++i];
}
} else if ("-c".equals(arg) || "--channel".equals(arg)) {
if (i + 1 < args.length) {
result.channelId = args[++i];
}
} else if ("-p".equals(arg) || "--param".equals(arg)) {
if (i + 1 < args.length) {
String paramValue = args[++i];
String[] parts = paramValue.split("=", 2);
if (parts.length == 2) {
result.params.put(parts[0], parts[1]);
}
}
}
}
// 如果没有参数，使用默认参数进行演示
if (result.params.isEmpty()) {
result.params.put("userId", "12345");
result.params.put("action", "getData");
result.params.put("data", "测试数据"); // 包含非ASCII字符，测试URL编码
}
return result;
}
/**
* 从环境变量获取值或使用默认值
*
* @param env 环境变量
* @param key 键
* @param defaultValue 默认值
* @return 环境变量值或默认值
*/
private static String getEnvOrDefault(Properties env, String key, String defaultValue) {
// 先检查系统环境变量
String value = System.getenv(key);
if (value != null && !value.isEmpty()) {
return value;
}
// 然后检查.env文件
value = env.getProperty(key);
if (value != null && !value.isEmpty()) {
return value;
}
// 最后使用默认值
return defaultValue;
}
/**
* 打印帮助信息
*/
private static void printHelp() {
System.out.println("API签名工具 - 命令行接口");
System.out.println();
System.out.println("用法: java -jar api-signer.jar [选项]");
System.out.println();
System.out.println("选项:");
System.out.println(" -a, --algorithm <algorithm> 签名算法: MD5, SHA1, SHA256, HMAC_SHA256 (默认: MD5)");
System.out.println(" -k, --key <accessKeyId> 访问密钥ID (默认: 环境变量ACCESS_KEY_ID)");
System.out.println(" -c, --channel <channelId> 合作渠道方ID (默认: 环境变量CHANNEL_ID)");
System.out.println(" -s, --secret <secretKey> 密钥 (默认: 环境变量SECRET_KEY)");
System.out.println(" -u, --url <url> 基础URL地址 (默认: 环境变量API_BASE_URL)");
System.out.println(" -p, --param <key=value> 请求参数，格式为key=value，可多次指定");
System.out.println(" -m, --mode <mode> 操作模式: url, params, verify (默认: url)");
System.out.println(" -h, --help 显示帮助信息");
System.out.println();
System.out.println("示例:");
System.out.println(" java -jar api-signer.jar -a MD5 -u \"https://api.example.com/v1/data\" -p \"userId=12345\" -p \"action=getData\"");
}
}

163
java/src/main/java/com/soundforce/apisign/SignOptions.java Normal file
View File

@@ -0,0 +1,163 @@
package com.soundforce.apisign;
/**
* 签名选项
*/
public class SignOptions {
/**
* 签名算法
*/
private SignatureAlgorithm algorithm = SignatureAlgorithm.MD5;
/**
* AccessKeyId参数名
*/
private String keyName = "AccessKeyId";
/**
* 合作渠道方ID参数名
*/
private String channelIdName = "channelId";
/**
* 时间戳参数名
*/
private String timestampName = "timestamp";
/**
* 随机字符串参数名
*/
private String nonceName = "nonce";
/**
* 签名参数名
*/
private String signatureName = "sign";
/**
* 创建默认签名选项
*/
public SignOptions() {
// 使用默认值
}
/**
* 获取签名算法
*
* @return 签名算法
*/
public SignatureAlgorithm getAlgorithm() {
return algorithm;
}
/**
* 设置签名算法
*
* @param algorithm 签名算法
* @return 当前对象，支持链式调用
*/
public SignOptions setAlgorithm(SignatureAlgorithm algorithm) {
this.algorithm = algorithm;
return this;
}
/**
* 获取AccessKeyId参数名
*
* @return AccessKeyId参数名
*/
public String getKeyName() {
return keyName;
}
/**
* 设置AccessKeyId参数名
*
* @param keyName AccessKeyId参数名
* @return 当前对象，支持链式调用
*/
public SignOptions setKeyName(String keyName) {
this.keyName = keyName;
return this;
}
/**
* 获取合作渠道方ID参数名
*
* @return 合作渠道方ID参数名
*/
public String getChannelIdName() {
return channelIdName;
}
/**
* 设置合作渠道方ID参数名
*
* @param channelIdName 合作渠道方ID参数名
* @return 当前对象，支持链式调用
*/
public SignOptions setChannelIdName(String channelIdName) {
this.channelIdName = channelIdName;
return this;
}
/**
* 获取时间戳参数名
*
* @return 时间戳参数名
*/
public String getTimestampName() {
return timestampName;
}
/**
* 设置时间戳参数名
*
* @param timestampName 时间戳参数名
* @return 当前对象，支持链式调用
*/
public SignOptions setTimestampName(String timestampName) {
this.timestampName = timestampName;
return this;
}
/**
* 获取随机字符串参数名
*
* @return 随机字符串参数名
*/
public String getNonceName() {
return nonceName;
}
/**
* 设置随机字符串参数名
*
* @param nonceName 随机字符串参数名
* @return 当前对象，支持链式调用
*/
public SignOptions setNonceName(String nonceName) {
this.nonceName = nonceName;
return this;
}
/**
* 获取签名参数名
*
* @return 签名参数名
*/
public String getSignatureName() {
return signatureName;
}
/**
* 设置签名参数名
*
* @param signatureName 签名参数名
* @return 当前对象，支持链式调用
*/
public SignOptions setSignatureName(String signatureName) {
this.signatureName = signatureName;
return this;
}
@Override
public String toString() {
return "SignOptions{" + "algorithm=" + algorithm + ", keyName='" + keyName + '\'' + ", channelIdName='" + channelIdName + '\'' + ", timestampName='" + timestampName + '\'' + ", nonceName='" + nonceName + '\'' + ", signatureName='" + signatureName + '\'' + '}';
}
}

57
java/src/main/java/com/soundforce/apisign/SignatureAlgorithm.java Normal file
View File

@@ -0,0 +1,57 @@
package com.soundforce.apisign;
/**
* 签名算法类型
*/
public enum SignatureAlgorithm {
/**
* MD5算法（默认、最快）
*/
MD5("MD5"),
/**
* SHA1算法
*/
SHA1("SHA1"),
/**
* SHA256算法
*/
SHA256("SHA256"),
/**
* HMAC-SHA256算法（最安全）
*/
HMAC_SHA256("HMAC-SHA256");
private final String description;
SignatureAlgorithm(String description) {
this.description = description;
}
/**
* 从字符串解析算法类型
*
* @param algorithm 算法字符串
* @return 签名算法枚举
* @throws IllegalArgumentException 如果算法无效
*/
public static SignatureAlgorithm fromString(String algorithm) {
if (algorithm == null) {
return MD5;
}
String upperAlgorithm = algorithm.toUpperCase();
return switch (upperAlgorithm) {
case "MD5" -> MD5;
case "SHA1" -> SHA1;
case "SHA256" -> SHA256;
case "HMAC_SHA256", "HMACSHA256", "HMAC-SHA256" -> HMAC_SHA256;
default -> throw new IllegalArgumentException("无效的签名算法: " + algorithm);
};
}
@Override
public String toString() {
return description;
}
}