@multiplatform.one/wallet 7.7.2

package/src/main/java/com/bitspur/keycloak/siwe/siu/SiuMessage.java

@@ -0,0 +1,362 @@
+/**
+ * File: /src/main/java/com/bitspur/keycloak/siwe/siu/SiuMessage.java
+ * Project: siwe-keycloak
+ * File Created: 24-01-2026
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2022 - 2026
+ *
+ * Sign-In With Sui (SIU) message parser
+ * Based on EIP-4361 / CAIP-122 specification adapted for Sui
+ */
+
+package com.bitspur.keycloak.siwe.siu;
+
+import java.time.OffsetDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Represents a parsed SIU (Sign-In With Sui) message.
+ *
+ * SIU message format follows EIP-4361 / CAIP-122:
+ * <pre>
+ * ${domain} wants you to sign in with your Sui account:
+ * ${address}
+ *
+ * ${statement}
+ *
+ * URI: ${uri}
+ * Version: ${version}
+ * Chain ID: ${chainId}
+ * Nonce: ${nonce}
+ * Issued At: ${issuedAt}
+ * Expiration Time: ${expirationTime}
+ * Not Before: ${notBefore}
+ * Request ID: ${requestId}
+ * Resources:
+ * - ${resource1}
+ * - ${resource2}
+ * </pre>
+ */
+public class SiuMessage {
+    // Sui address: Hex encoded, 0x followed by 64 hex characters (32 bytes)
+    private static final Pattern SUI_ADDRESS_PATTERN = Pattern.compile("^0x[a-fA-F0-9]{64}$");
+
+    private String domain;
+    private String address;
+    private String statement;
+    private String uri;
+    private String version;
+    private String chainId;
+    private String nonce;
+    private OffsetDateTime issuedAt;
+    private OffsetDateTime expirationTime;
+    private OffsetDateTime notBefore;
+    private String requestId;
+    private List<String> resources;
+
+    private SiuMessage() {
+        this.resources = new ArrayList<>();
+    }
+
+    public String getDomain() {
+        return domain;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public String getStatement() {
+        return statement;
+    }
+
+    public String getUri() {
+        return uri;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public String getChainId() {
+        return chainId;
+    }
+
+    public String getNonce() {
+        return nonce;
+    }
+
+    public OffsetDateTime getIssuedAt() {
+        return issuedAt;
+    }
+
+    public OffsetDateTime getExpirationTime() {
+        return expirationTime;
+    }
+
+    public OffsetDateTime getNotBefore() {
+        return notBefore;
+    }
+
+    public String getRequestId() {
+        return requestId;
+    }
+
+    public List<String> getResources() {
+        return resources;
+    }
+
+    /**
+     * Validates that the Sui address is in the correct format.
+     * Sui addresses are hex-encoded Ed25519 public keys (0x + 64 hex chars).
+     */
+    public static boolean isValidSuiAddress(String address) {
+        if (address == null || address.isEmpty()) {
+            return false;
+        }
+        return SUI_ADDRESS_PATTERN.matcher(address).matches();
+    }
+
+    /**
+     * Parser for SIU messages.
+     */
+    public static class Parser {
+        // ABNF grammar patterns based on EIP-4361 / CAIP-122
+        private static final Pattern DOMAIN_PATTERN = Pattern.compile(
+            "^(.+) wants you to sign in with your Sui account:$",
+            Pattern.MULTILINE
+        );
+        private static final Pattern ADDRESS_PATTERN = Pattern.compile(
+            "^(0x[a-fA-F0-9]{64})$",
+            Pattern.MULTILINE
+        );
+        private static final Pattern URI_PATTERN = Pattern.compile("^URI: (.+)$", Pattern.MULTILINE);
+        private static final Pattern VERSION_PATTERN = Pattern.compile("^Version: (.+)$", Pattern.MULTILINE);
+        private static final Pattern CHAIN_ID_PATTERN = Pattern.compile("^Chain ID: (.+)$", Pattern.MULTILINE);
+        private static final Pattern NONCE_PATTERN = Pattern.compile("^Nonce: ([A-Za-z0-9]{8,})$", Pattern.MULTILINE);
+        private static final Pattern ISSUED_AT_PATTERN = Pattern.compile("^Issued At: (.+)$", Pattern.MULTILINE);
+        private static final Pattern EXPIRATION_TIME_PATTERN = Pattern.compile("^Expiration Time: (.+)$", Pattern.MULTILINE);
+        private static final Pattern NOT_BEFORE_PATTERN = Pattern.compile("^Not Before: (.+)$", Pattern.MULTILINE);
+        private static final Pattern REQUEST_ID_PATTERN = Pattern.compile("^Request ID: (.+)$", Pattern.MULTILINE);
+        private static final Pattern RESOURCES_PATTERN = Pattern.compile("^Resources:$", Pattern.MULTILINE);
+        private static final Pattern RESOURCE_ITEM_PATTERN = Pattern.compile("^- (.+)$", Pattern.MULTILINE);
+
+        /**
+         * Parses a SIU message string into a SiuMessage object.
+         *
+         * @param message The raw SIU message string
+         * @return Parsed SiuMessage
+         * @throws SiuParseException If the message cannot be parsed
+         */
+        public SiuMessage parse(String message) throws SiuParseException {
+            if (message == null || message.trim().isEmpty()) {
+                throw new SiuParseException("Message cannot be null or empty");
+            }
+
+            SiuMessage siu = new SiuMessage();
+            String[] lines = message.split("\n");
+
+            if (lines.length < 2) {
+                throw new SiuParseException("Invalid SIU message format: too few lines");
+            }
+
+            // Parse domain from first line
+            Matcher domainMatcher = DOMAIN_PATTERN.matcher(lines[0]);
+            if (!domainMatcher.matches()) {
+                throw new SiuParseException("Invalid SIU message: missing or invalid domain line");
+            }
+            siu.domain = domainMatcher.group(1).trim();
+
+            // Parse address from second line
+            if (lines.length < 2 || !ADDRESS_PATTERN.matcher(lines[1].trim()).matches()) {
+                throw new SiuParseException("Invalid SIU message: missing or invalid Sui address");
+            }
+            siu.address = lines[1].trim();
+
+            // Parse statement (optional, between address and first field)
+            StringBuilder statementBuilder = new StringBuilder();
+            int fieldStartIndex = -1;
+            for (int i = 2; i < lines.length; i++) {
+                String line = lines[i];
+                if (line.startsWith("URI:") || line.startsWith("Version:") ||
+                    line.startsWith("Chain ID:") || line.startsWith("Nonce:") ||
+                    line.startsWith("Issued At:") || line.startsWith("Expiration Time:") ||
+                    line.startsWith("Not Before:") || line.startsWith("Request ID:") ||
+                    line.startsWith("Resources:")) {
+                    fieldStartIndex = i;
+                    break;
+                }
+                // Skip empty lines at the start/end of statement
+                if (statementBuilder.length() > 0 || !line.trim().isEmpty()) {
+                    if (statementBuilder.length() > 0) {
+                        statementBuilder.append("\n");
+                    }
+                    statementBuilder.append(line);
+                }
+            }
+            String statement = statementBuilder.toString().trim();
+            if (!statement.isEmpty()) {
+                siu.statement = statement;
+            }
+
+            // Parse remaining fields
+            String remainingMessage = fieldStartIndex > 0
+                ? String.join("\n", java.util.Arrays.copyOfRange(lines, fieldStartIndex, lines.length))
+                : "";
+
+            // Required fields
+            siu.uri = extractField(remainingMessage, URI_PATTERN, "URI");
+            siu.version = extractField(remainingMessage, VERSION_PATTERN, "Version");
+            siu.nonce = extractField(remainingMessage, NONCE_PATTERN, "Nonce");
+            siu.issuedAt = parseDateTime(extractField(remainingMessage, ISSUED_AT_PATTERN, "Issued At"));
+
+            // Optional fields
+            String chainIdStr = extractFieldOptional(remainingMessage, CHAIN_ID_PATTERN);
+            if (chainIdStr != null) {
+                siu.chainId = chainIdStr;
+            }
+
+            String expirationTimeStr = extractFieldOptional(remainingMessage, EXPIRATION_TIME_PATTERN);
+            if (expirationTimeStr != null) {
+                siu.expirationTime = parseDateTime(expirationTimeStr);
+            }
+
+            String notBeforeStr = extractFieldOptional(remainingMessage, NOT_BEFORE_PATTERN);
+            if (notBeforeStr != null) {
+                siu.notBefore = parseDateTime(notBeforeStr);
+            }
+
+            String requestIdStr = extractFieldOptional(remainingMessage, REQUEST_ID_PATTERN);
+            if (requestIdStr != null) {
+                siu.requestId = requestIdStr;
+            }
+
+            // Parse resources (optional)
+            Matcher resourcesMatcher = RESOURCES_PATTERN.matcher(remainingMessage);
+            if (resourcesMatcher.find()) {
+                int resourcesStart = resourcesMatcher.end();
+                String resourcesSection = remainingMessage.substring(resourcesStart);
+                Matcher resourceItemMatcher = RESOURCE_ITEM_PATTERN.matcher(resourcesSection);
+                while (resourceItemMatcher.find()) {
+                    siu.resources.add(resourceItemMatcher.group(1).trim());
+                }
+            }
+
+            // Validate the message
+            validate(siu);
+
+            return siu;
+        }
+
+        private String extractField(String message, Pattern pattern, String fieldName) throws SiuParseException {
+            Matcher matcher = pattern.matcher(message);
+            if (!matcher.find()) {
+                throw new SiuParseException("Missing required field: " + fieldName);
+            }
+            return matcher.group(1).trim();
+        }
+
+        private String extractFieldOptional(String message, Pattern pattern) {
+            Matcher matcher = pattern.matcher(message);
+            if (matcher.find()) {
+                return matcher.group(1).trim();
+            }
+            return null;
+        }
+
+        private OffsetDateTime parseDateTime(String dateTimeStr) throws SiuParseException {
+            if (dateTimeStr == null || dateTimeStr.isEmpty()) {
+                return null;
+            }
+            try {
+                return OffsetDateTime.parse(dateTimeStr, DateTimeFormatter.ISO_OFFSET_DATE_TIME);
+            } catch (DateTimeParseException e) {
+                // Try parsing without timezone offset
+                try {
+                    return OffsetDateTime.parse(dateTimeStr + "Z", DateTimeFormatter.ISO_OFFSET_DATE_TIME);
+                } catch (DateTimeParseException e2) {
+                    throw new SiuParseException("Invalid datetime format: " + dateTimeStr);
+                }
+            }
+        }
+
+        private void validate(SiuMessage siu) throws SiuParseException {
+            // Validate Sui address format
+            if (!SiuMessage.isValidSuiAddress(siu.address)) {
+                throw new SiuParseException("Invalid Sui address format: " + siu.address);
+            }
+
+            // Validate version is "1"
+            if (!"1".equals(siu.version)) {
+                throw new SiuParseException("Unsupported SIU version: " + siu.version + " (expected: 1)");
+            }
+
+            // Validate nonce length (at least 8 alphanumeric characters)
+            if (siu.nonce == null || siu.nonce.length() < 8) {
+                throw new SiuParseException("Nonce must be at least 8 alphanumeric characters");
+            }
+
+            // Validate expiration time if present
+            if (siu.expirationTime != null && siu.expirationTime.isBefore(OffsetDateTime.now())) {
+                throw new SiuParseException("Message has expired");
+            }
+
+            // Validate not before if present
+            if (siu.notBefore != null && siu.notBefore.isAfter(OffsetDateTime.now())) {
+                throw new SiuParseException("Message is not yet valid (notBefore is in the future)");
+            }
+        }
+    }
+
+    /**
+     * Reconstructs the SIU message from its components.
+     * Used for signature verification to ensure message integrity.
+     */
+    public String toMessage() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(domain).append(" wants you to sign in with your Sui account:\n");
+        sb.append(address).append("\n");
+
+        if (statement != null && !statement.isEmpty()) {
+            sb.append("\n").append(statement).append("\n");
+        }
+
+        sb.append("\n");
+        sb.append("URI: ").append(uri).append("\n");
+        sb.append("Version: ").append(version).append("\n");
+
+        if (chainId != null) {
+            sb.append("Chain ID: ").append(chainId).append("\n");
+        }
+
+        sb.append("Nonce: ").append(nonce).append("\n");
+        sb.append("Issued At: ").append(issuedAt.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)).append("\n");
+
+        if (expirationTime != null) {
+            sb.append("Expiration Time: ").append(expirationTime.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)).append("\n");
+        }
+
+        if (notBefore != null) {
+            sb.append("Not Before: ").append(notBefore.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)).append("\n");
+        }
+
+        if (requestId != null) {
+            sb.append("Request ID: ").append(requestId).append("\n");
+        }
+
+        if (resources != null && !resources.isEmpty()) {
+            sb.append("Resources:\n");
+            for (String resource : resources) {
+                sb.append("- ").append(resource).append("\n");
+            }
+        }
+
+        return sb.toString();
+    }
+}

package/src/main/java/com/bitspur/keycloak/siwe/siu/SiuParseException.java

@@ -0,0 +1,23 @@
+/**
+ * File: /src/main/java/com/bitspur/keycloak/siwe/siu/SiuParseException.java
+ * Project: siwe-keycloak
+ * File Created: 24-01-2026
+ * Author: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2022 - 2026
+ */
+
+package com.bitspur.keycloak.siwe.siu;
+
+/**
+ * Exception thrown when parsing a SIU message fails.
+ */
+public class SiuParseException extends Exception {
+    public SiuParseException(String message) {
+        super(message);
+    }
+
+    public SiuParseException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}