Request signing

<?php

function is_assoc_array(array $value): bool {
    if ($value === []) {
        return false;
    }
    return array_keys($value) !== range(0, count($value) - 1);
}

function normalize_nested($value) {
    if (!is_array($value)) {
        return $value;
    }

    if (!is_assoc_array($value)) {
        return array_map('normalize_nested', $value);
    }

    $result = [];
    foreach ($value as $key => $child) {
        $result[$key] = is_array($child)
            ? json_encode(normalize_nested($child), JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE)
            : $child;
    }
    return $result;
}

function normalize_value($value) {
    if ($value === null || $value === '') {
        return $value;
    }
    if (is_bool($value)) {
        return $value ? 'true' : 'false';
    }
    return is_array($value)
        ? json_encode(normalize_nested($value), JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE)
        : (string) $value;
}

function generate_signature(array $payload, string $secret): string {
    $normalized = [];
    foreach ($payload as $key => $value) {
        if ($key !== 'sign') {
            $normalized[$key] = normalize_value($value);
        }
    }

    ksort($normalized, SORT_STRING);

    $canonical = '';
    foreach ($normalized as $value) {
        if ($value !== null && $value !== '') {
            $canonical .= $value;
        }
    }

    return hash('sha256', $canonical . $secret);
}

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

public final class OnerwaySign {
    private static final ObjectMapper JSON = new ObjectMapper();

    private static Object normalizeNested(Object value) throws JsonProcessingException {
        if (value instanceof List<?> list) {
            List<Object> result = new ArrayList<>();
            for (Object item : list) {
                result.add(normalizeNested(item));
            }
            return result;
        }

        if (value instanceof Map<?, ?> map) {
            TreeMap<String, Object> result = new TreeMap<>();
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                Object child = entry.getValue();
                result.put(
                    String.valueOf(entry.getKey()),
                    child instanceof Map<?, ?> || child instanceof List<?>
                        ? JSON.writeValueAsString(normalizeNested(child))
                        : child
                );
            }
            return result;
        }

        return value;
    }

    private static String normalizeValue(Object value) throws JsonProcessingException {
        if (value == null) {
            return null;
        }
        if (value instanceof String text) {
            return text.isEmpty() ? null : text;
        }
        if (value instanceof Map<?, ?> || value instanceof List<?>) {
            return JSON.writeValueAsString(normalizeNested(value));
        }
        return String.valueOf(value);
    }

    public static String generateSignature(Map<String, Object> payload, String secret) throws Exception {
        TreeMap<String, String> normalized = new TreeMap<>();
        for (Map.Entry<String, Object> entry : payload.entrySet()) {
            if (!"sign".equals(entry.getKey())) {
                normalized.put(entry.getKey(), normalizeValue(entry.getValue()));
            }
        }

        StringBuilder canonical = new StringBuilder();
        for (String value : normalized.values()) {
            if (value != null && !value.isEmpty()) {
                canonical.append(value);
            }
        }

        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest((canonical + secret).getBytes(StandardCharsets.UTF_8));

        StringBuilder hex = new StringBuilder();
        for (byte b : hash) {
            hex.append(String.format("%02x", b));
        }
        return hex.toString();
    }
}

package signing

import (
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "sort"
)

func normalizeNested(value any) any {
    switch typed := value.(type) {
    case []any:
        result := make([]any, len(typed))
        for i, item := range typed {
            result[i] = normalizeNested(item)
        }
        return result
    case map[string]any:
        result := map[string]any{}
        for key, child := range typed {
            switch child.(type) {
            case map[string]any, []any:
                bytes, _ := json.Marshal(normalizeNested(child))
                result[key] = string(bytes)
            default:
                result[key] = child
            }
        }
        return result
    default:
        return value
    }
}

func normalizeValue(value any) *string {
    if value == nil {
        return nil
    }

    switch typed := value.(type) {
    case string:
        if typed == "" {
            return nil
        }
        return &typed
    case map[string]any, []any:
        bytes, _ := json.Marshal(normalizeNested(value))
        text := string(bytes)
        return &text
    default:
        text := fmt.Sprint(typed)
        return &text
    }
}

func GenerateSignature(payload map[string]any, secret string) string {
    keys := make([]string, 0, len(payload))
    normalized := map[string]*string{}

    for key, value := range payload {
        if key == "sign" {
            continue
        }
        normalized[key] = normalizeValue(value)
        keys = append(keys, key)
    }

    sort.Strings(keys)

    canonical := ""
    for _, key := range keys {
        if value := normalized[key]; value != nil {
            canonical += *value
        }
    }

    sum := sha256.Sum256([]byte(canonical + secret))
    return hex.EncodeToString(sum[:])
}

import { createHash } from 'node:crypto'

function isPlainObject(value) {
  return Object.prototype.toString.call(value) === '[object Object]'
}

function normalizeNested(value) {
  if (Array.isArray(value)) {
    return value.map((item) => normalizeNested(item))
  }

  if (isPlainObject(value)) {
    const result = {}
    Object.keys(value).forEach((key) => {
      const child = value[key]
      result[key] = child !== null && typeof child === 'object'
        ? JSON.stringify(normalizeNested(child))
        : child
    })
    return result
  }

  return value
}

function normalizeValue(value) {
  if (value === null || value === undefined || value === '') {
    return value
  }
  if (typeof value === 'object') {
    return JSON.stringify(normalizeNested(value))
  }
  return String(value)
}

export function generateSignature(payload, secret) {
  const canonical = Object.keys(payload)
    .filter((key) => key !== 'sign')
    .sort()
    .map((key) => normalizeValue(payload[key]))
    .filter((value) => value !== null && value !== undefined && value !== '')
    .join('')

  return createHash('sha256')
    .update(canonical + secret, 'utf8')
    .digest('hex')
}