sign签名算法一致算法-.net、java、golang

签名在接口中使用广泛，那么进行接口交互的时候为了保证数据中途不会被篡改需要进行一致性签名，下面将为大家展示个语言一致性前面的算法，同样的内容签名后的数据必须是一致的：

java版本：

package cn.com.gome.utils;

/**
 * 编码
 * @author 
 *
 */
public abstract class Constants {
    
    /**
     * TOP默认时间格式
     */
    public static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    
    /**
     * TOP Date默认时区
     */
    public static final String DATE_TIMEZONE = "GMT+8";
    
    /**
     * UTF-8字符集
     */
    public static final String CHARSET_UTF8 = "UTF-8";
    
    /**
     * GBK字符集
     */
    public static final String CHARSET_GBK = "GBK";
    
    /**
     * TOP JSON 应格式
     */
    public static final String FORMAT_JSON = "json";
    
    /**
     * TOP XML 应格式
     */
    public static final String FORMAT_XML = "xml";
    
    /**
     * MD5签名方式
     */
    public static final String SIGN_METHOD_MD5 = "md5";
    
    /**
     * HMAC签名方式
     */
    public static final String SIGN_METHOD_HMAC = "hmac";
    
    
}

package cn.com.gome.utils;

import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Map;

import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import cn.com.gome.utils.StringUtils;

/**
 * 签名工具
 * @author 
 *
 */
public class SignUtil {
    /**
     * 签名算法
     * 
     * @param params
     * @param secret
     * @param signMethod
     * @return
     * @throws IOException
     */
    public static String signTopRequest(Map<String, String> params, String secret, String signMethod)
            throws IOException {
        // 第一步：检查参数是否已经排序
        String[] keys = params.keySet().toArray(new String[0]);
        Arrays.sort(keys);

        // 第二步：把所有参数名和参数值串在一起
        StringBuilder query = new StringBuilder();
        if (Constants.CHARSET_UTF8.equals(signMethod)) {
            query.append(secret);
        }
        for (String key : keys) {
            String value = params.get(key);
            if (StringUtils.areNotEmpty(key, value)) {
                query.append(key).append(value);
            }
        }

        // 第三步：使用MD5/HMAC加密
        byte[] bytes = new byte[0];
        if (Constants.CHARSET_UTF8.equals(signMethod)) {
            bytes = encryptHMAC(query.toString(), secret);
        } else {
            query.append(secret);
            try {
                bytes = encryptMD5(query.toString());
            } catch (NoSuchAlgorithmException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        // 第四步：把二进制转化为大写的十六进制
        return byte2hex(bytes);
    }
    
    /**
     * hmac加密
     * @param data
     * @param secret
     * @return
     * @throws IOException
     */
    public static byte[] encryptHMAC(String data, String secret) throws IOException {
        byte[] bytes = null;
        try {
            SecretKey secretKey = new SecretKeySpec(secret.getBytes(Constants.CHARSET_UTF8), "HmacMD5");
            Mac mac = Mac.getInstance(secretKey.getAlgorithm());
            mac.init(secretKey);
            bytes = mac.doFinal(data.getBytes(Constants.CHARSET_UTF8));
        } catch (GeneralSecurityException gse) {
            throw new IOException(gse.toString());
        }
        return bytes;
    }

    /**
     * 实现md5加密
     * @param data
     * @return
     * @throws IOException
     * @throws NoSuchAlgorithmException
     */
    public static byte[] encryptMD5(String data) throws IOException, NoSuchAlgorithmException {
        
        //确定计算方法
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        return md5.digest(data.getBytes(Constants.CHARSET_UTF8));
    }

    /**
     * 将字节数据进行16位处理
     * @param bytes
     * @return
     */
    public static String byte2hex(byte[] bytes) {
        StringBuilder sign = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(bytes[i] & 0xFF);
            if (hex.length() == 1) {
                sign.append("0");
            }
            sign.append(hex.toUpperCase());
        }
        return sign.toString();
    }
}

package cn.com.gome.utils;

/**
 * 字符串工具类
 * @author 
 *
 */
public abstract  class StringUtils {
    
    private StringUtils() {}

    /**
     * 检查指定的字符串是否为空。
     * <ul>
     * <li>SysUtils.isEmpty(null) = true</li>
     * <li>SysUtils.isEmpty("") = true</li>
     * <li>SysUtils.isEmpty("   ") = true</li>
     * <li>SysUtils.isEmpty("abc") = false</li>
     * </ul>
     * 
     * @param value 待检查的字符串
     * @return true/false
     */
    public static boolean isEmpty(String value) {
        int strLen;
        if (value == null || (strLen = value.length()) == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if ((Character.isWhitespace(value.charAt(i)) == false)) {
                return false;
            }
        }
        return true;
    }

    /**
     * 检查对象是否为数字型字符串,包含负数开头的。
     */
    public static boolean isNumeric(Object obj) {
        if (obj == null) {
            return false;
        }
        char[] chars = obj.toString().toCharArray();
        int length = chars.length;
        if(length < 1)
            return false;
        
        int i = 0;
        if(length > 1 && chars[0] == '-')
            i = 1;
        
        for (; i < length; i++) {
            if (!Character.isDigit(chars[i])) {
                return false;
            }
        }
        return true;
    }

    /**
     * 检查指定的字符串列表是否不为空。
     */
    public static boolean areNotEmpty(String... values) {
        boolean result = true;
        if (values == null || values.length == 0) {
            result = false;
        } else {
            for (String value : values) {
                result &= !isEmpty(value);
            }
        }
        return result;
    }

    /**
     * 把通用字符编码的字符串转化为汉字编码。
     */
    public static String unicodeToChinese(String unicode) {
        StringBuilder out = new StringBuilder();
        if (!isEmpty(unicode)) {
            for (int i = 0; i < unicode.length(); i++) {
                out.append(unicode.charAt(i));
            }
        }
        return out.toString();
    }

    /**
     * 过滤不可见字符
     */
    public static String stripNonValidXMLCharacters(String input) {
        if (input == null || ("".equals(input)))
            return "";
        StringBuilder out = new StringBuilder();
        char current;
        for (int i = 0; i < input.length(); i++) {
            current = input.charAt(i);
            if ((current == 0x9) || (current == 0xA) || (current == 0xD)
                    || ((current >= 0x20) && (current <= 0xD7FF))
                    || ((current >= 0xE000) && (current <= 0xFFFD))
                    || ((current >= 0x10000) && (current <= 0x10FFFF)))
                out.append(current);
        }
        return out.toString();
    }

}

.net版本

 private static string SignTopRequest(IDictionary<string, string> parameters, string secret, string signMethod)
        {
            // 第一步：把字典按Key的字母顺序排序
            IDictionary<string, string> sortedParams = new SortedDictionary<string, string>(parameters, StringComparer.Ordinal);
            IEnumerator<KeyValuePair<string, string>> dem = sortedParams.GetEnumerator();

            // 第二步：把所有参数名和参数值串在一起
            StringBuilder query = new StringBuilder();
            if (Constants.CHARSET_UTF_8.Equals(signMethod))
            {
                query.Append(secret);
            }
            while (dem.MoveNext())
            {
                string key = dem.Current.Key;
                string value = dem.Current.Value;
                if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(value))
                {
                    query.Append(key).Append(value);
                }
            }

            // 第三步：使用MD5/HMAC加密
            byte[] bytes;
            if (Constants.CHARSET_UTF_8.Equals(signMethod))
            {
                HMACMD5 hmac = new HMACMD5(Encoding.UTF8.GetBytes(secret));
                bytes = hmac.ComputeHash(Encoding.UTF8.GetBytes(query.ToString()));
            }
            else
            {
                query.Append(secret);
                MD5 md5 = MD5.Create();
                bytes = md5.ComputeHash(Encoding.UTF8.GetBytes(query.ToString()));
            }

            // 第四步：把二进制转化为大写的十六进制
            StringBuilder result = new StringBuilder();
            for (int i = 0; i < bytes.Length; i++)
            {
                result.Append(bytes[i].ToString("X2"));
            }

            return result.ToString();
        }

namespace Sys.Common
{
    public sealed class Constants
    {
        public static string CHARSET_ISO_2022_JP = "ISO-2022-JP";
        public static string CHARSET_ISO_2022_CN = "ISO-2022-CN";
        public static string CHARSET_ISO_2022_KR = "ISO-2022-KR";
        public static string CHARSET_ISO_8859_5 = "ISO-8859-5";
        public static string CHARSET_ISO_8859_7 = "ISO-8859-7";
        public static string CHARSET_ISO_8859_8 = "ISO-8859-8";
        public static string CHARSET_BIG5 = "BIG5";
        public static string CHARSET_GB18030 = "GB18030";
        public static string CHARSET_EUC_JP = "EUC-JP";
        public static string CHARSET_EUC_KR = "EUC-KR";
        public static string CHARSET_EUC_TW = "EUC-TW";
        public static string CHARSET_SHIFT_JIS = "SHIFT_JIS";
        public static string CHARSET_IBM855 = "IBM855";
        public static string CHARSET_IBM866 = "IBM866";
        public static string CHARSET_KOI8_R = "KOI8-R";
        public static string CHARSET_MACCYRILLIC = "x-mac-cyrillic"; //C#中"MACCYRILLIC"改名了
        public static string CHARSET_WINDOWS_1251 = "WINDOWS-1251";
        public static string CHARSET_WINDOWS_1252 = "WINDOWS-1252";
        public static string CHARSET_WINDOWS_1253 = "WINDOWS-1253";
        public static string CHARSET_WINDOWS_1255 = "WINDOWS-1255";
        public static string CHARSET_UTF_8 = "UTF-8";
        public static string CHARSET_UTF_16BE = "UTF-16BE";
        public static string CHARSET_UTF_16LE = "UTF-16LE";
        public static string CHARSET_UTF_32BE = "UTF-32BE";
        public static string CHARSET_UTF_32LE = "UTF-32LE";
        public static string CHARSET_TIS_620 = "WINDOWS-874";//C#泰语的TIS-620在.NET里叫WINDOWS-874
        //.NET直接支持GB2312编码的
        //public static string CHARSET_HZ_GB_2312 = "GB2312"; 

        // WARNING: Listed below are charsets which Java does not support.
        public static string CHARSET_HZ_GB_2312 = "HZ-GB-2312"; // Simplified Chinese
        public static string CHARSET_X_ISO_10646_UCS_4_3412 = "X-ISO-10646-UCS-4-3412"; // Malformed UTF-32
        public static string CHARSET_X_ISO_10646_UCS_4_2143 = "X-ISO-10646-UCS-4-2143"; // Malformed UTF-32
    }
}

golang版本

package utils

import (
    "bytes"
    "crypto/hmac"
    "crypto/md5"
    "fmt"
    "sort"
    "strconv"
    "strings"
    "sync"
)

//签名的字符编码类型
type GOLANG_CHARSET string

//字符编码类型常量
const (
    CHARSET_ISO_2022_JP            GOLANG_CHARSET = "ISO-2022-JP"
    CHARSET_ISO_2022_CN                           = "ISO-2022-CN"
    CHARSET_ISO_2022_KR                           = "ISO-2022-KR"
    CHARSET_ISO_8859_5                            = "ISO-8859-5"
    CHARSET_ISO_8859_7                            = "ISO-8859-7"
    CHARSET_ISO_8859_8                            = "ISO-8859-8"
    CHARSET_BIG5                                  = "BIG5"
    CHARSET_GB18030                               = "GB18030"
    CHARSET_EUC_JP                                = "EUC-JP"
    CHARSET_EUC_KR                                = "EUC-KR"
    CHARSET_EUC_TW                                = "EUC-TW"
    CHARSET_SHIFT_JIS                             = "SHIFT_JIS"
    CHARSET_IBM855                                = "IBM855"
    CHARSET_IBM866                                = "IBM866"
    CHARSET_KOI8_R                                = "KOI8-R"
    CHARSET_MACCYRILLIC                           = "x-mac-cyrillic"
    CHARSET_WINDOWS_1251                          = "WINDOWS-1251"
    CHARSET_WINDOWS_1252                          = "WINDOWS-1252"
    CHARSET_WINDOWS_1253                          = "WINDOWS-1253"
    CHARSET_WINDOWS_1255                          = "WINDOWS-1255"
    CHARSET_UTF_8                                 = "UTF-8"
    CHARSET_UTF_16BE                              = "UTF-16BE"
    CHARSET_UTF_16LE                              = "UTF-16LE"
    CHARSET_UTF_32BE                              = "UTF-32BE"
    CHARSET_UTF_32LE                              = "UTF-32LE"
    CHARSET_TIS_620                               = "WINDOWS-874"
    CHARSET_HZ_GB_2312                            = "HZ-GB-2312"
    CHARSET_X_ISO_10646_UCS_4_3412                = "X-ISO-10646-UCS-4-3412"
    CHARSET_X_ISO_10646_UCS_4_2143                = "X-ISO-10646-UCS-4-2143"
)

//当前类的指针
var sign *signUtils

//同步锁
var signone sync.Once

//签名类
type signUtils struct {
    mapExtend *MapExtend
}

//实例化签名
func Sign() *signUtils {
    signone.Do(func() {
        sign = new(signUtils)
        sign.mapExtend = new(MapExtend)
    })
    return sign
}

/**
签名算法
parameters 要签名的数据项
secret 生成的publicKey
signMethod 签名的字符编码
*/
func (s *signUtils) SignTopRequest(parameters *map[string]string, secret string, signMethod GOLANG_CHARSET) string {
    /**
    1、第一步：把字典按Key的字母顺序排序
    2、第二步：把所有参数名和参数值串在一起
    3、第三步：使用MD5/HMAC加密
    4、第四步：把二进制转化为大写的十六进制
    */

    //第一步：把字典按Key的字母顺序排序
    keys, err := s.mapExtend.GetKeys(parameters)
    if err != nil {
        //        goto result
        return ""
    }
    sort.Strings(keys)
    //第二步：把所有参数名和参数值串在一起
    var bb bytes.Buffer
    if CHARSET_UTF_8 == signMethod {
        bb.WriteString(secret)
    }
    for i, v := range keys {
        _ = i
        val := (*parameters)[v]
        if len(val) > 0 {
            bb.WriteString(v)
            bb.WriteString(val)
        }
    }
    fmt.Println(bb.String())
    //第三步：使用MD5/HMAC加密
    b := make([]byte, 0)
    if CHARSET_UTF_8 == signMethod {
        h := hmac.New(md5.New, s.GetUtf8Bytes(secret))
        h.Write(bb.Bytes())
        b = h.Sum(nil)
    } else {
        bb.WriteString(secret)
        md5instence := md5.New()
        md5instence.Write(bb.Bytes())
        b = md5instence.Sum(nil)
    }
    //第四步：把二进制转化为大写的十六进制
    var result bytes.Buffer
    for i := 0; i < len(b); i++ {
        s := strconv.FormatInt(int64(b[i]&0xff), 16)
        if len(s) == 1 {
            result.WriteString("0")
        }
        result.WriteString(s)
    }
    //返回签名完成的字符串
    return strings.ToUpper(result.String())
}

//默认utf8字符串
func (s *signUtils) GetUtf8Bytes(str string) []byte {
    b := []byte(str)
    return b
}