https://auth.dylk.com/auth-isv/?client_key=awxxxxxxxx&timestamp=1677686399&sign=xxxxxxxxxxxxxx&solution_key=1&permission_keys=1,16&out_shop_id=shop_id&charset=UTF-8&extra=aaaaaaaaaa

{
  "event": "life_saas_cooperate_auth_with_bind",
  "client_key": "axxxxxxxxxxxxx",
  "content": "{\"account_id\": \"7187258584315758632\", \"solution_key\": \"1\",\"permission_key\":[\"1\",\"16\"], \"out_shop_id\":\"out_id_1\", \"poi_id\":\"7264432090391775270\",\"extra\":\"123\"}",
  "log_id": "202210101930530102281180650970B5AF"
}

package open

import (
   "life_service/life_open_sdk/sign"
   urll "net/url"
   "strconv"
   "strings"
   "time"
)

const AuthWithBindUrl string = "https://auth.dylk.com/auth-isv/"
// 请求应用ck TODO 更换成开发者自己的ck
const ClientKey string = ""
// clientKey对应的secret 切勿泄漏 TODO 更换成开发者自己的secret
const ClientSecret string = ""

func GenAuthWithBindValidUrlFast(solutionKey string, outShopId string,extra string, permissionKeys []string, ) (result string, err error) {
   dto := &GenAuthWithBindValidUrlDto{
      Timestamp:    strconv.FormatInt(time.Now().Unix(), 10),
      Extra:        extra,
      SolutionKey:  solutionKey,
      OutShopId:    outShopId,
      PermissionKey: permissionKeys,
   }
   return GenAuthValidUrl(dto)
}

// GenAuthValidUrl 生成一个合法的签名url
func GenAuthWithBindValidUrl(dto *GenAuthValidUrlDto) (result string, err error) {
   parsedUrl, err := urll.Parse(AuthUrl)
   if err != nil {
      return "", err
   }

   query := map[string]string{}
   query["client_key"] = ClientKey
   query["timestamp"] = dto.Timestamp
   query["charset"] = "UTF-8"
   query["solution_key"] = dto.SolutionKey
   query["permission_keys"] = strings.Join(dto.PermissionKeys, ",")
   query["out_shop_id"] = dto.OutShopId
   if dto.Extra != "" {
      query["extra"] = dto.Extra
   }

   signResult := sign.SignV2(ClientSecret, "", query)

   // set final url params
   parsedQuery := parsedUrl.Query()
   parsedQuery.Add("sign", signResult)
   for k, v := range query {
      parsedQuery.Add(k, v)
   }

   parsedUrl.RawQuery = parsedQuery.Encode()
   return parsedUrl.String(), nil
}

type GenAuthWithBindValidUrlDto struct {
   // url开始生效时间
   Timestamp string
   // 服务商自定义字符串，长度不可超过1000字节
   Extra string
   // 解决方案 具体值参照
   SolutionKey string
   // 授权能力列表
   PermissionKeys []string
   // 外部门店ID
   OutShopId    string
}

package sign

import (
   "crypto/md5"
   "crypto/sha256"
   "fmt"
   "sort"
)

// SignV2 用于生活服务应用计算header中的签名(sha256) 新申请应用请使用该方法计算
func SignV2(clientSecret, body string, query map[string]string) string {

   keys := make([]string, 0)
   for k, _ := range query {
      if k == "sign" {
         continue
      }
      keys = append(keys, k)
   }
   sort.Sort(stringSlice(keys))

   str := clientSecret
   for _, k := range keys {
      val := query[k]
      str = fmt.Sprintf("%s&%s", str, fmt.Sprintf("%s=%s", k, val))
   }
   if body != "" {
      str = fmt.Sprintf("%s&http_body=%s", str, body)
   }

   result := Sha256(str)
   fmt.Printf("[Sign] v2 str:%s, result:%s\n", str, result)

   return result
}

// Sign 用于生活服务网站应用计算url签名(md5) 不再使用
func Sign(clientSecret, body string, query map[string]string) string {
   keys := make([]string, 0)
   for k, _ := range query {
      if k == "sign" {
         continue
      }
      keys = append(keys, k)
   }
   sort.Sort(stringSlice(keys))

   str := clientSecret
   for _, k := range keys {
      val := query[k]
      str = fmt.Sprintf("%s&%s", str, fmt.Sprintf("%s=%s", k, val))
   }
   if body != "" {
      str = fmt.Sprintf("%s&http_body=%s", str, body)
   }

   fmt.Printf("[Sign] str:%s\n", str)

   return MD5(str)
}

func MD5(str string) string {
   data := []byte(str) // 切片
   hash := md5.Sum(data)
   md5str := fmt.Sprintf("%x", hash) // 将[]byte转成16进制
   return md5str
}

func Sha256(str string) string {
   sum256 := sha256.Sum256([]byte(str))
   shaStr := fmt.Sprintf("%x", sum256) // 将[]byte转成16进制
   return shaStr
}

type stringSlice []string

func (p stringSlice) Len() int           { return len(p) }
func (p stringSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p stringSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

package com.douyin.open.goodlife;

import java.util.*;

import java.util.stream.Collectors;

public class GenAuthWithBindUrlUtil {

    private final static String AuthUrl = "https://auth.dylk.com/auth-isv/";

    /**
     * 请求应用ck TODO 更换成开发者自己的ck
     */
    private final static String ClientKey = "";

    /**
     * clientKey对应的secret 切勿泄漏 TODO 更换成开发者自己的secret
     */
    private final static String ClientSecret = "";

    public static String GenAuthWithBindValidUrlFast(List<String> permissionKeys, String outShopId, String solutionKey, String extra) {
        GenAuthWithBindValidUrlDto dto = new GenAuthWithBindValidUrlDto();
        dto.setTimestamp(String.valueOf(System.currentTimeMillis() / 1000));
        dto.setSolutionKey(solutionKey);
        dto.setExtra(extra);
        dto.setPermissionKeys(permissionKeys);
        dto.setOutShopId(outShopId);
        return GenAuthWithBindValidUrl(dto);
    }

    /**
     * 生成一个合法的签名url
     *
     * @param dto
     * @return
     */
    public static String GenAuthWithBindValidUrl(GenAuthWithBindValidUrlDto dto) {
        Map<String, String> query = new HashMap<>();
        query.put("client_key", ClientKey);
        query.put("timestamp", dto.getTimestamp());
        query.put("charset", "UTF-8");
        query.put("solution_key", dto.getSolutionKey());
        query.put("out_shop_id", dto.getOutShopId());
        query.put("permission_keys", String.join(",", dto.getPermissionKeys()));
        if (dto.getExtra() != null && dto.getExtra() != "") {
            query.put("extra", dto.getExtra());
        }

        String signResult = SignUtil.SignV2(ClientSecret, "", query);
        query.put("sign", signResult);

        String queryStr = query.entrySet().stream()
                .map(entry -> new StringBuilder().append(entry.getKey()).append("=").append(entry.getValue()))
                .collect(Collectors.joining("&"));
        StringBuilder resultSb = new StringBuilder(AuthUrl).append("?").append(queryStr);

        return resultSb.toString();
    }
}

package com.douyin.open.goodlife;

import java.util.Map;

public class SignUtil {

    /**
     * SignV2 用于生活服务应用计算header中的签名(sha256) 新申请应用请使用该方法计算
     *@param clientSecret 应用secret
     * @param body post请求/spi请求中的body参数json字符串
     * @param query url参数
     * @return 签名
     */
    public static String SignV2(String clientSecret, String body, Map<String, String> query) {
        StringBuilder str = new StringBuilder(clientSecret);

        query.keySet().stream()
                .filter(a -> !"sign".equals(a))
                .sorted()
                .forEach(k -> {
                    String val = query.get(k);
                    str.append("&");
                    str.append(k).append("=").append(val);
                });

        if (body != null && !"".equals(body)) {
            str.append("&");
            str.append("body").append("=").append(body);
        }

        String result = EncryptUtil.SHA256(str.toString());
        System.out.printf("[Sign] v2 str:%s, result:%s\n", str.toString(), result);

        return result;
    }

}

package com.douyin.open.goodlife;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

public class EncryptUtil {
    /*
     * appid/client_key对应的client_secret
     * TODO: 更换成开发者自己的secret
     */
    private static final String secret = "";
    private static final String key;

    private static final String iv;

    static {
        key = parseSecret(secret);
        iv = secret.substring(16);
    }

    /**
     * @description AES加密
     * @param data 明文数据
     * @return 密文
     */
    public static String encryptAES(String data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            int blockSize = cipher.getBlockSize();
            byte[] dataBytes = data.getBytes();
            int plaintextLength = dataBytes.length;

            if (plaintextLength % blockSize != 0) {
                plaintextLength = plaintextLength + (blockSize - (plaintextLength % blockSize));
            }

            byte[] plaintext = new byte[plaintextLength];
            System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);

            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());  // CBC模式，需要一个向量iv，可增加加密算法的强度

            cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
            byte[] encrypted = cipher.doFinal(plaintext);

            System.out.println(encrypted);
            return encode(encrypted).trim(); // BASE64做转码。

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @Description AES解密
     * @param data base64后的密文
     * @return 明文
     */
    public static String decryptAES(String data) throws Exception {
        try
        {
            byte[] encrypted1 = decode(data);//先用base64解密

            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());

            cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);

            byte[] original = cipher.doFinal(encrypted1);
            String originalString = new String(original);
            return originalString.trim();
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * SHA-256加密
     * @param input 明文
     * @return 密文
     */
    public static String SHA256(String input) {
        String result = "";
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(input.getBytes(StandardCharsets.UTF_8));
            byte[] digest = md.digest();
            result = bytes2Hex(digest);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return result;

    }

    /**
     * 将字节数组转换为十六进制字符串
     */
    public static String bytes2Hex(byte[] bts) {
        StringBuilder hexSb = new StringBuilder();
        for (byte b : bts) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexSb.append('0');
            hexSb.append(hex);
        }
        return hexSb.toString();
    }

    /**
     * base64编码
     * @param byteArray
     * @return
     */
    public static String encode(byte[] byteArray) {
        return new String(Base64.getEncoder().encode(byteArray));
    }

    /**
     * base64解码
     * @param base64EncodedString
     * @return
     */
    public static byte[] decode(String base64EncodedString) {
        return Base64.getDecoder().decode(base64EncodedString);
    }

    private static String parseSecret(String secret) {
        secret = fillSecret(secret);
        secret = cutSecret(secret);
        return secret;
    }

    private static String cutSecret(String secret) {
        if (secret.length() <= 32) {
            return secret;
        }

        int rightCnt = (secret.length() - 32) / 2;
        int leftCnt = secret.length() - 32 - rightCnt;

        return secret.substring(leftCnt, 32 + leftCnt);
    }

    private static String fillSecret(String secret) {
        if (secret.length() >= 32) {
            return secret;
        }
        int rightCnt = (32 - secret.length()) / 2;
        int leftCnt = 32 - secret.length() - rightCnt;

        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < leftCnt; i++) {
            sb.append('#');
        }
        sb.append(secret);
        for (int i = 0; i < rightCnt; i++) {
            sb.append('#');
        }
        return sb.toString();
    }
}

package com.douyin.open.goodlife.dto;

import java.util.List;

public class GenAuthWithBindValidUrlDto {
    // url开始生效时间
    private String Timestamp;
    // 透传信息
    private String Extra;
    // 解决方案key 根据接口文档填充值
    private String SolutionKey;
   // 授权能力列表
    private List<String> PermissionKeys;
   // 外部门店ID
    private String OutShopId;
    
    public String getTimestamp() {
        return Timestamp;
    }

    public void setTimestamp(String timestamp) {
        Timestamp = timestamp;
    }
    //
    public String getExtra() {
        return Extra;
    }

    public void setExtra(String extra) {
        Extra = extra;
    }
    //
    public String getSolutionKey() {
        return SolutionKey;
    }

    public void setSolutionKey(String solutionKey) {
        SolutionKey = solutionKey;
    }
    
    //
    public List<String> getPermissionKeys() {
        return PermissionKeys;
    }

    public void setPermissionKeys(List<String> permissionKeys) {
        PermissionKeys = permissionKeys;
    }
    
    //
    public String getOutShopId() {
        return OutShopId;
    }

    public void setOutShopId(String outShopId) {
        OutShopId = outShopId;
    }
}