Node.js
const crypto = require("crypto");
function generateSignature(url, queryParamMap = {}, bodyJSONString = "", clientSecret) {
const parts = [url];
for (const key of Object.keys(queryParamMap).sort()) {
const value = queryParamMap[key] ?? "";
parts.push(`${key}=${value}`);
}
const body = bodyJSONString.trim();
if (body && body !== "{}") parts.push(bodyJSONString);
return crypto.createHmac("sha256", clientSecret).update(parts.join("&"), "utf8").digest("base64");
}Exemplos em Java, Python e PHP:
Expandir/recolher Java
import org.apache.commons.lang.StringUtils;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Map;
import java.util.TreeMap;
public class SignatureUtils {
/**
* generate signature
* @param url: request url
* @param queryParamMap: request query parameters Map Structure
* @param bodyJSONString: request body JSON String
* @param clientSecret: client secret
* @return
*/
public String generateSignature(String url, Map<String, Object> queryParamMap, String bodyJSONString, String clientSecret) {
StringBuilder sb = new StringBuilder();
// step 1: concat url
sb.append(url);
// step 2: concat query parameters
if (!queryParamMap.isEmpty()) {
// 2.1: sort by alphabetical order
TreeMap<String, Object> sortedParams = new TreeMap<>(queryParamMap);
// 2.2: concat key and value
for (Map.Entry<String, Object> entry : sortedParams.entrySet()) {
String key = entry.getKey();
String value = entry.getValue() != null ? entry.getValue().toString() : "";
sb.append("&");
sb.append(key + "=" + value);
}
}
// step 3: concat body
if (StringUtils.isNotBlank(bodyJSONString) && !"{}".equals(bodyJSONString.trim())) {
sb.append("&");
sb.append(bodyJSONString);
}
// step 4: got a complete string waiting to generate a signature
String signatureString = sb.toString();
try {
// step 5: initialize the HmacSHA256 algorithm with the clientSecret
Mac mac = Mac.getInstance("HmacSHA256");
mac.init(new SecretKeySpec(clientSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
// step 6: calculate signature
byte[] bytes = mac.doFinal(signatureString.getBytes(StandardCharsets.UTF_8));
// step 7: encode the signature in Base64 format
String signature = new String(Base64.getEncoder().encode(bytes), StandardCharsets.UTF_8);
return signature;
}catch (NoSuchAlgorithmException e){
throw new IllegalStateException("Algorithm HmacSHA256 does not exist.", e);
}catch (InvalidKeyException e){
throw new RuntimeException("Key is invalid.", e);
}
}
}
Expandir/recolher Python
import hashlib
import hmac
import base64
from typing import Dict, Any
class SignatureUtils:
"""
Generate signature utility class
"""
@staticmethod
def generate_signature(url: str,
query_param_map: Dict[str, Any],
body_json_string: str,
client_secret: str) -> str:
"""
Generate signature
Args:
url: request url
query_param_map: request query parameters dict
body_json_string: request body JSON string
client_secret: client secret
Returns:
Generated signature string
"""
sb = []
# Step 1: concat url
sb.append(url)
# Step 2: concat query parameters
if query_param_map:
# 2.1: sort by alphabetical order
sorted_params = dict(sorted(query_param_map.items()))
# 2.2: concat key and value
for key, value in sorted_params.items():
value_str = str(value) if value is not None else ""
sb.append(f"&{key}={value_str}")
# Step 3: concat body
if body_json_string and body_json_string.strip() and body_json_string.strip() != "{}":
sb.append(f"&{body_json_string}")
# Step 4: got complete string for signature generation
signature_string = "".join(sb)
try:
# Step 5 & 6: calculate HMAC-SHA256 signature
signature_bytes = hmac.new(
client_secret.encode('utf-8'),
signature_string.encode('utf-8'),
hashlib.sha256
).digest()
# Step 7: encode in Base64
signature = base64.b64encode(signature_bytes).decode('utf-8')
return signature
except Exception as e:
raise RuntimeError(f"Failed to generate signature: {str(e)}")
Expandir/recolher PHP
<?php
class SignatureUtils
{
/**
* Generate signature
*
* @param string $url Request URL
* @param array $queryParamMap Request query parameters associative array
* @param string $bodyJSONString Request body JSON string
* @param string $clientSecret Client secret
* @return string Generated signature string
* @throws RuntimeException If signature generation fails
*/
public static function generateSignature(
string $url,
array $queryParamMap,
string $bodyJSONString,
string $clientSecret
): string {
$sb = '';
// Step 1: concat url
$sb .= $url;
// Step 2: concat query parameters
if (!empty($queryParamMap)) {
// 2.1: sort by alphabetical order (PHP's ksort sorts in-place)
ksort($queryParamMap);
// 2.2: concat key and value
foreach ($queryParamMap as $key => $value) {
// String value = entry.getValue() != null ? entry.getValue().toString() : null;
// In PHP, null becomes empty string when concatenated, but we need "null" string
$valueStr = $value !== null ? (string)$value : '';
$sb .= '&' . $key . '=' . $valueStr;
}
}
// Step 3: concat body
if (trim($bodyJSONString) !== '' && trim($bodyJSONString) !== '{}') {
$sb .= '&' . $bodyJSONString;
}
// Step 4: got a complete string waiting to generate a signature
$signatureString = $sb;
try {
// Step 5 & 6: calculate HMAC-SHA256 signature
// Note: hash_hmac returns raw binary data by default
$signatureBytes = hash_hmac('sha256', $signatureString, $clientSecret, true);
if ($signatureBytes === false) {
throw new RuntimeException('Failed to calculate HMAC signature');
}
// Step 7: encode the signature in Base64 format
$signature = base64_encode($signatureBytes);
return $signature;
} catch (Exception $e) {
// Re-throw with appropriate message
throw new RuntimeException('Failed to generate signature: ' . $e->getMessage(), 0, $e);
}
}
}