From 86efe494296e3116087f4f34151a16672ab36c71 Mon Sep 17 00:00:00 2001 From: Sun Cao Date: Tue, 1 Sep 2026 13:55:35 -0700 Subject: [PATCH 1/5] Add bearer-token utilities for authentication. --- .../io/opensharing/auth/BearerTokens.java | 24 +++++++++ .../java/io/opensharing/auth/Secrets.java | 54 +++++++++++++++++++ .../java/io/opensharing/auth/SecretsTest.java | 31 +++++++++++ 3 files changed, 109 insertions(+) create mode 100644 server/src/main/java/io/opensharing/auth/BearerTokens.java create mode 100644 server/src/main/java/io/opensharing/auth/Secrets.java create mode 100644 server/src/test/java/io/opensharing/auth/SecretsTest.java diff --git a/server/src/main/java/io/opensharing/auth/BearerTokens.java b/server/src/main/java/io/opensharing/auth/BearerTokens.java new file mode 100644 index 000000000..92e2877cc --- /dev/null +++ b/server/src/main/java/io/opensharing/auth/BearerTokens.java @@ -0,0 +1,24 @@ +package io.opensharing.auth; + +import jakarta.servlet.http.HttpServletRequest; +import java.util.Optional; + +/** Extracts RFC 6750 bearer tokens from requests. */ +public final class BearerTokens { + + private static final String SCHEME = "Bearer "; + + private BearerTokens() {} + + public static Optional from(HttpServletRequest request) { + String header = request.getHeader("Authorization"); + if (header == null || header.length() <= SCHEME.length()) { + return Optional.empty(); + } + if (!header.regionMatches(true, 0, SCHEME, 0, SCHEME.length())) { + return Optional.empty(); + } + String token = header.substring(SCHEME.length()).trim(); + return token.isEmpty() ? Optional.empty() : Optional.of(token); + } +} diff --git a/server/src/main/java/io/opensharing/auth/Secrets.java b/server/src/main/java/io/opensharing/auth/Secrets.java new file mode 100644 index 000000000..060b5c271 --- /dev/null +++ b/server/src/main/java/io/opensharing/auth/Secrets.java @@ -0,0 +1,54 @@ +package io.opensharing.auth; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.security.SecureRandom; +import java.util.Base64; +import java.util.HexFormat; + +/** Generates bearer tokens and activation nonces, and hashes them for storage. */ +public final class Secrets { + + public static final String TOKEN_PREFIX = "os_"; + + private static final SecureRandom RANDOM = new SecureRandom(); + private static final int TOKEN_BYTES = 32; + + private Secrets() {} + + /** A new recipient bearer token. Returned to the caller once and never stored in clear text. */ + public static String newToken() { + return TOKEN_PREFIX + randomUrlSafe(); + } + + /** A new single-use activation nonce. */ + public static String newActivationNonce() { + return randomUrlSafe(); + } + + /** Lowercase hex SHA-256, the form persisted for tokens and nonces. */ + public static String sha256(String value) { + try { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + return HexFormat.of().formatHex(digest.digest(value.getBytes(StandardCharsets.UTF_8))); + } catch (NoSuchAlgorithmException e) { + throw new IllegalStateException("SHA-256 is required but unavailable", e); + } + } + + /** Constant-time comparison, for secrets compared outside the database. */ + public static boolean constantTimeEquals(String a, String b) { + if (a == null || b == null) { + return false; + } + return MessageDigest.isEqual( + a.getBytes(StandardCharsets.UTF_8), b.getBytes(StandardCharsets.UTF_8)); + } + + private static String randomUrlSafe() { + byte[] bytes = new byte[TOKEN_BYTES]; + RANDOM.nextBytes(bytes); + return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes); + } +} diff --git a/server/src/test/java/io/opensharing/auth/SecretsTest.java b/server/src/test/java/io/opensharing/auth/SecretsTest.java new file mode 100644 index 000000000..a68ed8cf4 --- /dev/null +++ b/server/src/test/java/io/opensharing/auth/SecretsTest.java @@ -0,0 +1,31 @@ +package io.opensharing.auth; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class SecretsTest { + + @Test + void hashesDeterministically() { + assertEquals(Secrets.sha256("hello"), Secrets.sha256("hello")); + assertNotEquals(Secrets.sha256("hello"), Secrets.sha256("world")); + } + + @Test + void mintsPrefixedTokens() { + String token = Secrets.newToken(); + assertTrue(token.startsWith(Secrets.TOKEN_PREFIX)); + assertNotEquals(token, Secrets.newToken()); + } + + @Test + void comparesInConstantTime() { + assertTrue(Secrets.constantTimeEquals("same", "same")); + assertFalse(Secrets.constantTimeEquals("same", "other")); + assertFalse(Secrets.constantTimeEquals(null, "other")); + } +} From 8f092ba9d254c5d9d524398158b2b04095f16f9f Mon Sep 17 00:00:00 2001 From: Sun Cao Date: Tue, 1 Sep 2026 15:31:58 -0700 Subject: [PATCH 2/5] Rename constantTimeEquals to timingSafeEquals. --- server/src/main/java/io/opensharing/auth/Secrets.java | 4 ++-- server/src/test/java/io/opensharing/auth/SecretsTest.java | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/server/src/main/java/io/opensharing/auth/Secrets.java b/server/src/main/java/io/opensharing/auth/Secrets.java index 060b5c271..bebc98bdd 100644 --- a/server/src/main/java/io/opensharing/auth/Secrets.java +++ b/server/src/main/java/io/opensharing/auth/Secrets.java @@ -37,8 +37,8 @@ public static String sha256(String value) { } } - /** Constant-time comparison, for secrets compared outside the database. */ - public static boolean constantTimeEquals(String a, String b) { + /** Timing-safe comparison for secrets compared outside the database. */ + public static boolean timingSafeEquals(String a, String b) { if (a == null || b == null) { return false; } diff --git a/server/src/test/java/io/opensharing/auth/SecretsTest.java b/server/src/test/java/io/opensharing/auth/SecretsTest.java index a68ed8cf4..7c569a547 100644 --- a/server/src/test/java/io/opensharing/auth/SecretsTest.java +++ b/server/src/test/java/io/opensharing/auth/SecretsTest.java @@ -23,9 +23,9 @@ void mintsPrefixedTokens() { } @Test - void comparesInConstantTime() { - assertTrue(Secrets.constantTimeEquals("same", "same")); - assertFalse(Secrets.constantTimeEquals("same", "other")); - assertFalse(Secrets.constantTimeEquals(null, "other")); + void comparesTimingSafe() { + assertTrue(Secrets.timingSafeEquals("same", "same")); + assertFalse(Secrets.timingSafeEquals("same", "other")); + assertFalse(Secrets.timingSafeEquals(null, "other")); } } From 07b33176782aae7257e9717949f32d07830d44e9 Mon Sep 17 00:00:00 2001 From: Sun Cao Date: Tue, 1 Sep 2026 15:36:42 -0700 Subject: [PATCH 3/5] Drop timing-safe equals helper from Secrets. Call sites can use String.equals; token lookup uses hashed values anyway. --- server/src/main/java/io/opensharing/auth/Secrets.java | 9 --------- .../src/test/java/io/opensharing/auth/SecretsTest.java | 8 -------- 2 files changed, 17 deletions(-) diff --git a/server/src/main/java/io/opensharing/auth/Secrets.java b/server/src/main/java/io/opensharing/auth/Secrets.java index bebc98bdd..985be2796 100644 --- a/server/src/main/java/io/opensharing/auth/Secrets.java +++ b/server/src/main/java/io/opensharing/auth/Secrets.java @@ -37,15 +37,6 @@ public static String sha256(String value) { } } - /** Timing-safe comparison for secrets compared outside the database. */ - public static boolean timingSafeEquals(String a, String b) { - if (a == null || b == null) { - return false; - } - return MessageDigest.isEqual( - a.getBytes(StandardCharsets.UTF_8), b.getBytes(StandardCharsets.UTF_8)); - } - private static String randomUrlSafe() { byte[] bytes = new byte[TOKEN_BYTES]; RANDOM.nextBytes(bytes); diff --git a/server/src/test/java/io/opensharing/auth/SecretsTest.java b/server/src/test/java/io/opensharing/auth/SecretsTest.java index 7c569a547..044a61f25 100644 --- a/server/src/test/java/io/opensharing/auth/SecretsTest.java +++ b/server/src/test/java/io/opensharing/auth/SecretsTest.java @@ -1,7 +1,6 @@ package io.opensharing.auth; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -21,11 +20,4 @@ void mintsPrefixedTokens() { assertTrue(token.startsWith(Secrets.TOKEN_PREFIX)); assertNotEquals(token, Secrets.newToken()); } - - @Test - void comparesTimingSafe() { - assertTrue(Secrets.timingSafeEquals("same", "same")); - assertFalse(Secrets.timingSafeEquals("same", "other")); - assertFalse(Secrets.timingSafeEquals(null, "other")); - } } From e44fe431d4b67bc32afe58807c29820a5b696960 Mon Sep 17 00:00:00 2001 From: Sun Cao Date: Tue, 1 Sep 2026 15:38:57 -0700 Subject: [PATCH 4/5] Rename randomUrlSafe to randomToken. --- server/src/main/java/io/opensharing/auth/Secrets.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/server/src/main/java/io/opensharing/auth/Secrets.java b/server/src/main/java/io/opensharing/auth/Secrets.java index 985be2796..7c9ccf846 100644 --- a/server/src/main/java/io/opensharing/auth/Secrets.java +++ b/server/src/main/java/io/opensharing/auth/Secrets.java @@ -19,12 +19,12 @@ private Secrets() {} /** A new recipient bearer token. Returned to the caller once and never stored in clear text. */ public static String newToken() { - return TOKEN_PREFIX + randomUrlSafe(); + return TOKEN_PREFIX + randomToken(); } /** A new single-use activation nonce. */ public static String newActivationNonce() { - return randomUrlSafe(); + return randomToken(); } /** Lowercase hex SHA-256, the form persisted for tokens and nonces. */ @@ -37,7 +37,7 @@ public static String sha256(String value) { } } - private static String randomUrlSafe() { + private static String randomToken() { byte[] bytes = new byte[TOKEN_BYTES]; RANDOM.nextBytes(bytes); return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes); From 44bd34f651503ead943da9ad4e5c137cab0995cc Mon Sep 17 00:00:00 2001 From: Sun Cao Date: Tue, 1 Sep 2026 15:44:36 -0700 Subject: [PATCH 5/5] Assert token length and URL-safe Base64 format in SecretsTest. --- .../java/io/opensharing/auth/SecretsTest.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/server/src/test/java/io/opensharing/auth/SecretsTest.java b/server/src/test/java/io/opensharing/auth/SecretsTest.java index 044a61f25..e495c5e37 100644 --- a/server/src/test/java/io/opensharing/auth/SecretsTest.java +++ b/server/src/test/java/io/opensharing/auth/SecretsTest.java @@ -4,10 +4,17 @@ import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.Base64; +import java.util.regex.Pattern; import org.junit.jupiter.api.Test; class SecretsTest { + private static final int TOKEN_BYTES = 32; + private static final int RANDOM_PART_LENGTH = (TOKEN_BYTES * 8 + 5) / 6; // unpadded Base64url + private static final Pattern URL_SAFE_BASE64 = + Pattern.compile("^[A-Za-z0-9_-]+$"); + @Test void hashesDeterministically() { assertEquals(Secrets.sha256("hello"), Secrets.sha256("hello")); @@ -18,6 +25,21 @@ void hashesDeterministically() { void mintsPrefixedTokens() { String token = Secrets.newToken(); assertTrue(token.startsWith(Secrets.TOKEN_PREFIX)); + assertEquals(Secrets.TOKEN_PREFIX.length() + RANDOM_PART_LENGTH, token.length()); + + String randomPart = token.substring(Secrets.TOKEN_PREFIX.length()); + assertTrue(URL_SAFE_BASE64.matcher(randomPart).matches()); + assertEquals(TOKEN_BYTES, Base64.getUrlDecoder().decode(randomPart).length); + assertNotEquals(token, Secrets.newToken()); } + + @Test + void mintsActivationNonces() { + String nonce = Secrets.newActivationNonce(); + assertEquals(RANDOM_PART_LENGTH, nonce.length()); + assertTrue(URL_SAFE_BASE64.matcher(nonce).matches()); + assertEquals(TOKEN_BYTES, Base64.getUrlDecoder().decode(nonce).length); + assertNotEquals(nonce, Secrets.newActivationNonce()); + } }