Java Signing And Verification

import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAKey;
import java.security.spec.*;
import java.util.Base64;
import java.util.HexFormat;
import java.util.regex.Pattern;

public final class SignUtil {
    private SignUtil() {}
    private static final byte[] RSA_ALGORITHM = HexFormat.of().parseHex("300d06092a864886f70d0101010500");

    private static String timestamp(String text) {
        try {
            if (text == null || !text.matches("[1-9][0-9]{0,18}") || Long.parseLong(text) <= 0) throw new IllegalArgumentException();
            return text;
        } catch (IllegalArgumentException e) { throw new IllegalArgumentException("invalid Timestamp: use Unix seconds"); }
    }

    private static byte[] base64(String text, String label) {
        try {
            byte[] bytes = Base64.getDecoder().decode(text);
            if (bytes.length == 0 || !Base64.getEncoder().encodeToString(bytes).equals(text)) throw new IllegalArgumentException();
            return bytes;
        } catch (IllegalArgumentException | NullPointerException e) { throw new IllegalArgumentException(label + ": invalid Base64"); }
    }

    private static byte[] keyDER(String input, boolean privateKey) {
        if (input == null || input.length() > 16384) throw new IllegalArgumentException("key: missing or too large");
        String text = input.replace("\\r\\n", "\n").replace("\\n", "\n").trim();
        if (text.startsWith("-----BEGIN")) {
            var m = Pattern.compile("\\A-----BEGIN ([A-Z ]+)-----\\s*([A-Za-z0-9+/=\\s]+)\\s*-----END \\1-----\\z").matcher(text);
            if (!m.matches()) throw new IllegalArgumentException("key: expected one complete PEM block");
            String label = m.group(1);
            boolean allowed = privateKey ? label.equals("PRIVATE KEY") || label.equals("RSA PRIVATE KEY")
                    : label.equals("PUBLIC KEY") || label.equals("RSA PUBLIC KEY");
            if (!allowed) throw new IllegalArgumentException("key: expected unencrypted RSA PEM of the correct kind");
            text = m.group(2);
        }
        return base64(text.replaceAll("\\s", ""), "key");
    }

    // Container wrapping only; JCA performs ASN.1 parsing and RSA key import.
    private static byte[] der(int tag, byte[]... values) {
        var data = new ByteArrayOutputStream();
        for (byte[] value : values) data.writeBytes(value);
        byte[] bytes = data.toByteArray();
        var out = new ByteArrayOutputStream();
        out.write(tag);
        if (bytes.length < 128) out.write(bytes.length);
        else {
            int count = (32 - Integer.numberOfLeadingZeros(bytes.length) + 7) / 8;
            out.write(128 | count);
            for (int i = count - 1; i >= 0; i--) out.write(bytes.length >>> (i * 8));
        }
        out.writeBytes(bytes);
        return out.toByteArray();
    }

    private static Key key(String input, boolean privateKey) throws GeneralSecurityException {
        byte[] raw = keyDER(input, privateKey);
        byte[] wrapped = privateKey
                ? der(48, new byte[]{2, 1, 0}, RSA_ALGORITHM, der(4, raw))
                : der(48, RSA_ALGORITHM, der(3, new byte[]{0}, raw));
        for (byte[] bytes : new byte[][]{raw, wrapped}) {
            try {
                var factory = KeyFactory.getInstance("RSA");
                return privateKey ? factory.generatePrivate(new PKCS8EncodedKeySpec(bytes))
                        : factory.generatePublic(new X509EncodedKeySpec(bytes));
            } catch (InvalidKeySpecException e) { /* Try the other documented container. */ }
        }
        throw new InvalidKeySpecException("key: invalid/truncated, encrypted or non-RSA key; DER bytes=" + raw.length);
    }

    private static String hash(byte[] body) throws GeneralSecurityException {
        if (body == null) throw new IllegalArgumentException("body: expected raw bytes");
        return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-512").digest(body));
    }

    private static void log(String operation, byte[] body, Exception e) {
        String reason = e instanceof IllegalArgumentException || e instanceof InvalidKeySpecException
                ? e.getMessage() : "RSA operation failed (" + e.getClass().getSimpleName() + ")";
        System.err.printf("[payment-%s] FAILED body_bytes=%d error=%s%n", operation, body == null ? 0 : body.length, reason);
    }

    // null means no request body; new byte[0] means a present, empty body.
    public static String signRequest(String path, byte[] body, String timestamp, String merchantPrivateKey) throws GeneralSecurityException {
        try {
            if (path == null || !path.startsWith("/")) throw new IllegalArgumentException("path: expected API path");
            String origin = path + (body == null ? "" : hash(body)) + timestamp(timestamp);
            var signer = Signature.getInstance("SHA512withRSA");
            signer.initSign((PrivateKey) key(merchantPrivateKey, true));
            signer.update(origin.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(signer.sign());
        } catch (GeneralSecurityException | RuntimeException e) { log("sign", body, e); throw e; }
    }

    // Exact callback bytes, or exact signed data bytes for API envelopes. NO path.
    public static void verifyPlatform(byte[] body, String timestamp, String signature, String platformPublicKey) throws GeneralSecurityException {
        try {
            String origin = hash(body) + timestamp(timestamp);
            PublicKey publicKey = (PublicKey) key(platformPublicKey, false);
            byte[] sig = base64(signature, "Signature");
            int expected = (((RSAKey) publicKey).getModulus().bitLength() + 7) / 8;
            if (sig.length != expected) throw new IllegalArgumentException("Signature length: got " + sig.length + ", expected " + expected + " bytes");
            var verifier = Signature.getInstance("SHA512withRSA");
            verifier.initVerify(publicKey);
            verifier.update(origin.getBytes(StandardCharsets.UTF_8));
            if (!verifier.verify(sig)) throw new IllegalArgumentException("RSA SHA512 verification failed: check platform key, raw bytes, timestamp and formula");
        } catch (GeneralSecurityException | RuntimeException e) { log("verify", body, e); throw e; }
    }
}

import java.io.IOException;
import java.net.URI;
import java.net.http.*;
import java.time.Duration;
import java.time.Instant;
import java.security.GeneralSecurityException;

public final class HttpUtil {
    private static final HttpClient CLIENT = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10))
            .followRedirects(HttpClient.Redirect.NEVER).build();

    public static byte[] send(String baseUrl, String path, String merchantCode, byte[] rawBody, String merchantPrivateKey)
            throws GeneralSecurityException, IOException, InterruptedException {
        if (!baseUrl.startsWith("https://")) throw new IllegalArgumentException("HTTPS is required");
        String timestamp = Long.toString(Instant.now().getEpochSecond());
        String signature = SignUtil.signRequest(path, rawBody, timestamp, merchantPrivateKey);
        var builder = HttpRequest.newBuilder(URI.create(baseUrl + path)).timeout(Duration.ofSeconds(60))
                .header("Content-Type", "application/json").header("Merchant-Code", merchantCode)
                .header("Timestamp", timestamp).header("Signature", signature);
        if (rawBody == null) builder.GET();
        else builder.POST(HttpRequest.BodyPublishers.ofByteArray(rawBody));
        var response = CLIENT.send(builder.build(), HttpResponse.BodyHandlers.ofInputStream());
        try (var stream = response.body()) {
            if (response.statusCode() < 200 || response.statusCode() >= 300)
                throw new IOException("HTTP " + response.statusCode() + "; reconcile before retrying");
            byte[] result = stream.readNBytes((8 << 20) + 1);
            if (result.length > (8 << 20)) throw new IOException("Response exceeds 8 MiB");
            return result; // Preserve raw response for envelope verification.
        }
    }
}

// Java 17+, imports java.nio.charset.StandardCharsets.
// Serialize payload once with your JSON library, without changing the bytes after signing.
byte[] body = serializedJson.getBytes(StandardCharsets.UTF_8);
byte[] responseBytes = HttpUtil.send(baseUrl, "/v1/merchant/pay", merchantCode, body, merchantPrivateKey);
// GET: HttpUtil.send(baseUrl, "/v1/merchant/account", merchantCode, null, merchantPrivateKey);
// Verify the signed response data before using it. Do not treat HTTP 200 as payment success.

// Inside your servlet handler. Also enforce an ingress/request body limit.
byte[] rawBody = request.getInputStream().readNBytes((1 << 20) + 1);
if (rawBody.length > (1 << 20)) { response.sendError(413); return; }
try {
    SignUtil.verifyPlatform(rawBody, request.getHeader("Timestamp"),
        request.getHeader("Signature"), configuredPlatformPublicKey);
} catch (java.security.GeneralSecurityException | IllegalArgumentException e) {
    response.sendError(401, "invalid signature"); return;
}
// Only now parse rawBody, validate order/amount/currency and commit an idempotent update.
// Write SUCCESS only after durable processing.