Go Signing And Verification

package paymentsign

import (
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha512"
	"crypto/x509"
	"encoding/base64"
	"encoding/hex"
	"encoding/pem"
	"fmt"
	"log"
	"strconv"
	"strings"
)

func keyDER(input string, private bool) ([]byte, error) {
	if len(input) > 16384 {
		return nil, fmt.Errorf("key: exceeds 16 KiB")
	}
	input = strings.TrimSpace(input)
	input = strings.ReplaceAll(input, `\r\n`, "\n")
	input = strings.ReplaceAll(input, `\n`, "\n")
	if strings.HasPrefix(input, "-----BEGIN") {
		block, rest := pem.Decode([]byte(input))
		if block == nil || strings.TrimSpace(string(rest)) != "" {
			return nil, fmt.Errorf("key: expected one complete PEM block")
		}
		allowed := block.Type == "PUBLIC KEY" || block.Type == "RSA PUBLIC KEY"
		if private {
			allowed = block.Type == "PRIVATE KEY" || block.Type == "RSA PRIVATE KEY"
		}
		if !allowed || len(block.Headers) != 0 {
			return nil, fmt.Errorf("key: expected unencrypted RSA PEM of the correct kind")
		}
		return block.Bytes, nil
	}
	return decodeBase64(strings.Join(strings.Fields(input), ""), "key")
}

func decodeBase64(text, label string) ([]byte, error) {
	value, err := base64.StdEncoding.DecodeString(text)
	if err != nil || len(value) == 0 || base64.StdEncoding.EncodeToString(value) != text {
		return nil, fmt.Errorf("%s: invalid Base64", label)
	}
	return value, nil
}

func privateKey(input string) (*rsa.PrivateKey, error) {
	der, err := keyDER(input, true)
	if err != nil {
		return nil, err
	}
	if key, err := x509.ParsePKCS1PrivateKey(der); err == nil {
		return key, nil
	}
	key, err := x509.ParsePKCS8PrivateKey(der)
	if err == nil {
		if rsaKey, ok := key.(*rsa.PrivateKey); ok {
			return rsaKey, nil
		}
	}
	return nil, fmt.Errorf("key: invalid/truncated, encrypted or non-RSA private key; DER bytes=%d", len(der))
}

func publicKey(input string) (*rsa.PublicKey, error) {
	der, err := keyDER(input, false)
	if err != nil {
		return nil, err
	}
	if key, err := x509.ParsePKCS1PublicKey(der); err == nil {
		return key, nil
	}
	key, err := x509.ParsePKIXPublicKey(der)
	if err == nil {
		if rsaKey, ok := key.(*rsa.PublicKey); ok {
			return rsaKey, nil
		}
	}
	return nil, fmt.Errorf("key: invalid/truncated or non-RSA public key; DER bytes=%d", len(der))
}

func validTimestamp(text string) error {
	value, err := strconv.ParseInt(text, 10, 64)
	if err != nil || value <= 0 || strconv.FormatInt(value, 10) != text {
		return fmt.Errorf("invalid Timestamp: use Unix seconds")
	}
	return nil
}

func bodyHash(body []byte) string {
	digest := sha512.Sum512(body)
	return hex.EncodeToString(digest[:])
}

// nil means no request body; []byte{} means a present, empty body.
func SignRequest(path string, body []byte, timestamp, merchantPrivateKey string) (signature string, err error) {
	defer func() {
		if err != nil {
			log.Printf("[payment-sign] FAILED body_bytes=%d error=%q", len(body), err.Error())
		}
	}()
	if !strings.HasPrefix(path, "/") {
		return "", fmt.Errorf("path: expected API path")
	}
	if err := validTimestamp(timestamp); err != nil {
		return "", err
	}
	key, err := privateKey(merchantPrivateKey)
	if err != nil {
		return "", err
	}
	hash := ""
	if body != nil {
		hash = bodyHash(body)
	}
	digest := sha512.Sum512([]byte(path + hash + timestamp))
	sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA512, digest[:])
	if err != nil {
		return "", fmt.Errorf("RSA SHA512 signing failed: %w", err)
	}
	return base64.StdEncoding.EncodeToString(sig), nil
}

// Exact callback bytes, or exact signed data bytes for API envelopes. NO path.
func VerifyPlatform(body []byte, timestamp, signature, platformPublicKey string) (err error) {
	defer func() {
		if err != nil {
			log.Printf("[payment-verify] FAILED body_bytes=%d error=%q", len(body), err.Error())
		}
	}()
	if err := validTimestamp(timestamp); err != nil {
		return err
	}
	key, err := publicKey(platformPublicKey)
	if err != nil {
		return err
	}
	sig, err := decodeBase64(signature, "Signature")
	if err != nil {
		return err
	}
	if len(sig) != key.Size() {
		return fmt.Errorf("Signature length: got %d, expected %d bytes", len(sig), key.Size())
	}
	digest := sha512.Sum512([]byte(bodyHash(body) + timestamp))
	if err := rsa.VerifyPKCS1v15(key, crypto.SHA512, digest[:], sig); err != nil {
		return fmt.Errorf("RSA SHA512 verification failed: check platform key, raw bytes, timestamp and formula: %w", err)
	}
	return nil
}

package paymentsign

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"net/http"
	"strconv"
	"strings"
	"time"
)

// rawBody is the exact serialized bytes, or nil for a bodyless GET.
func Send(ctx context.Context, baseURL, path, merchantCode string, rawBody []byte, merchantPrivateKey string) ([]byte, error) {
	if !strings.HasPrefix(baseURL, "https://") {
		return nil, fmt.Errorf("HTTPS is required")
	}
	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	signature, err := SignRequest(path, rawBody, timestamp, merchantPrivateKey)
	if err != nil {
		return nil, err
	}
	method := http.MethodPost
	var body io.Reader = bytes.NewReader(rawBody)
	if rawBody == nil {
		method = http.MethodGet
		body = nil
	}
	req, err := http.NewRequestWithContext(ctx, method, baseURL+path, body)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Merchant-Code", merchantCode)
	req.Header.Set("Timestamp", timestamp)
	req.Header.Set("Signature", signature)
	client := &http.Client{Timeout: 60 * time.Second, CheckRedirect: func(_ *http.Request, _ []*http.Request) error { return http.ErrUseLastResponse }}
	response, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()
	if response.StatusCode < 200 || response.StatusCode >= 300 {
		return nil, fmt.Errorf("HTTP %d; reconcile before retrying", response.StatusCode)
	}
	result, err := io.ReadAll(io.LimitReader(response.Body, (8<<20)+1))
	if err != nil {
		return nil, err
	}
	if len(result) > 8<<20 {
		return nil, fmt.Errorf("response exceeds 8 MiB")
	}
	return result, nil // Preserve raw response for envelope verification.
}

// Imports: encoding/json, strconv, time, io, net/http.
body, err := json.Marshal(payload)
if err != nil { return err }
timestamp := strconv.FormatInt(time.Now().Unix(), 10)
signature, err := paymentsign.SignRequest("/v1/merchant/pay", body, timestamp, merchantPrivateKey)
if err != nil { return err }
// Transmit exactly body; use timestamp/signature as headers. Do not marshal again.
// No body: paymentsign.SignRequest("/v1/merchant/account", nil, timestamp, merchantPrivateKey)

// Inside an http.Handler; configuredPlatformPublicKey is loaded from trusted configuration.
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
defer r.Body.Close()
rawBody, err := io.ReadAll(r.Body)
if err != nil { http.Error(w, "invalid body", 400); return }
if err := paymentsign.VerifyPlatform(rawBody, r.Header.Get("Timestamp"),
    r.Header.Get("Signature"), configuredPlatformPublicKey); err != nil {
    http.Error(w, "invalid signature", 401); return
}
// Only now decode JSON, validate the order and commit an idempotent update.
// Write SUCCESS only after durable processing.