This exception typically indicates a mismatch between the client's configured * {@code ChannelBindingPolicy} and the server's advertised mechanisms, or a failure * in processing cryptographic channel binding data (e.g., TLS server endpoint data). * * @since 3.3 */ public class ChannelBindingException extends MechanismNegotiationException { private static final long serialVersionUID = 1L; /** * Constructs a new {@code ChannelBindingException} with the specified detail message. * * @param detail the detail message explaining the cause of the negotiation failure. */ public ChannelBindingException(String detail) { super(detail); } } ongres-scram-f6bd6e2/scram-client/src/main/java/com/ongres/scram/client/ChannelBindingPolicy.java 0000664 0000000 0000000 00000006217 15210312475 0033161 0 ustar 00root root 0000000 0000000 /* * Copyright (c) 2026 OnGres, Inc. * SPDX-License-Identifier: BSD-2-Clause */ package com.ongres.scram.client; /** * Defines the client-side security policies for negotiating channel binding during a SCRAM * authentication execution. * *
Channel binding protects the authentication flow against active Machine-in-the-Middle (MITM) * and session hijacking attacks by cryptographically binding the outer security layer (such as TLS) * to the inner SASL/SCRAM authentication layer. * *
This policy dictates how the {@link ScramClient} evaluates available channel binding data * against the server's advertised mechanisms (e.g., {@code SCRAM-SHA-256} vs {@code SCRAM-SHA-256-PLUS}) * during the mechanism negotiation phase, ultimately determining the runtime wire-format * {@code gs2-cbind-flag} ('n', 'y', or 'p'). * * @see RFC 5802 Section 6: Channels and Channel Binding * * @since 3.3 */ public enum ChannelBindingPolicy { /** * Disables channel binding entirely. * *
The client will strictly use standard, non-channel-bound SCRAM mechanisms (e.g., * {@code SCRAM-SHA-256}), even if valid channel binding data or server-supported * {@code -PLUS} mechanisms are available. * *
This policy forces the internal protocol engine to output the {@code 'n'} * (Client does not support channel binding) GS2 flag. Use this policy primarily * for debugging, unencrypted connections, or working around proxy servers or middleboxes * that strip channel data. */ DISABLE, /** * Permits channel binding if supported by the server, but allows a secure fallback if it is not. * *
This is the default recommended behavior for general-purpose applications: *
The authentication execution will fail immediately during the client initialization * phase (throwing an {@link ChannelBindingException}) if any of the following boundaries * are violated: *
This policy forces the use of the {@code 'p'} GS2 flag and is intended for high-security * environments where channel verification is a mandatory operational requirement (e.g., * applications requiring strict compliance matching database configurations like PostgreSQL's * {@code channel_binding=require}). */ REQUIRE } ongres-scram-f6bd6e2/scram-client/src/main/java/com/ongres/scram/client/ClientFinalProcessor.java 0000664 0000000 0000000 00000012214 15210312475 0033220 0 ustar 00root root 0000000 0000000 /* * Copyright (c) 2017 OnGres, Inc. * SPDX-License-Identifier: BSD-2-Clause */ package com.ongres.scram.client; import static com.ongres.scram.common.util.Preconditions.checkNotEmpty; import static com.ongres.scram.common.util.Preconditions.checkNotNull; import com.ongres.scram.common.ClientFinalMessage; import com.ongres.scram.common.ClientFirstMessage; import com.ongres.scram.common.ScramFunctions; import com.ongres.scram.common.ScramMechanism; import com.ongres.scram.common.ServerFinalMessage; import com.ongres.scram.common.ServerFirstMessage; import com.ongres.scram.common.StringPreparation; import com.ongres.scram.common.exception.ScramInvalidServerSignatureException; import com.ongres.scram.common.exception.ScramParseException; import com.ongres.scram.common.exception.ScramServerErrorException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; /** * Processor that allows to generate the client-final-message, as well as process the * server-final-message and verify server's signature. Generate the processor by calling either * {@code ServerFirstProcessor#clientFinalProcessor(char[])} or * {@code ServerFirstProcessor#clientFinalProcessor(byte[], byte[])}. */ final class ClientFinalProcessor { private final byte[] clientKey; private final byte[] storedKey; private final byte[] serverKey; private final ScramMechanism scramMechanism; private final ClientFirstMessage clientFirstMessage; private final ServerFirstMessage serverFirstMessage; private String authMessage; private ClientFinalProcessor(ScramMechanism scramMechanism, byte[] clientKey, byte[] storedKey, byte[] serverKey, ClientFirstMessage clientFirstMessage, ServerFirstMessage serverFirstMessage) { this.scramMechanism = scramMechanism; this.clientKey = checkNotNull(clientKey, "clientKey"); this.storedKey = checkNotNull(storedKey, "storedKey"); this.serverKey = checkNotNull(serverKey, "serverKey"); this.clientFirstMessage = clientFirstMessage; this.serverFirstMessage = serverFirstMessage; } ClientFinalProcessor(ScramMechanism scramMechanism, byte[] clientKey, byte[] serverKey, ClientFirstMessage clientFirstMessage, ServerFirstMessage serverFirstMessage) { this(scramMechanism, clientKey, ScramFunctions.storedKey(scramMechanism, clientKey), serverKey, clientFirstMessage, serverFirstMessage); } ClientFinalProcessor(ScramMechanism scramMechanism, byte[] saltedPassword, ClientFirstMessage clientFirstMessage, ServerFirstMessage serverFirstMessage) { this( scramMechanism, ScramFunctions.clientKey(scramMechanism, saltedPassword), ScramFunctions.serverKey(scramMechanism, saltedPassword), clientFirstMessage, serverFirstMessage); } ClientFinalProcessor(ScramMechanism scramMechanism, StringPreparation stringPreparation, char[] password, byte[] salt, ClientFirstMessage clientFirstMessage, ServerFirstMessage serverFirstMessage) { this(scramMechanism, ScramFunctions.saltedPassword(scramMechanism, stringPreparation, password, salt, serverFirstMessage.getIterationCount()), clientFirstMessage, serverFirstMessage); } private void generateAndCacheAuthMessage(byte[] cbindData) { if (null == this.authMessage) { this.authMessage = ScramFunctions.authMessage(clientFirstMessage, serverFirstMessage, cbindData); } } /** * Generates the SCRAM representation of the client-final-message, including the given * channel-binding data. * * @param cbindData The bytes of the channel-binding data * @return The message */ @NotNull ClientFinalMessage clientFinalMessage(byte @Nullable [] cbindData) { generateAndCacheAuthMessage(cbindData); return new ClientFinalMessage( clientFirstMessage.getGs2Header(), cbindData, serverFirstMessage.getNonce(), ScramFunctions.clientProof( clientKey, ScramFunctions.clientSignature(scramMechanism, storedKey, authMessage))); } /** * Receive and process the server-final-message. Server SCRAM signatures is verified. * * @param serverFinalMessage The received server-final-message * @throws ScramParseException If the message is not a valid server-final-message * @throws ScramServerErrorException If the server-final-message contained an error * @throws ScramInvalidServerSignatureException If the server signature is invalid * @throws IllegalArgumentException If the message is null or empty */ @NotNull ServerFinalMessage receiveServerFinalMessage(@NotNull String serverFinalMessage) throws ScramParseException, ScramServerErrorException, ScramInvalidServerSignatureException { checkNotEmpty(serverFinalMessage, "serverFinalMessage"); ServerFinalMessage message = ServerFinalMessage.parseFrom(serverFinalMessage); if (message.isError()) { throw new ScramServerErrorException(message.getServerError()); } if (!ScramFunctions.verifyServerSignature( scramMechanism, serverKey, authMessage, message.getVerifier())) { throw new ScramInvalidServerSignatureException("Invalid SCRAM server signature"); } return message; } } MechanismNegotiationException.java 0000664 0000000 0000000 00000002016 15210312475 0035034 0 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-client/src/main/java/com/ongres/scram/client /* * Copyright (c) 2026 OnGres, Inc. * SPDX-License-Identifier: BSD-2-Clause */ package com.ongres.scram.client; import com.ongres.scram.common.exception.ScramRuntimeException; /** * Signals that an error occurred during the SASL SCRAM mechanism negotiation, * capability handshake, or policy enforcement phase. * *
This exception typically indicates a structural mismatch between the mechanisms * advertised by the server and those supported or allowed by the client, such as * a failure to find a mutually acceptable authentication variant or a breakdown in * channel binding requirements. * * @since 3.3 */ public class MechanismNegotiationException extends ScramRuntimeException { private static final long serialVersionUID = 1L; /** * Constructs a new {@code MechanismNegotiationException} with the specified detail message. * * @param detail the detail message explaining the cause of the negotiation failure. */ public MechanismNegotiationException(String detail) { super(detail); } } ongres-scram-f6bd6e2/scram-client/src/main/java/com/ongres/scram/client/MessageFlow.java 0000664 0000000 0000000 00000001561 15210312475 0031347 0 ustar 00root root 0000000 0000000 /* * Copyright (c) 2017 OnGres, Inc. * SPDX-License-Identifier: BSD-2-Clause */ package com.ongres.scram.client; import com.ongres.scram.common.ClientFinalMessage; import com.ongres.scram.common.ClientFirstMessage; import com.ongres.scram.common.ServerFinalMessage; import com.ongres.scram.common.ServerFirstMessage; import com.ongres.scram.common.exception.ScramException; import org.jetbrains.annotations.NotNull; interface MessageFlow { @NotNull ClientFirstMessage clientFirstMessage(); @NotNull ServerFirstMessage serverFirstMessage(@NotNull String serverFirstMessage) throws ScramException; @NotNull ClientFinalMessage clientFinalMessage(); @NotNull ServerFinalMessage serverFinalMessage(@NotNull String serverFinalMessage) throws ScramException; enum Stage { NONE, CLIENT_FIRST, SERVER_FIRST, CLIENT_FINAL, SERVER_FINAL; } } ongres-scram-f6bd6e2/scram-client/src/main/java/com/ongres/scram/client/ScramClient.java 0000664 0000000 0000000 00000057216 15210312475 0031347 0 ustar 00root root 0000000 0000000 /* * Copyright (c) 2017 OnGres, Inc. * SPDX-License-Identifier: BSD-2-Clause */ package com.ongres.scram.client; import static com.ongres.scram.common.util.Preconditions.checkArgument; import static com.ongres.scram.common.util.Preconditions.checkNotEmpty; import static com.ongres.scram.common.util.Preconditions.checkNotNull; import static com.ongres.scram.common.util.Preconditions.gt0; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.SecureRandom; import java.util.Arrays; import java.util.Collection; import java.util.function.Supplier; import com.ongres.scram.common.ClientFinalMessage; import com.ongres.scram.common.ClientFirstMessage; import com.ongres.scram.common.Gs2CbindFlag; import com.ongres.scram.common.ScramFunctions; import com.ongres.scram.common.ScramMechanism; import com.ongres.scram.common.ServerFinalMessage; import com.ongres.scram.common.ServerFirstMessage; import com.ongres.scram.common.StringPreparation; import com.ongres.scram.common.exception.ScramInvalidServerSignatureException; import com.ongres.scram.common.exception.ScramParseException; import com.ongres.scram.common.exception.ScramServerErrorException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; /** * A class that represents a SCRAM client. Use this class to perform a SCRAM negotiation with a * SCRAM server. This class performs an authentication execution for a given user, and has state * related to it. Thus, it cannot be shared across users or authentication executions. * *
Example of usage: * *
{@code
* ScramClient scramClient = ScramClient.builder()
* .advertisedMechanisms(Arrays.asList("SCRAM-SHA-256", "SCRAM-SHA-256-PLUS"))
* .username("user")
* .password("pencil".toCharArray())
* .channelBindingPolicy(ChannelBindingPolicy.REQUIRE) // client requires channel binding
* .channelBinding("tls-server-end-point", channelBindingData)
* .build();
*
* // The build() call negotiates the SCRAM mechanism to be used. In this example,
* // since the server advertise support for the SCRAM-SHA-256-PLUS mechanism,
* // and the builder is set with the channel binding type and data, the constructed
* // scramClient will use the "SCRAM-SHA-256-PLUS" mechanism for authentication.
*
* // Send the client-first-message ("p=...,,n=...,r=...")
* ClientFirstMessage clientFirstMsg = scramClient.clientFirstMessage();
* ...
* // Receive the server-first-message
* ServerFirstMessage serverFirstMsg = scramClient.serverFirstMessage("r=...,s=...,i=...");
* ...
* // Send the client-final-message ("c=...,r=...,p=...")
* ClientFinalMessage clientFinalMsg = scramClient.clientFinalMessage();
* ...
* // Receive the server-final-message, throw an ScramException on error
* ServerFinalMessage serverFinalMsg = scramClient.serverFinalMessage("v=...");
* }
*
* Commonly, a protocol will specify that the server advertises supported and available * mechanisms to the client via some facility provided by the protocol, and the client will then * select the "best" mechanism from this list that it supports and finds suitable. * *
When building the ScramClient, it provides mechanism negotiation based on parameters, if * channel binding is missing the client will use {@code "n"} as gs2-cbind-flag, if the channel * binding is set, but the mechanisms send by the server do not advertise the {@code -PLUS} * version, it will use {@code "y"} as gs2-cbind-flag, when both client and server support channel * binding, it will use {@code "p=" cb-name} as gs2-cbind-flag. * * @see RFC-5802: Salted Challenge Response * Authentication Mechanism (SCRAM) SASL and GSS-API Mechanisms * @see RFC-7677: SCRAM-SHA-256 and * SCRAM-SHA-256-PLUS Simple Authentication and Security Layer (SASL) Mechanisms */ public final class ScramClient implements MessageFlow { private final ScramMechanism scramMechanism; private final Gs2CbindFlag channelBinding; private final StringPreparation stringPreparation; private final String username; private final char[] password; private final byte[] saltedPassword; private final byte[] clientKey; private final byte[] serverKey; private final String cbindType; private final byte[] cbindData; private final String authzid; private final String nonce; private Stage currentState = Stage.NONE; private ClientFirstMessage clientFirstMessage; private ServerFirstProcessor serverFirstProcessor; private ClientFinalProcessor clientFinalProcessor; /** * Constructs a SCRAM client, to perform an authentication for a given user. This class can not be * instantiated directly, use a {@link #builder()} is used instead. * * @param builder The Builder used to initialize this client */ private ScramClient(@NotNull Builder builder) { this.channelBinding = builder.channelBinding; this.scramMechanism = builder.selectedScramMechanism; this.stringPreparation = builder.stringPreparation; this.username = builder.username; this.password = builder.password != null ? builder.password.clone() : null; this.saltedPassword = builder.saltedPassword != null ? builder.saltedPassword.clone() : null; this.clientKey = builder.clientKey != null ? builder.clientKey.clone() : null; this.serverKey = builder.serverKey != null ? builder.serverKey.clone() : null; this.nonce = builder.nonce; this.cbindType = builder.cbindType; this.cbindData = builder.cbindData; this.authzid = builder.authzid; } /** * Returns the scram mechanism negotiated by this SASL client. * * @return the SCRAM mechanims selected during the negotiation */ public ScramMechanism getScramMechanism() { return scramMechanism; } /** * Returns the text representation of a SCRAM {@code client-first-message}. * * @apiNote should be the initial call and can be called only once * @return The {@code client-first-message} */ @Override public ClientFirstMessage clientFirstMessage() { if (currentState != Stage.NONE) { throw new IllegalStateException("Invalid state for processing client first message"); } this.clientFirstMessage = new ClientFirstMessage(channelBinding, cbindType, authzid, username, nonce); this.currentState = Stage.CLIENT_FIRST; return clientFirstMessage; } /** * Process the {@code server-first-message}, from its String representation. * * @apiNote should be called after {@link #clientFirstMessage()} and can be called only once * @param serverFirstMessage The {@code server-first-message} * @throws ScramParseException If the message is not a valid server-first-message * @throws IllegalArgumentException If the message is null or empty */ @Override public ServerFirstMessage serverFirstMessage(String serverFirstMessage) throws ScramParseException { if (currentState != Stage.CLIENT_FIRST) { throw new IllegalStateException("Invalid state for processing server first message"); } checkNotEmpty(serverFirstMessage, "serverFirstMessage"); this.serverFirstProcessor = new ServerFirstProcessor(scramMechanism, stringPreparation, serverFirstMessage, nonce, clientFirstMessage); this.currentState = Stage.SERVER_FIRST; return serverFirstProcessor.getServerFirstMessage(); } /** * Returns the text representation of a SCRAM {@code client-final-message}. * * @apiNote should be called after {@link #serverFirstMessage(String)} and can be called only once * @return The {@code client-final-message} */ @Override public ClientFinalMessage clientFinalMessage() { if (currentState != Stage.SERVER_FIRST || serverFirstProcessor == null) { throw new IllegalStateException("Invalid state for processing client final message"); } try { if (password != null) { this.clientFinalProcessor = serverFirstProcessor.clientFinalProcessor(password); } else if (saltedPassword != null) { this.clientFinalProcessor = serverFirstProcessor.clientFinalProcessor(saltedPassword); } else if (clientKey != null && serverKey != null) { this.clientFinalProcessor = serverFirstProcessor.clientFinalProcessor(clientKey, serverKey); } } finally { // Wipe the sensitive data, even if an exception was thrown above if (password != null) { Arrays.fill(password, (char) 0); } if (saltedPassword != null) { Arrays.fill(saltedPassword, (byte) 0); } if (clientKey != null) { Arrays.fill(clientKey, (byte) 0); } if (serverKey != null) { Arrays.fill(serverKey, (byte) 0); } } ClientFinalMessage clientFinalMessage = clientFinalProcessor.clientFinalMessage(cbindData); this.currentState = Stage.CLIENT_FINAL; return clientFinalMessage; } /** * Process and verify the {@code server-final-message}, from its String representation. * * @apiNote should be called after {@link #clientFinalMessage()} and can be called only once * @param serverFinalMessage The {@code server-final-message} * @throws ScramParseException If the message is not a valid * @throws ScramServerErrorException If the message is an error * @throws ScramInvalidServerSignatureException If the verification fails * @throws IllegalArgumentException If the message is null or empty */ @Override public ServerFinalMessage serverFinalMessage(String serverFinalMessage) throws ScramParseException, ScramServerErrorException, ScramInvalidServerSignatureException { if (currentState != Stage.CLIENT_FINAL || clientFinalProcessor == null) { throw new IllegalStateException("Invalid state for processing server final message"); } ServerFinalMessage receiveServerFinalMessage = clientFinalProcessor.receiveServerFinalMessage(serverFinalMessage); this.currentState = Stage.SERVER_FINAL; return receiveServerFinalMessage; } /** * Creates a builder for {@link ScramClient ScramClient} instances. * * @return Builder instance to contruct a {@link ScramClient ScramClient} */ public static MechanismsBuildStage builder() { return new Builder(); } /** * Builder stage for the advertised mechanisms. */ public interface MechanismsBuildStage { /** * List of the advertised mechanisms that will be negotiated between the server and the client. * * @param scramMechanisms list with the IANA-registered mechanism name of this SASL client * @return {@code this} builder for use in a chained invocation */ UsernameBuildStage advertisedMechanisms(@NotNull Collection<@NotNull String> scramMechanisms); } /** * Builder stage for the required username. */ public interface UsernameBuildStage { /** * Sets the username. * * @param username the required username * @return {@code this} builder for use in a chained invocation */ PasswordBuildStage username(@NotNull String username); } /** * Builder stage for the password (or a ClientKey/ServerKey, or SaltedPassword). */ public interface PasswordBuildStage { /** * Sets the password. * * @param password the required password * @return {@code this} builder for use in a chained invocation */ FinalBuildStage password(char @NotNull [] password); /** * Sets the SaltedPassword. * * @param saltedPassword the required SaltedPassword * @return {@code this} builder for use in a chained invocation */ FinalBuildStage saltedPassword(byte @NotNull [] saltedPassword); /** * Sets the ClientKey/ServerKey. * * @param clientKey the required ClientKey * @param serverKey the required ServerKey * @return {@code this} builder for use in a chained invocation */ FinalBuildStage clientAndServerKey(byte @NotNull [] clientKey, byte @NotNull [] serverKey); } /** * Builder stage for the optional atributes and the final build() call. */ public interface FinalBuildStage { /** * Sets the channel binding policy to determine how the client negotiates * security layers with the server. By default is ALLOW. * * @param policy the channel binding policy (DISABLE, ALLOW, REQUIRE) * @return {@code this} builder for use in a chained invocation */ FinalBuildStage channelBindingPolicy(@NotNull ChannelBindingPolicy policy); /** * If the client supports channel binding negotiation, this method sets the type and data used * for channel binding. * * @apiNote If {@code cbindType} or {@code cbindData} are null, sets the gs2-cbind-flag to 'n' * and does not use channel binding. * * @param cbindType channel bynding type name * @param cbindData channel binding data * @return {@code this} builder for use in a chained invocation */ FinalBuildStage channelBinding(@Nullable String cbindType, byte @Nullable [] cbindData); /** * Sets the StringPreparation, is recommended to leave the default SASL_PREPARATION. * * @param stringPreparation type of string preparation normalization * @return {@code this} builder for use in a chained invocation */ FinalBuildStage stringPreparation(@NotNull StringPreparation stringPreparation); /** * Sets the authzid. * * @param authzid the optional authorization id * @return {@code this} builder for use in a chained invocation */ FinalBuildStage authzid(@NotNull String authzid); /** * Sets a non-default length for the nonce generation. * *
The default value is 24. This call overwrites the length used for the client nonce.
*
* @param length The length of the nonce. Must be positive and greater than 0
* @return {@code this} builder for use in a chained invocation
* @throws IllegalArgumentException If length is less than 1
*/
FinalBuildStage nonceLength(int length);
/**
* The client will use a default nonce generator, unless an external one is provided by this
* method.
*
* @apiNote you should rely on the default randomly generated nonce instead of this, this call
* exists mostly for testing with a predefined nonce
* @param nonceSupplier A supplier of valid nonce Strings. Please note that according to the SCRAM RFC only ASCII
* printable characters (except the comma, ',') are permitted on a nonce. Length is not
* limited.
* @return {@code this} builder for use in a chained invocation
* @throws IllegalArgumentException If nonceSupplier is null
*/
FinalBuildStage nonceSupplier(@NotNull Supplier<@NotNull String> nonceSupplier);
/**
* Selects a non-default SecureRandom instance, based on the given algorithm and optionally
* provider. This SecureRandom instance will be used to generate secure random values, like the
* ones required to generate the nonce. Algorithm and provider names are those supported by the
* {@link SecureRandom} class.
*
* @param algorithm The name of the algorithm to use
* @param provider The name of the provider of SecureRandom. Might be null
* @return {@code this} builder for use in a chained invocation
* @throws IllegalArgumentException If algorithm is null, or either the algorithm or provider
* are not supported
*/
FinalBuildStage secureRandomAlgorithmProvider(@NotNull String algorithm,
@Nullable String provider);
/**
* Returns the fully constructed {@link ScramClient} ready to start the message flow
* with the server.
*
* @return a ScramClient instance configured with the specified parameters
* @throws IllegalArgumentException if a parameter is null or empty
* @throws MechanismNegotiationException if the local mechanism configuration is incompatible
* with the client state engine or missing core fallback options
* @throws ChannelBindingException if a channel binding policy mismatch or cryptographic
* negotiation failure occurs
*/
ScramClient build();
}
/**
* Builds instances of type {@link ScramClient}. Initialize attributes and then invoke
* the {@link #build()} method to create an instance.
*
* @apiNote {@code Builder} is not thread-safe and generally should not be stored in a field or
* collection, but instead used immediately to create instances.
*/
static final class Builder
implements MechanismsBuildStage, UsernameBuildStage, PasswordBuildStage, FinalBuildStage {
ScramMechanism selectedScramMechanism;
Collection Concrete sub-classes should also provide a static parse(String) creation method.
*/
abstract class AbstractCharAttributeValue Checking the thread state via {@link Thread#isInterrupted()} on every
* iteration requires a native JVM call, which significantly degrades hashing
* throughput. This stride value batches iterations, allowing the loop to execute
* rapidly while remaining responsive to shutdown signals.
*
* Note: This value MUST be a power of two. This allows the compiler
* to use a highly optimized bitwise AND operation {@code (i & (STRIDE - 1))}
* rather than a slower modulo operator.
*/
private static final int INTERRUPT_CHECK_STRIDE = 1024;
private CryptoUtil() {
throw new IllegalStateException("Utility class");
}
/**
* Compute the "Hi" function for SCRAM.
*
* {@code
* Hi(str, salt, i):
*
* U1 := HMAC(str, salt + INT(1))
* U2 := HMAC(str, U1)
* ...
* Ui-1 := HMAC(str, Ui-2)
* Ui := HMAC(str, Ui-1)
*
* Hi := U1 XOR U2 XOR ... XOR Ui
*
* where "i" is the iteration count, "+" is the string concatenation
* operator, and INT(g) is a 4-octet encoding of the integer g, most
* significant octet first.
*
* Hi() is, essentially, PBKDF2 [RFC2898] with HMAC() as the
* pseudorandom function (PRF) and with dkLen == output length of
* HMAC() == output length of H().
* }
*
* @param mac The Mac instance to use
* @param password The char array to compute the Hi function
* @param salt The salt
* @param iterationCount The number of iterations
* @return The bytes of the computed Hi value
* @throws ScramRuntimeException if unsupported key for Mac algorithm, or if
* thread is interrupted
*/
static byte[] hi(Mac mac, char[] password, byte[] salt, int iterationCount) {
checkNotNull(mac, "mac");
checkNotNull(password, "password");
checkNotNull(salt, "salt");
checkArgument(salt.length != 0, "salt");
gt0(iterationCount, "iterationCount");
try {
byte[] pwBytes = passwordToUtf8Bytes(password);
try {
mac.init(new SecretKeySpec(pwBytes, mac.getAlgorithm()));
} finally {
Arrays.fill(pwBytes, (byte) 0);
}
} catch (InvalidKeyException ex) {
throw new ScramRuntimeException(
String.format(Locale.ROOT, "Platform error: unsupported key for %s algorithm",
mac.getAlgorithm()),
ex);
}
mac.update(salt);
// The 4-octet encoding of the integer 1 INT(1).
mac.update((byte) 0);
mac.update((byte) 0);
mac.update((byte) 0);
mac.update((byte) 1);
byte[] ui = mac.doFinal();
byte[] result = Arrays.copyOf(ui, ui.length);
boolean success = false;
try {
for (int i = 2; i <= iterationCount; i++) {
if ((i & (INTERRUPT_CHECK_STRIDE - 1)) == 0 && Thread.currentThread().isInterrupted()) {
throw new ScramInterruptedException("PBKDF2 computation interrupted at iteration " + i);
}
mac.update(ui);
mac.doFinal(ui, 0);
for (int j = 0; j < result.length; j++) {
result[j] ^= ui[j];
}
}
success = true;
return result;
} catch (ShortBufferException e) {
throw new AssertionError("Buffer sized by Mac.doFinal() is suddenly too short", e);
} finally {
Arrays.fill(ui, (byte) 0);
if (!success) {
Arrays.fill(result, (byte) 0);
}
}
}
/**
* Convert password to UTF-8 bytes and secure clear the backing array.
*
* @param password The password to convert
* @return The UTF-8 bytes of the password
*/
private static byte[] passwordToUtf8Bytes(char[] password) {
ByteBuffer bb = StandardCharsets.UTF_8.encode(CharBuffer.wrap(password));
try {
byte[] pwBytes = new byte[bb.remaining()];
bb.get(pwBytes);
return pwBytes;
} finally {
// Wipe of the intermediate buffer
if (bb.hasArray()) {
Arrays.fill(bb.array(), bb.arrayOffset(), bb.arrayOffset() + bb.capacity(), (byte) 0);
} else {
// Fallback just in case a future JDK returns a DirectBuffer here
bb.clear();
while (bb.hasRemaining()) {
bb.put((byte) 0);
}
}
}
}
/**
* Computes the HMAC of a given message.
*
* {@code
* HMAC(key, str): Apply the HMAC keyed hash algorithm (defined in
* [RFC2104]) using the octet string represented by "key" as the key
* and the octet string "str" as the input string. The size of the
* result is the hash result size for the hash function in use. For
* example, it is 20 octets for SHA-1 (see [RFC3174]).
* }
*
* @param secretKeySpec A key of the given algorithm
* @param mac A MAC instance of the given algorithm
* @param message The message to compute the HMAC
* @return The bytes of the computed HMAC value
* @throws ScramRuntimeException unsupported key for HMAC algorithm
*/
static byte[] hmac(SecretKeySpec secretKeySpec, Mac mac, byte[] message) {
try {
mac.init(secretKeySpec);
} catch (InvalidKeyException ex) {
throw new ScramRuntimeException(
String.format(Locale.ROOT, "Platform error: unsupported key for %s algorithm",
mac.getAlgorithm()),
ex);
}
return mac.doFinal(message);
}
/**
* Computes a byte-by-byte xor operation.
* {@code
* XOR: Apply the exclusive-or operation to combine the octet string
* on the left of this operator with the octet string on the right of
* this operator. The length of the output and each of the two
* inputs will be the same for this use.
* }
*
* @param value1 first value to apply xor
* @param value2 second value to apply xor
* @return xor operation
*/
static byte @NotNull [] xor(byte @NotNull [] value1, byte @NotNull [] value2) {
checkNotNull(value1, "value1");
checkNotNull(value2, "value2");
checkArgument(value1.length == value2.length, "Both values must have the same length");
byte[] result = new byte[value1.length];
for (int i = 0; i < value1.length; i++) {
result[i] = (byte) (value1[i] ^ value2[i]);
}
return result;
}
/**
* Generates a random salt. Normally the output is encoded to Base64.
*
* @param saltSize The length of the salt, in bytes
* @param random The SecureRandom to use
* @return The bye[] representing the salt
* @throws IllegalArgumentException if the saltSize is not positive, or if random is null
*/
static byte @NotNull [] salt(int saltSize, @NotNull SecureRandom random) {
gt0(saltSize, "saltSize");
checkNotNull(random, "random");
byte[] randomSalt = new byte[saltSize];
random.nextBytes(randomSalt);
return randomSalt;
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/Gs2AttributeValue.java 0000664 0000000 0000000 00000002503 15210312475 0032470 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* Parse and write GS2 Attribute-Value pairs.
*/
final class Gs2AttributeValue extends AbstractCharAttributeValue Not all the available attributes may be available in this implementation.
*/
enum ScramAttributes implements CharSupplier {
/**
* This attribute specifies the name of the user whose password is used for authentication (a.k.a.
* "authentication identity" [RFC4422]). If the
* "a" attribute is not specified (which would normally be the case), this username is also the
* identity that will be associated with the connection subsequent to authentication and
* authorization.
*
* The client SHOULD prepare the username using the "SASLprep" profile [RFC4013] of the "stringprep" algorithm [RFC3454] treating it as a query string (i.e.,
* unassigned Unicode code points are allowed).
*
* The characters ',' or '=' in usernames are sent as '=2C' and '=3D' respectively.
*/
USERNAME('n'),
/**
* This is an optional attribute, and is part of the GS2 [RFC5801] bridge between the GSS-API and SASL.
* This attribute specifies an authorization identity. A client may include it in its first
* message to the server if it wants to authenticate as one user, but subsequently act as a
* different user. This is typically used by an administrator to perform some management task on
* behalf of another user, or by a proxy in some situations.
*
* If this attribute is omitted (as it normally would be), the authorization identity is
* assumed to be derived from the username specified with the (required) "n" attribute.
*
* The server always authenticates the user specified by the "n" attribute. If the "a"
* attribute specifies a different user, the server associates that identity with the connection
* after successful authentication and authorization checks.
*
* The syntax of this field is the same as that of the "n" field with respect to quoting of '='
* and ','.
*/
AUTHZID('a'),
/**
* This attribute specifies a sequence of random printable ASCII characters excluding ',' (which
* forms the nonce used as input to the hash function). No quoting is applied to this string.
*/
NONCE('r'),
/**
* This REQUIRED attribute specifies the base64-encoded GS2 header and channel binding data. The
* attribute data consist of: {@link java.security.MessageDigest}: "Every implementation of the Java platform is required to
* support the following standard MessageDigest algorithms: {@code SHA-1}, {@code SHA-256}".
*
* {@link javax.crypto.Mac}: "Every implementation of the Java platform is required to support
* the following standard Mac algorithms: {@code HmacSHA1}, {@code HmacSHA256}".
*
* @see SASL
* SCRAM Family Mechanisms
*/
public enum ScramMechanism {
/**
* SCRAM-SHA-1 mechanism, defined in RFC-5802.
*/
SCRAM_SHA_1("SCRAM-SHA-1", "SHA-1", "HmacSHA1"),
/**
* SCRAM-SHA-1-PLUS mechanism, defined in RFC-5802.
*/
SCRAM_SHA_1_PLUS("SCRAM-SHA-1-PLUS", "SHA-1", "HmacSHA1"),
/**
* SCRAM-SHA-224 mechanism, not defined in an RFC.
*/
SCRAM_SHA_224("SCRAM-SHA-224", "SHA-224", "HmacSHA224"),
/**
* SCRAM-SHA-224-PLUS mechanism, not defined in an RFC.
*/
SCRAM_SHA_224_PLUS("SCRAM-SHA-224-PLUS", "SHA-224", "HmacSHA224"),
/**
* SCRAM-SHA-256 mechanism, defined in RFC-7677.
*/
SCRAM_SHA_256("SCRAM-SHA-256", "SHA-256", "HmacSHA256"),
/**
* SCRAM-SHA-256-PLUS mechanism, defined in RFC-7677.
*/
SCRAM_SHA_256_PLUS("SCRAM-SHA-256-PLUS", "SHA-256", "HmacSHA256"),
/**
* SCRAM-SHA-384 mechanism, not defined in an RFC.
*/
SCRAM_SHA_384("SCRAM-SHA-384", "SHA-384", "HmacSHA384"),
/**
* SCRAM-SHA-384-PLUS mechanism, not defined in an RFC.
*/
SCRAM_SHA_384_PLUS("SCRAM-SHA-384-PLUS", "SHA-384", "HmacSHA384"),
/**
* SCRAM-SHA-512 mechanism.
*/
SCRAM_SHA_512("SCRAM-SHA-512", "SHA-512", "HmacSHA512"),
/**
* SCRAM-SHA-512-PLUS mechanism.
*/
SCRAM_SHA_512_PLUS("SCRAM-SHA-512-PLUS", "SHA-512", "HmacSHA512"),
/**
* SCRAM-SHA3-512 mechanism.
*/
SCRAM_SHA3_512("SCRAM-SHA3-512", "SHA3-512", "HmacSHA3-512"),
/**
* SCRAM-SHA3-512-PLUS mechanism.
*/
SCRAM_SHA3_512_PLUS("SCRAM-SHA3-512-PLUS", "SHA3-512", "HmacSHA3-512");
private static final @Unmodifiable Map Must be a value registered under IANA: SASL SCRAM
* Family Mechanisms
*
* @return The mechanism name
*/
@NotNull
public String getName() {
return mechanismName;
}
/**
* The mechanism {@code -PLUS} require channel binding.
*
* @return true if the mechanism requires channel binding
*/
public boolean isPlus() {
return channelBinding;
}
/**
* Calculate a message digest, according to the algorithm of the SCRAM mechanism.
*
* @param message the message
* @return The calculated message digest
* @throws ScramRuntimeException If the algorithm is not provided by current JVM or any included
* implementations
*/
byte @NotNull [] digest(byte @NotNull [] message) {
try {
return MessageDigest.getInstance(hashAlgorithmName).digest(message);
} catch (NoSuchAlgorithmException e) {
throw new ScramRuntimeException(
"Hash algorithm " + hashAlgorithmName + " not present in current JVM", e);
}
}
/**
* Calculate the hmac of a key and a message, according to the algorithm of the SCRAM mechanism.
*
* @param key the key
* @param message the message
* @return The calculated message hmac instance
* @throws ScramRuntimeException If the algorithm is not provided by current JVM or any included
* implementations
*/
byte @NotNull [] hmac(byte @NotNull [] key, byte @NotNull [] message) {
try {
return CryptoUtil.hmac(new SecretKeySpec(key, hmacAlgorithmName),
Mac.getInstance(hmacAlgorithmName), message);
} catch (NoSuchAlgorithmException e) {
throw new ScramRuntimeException(
"HMAC algorithm " + hmacAlgorithmName + " not present in current JVM", e);
}
}
/**
* Compute the salted password.
*
* @param stringPreparation Type of preparation to perform in the string
* @param password Password used
* @param salt Salt used
* @param iterationCount Number of iterations
* @return The salted password
* @throws ScramRuntimeException If the algorithm is not provided by current JVM or any included
* implementations
*/
byte @NotNull [] saltedPassword(@NotNull StringPreparation stringPreparation,
char @NotNull [] password, byte @NotNull [] salt, int iterationCount) {
final char[] normalizedPassword = stringPreparation.normalize(password);
try {
return CryptoUtil.hi(
Mac.getInstance(hmacAlgorithmName),
normalizedPassword,
salt,
iterationCount);
} catch (NoSuchAlgorithmException ex) {
throw new ScramRuntimeException(
"Unsupported " + hmacAlgorithmName + " for " + mechanismName, ex);
}
}
/**
* Gets a SCRAM mechanism given its standard IANA name, supported by the Java security provider.
*
* @apiNote This will get only the mechanims supported by the Java security provider, if the
* configured security provider lacks the algorithm this method will return {@code null}.
*
* @param name The standard IANA full name of the mechanism.
* @return An instance that contains the ScramMechanism if it was found, or null otherwise.
*/
public static @Nullable ScramMechanism byName(@NotNull String name) {
return BY_NAME_MAPPING.get(checkNotNull(name, "name"));
}
/**
* List all the supported SCRAM mechanisms by this client implementation.
*
* @return A unmodifiable list of the IANA-registered, SCRAM supported mechanisms
*/
@Unmodifiable
public static @NotNull List<@NotNull String> supportedMechanisms() {
return Collections.unmodifiableList(SUPPORTED_MECHANISMS);
}
private static boolean isAlgorithmSupported(@NotNull ScramMechanism mechanism) {
try {
MessageDigest.getInstance(mechanism.hashAlgorithmName);
Mac.getInstance(mechanism.hmacAlgorithmName);
return true;
} catch (NoSuchAlgorithmException e) {
return false;
}
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/ScramStringFormatting.java 0000664 0000000 0000000 00000007777 15210312475 0033465 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.checkNotEmpty;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.util.Base64;
import com.ongres.saslprep.SASLprep;
import com.ongres.stringprep.Profile;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* Class with static methods that provide support for converting to/from salNames.
*
* @see [RFC5802] Section 7: Formal
* Syntax
*/
final class ScramStringFormatting {
static final Profile SASL_PREP = new SASLprep();
private ScramStringFormatting() {
throw new IllegalStateException("Utility class");
}
/**
* Given a value-safe-char (normalized UTF-8 String), return one where characters ',' and '=' are
* represented by '=2C' or '=3D', respectively.
*
* @param value The value to convert so saslName
* @return The saslName, with caracter escaped (if any)
*/
@NotNull
static String toSaslName(@NotNull final String value) {
if (value.isEmpty()) {
return value;
}
final char[] originalChars = SASL_PREP.prepareQuery(value.toCharArray());
int comma = 0;
int equal = 0;
// Fast path
for (char c : originalChars) {
if (',' == c) {
comma++;
} else if ('=' == c) {
equal++;
}
}
if (comma == 0 && equal == 0) {
return new String(originalChars);
}
// Replace chars
char[] saslChars = new char[originalChars.length + comma * 2 + equal * 2];
int i = 0;
for (char c : originalChars) {
if (',' == c) {
saslChars[i++] = '=';
saslChars[i++] = '2';
saslChars[i++] = 'C';
} else if ('=' == c) {
saslChars[i++] = '=';
saslChars[i++] = '3';
saslChars[i++] = 'D';
} else {
saslChars[i++] = c;
}
}
return new String(saslChars);
}
/**
* Given a saslName, return a non-escaped String.
*
* @param value The saslName
* @return The saslName, unescaped
* @throws IllegalArgumentException If a ',' character is present, or a '=' not followed by either
* '2C' or '3D'
*/
@Nullable
static String fromSaslName(@Nullable String value) {
if (null == value || value.isEmpty()) {
return value;
}
int equal = 0;
char[] orig = value.toCharArray();
// Fast path
for (int i = 0; i < orig.length; i++) {
if (orig[i] == ',') {
throw new IllegalArgumentException("Invalid ',' character present in saslName");
}
if (orig[i] == '=') {
equal++;
if (i + 2 > orig.length - 1) {
throw new IllegalArgumentException("Invalid '=' character present in saslName");
}
if (!(orig[i + 1] == '2' && orig[i + 2] == 'C'
|| orig[i + 1] == '3' && orig[i + 2] == 'D')) {
throw new IllegalArgumentException(
"Invalid char '=" + orig[i + 1] + orig[i + 2] + "' found in saslName");
}
}
}
if (equal == 0) {
return value;
}
// Replace characters
char[] replaced = new char[orig.length - equal * 2];
for (int r = 0, o = 0; r < replaced.length; r++) {
if ('=' == orig[o]) {
if (orig[o + 1] == '2' && orig[o + 2] == 'C') {
replaced[r] = ',';
} else if (orig[o + 1] == '3' && orig[o + 2] == 'D') {
replaced[r] = '=';
}
o += 3;
} else {
replaced[r] = orig[o];
o += 1;
}
}
return new String(replaced);
}
static @NotNull String base64Encode(byte @NotNull [] value) {
checkNotNull(value, "value");
return new String(Base64.getEncoder().encode(value), UTF_8);
}
static byte @NotNull [] base64Decode(@NotNull String value) {
checkNotEmpty(value, "value");
return Base64.getDecoder().decode(value.getBytes(UTF_8));
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/ServerFinalMessage.java 0000664 0000000 0000000 00000012636 15210312475 0032711 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.castNonNull;
import static com.ongres.scram.common.util.Preconditions.checkNotEmpty;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import com.ongres.scram.common.exception.ScramParseException;
import com.ongres.scram.common.exception.ServerErrorValue;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* Constructs and parses {@code server-final-messages}.
*
* Even though the [RFC5802] is not very
* clear about it, this implementation will normalize non-printable US-ASCII characters similarly
* to what SASLprep does (i.e., removing them).
*/
NO_PREPARATION {
@Override
char[] doNormalize(char[] value) {
return UsAsciiUtils.toPrintable(value);
}
},
/**
* Implementation of StringPreparation that performs {@code SASLprep} preparation. UTF-8 byte
* sequences that are prohibited by the SASLprep algorithm will produce an exception.
*/
SASL_PREPARATION {
@Override
char[] doNormalize(char[] value) {
return ScramStringFormatting.SASL_PREP.prepareStored(value);
}
},
/**
* Implementation of StringPreparation that performs {@code SASLprep} preparation for PostgreSQL.
*
* This class serves as a {@link ScramRuntimeException} wrapper for an
* interruption signal. It is primarily used during cryptographic operations
* where a checked {@link InterruptedException} cannot be propagated directly
* due to API or functional interface constraints.
*
* @see Thread#isInterrupted()
* @see InterruptedException
* @see ScramRuntimeException
*
* @since 3.3
*/
public class ScramInterruptedException extends ScramRuntimeException {
private static final long serialVersionUID = 1L;
/**
* Constructs a new {@code ScramInterruptedException} with the specified detail message.
*
* @param detail the detail message explaining the context of the interruption.
*/
public ScramInterruptedException(String detail) {
super(detail);
}
/**
* Constructs a new {@code ScramInterruptedException} with the specified detail
* message and the underlying cause.
*
* @param detail the detail message explaining the context.
* @param ex the cause (which is saved for later retrieval by the {@link #getCause()} method).
*/
public ScramInterruptedException(String detail, Throwable ex) {
super(detail, ex);
}
}
ScramInvalidServerSignatureException.java 0000664 0000000 0000000 00000002126 15210312475 0040400 0 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/exception /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common.exception;
/**
* This class represents an error when verifying the a base64-encoded ServerSignature in a
* {@code server-final-message}.
*
* Is used by the client to verify that the server has access to the user's authentication
* information.
*/
public class ScramInvalidServerSignatureException extends ScramException {
private static final long serialVersionUID = 1L;
/**
* Constructs a new instance of ScramInvalidServerSignatureException with a detailed message.
*
* @param detail A String containing details about the exception
*/
public ScramInvalidServerSignatureException(String detail) {
super(detail);
}
/**
* Constructs a new instance of ScramInvalidServerSignatureException with a detailed message and a
* root cause.
*
* @param detail A String containing details about the exception
* @param ex The root exception
*/
public ScramInvalidServerSignatureException(String detail, Throwable ex) {
super(detail, ex);
}
}
ScramParseException.java 0000664 0000000 0000000 00000001516 15210312475 0035015 0 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/exception /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common.exception;
/**
* This class represents an error when parsing SCRAM messages.
*/
public class ScramParseException extends ScramException {
private static final long serialVersionUID = 1L;
/**
* Constructs a new instance of ScramParseException with a detailed message.
*
* @param detail A String containing details about the exception
*/
public ScramParseException(String detail) {
super(detail);
}
/**
* Constructs a new instance of ScramParseException with a detailed message and a root cause.
*
* @param detail A String containing details about the exception
* @param ex The root exception
*/
public ScramParseException(String detail, Throwable ex) {
super(detail, ex);
}
}
ScramRuntimeException.java 0000664 0000000 0000000 00000001547 15210312475 0035372 0 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/exception /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common.exception;
/**
* This class represents an error when using SCRAM, which is a SASL method.
*/
public class ScramRuntimeException extends RuntimeException {
private static final long serialVersionUID = 1L;
/**
* Constructs a new instance of ScramRuntimeException with a detailed message.
*
* @param detail A String containing details about the exception
*/
public ScramRuntimeException(String detail) {
super(detail);
}
/**
* Constructs a new instance of ScramRuntimeException with a detailed message and a root cause.
*
* @param detail A String containing details about the exception
* @param ex The root exception
*/
public ScramRuntimeException(String detail, Throwable ex) {
super(detail, ex);
}
}
ScramServerErrorException.java 0000664 0000000 0000000 00000002754 15210312475 0036230 0 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/exception /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common.exception;
/**
* This class specifies an error that occurred during authentication exchange in a
* {@code server-final-message}.
*
* It is sent by the server in its {@code server-final-message} and can help diagnose the reason
* for the authentication exchange failure.
*/
public class ScramServerErrorException extends ScramException {
private static final long serialVersionUID = 1L;
/**
* {@code server-error-value}.
*/
private final String serverError;
/**
* Constructs a new instance of ScramServerErrorException with a detailed message.
*
* @param serverError The SCRAM error in the message
*/
public ScramServerErrorException(String serverError) {
super(ServerErrorValue.getErrorMessage(serverError));
this.serverError = serverError;
}
/**
* Constructs a new instance of ScramServerErrorException with a detailed message and a root
* cause.
*
* @param serverError The SCRAM error in the message
* @param ex The root exception
*/
public ScramServerErrorException(String serverError, Throwable ex) {
super(ServerErrorValue.getErrorMessage(serverError), ex);
this.serverError = serverError;
}
/**
* Return the "e=" server-error-value from the server-final-message.
*
* @return the error type returned in the server-final-message
*/
public String getServerError() {
return serverError;
}
}
ServerErrorValue.java 0000664 0000000 0000000 00000004257 15210312475 0034360 0 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/exception /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common.exception;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
* This attribute specifies an error that occurred during authentication exchange. It is sent by the
* server in its final message and can help diagnose the reason for the authentication exchange
* failure.
*/
public final class ServerErrorValue {
private static final ConcurrentMap The TLS server's certificate bytes need to be hashed with SHA-256 if its signature algorithm
* is MD5 or SHA-1 as per RFC 5929 (https://tools.ietf.org/html/rfc5929#section-4.1). If something
* else is used, the same hash as the signature algorithm is used.
*
* @param serverCert the TLS server's peer certificate
* @return the MessageDigest algorithm
* @throws NoSuchAlgorithmException if the signature algorithm is unrecognized or unmapped
* @see The tls-server-end-point
* Channel Binding Type
*/
private static MessageDigest getDigestAlgorithm(final X509Certificate serverCert)
throws NoSuchAlgorithmException {
String sigAlgName = serverCert.getSigAlgName();
if (sigAlgName == null) {
throw new NoSuchAlgorithmException("Certificate signature algorithm is null");
}
// Normalize name to upper case
sigAlgName = sigAlgName.toUpperCase(Locale.ROOT);
String algorithmName;
// Handle Parameterized Algorithms (Bury the hash in ASN.1 params)
if ("RSASSA-PSS".equals(sigAlgName)) {
byte[] sigAlgParams = serverCert.getSigAlgParams();
if (sigAlgParams == null) {
throw new NoSuchAlgorithmException("RSASSA-PSS signature parameters are missing");
}
try {
AlgorithmParameters params = AlgorithmParameters.getInstance("RSASSA-PSS");
params.init(sigAlgParams);
PSSParameterSpec spec = params.getParameterSpec(PSSParameterSpec.class);
algorithmName = spec.getDigestAlgorithm().toUpperCase(Locale.ROOT);
} catch (IOException | GeneralSecurityException e) {
throw new NoSuchAlgorithmException("Could not extract hash from RSASSA-PSS parameters", e);
}
} else {
// Handle Traditional Algorithms (Hash is explicitly in the name, e.g., "SHA256withRSA")
int index = sigAlgName.indexOf("WITH");
if (index > 0) {
algorithmName = sigAlgName.substring(0, index); // e.g., "SHA256" or "SHA3-512"
} else {
// Correctly mirrors PostgreSQL/OpenSSL behavior: Ed25519/Ed448 yield NID_undef.
// We must fail here because the Postgres server will also fail.
throw new NoSuchAlgorithmException(
"Could not determine server certificate signature algorithm: "
+ serverCert.getSigAlgName());
}
}
// Normalize the hash name (Applies to both Traditional and RSASSA-PSS)
switch (algorithmName) {
// Enforce RFC 5929 Mandatory Upgrades (MD5 or SHA-1 must become SHA-256)
case "MD5":
case "SHA1":
case "SHA-1":
case "SHA256":
case "SHA-256":
algorithmName = "SHA-256";
break;
case "SHA224":
case "SHA-224":
algorithmName = "SHA-224";
break;
case "SHA384":
case "SHA-384":
algorithmName = "SHA-384";
break;
case "SHA512":
case "SHA-512":
algorithmName = "SHA-512";
break;
default:
// Pass-through for valid modern algorithms like SHA3-512
break;
}
return MessageDigest.getInstance(algorithmName);
}
/**
* The hash of the TLS server's certificate [RFC5280] as it appears, octet for octet, in the
* server's Certificate message.
*
* @param serverCert the TLS server's peer certificate
* @return the hash of the TLS server's peer certificate
* @throws CertificateEncodingException if an encoding error occurs.
* @deprecated this method silently swallows {@link NoSuchAlgorithmException} and returns an
* empty array. It is replaced by {@link #getChannelBindingHash(X509Certificate)}
* and will be removed in a future release.
*/
@Deprecated
public static byte @NotNull [] getChannelBindingData(final @NotNull X509Certificate serverCert)
throws CertificateEncodingException {
try {
return getChannelBindingHash(serverCert);
} catch (NoSuchAlgorithmException e) {
// Preserve the old (and dangerous) silent-failure behavior for backward compatibility
return new byte[0];
}
}
/**
* Computes the hash of the TLS server's certificate [RFC5280] as it appears, octet for octet, in
* the server's Certificate message, for use as {@code "tls-server-end-point"} channel binding.
*
* The TLS server's certificate bytes need to be hashed with {@code SHA-256} if its signature
* algorithm is {@code MD5} or {@code SHA-1} as per
* RFC 5929 Section 4.1. If another
* algorithm is used, the same hash function as the signature algorithm is applied. Unsupported
* or unmapped signature structures throw a {@link NoSuchAlgorithmException}.
*
* @param serverCert the TLS server's peer certificate
* @return the hash of the TLS server's peer certificate
* @throws CertificateEncodingException if an encoding error occurs
* @throws NoSuchAlgorithmException if the required digest algorithm cannot be determined or is
* unsupported by the underlying security provider
*/
public static byte @NotNull [] getChannelBindingHash(final @NotNull X509Certificate serverCert)
throws CertificateEncodingException, NoSuchAlgorithmException {
MessageDigest digestAlgorithm = getDigestAlgorithm(serverCert);
return digestAlgorithm.digest(serverCert.getEncoded());
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java9/ 0000775 0000000 0000000 00000000000 15210312475 0021732 5 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/main/java9/module-info.java 0000664 0000000 0000000 00000000431 15210312475 0025011 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2024 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
module com.ongres.scram.common {
requires transitive com.ongres.saslprep;
exports com.ongres.scram.common;
exports com.ongres.scram.common.exception;
exports com.ongres.scram.common.util;
} ongres-scram-f6bd6e2/scram-common/src/test/ 0000775 0000000 0000000 00000000000 15210312475 0020753 5 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/test/java/ 0000775 0000000 0000000 00000000000 15210312475 0021674 5 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/test/java/com/ 0000775 0000000 0000000 00000000000 15210312475 0022452 5 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/ 0000775 0000000 0000000 00000000000 15210312475 0023747 5 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/scram/ 0000775 0000000 0000000 00000000000 15210312475 0025054 5 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/scram/JarFileCheckIT.java 0000664 0000000 0000000 00000004475 15210312475 0030440 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2024 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.module.ModuleDescriptor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
class JarFileCheckIT {
private static JarFile jarFile;
private static Path buildJarPath;
@BeforeAll
static void beforeAll() throws IOException {
buildJarPath = Paths.get(System.getProperty("buildJar"));
assertTrue(Files.exists(buildJarPath));
jarFile = new JarFile(buildJarPath.toFile(), true);
}
@AfterAll
static void afterAll() throws IOException {
jarFile.close();
}
@Test
void checkLicense() throws IOException {
JarEntry jarLicense = jarFile.getJarEntry("META-INF/LICENSE");
assertNotNull(jarLicense, "LICENSE file should be present in the final JAR file");
try (InputStream is = jarFile.getInputStream(jarLicense);
BufferedReader reader = new BufferedReader(new InputStreamReader(is, UTF_8))) {
String line = reader.readLine();
assertEquals("Copyright (c) 2017 OnGres, Inc.", line);
}
}
@Test
void checkMultiReleaseManifest() throws IOException {
Attributes mainAttributes = jarFile.getManifest().getMainAttributes();
String multiReleaseValue = mainAttributes.getValue(new Attributes.Name("Multi-Release"));
assertNotNull(multiReleaseValue);
assertEquals("true", multiReleaseValue);
}
@Test
void checkModuleInfoPresent() throws IOException {
JarEntry jarModuleInfo = jarFile.getJarEntry("META-INF/versions/9/module-info.class");
ModuleDescriptor moduleDescriptor = ModuleDescriptor.read(jarFile.getInputStream(jarModuleInfo));
assertNotNull(moduleDescriptor);
assertEquals("com.ongres.scram.common", moduleDescriptor.name());
}
}
ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/scram/common/ 0000775 0000000 0000000 00000000000 15210312475 0026344 5 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/scram/common/ClientFinalMessageTest.java 0000664 0000000 0000000 00000001036 15210312475 0033544 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
class ClientFinalMessageTest {
@Test
void writeToWithoutProofValid() {
StringBuilder sb = ClientFinalMessage.withoutProof(new StringBuilder(),
new Gs2Header(Gs2CbindFlag.CLIENT_NOT), null, RfcExampleSha1.FULL_NONCE);
assertEquals(RfcExampleSha1.CLIENT_FINAL_MESSAGE_WITHOUT_PROOF, sb.toString());
}
}
ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/scram/common/ClientFirstMessageTest.java 0000664 0000000 0000000 00000012644 15210312475 0033611 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.RfcExampleSha1.CLIENT_NONCE;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.ongres.scram.common.exception.ScramParseException;
import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
class ClientFirstMessageTest {
@ParameterizedTest
@CsvSource(value = {"CLIENT_NOT,cbind,,user,nonce",
"CHANNEL_BINDING_REQUIRED,,,user,nonce",
"CHANNEL_BINDING_REQUIRED,tls-*,,user,nonce",
"CLIENT_YES_SERVER_NOT,,,,nonce",
"CLIENT_YES_SERVER_NOT,,,'',nonce",
"CHANNEL_BINDING_REQUIRED,tls-export,,u,",
"CHANNEL_BINDING_REQUIRED,tls-export,,u,''"})
void constructorTestInvalid(@NotNull Gs2CbindFlag flag, String cbName, String authzid,
@NotNull String user, @NotNull String nonce) {
assertThrows(IllegalArgumentException.class,
() -> new ClientFirstMessage(flag, cbName, authzid, user, nonce));
}
@Test
void writeToValidValues() {
assertEquals("n,,n=user,r=fyko",
new ClientFirstMessage("user", "fyko").toString());
assertEquals("y,,n=user,r=fyko",
new ClientFirstMessage(Gs2CbindFlag.CLIENT_YES_SERVER_NOT, null, null, "user", "fyko")
.toString());
assertEquals("p=tls-server-end-point,,n=user,r=fyko",
new ClientFirstMessage(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, "tls-server-end-point", null,
"user", "fyko").toString());
assertEquals("p=tls-server-end-point,a=authzid,n=user,r=fyko",
new ClientFirstMessage(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, "tls-server-end-point",
"authzid", "user", "fyko").toString());
}
@Test
void parseToValidValues() throws ScramParseException {
assertEquals(ClientFirstMessage.parseFrom("n,,n=user,r=fyko").toString(),
new ClientFirstMessage("user", "fyko").toString());
assertEquals(ClientFirstMessage.parseFrom("y,,n=user,r=fyko").toString(),
new ClientFirstMessage(Gs2CbindFlag.CLIENT_YES_SERVER_NOT, null, null, "user", "fyko")
.toString());
assertEquals(ClientFirstMessage.parseFrom("p=tls-server-end-point,,n=user,r=fyko").toString(),
new ClientFirstMessage(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, "tls-server-end-point", null,
"user", "fyko").toString());
assertEquals(
ClientFirstMessage.parseFrom("p=tls-server-end-point,a=authzid,n=user,r=fyko").toString(),
new ClientFirstMessage(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, "tls-server-end-point",
"authzid", "user", "fyko").toString());
}
@Test
void parseFromValidValues() throws ScramParseException {
ClientFirstMessage m1 = ClientFirstMessage.parseFrom("n,,n=user,r=" + CLIENT_NONCE);
assertFalse(m1.isChannelBindingRequired());
assertSame(Gs2CbindFlag.CLIENT_NOT, m1.getGs2Header().getChannelBindingFlag());
assertNull(m1.getGs2Header().getChannelBindingName());
assertNull(m1.getGs2Header().getAuthzid());
assertEquals("user", m1.getUsername());
assertEquals(CLIENT_NONCE, m1.getClientNonce());
ClientFirstMessage m2 = ClientFirstMessage.parseFrom("y,,n=user,r=" + CLIENT_NONCE);
assertTrue(
!m2.isChannelBindingRequired()
&& m2.getGs2Header().getChannelBindingFlag() == Gs2CbindFlag.CLIENT_YES_SERVER_NOT
&& null == m2.getGs2Header().getAuthzid() && "user".equals(m2.getUsername())
&& CLIENT_NONCE.equals(m2.getClientNonce()));
ClientFirstMessage m3 = ClientFirstMessage.parseFrom("y,a=user2,n=user,r=" + CLIENT_NONCE);
assertTrue(
!m3.isChannelBindingRequired()
&& m3.getGs2Header().getChannelBindingFlag() == Gs2CbindFlag.CLIENT_YES_SERVER_NOT
&& null != m3.getGs2Header().getAuthzid()
&& "user2".equals(m3.getGs2Header().getAuthzid())
&& "user".equals(m3.getUsername()) && CLIENT_NONCE.equals(m3.getClientNonce()));
ClientFirstMessage m4 =
ClientFirstMessage.parseFrom("p=tls-unique,a=user2,n=user,r=" + CLIENT_NONCE);
assertTrue(m4.isChannelBindingRequired());
assertSame(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, m4.getGs2Header().getChannelBindingFlag());
assertNotNull(m4.getGs2Header().getChannelBindingName());
assertEquals("tls-unique", m4.getGs2Header().getChannelBindingName());
assertNotNull(m4.getGs2Header().getAuthzid());
assertEquals("user2", m4.getGs2Header().getAuthzid());
assertEquals("user", m4.getUsername());
assertEquals(CLIENT_NONCE, m4.getClientNonce());
}
@Test
void parseFromInvalidValues() {
String[] invalidValues = new String[] {
"n,,r=user,r=" + CLIENT_NONCE, "n,,z=user,r=" + CLIENT_NONCE, "n,,n=user", "n,", "n,,",
"n,,n=user,r", "n,,n=user,r="
};
int n = 0;
for (String s : invalidValues) {
try {
assertNotNull(ClientFirstMessage.parseFrom(s));
} catch (ScramParseException e) {
n++;
}
}
assertEquals(invalidValues.length, n);
}
}
ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/scram/common/Gs2AttributeValueTest.java 0000664 0000000 0000000 00000004352 15210312475 0033367 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;
import org.junit.jupiter.params.provider.NullSource;
class Gs2AttributeValueTest {
@ParameterizedTest
@NullSource
@EnumSource(value = Gs2Attributes.class, names = {"CHANNEL_BINDING_REQUIRED", "AUTHZID"})
void constructorNotAllowsNullValuesForCbAuthzId(Gs2Attributes attrib) {
assertThrows(IllegalArgumentException.class,
() -> new Gs2AttributeValue(attrib, null));
}
@ParameterizedTest
@EnumSource(value = Gs2Attributes.class, names = {"CLIENT_NOT", "CLIENT_YES_SERVER_NOT"})
void constructorAllowsNullValuesForClientnClienty(Gs2Attributes attrib) {
Gs2AttributeValue gs2 = assertDoesNotThrow(() -> new Gs2AttributeValue(attrib, null));
assertNotNull(gs2);
}
@Test
void parseIllegalValuesStructure() {
String[] values =
new String[] {"", "as", "asdfjkl", Gs2Attributes.CHANNEL_BINDING_REQUIRED.getChar() + "="};
int n = 0;
for (String value : values) {
try {
assertNotNull(Gs2AttributeValue.parse(value));
} catch (IllegalArgumentException e) {
n++;
}
}
assertEquals(values.length, n, "Not every illegal value thrown IllegalArgumentException");
}
@Test
void parseIllegalValuesInvalidGS2Attibute() {
String[] values = new String[] {"z=asdfasdf", "i=value"};
int n = 0;
for (String value : values) {
try {
assertNotNull(Gs2AttributeValue.parse(value));
} catch (IllegalArgumentException e) {
n++;
}
}
assertEquals(values.length, n, "Not every illegal value thrown IllegalArgumentException");
}
@Test
void parseLegalValues() {
String[] values = new String[] {"n", "y", "p=value", "a=authzid"};
for (String value : values) {
assertNotNull(Gs2AttributeValue.parse(value));
}
}
}
ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/scram/common/Gs2HeaderTest.java 0000664 0000000 0000000 00000004650 15210312475 0031620 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;
class Gs2HeaderTest {
private static final String[] VALID_GS2HEADER_STRINGS = new String[] {
"n,", "y,", "n,a=blah", "p=tls-server-end-point,", "p=tls-server-end-point,a=b"
};
private static final Gs2Header[] VALID_GS_2_HEADERS = new Gs2Header[] {
new Gs2Header(Gs2CbindFlag.CLIENT_NOT),
new Gs2Header(Gs2CbindFlag.CLIENT_YES_SERVER_NOT),
new Gs2Header(Gs2CbindFlag.CLIENT_NOT, null, "blah"),
new Gs2Header(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, "tls-server-end-point"),
new Gs2Header(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, "tls-server-end-point", "b")
};
private void assertGS2Header(String expected, Gs2Header gs2Header) {
assertEquals(expected, gs2Header.writeTo(new StringBuilder()).toString());
}
@Test
void constructorValid() {
for (int i = 0; i < VALID_GS2HEADER_STRINGS.length; i++) {
assertGS2Header(VALID_GS2HEADER_STRINGS[i], VALID_GS_2_HEADERS[i]);
}
}
@Test
void constructorInvalid1() {
assertThrows(IllegalArgumentException.class,
() -> new Gs2Header(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, null));
}
@Test
void constructorInvalid2() {
assertThrows(IllegalArgumentException.class,
() -> new Gs2Header(Gs2CbindFlag.CLIENT_NOT, "blah"));
}
@Test
void constructorInvalid3() {
assertThrows(IllegalArgumentException.class,
() -> new Gs2Header(Gs2CbindFlag.CLIENT_YES_SERVER_NOT, "blah"));
}
@Test
void constructorInvalid4() {
assertThrows(IllegalArgumentException.class,
() -> new Gs2Header(Gs2CbindFlag.CHANNEL_BINDING_REQUIRED, null, "b"));
}
@Test
void parseFromInvalid() {
String[] invalids = new String[] {"Z,", "n,Z=blah", "p,", "n=a,"};
int n = 0;
for (String invalid : invalids) {
try {
Gs2Header.parseFrom(invalid);
} catch (IllegalArgumentException e) {
n++;
}
}
assertEquals(invalids.length, n);
}
@Test
void parseFromValid() {
for (int i = 0; i < VALID_GS2HEADER_STRINGS.length; i++) {
assertGS2Header(
VALID_GS_2_HEADERS[i].writeTo(new StringBuilder()).toString(),
Gs2Header.parseFrom(VALID_GS2HEADER_STRINGS[i]));
}
}
}
ongres-scram-f6bd6e2/scram-common/src/test/java/com/ongres/scram/common/HiFunctionTest.java 0000664 0000000 0000000 00000020243 15210312475 0032116 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2026 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Stream;
import javax.crypto.Mac;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import com.ongres.scram.common.exception.ScramInterruptedException;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class HiFunctionTest {
private static final SecureRandom SECURE_RANDOM = new SecureRandom();
// Character sets for different edge cases
private static final String ALPHANUMERIC = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
private static final String SPECIAL = "!@#$%^&*()-_=+[{]}\\|;:'\",.<>/?`~ ";
private static final String UNICODE_EMOJI = "🚀🔥🛡️🔑";
private static final String UNICODE_EXTENDED = "こんにちは世界"; // "Hello World" in Japanese
private static final String COMBINED_POOL = ALPHANUMERIC + SPECIAL + UNICODE_EXTENDED + UNICODE_EMOJI;
private static final int[] VALID_CODE_POINTS = COMBINED_POOL.codePoints().toArray();
private static char[] generateRandom(int length) {
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < length; i++) {
int randomCodePoint = VALID_CODE_POINTS[SECURE_RANDOM.nextInt(VALID_CODE_POINTS.length)];
sb.appendCodePoint(randomCodePoint);
}
return sb.toString().toCharArray();
}
/**
* ScramMechanism x Random Passwords (of different lengths) x Iteration Counts.
*/
static Stream
*
*
* @implNote {@code extensions} are not supported.
* @see [RFC5802] Section 7
*/
public final class ClientFinalMessage extends AbstractScramMessage {
/**
* channel-binding = "c=" base64 encoding of cbind-input.
*/
private final String cbindInput;
/**
* nonce = "r=" c-nonce [s-nonce]. Second part provided by server.
*/
private final String nonce;
/**
* proof = "p=" base64.
*/
private final byte[] proof;
/**
* Constructus a client-final-message with the provided gs2Header (the same one used in the
* client-first-message), optionally the channel binding data, and the nonce. This method is
* intended to be used by SCRAM clients, and not to be constructed directly.
*
* @param gs2Header The GSS-API header
* @param cbindData If using channel binding, the channel binding data
* @param nonce The nonce
* @param proof The bytes representing the computed client proof
*/
public ClientFinalMessage(Gs2Header gs2Header, byte[] cbindData, String nonce, byte[] proof) {
this.cbindInput = generateCBindInput(gs2Header, cbindData);
this.nonce = checkNotEmpty(nonce, "nonce");
this.proof = checkNotNull(proof, "proof").clone();
}
/**
* Return the channel-binding "c=" base64 encoding of cbind-input.
*
* @return the {@code channel-binding}
*/
public String getCbindInput() {
return cbindInput;
}
/**
* Return the nonce.
*
* @return the {@code nonce}
*/
public String getNonce() {
return nonce;
}
/**
* Return the proof.
*
* @return the {@code proof}
*/
public byte[] getProof() {
return proof.clone();
}
private static void checkChannelBinding(Gs2Header gs2Header, byte[] cbindData) {
final Gs2CbindFlag channelBindingFlag = gs2Header.getChannelBindingFlag();
if (channelBindingFlag == Gs2CbindFlag.CHANNEL_BINDING_REQUIRED
&& null == cbindData) {
throw new IllegalArgumentException("Channel binding data is required");
}
if (channelBindingFlag != Gs2CbindFlag.CHANNEL_BINDING_REQUIRED
&& null != cbindData) {
throw new IllegalArgumentException("Channel binding data should not be present");
}
}
private static @NotNull String generateCBindInput(@NotNull Gs2Header gs2Header,
byte @Nullable [] cbindData) {
checkNotNull(gs2Header, "gs2Header");
checkChannelBinding(gs2Header, cbindData);
byte[] cbindInput = gs2Header.writeTo(new StringBuilder(32))
.append(',').toString().getBytes(StandardCharsets.UTF_8);
if (null != cbindData && cbindData.length != 0) {
byte[] cbindInputNew = new byte[cbindInput.length + cbindData.length];
System.arraycopy(cbindInput, 0, cbindInputNew, 0, cbindInput.length);
System.arraycopy(cbindData, 0, cbindInputNew, cbindInput.length, cbindData.length);
cbindInput = cbindInputNew;
}
return ScramStringFormatting.base64Encode(cbindInput);
}
private StringBuilder writeToWithoutProof(@NotNull StringBuilder sb) {
return StringWritableCsv.writeTo(sb,
new ScramAttributeValue(ScramAttributes.CHANNEL_BINDING, cbindInput),
new ScramAttributeValue(ScramAttributes.NONCE, nonce));
}
static StringBuilder withoutProof(StringBuilder sb, Gs2Header gs2Header, byte[] cbindData,
String nonce) {
return StringWritableCsv.writeTo(sb,
new ScramAttributeValue(ScramAttributes.CHANNEL_BINDING,
generateCBindInput(gs2Header, cbindData)),
new ScramAttributeValue(ScramAttributes.NONCE, nonce));
}
@Override
StringBuilder writeTo(StringBuilder sb) {
writeToWithoutProof(sb);
return StringWritableCsv.writeTo(
sb,
null, // This marks the position of writeToWithoutProof, required for the ","
new ScramAttributeValue(ScramAttributes.CLIENT_PROOF,
ScramStringFormatting.base64Encode(proof)));
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/ClientFirstMessage.java 0000664 0000000 0000000 00000015314 15210312475 0032713 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.checkNotEmpty;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import com.ongres.scram.common.exception.ScramParseException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* Constructs and parses client-first-messages. Message contains a {@code gs2-header}, a username
* and a
* nonce.
*
*
* cbind-input
* gs2-header [ cbind-data ]
*
* ;; cbind-data MUST be present for
* ;; gs2-cbind-flag of "p" and MUST be absent
* ;; for "y" or "n".
*
* channel-binding
* "c=" base64
*
* ;; base64 encoding of cbind-input.
*
* client-final-message-without-proof
* channel-binding "," nonce ["," extensions]
*
*
* client-final-message
* client-final-message-without-proof "," proof
*
*
*
* @implNote {@code extensions} are not supported.
* @see [RFC5802] Section 7
*/
public final class ClientFirstMessage extends AbstractScramMessage {
/**
* gs2-header = gs2-cbind-flag "," [ authzid ] ",".
*/
private final @NotNull Gs2Header gs2Header;
/**
* username = "n=" saslname.
*/
private final @NotNull String username;
/**
* nonce= "r=" c-nonce [s-nonce].
*/
private final @NotNull String clientNonce;
/**
* Constructs a client-first-message for the given user, nonce and gs2Header. This constructor is
* intended to be instantiated by a scram client, and not directly. The client should be providing
* the header, and nonce (and probably the user too).
*
* @param gs2Header The GSS-API header
* @param username The SCRAM username
* @param clientNonce The nonce for this session
* @throws IllegalArgumentException If any of the arguments is null or empty
*/
public ClientFirstMessage(@NotNull Gs2Header gs2Header, @NotNull String username,
@NotNull String clientNonce) {
this.gs2Header = checkNotNull(gs2Header, "gs2Header");
this.username = ScramStringFormatting.toSaslName(checkNotEmpty(username, "username"));
this.clientNonce = checkNotEmpty(clientNonce, "clientNonce");
}
/**
* Constructs a client-first-message for the given parameters. Under normal operation, this
* constructor is intended to be instantiated by a scram client, and not directly. However, this
* constructor is more user- or test-friendly, as the arguments are easier to provide without
* building other indirect object parameters.
*
* @param gs2CbindFlag The channel-binding flag
* @param authzid The optional authzid
* @param cbindName The optional channel binding name
* @param username The SCRAM user
* @param clientNonce The nonce for this session
* @throws IllegalArgumentException If the flag, user or nonce are null or empty
*/
public ClientFirstMessage(@NotNull Gs2CbindFlag gs2CbindFlag, @Nullable String cbindName,
@Nullable String authzid, @NotNull String username, @NotNull String clientNonce) {
this(new Gs2Header(gs2CbindFlag, cbindName, authzid), username, clientNonce);
}
/**
* Constructs a client-first-message for the given parameters, with no channel binding nor
* authzid. Under normal operation, this constructor is intended to be instantiated by a scram
* client, and not directly. However, this constructor is more user- or test-friendly, as the
* arguments are easier to provide without building other indirect object parameters.
*
* @param username The SCRAM user
* @param clientNonce The nonce for this session
* @throws IllegalArgumentException If the user or nonce are null or empty
*/
public ClientFirstMessage(@NotNull String username, @NotNull String clientNonce) {
this(new Gs2Header(Gs2CbindFlag.CLIENT_NOT), username, clientNonce);
}
/**
* Check to probe if gs2-cbind-flag is set to "p=".
*
* @return true if the message requires channel binding
*/
public boolean isChannelBindingRequired() {
return gs2Header.getChannelBindingFlag() == Gs2CbindFlag.CHANNEL_BINDING_REQUIRED;
}
/**
* Return the Gs2Header.
*
* @return the {@code gs2-header}
*/
public @NotNull Gs2Header getGs2Header() {
return gs2Header;
}
/**
* Return the username.
*
* @return the {@code "n=" saslname}
*/
public @NotNull String getUsername() {
return username;
}
/**
* Return the client nonce.
*
* @return the {@code c-nonce}
*/
public @NotNull String getClientNonce() {
return clientNonce;
}
/**
* Limited version of the StringWritableCsv method, that doesn't write the GS2 header. This method
* is useful to construct the auth message used as part of the SCRAM algorithm.
*
* @param sb A StringBuffer where to write the data to.
* @return The same StringBuffer
*/
@NotNull
StringBuilder clientFirstMessageBare(@NotNull StringBuilder sb) {
return StringWritableCsv.writeTo(
sb,
new ScramAttributeValue(ScramAttributes.USERNAME, username),
new ScramAttributeValue(ScramAttributes.NONCE, clientNonce));
}
/**
* Construct a {@link ClientFirstMessage} instance from a message (String).
*
* @param clientFirstMessage The String representing the client-first-message
* @return The instance
* @throws ScramParseException If the message is not a valid client-first-message
* @throws IllegalArgumentException If the message is null or empty
*/
@NotNull
public static ClientFirstMessage parseFrom(@NotNull String clientFirstMessage)
throws ScramParseException {
checkNotEmpty(clientFirstMessage, "clientFirstMessage");
@NotNull
String @NotNull [] userNonceString;
try {
userNonceString = StringWritableCsv.parseFrom(clientFirstMessage, 2, 2);
} catch (IllegalArgumentException e) {
throw new ScramParseException("Illegal series of attributes in client-first-message", e);
}
ScramAttributeValue user = ScramAttributeValue.parse(userNonceString[0]);
if (ScramAttributes.USERNAME.getChar() != user.getChar()) {
throw new ScramParseException("user must be the 3rd element of the client-first-message");
}
ScramAttributeValue nonce = ScramAttributeValue.parse(userNonceString[1]);
if (ScramAttributes.NONCE.getChar() != nonce.getChar()) {
throw new ScramParseException("nonce must be the 4th element of the client-first-message");
}
Gs2Header gs2Header = Gs2Header.parseFrom(clientFirstMessage); // Takes first two fields
return new ClientFirstMessage(gs2Header, user.getValue(), nonce.getValue());
}
@Override
StringBuilder writeTo(StringBuilder sb) {
StringWritableCsv.writeTo(
sb,
gs2Header,
null // This marks the position of the rest of the elements, required for the ","
);
return clientFirstMessageBare(sb);
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/CryptoUtil.java 0000664 0000000 0000000 00000017123 15210312475 0031276 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.checkArgument;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import static com.ongres.scram.common.util.Preconditions.gt0;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Locale;
import javax.crypto.Mac;
import javax.crypto.ShortBufferException;
import javax.crypto.spec.SecretKeySpec;
import com.ongres.scram.common.exception.ScramInterruptedException;
import com.ongres.scram.common.exception.ScramRuntimeException;
import org.jetbrains.annotations.NotNull;
/**
* Utility static methods for cryptography related tasks.
*/
final class CryptoUtil {
/**
* The interval at which the PBKDF2 loop checks for thread interruption.
*
*
*
* client-first-message-bare
* [reserved-mext ","] username "," nonce ["," extensions]
*
*
* client-first-message
* gs2-header client-first-message-bare
*
*
*
* @see [RFC5802] Formal Syntax
*/
public final class Gs2Header extends StringWritable {
private final @NotNull Gs2AttributeValue gs2CbindFlag;
private final @Nullable Gs2AttributeValue authzid;
/**
* Construct and validates a Gs2Header. Only provide the channel binding name if the channel
* binding flag is set to required.
*
* @param cbindFlag The channel binding flag
* @param cbName The channel-binding name. Should be not null if channel binding is required
* @param authzid The optional SASL authorization identity
* @throws IllegalArgumentException If the channel binding flag and argument are invalid
*/
public Gs2Header(@NotNull Gs2CbindFlag cbindFlag, @Nullable String cbName,
@Nullable String authzid) {
checkChannelBinding(cbindFlag, cbName);
this.gs2CbindFlag = new Gs2AttributeValue(Gs2Attributes.byGs2CbindFlag(cbindFlag), cbName);
this.authzid = authzid == null ? null
: new Gs2AttributeValue(Gs2Attributes.AUTHZID, ScramStringFormatting.toSaslName(authzid));
}
/**
* Construct and validates a Gs2Header with no authzid. Only provide the channel binding name if
* the channel binding flag is set to required.
*
* @param cbindFlag The channel binding flag
* @param cbName The channel-binding name. Should be not null iif channel binding is required
* @throws IllegalArgumentException If the channel binding flag and argument are invalid
*/
public Gs2Header(@NotNull Gs2CbindFlag cbindFlag, @Nullable String cbName) {
this(cbindFlag, cbName, null);
}
/**
* Construct and validates a Gs2Header with no authzid nor channel binding.
*
* @param cbindFlag The channel binding flag
* @throws IllegalArgumentException If the channel binding is supported (no cbname can be provided
* here)
*/
public Gs2Header(@NotNull Gs2CbindFlag cbindFlag) {
this(cbindFlag, null, null);
}
/**
* Return the channel binding flag.
*
* @return the {@code gs2-cbind-flag}
*/
public @NotNull Gs2CbindFlag getChannelBindingFlag() {
return Gs2CbindFlag.byChar(gs2CbindFlag.getChar());
}
/**
* Return the channel binding type.
*
* @return the {@code cb-name}
*/
public @Nullable String getChannelBindingName() {
return gs2CbindFlag.getValue();
}
/**
* Return the authzid.
*
* @return the {@code "a=" saslname}
*/
public @Nullable String getAuthzid() {
return authzid != null ? castNonNull(authzid).getValue() : null;
}
@Override
StringBuilder writeTo(StringBuilder sb) {
return StringWritableCsv.writeTo(sb, gs2CbindFlag, authzid);
}
/**
* Read a Gs2Header from a String. String may contain trailing fields that will be ignored.
*
* @param message The String containing the Gs2Header
* @return The parsed Gs2Header object
* @throws IllegalArgumentException If the format/values of the String do not conform to a
* Gs2Header
*/
public static @NotNull Gs2Header parseFrom(@NotNull String message) {
checkNotNull(message, "Null message");
@NotNull
String[] gs2HeaderSplit = StringWritableCsv.parseFrom(message, 2);
if (gs2HeaderSplit.length == 0) {
throw new IllegalArgumentException("Invalid number of fields for the GS2 Header");
}
Gs2AttributeValue gs2cbind = Gs2AttributeValue.parse(castNonNull(gs2HeaderSplit[0]));
String authzId = Preconditions.isNullOrEmpty(gs2HeaderSplit[1])
? null
: castNonNull(Gs2AttributeValue.parse(gs2HeaderSplit[1])).getValue();
return new Gs2Header(Gs2CbindFlag.byChar(gs2cbind.getChar()), gs2cbind.getValue(), authzId);
}
private static void checkChannelBinding(@NotNull Gs2CbindFlag cbindFlag,
@Nullable String cbName) {
checkNotNull(cbindFlag, "cbindFlag");
if (cbindFlag == Gs2CbindFlag.CHANNEL_BINDING_REQUIRED ^ cbName != null) {
throw new IllegalArgumentException(
"Specify required channel binding flag and type together, or none");
}
if (cbindFlag == Gs2CbindFlag.CHANNEL_BINDING_REQUIRED) {
validateChannelBindingType(castNonNull(cbName));
}
}
/**
* Checks that the channel binding name is valid.
*
*
* gs2-cbind-flag
* ("p=" cb-name) / "n" / "y"
*
* ;; "n" -> client doesn't support channel binding.
* ;; "y" -> client does support channel binding
* ;; but thinks the server does not.
* ;; "p" -> client requires channel binding.
* ;; The selected channel binding follows "p=".
*
* gs2-header
* gs2-cbind-flag "," [ authzid ] ","
*
* ;; GS2 header for SCRAM
* ;; (the actual GS2 header includes an optional
* ;; flag to indicate that the GSS mechanism is not
* ;; "standard", but since SCRAM is "standard", we
* ;; don't include that flag).
*
* authzid
* "a=" saslname
* {@code
* cb-name = 1*(ALPHA / DIGIT / "." / "-")
* ;; See RFC 5056, Section 7.
* }
*
* @see IANA
* Channel-Binding Types
* @param cbname Channel Binding Name
* @throws IllegalArgumentException If the name is not a valid channel binding type.
*/
private static void validateChannelBindingType(@NotNull String cbname) {
checkNotEmpty(cbname, "cbname");
switch (cbname) {
// IANA Registered Types
case "tls-server-end-point":
case "tls-unique":
case "tls-exporter":
break;
default:
// https://datatracker.ietf.org/doc/html/rfc5056#section-7
for (int i = 0; i < cbname.length(); i++) {
char ch = cbname.charAt(i);
if (!(ch >= 'A' && ch <= 'Z') && !(ch >= 'a' && ch <= 'z')
&& !(ch >= '0' && ch <= '9') && !(ch >= '-' && ch <= '.')) {
throw new IllegalArgumentException(
"Invalid Channel Binding Type name '" + cbname + "'");
}
}
break;
}
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/ScramAttributeValue.java 0000664 0000000 0000000 00000002541 15210312475 0033104 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.castNonNull;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import com.ongres.scram.common.exception.ScramParseException;
import org.jetbrains.annotations.NotNull;
/**
* Parse and write SCRAM Attribute-Value pairs.
*/
class ScramAttributeValue extends AbstractCharAttributeValue
*/
CHANNEL_BINDING('c'),
/**
* This attribute specifies the base64-encoded salt used by the server for this user.
*/
SALT('s'),
/**
* This attribute specifies an iteration count for the selected hash function and user.
*/
ITERATION('i'),
/**
* This attribute specifies a base64-encoded ClientProof.
*/
CLIENT_PROOF('p'),
/**
* This attribute specifies a base64-encoded ServerSignature.
*/
SERVER_SIGNATURE('v'),
/**
* This attribute specifies an error that occurred during authentication exchange. Can help
* diagnose the reason for the authentication exchange failure.
*/
ERROR('e');
private final char attributeChar;
ScramAttributes(char attributeChar) {
this.attributeChar = checkNotNull(attributeChar, "attributeChar");
}
@Override
public char getChar() {
return attributeChar;
}
/**
* Find a SCRAMAttribute by its character.
*
* @param c The character.
* @return The SCRAMAttribute that has that character.
* @throws ScramParseException If no SCRAMAttribute has this character.
*/
public static ScramAttributes byChar(char c) throws ScramParseException {
switch (c) {
case 'n':
return USERNAME;
case 'a':
return AUTHZID;
case 'r':
return NONCE;
case 'c':
return CHANNEL_BINDING;
case 's':
return SALT;
case 'i':
return ITERATION;
case 'p':
return CLIENT_PROOF;
case 'v':
return SERVER_SIGNATURE;
case 'e':
return ERROR;
default:
throw new ScramParseException("Attribute with char '" + c + "' does not exist");
}
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/ScramFunctions.java 0000664 0000000 0000000 00000022004 15210312475 0032110 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static java.nio.charset.StandardCharsets.UTF_8;
import java.security.MessageDigest;
import java.security.SecureRandom;
import com.ongres.scram.common.util.Preconditions;
import org.jetbrains.annotations.NotNull;
/**
* Utility functions (mostly crypto) for SCRAM.
*/
public final class ScramFunctions {
private static final byte @NotNull [] CLIENT_KEY_HMAC_MESSAGE = "Client Key".getBytes(UTF_8);
private static final byte @NotNull [] SERVER_KEY_HMAC_MESSAGE = "Server Key".getBytes(UTF_8);
private ScramFunctions() {
throw new IllegalStateException("Utility class");
}
/**
* Compute the salted password, based on the given SCRAM mechanism, the String preparation
* algorithm, the provided salt and the number of iterations.
*
* {@code
* SaltedPassword := Hi(Normalize(password), salt, i)
* }
*
* @param scramMechanism The SCRAM mechanism
* @param stringPreparation The String preparation
* @param password The non-salted password
* @param salt The bytes representing the salt
* @param iterationCount The number of iterations
* @return The salted password
*/
public static byte @NotNull [] saltedPassword(@NotNull ScramMechanism scramMechanism,
@NotNull StringPreparation stringPreparation, char @NotNull [] password,
byte @NotNull [] salt, int iterationCount) {
return scramMechanism.saltedPassword(stringPreparation, password, salt, iterationCount);
}
/**
* Computes the HMAC of the message and key, using the given SCRAM mechanism.
*
* {@code
* HMAC(key, str)
* }
*
* @param scramMechanism The SCRAM mechanism
* @param message The message to compute the HMAC
* @param key The key used to initialize the MAC
* @return The computed HMAC
*/
public static byte @NotNull [] hmac(@NotNull ScramMechanism scramMechanism, byte @NotNull [] key,
byte @NotNull [] message) {
return scramMechanism.hmac(key, message);
}
/**
* Generates a client key, from the salted password.
*
* {@code
* ClientKey := HMAC(SaltedPassword, "Client Key")
* }
*
* @param scramMechanism The SCRAM mechanism
* @param saltedPassword The salted password
* @return The client key
*/
public static byte[] clientKey(@NotNull ScramMechanism scramMechanism,
byte @NotNull [] saltedPassword) {
return hmac(scramMechanism, saltedPassword, CLIENT_KEY_HMAC_MESSAGE);
}
/**
* Generates a server key, from the salted password.
*
* {@code
* ServerKey := HMAC(SaltedPassword, "Server Key")
* }
*
* @param scramMechanism The SCRAM mechanism
* @param saltedPassword The salted password
* @return The server key
*/
public static byte[] serverKey(@NotNull ScramMechanism scramMechanism,
byte @NotNull [] saltedPassword) {
return hmac(scramMechanism, saltedPassword, SERVER_KEY_HMAC_MESSAGE);
}
/**
* Computes the hash function of a given value, based on the SCRAM mechanism hash function.
*
* {@code
* H(str)
* }
*
* @param scramMechanism The SCRAM mechanism
* @param message The message to hash
* @return The hashed value
*/
public static byte[] hash(@NotNull ScramMechanism scramMechanism, byte @NotNull [] message) {
return scramMechanism.digest(message);
}
/**
* Generates a stored key, from the salted password.
*
* {@code
* StoredKey := H(ClientKey)
* }
*
* @param scramMechanism The SCRAM mechanism
* @param clientKey The client key
* @return The stored key
*/
public static byte[] storedKey(@NotNull ScramMechanism scramMechanism,
byte @NotNull [] clientKey) {
return hash(scramMechanism, clientKey);
}
/**
* Computes the SCRAM client signature.
*
* {@code
* ClientSignature := HMAC(StoredKey, AuthMessage)
* }
*
* @param scramMechanism The SCRAM mechanism
* @param storedKey The stored key
* @param authMessage The auth message
* @return The client signature
*/
public static byte @NotNull [] clientSignature(@NotNull ScramMechanism scramMechanism,
byte @NotNull [] storedKey, @NotNull String authMessage) {
return hmac(scramMechanism, storedKey, authMessage.getBytes(UTF_8));
}
/**
* Computes the SCRAM client proof to be sent to the server on the client-final-message.
*
* {@code
* ClientProof := ClientKey XOR ClientSignature
* }
*
* @param clientKey The client key
* @param clientSignature The client signature
* @return The client proof
*/
public static byte[] clientProof(byte @NotNull [] clientKey, byte @NotNull [] clientSignature) {
return CryptoUtil.xor(clientKey, clientSignature);
}
/**
* Compute the SCRAM server signature.
*
* {@code
* ServerSignature := HMAC(ServerKey, AuthMessage)
* }
*
* @param scramMechanism The SCRAM mechanism
* @param serverKey The server key
* @param authMessage The auth message
* @return The server signature
*/
public static byte @NotNull [] serverSignature(@NotNull ScramMechanism scramMechanism,
byte @NotNull [] serverKey, @NotNull String authMessage) {
return hmac(scramMechanism, serverKey, authMessage.getBytes(UTF_8));
}
/**
* Verifies that a provided client proof is correct.
*
* @param scramMechanism The SCRAM mechanism
* @param clientProof The provided client proof
* @param storedKey The stored key
* @param authMessage The auth message
* @return True if the client proof is correct
*/
public static boolean verifyClientProof(
@NotNull ScramMechanism scramMechanism, byte @NotNull [] clientProof,
byte @NotNull [] storedKey, @NotNull String authMessage) {
byte[] clientSignature = clientSignature(scramMechanism, storedKey, authMessage);
byte[] clientKey = CryptoUtil.xor(clientSignature, clientProof);
byte[] computedStoredKey = hash(scramMechanism, clientKey);
return MessageDigest.isEqual(storedKey, computedStoredKey);
}
/**
* Verifies that a provided server proof is correct.
*
* @param scramMechanism The SCRAM mechanism
* @param serverKey The server key
* @param authMessage The auth message
* @param serverSignature The provided server signature
* @return True if the server signature is correct
*/
public static boolean verifyServerSignature(
ScramMechanism scramMechanism, byte[] serverKey, String authMessage, byte[] serverSignature) {
byte[] computedServerSignature = serverSignature(scramMechanism, serverKey, authMessage);
return MessageDigest.isEqual(serverSignature, computedServerSignature);
}
/**
* Generates a random string (called a 'nonce'), composed of ASCII printable characters, except
* comma (',').
*
* @param nonceSize The length of the nonce, in characters/bytes
* @param random The SecureRandom to use
* @return The String representing the nonce
* @throws IllegalArgumentException if the nonceSize is not positive, or if random is null
*/
public static String nonce(int nonceSize, SecureRandom random) {
Preconditions.gt0(nonceSize, "nonceSize");
Preconditions.checkNotNull(random, "random");
final StringBuilder nonceBuilder = new StringBuilder(nonceSize);
while (nonceBuilder.length() < nonceSize) {
int codePoint = random.nextInt(0x7E - 0x21 + 1) + 0x21;
if (codePoint != ',') {
nonceBuilder.append((char) codePoint);
}
}
return nonceBuilder.toString();
}
/**
* Generates a random salt that can be used to generate a salted password.
*
* @param saltSize The length of the salt, in bytes
* @param random The SecureRandom to use
* @return The bye[] representing the salt
* @throws IllegalArgumentException if the saltSize is not positive, or if random is null
*/
public static byte @NotNull [] salt(int saltSize, @NotNull SecureRandom random) {
return CryptoUtil.salt(saltSize, random);
}
/**
* The AuthMessage is computed by concatenating messages from the authentication exchange.
*
* {@code
* AuthMessage := client-first-message-bare + "," +
* server-first-message + "," +
* client-final-message-without-proof
* }
*
* @param clientFirstMessage the {@link ClientFirstMessage ClientFirstMessage}
* @param serverFirstMessage the {@link ServerFirstMessage ServerFirstMessage}
* @param cbindData the channel binding data, or null
* @return the AuthMessage
*/
public static String authMessage(ClientFirstMessage clientFirstMessage,
ServerFirstMessage serverFirstMessage, byte[] cbindData) {
StringBuilder sb = clientFirstMessage.clientFirstMessageBare(new StringBuilder(96))
.append(',').append(serverFirstMessage).append(',');
ClientFinalMessage.withoutProof(sb, clientFirstMessage.getGs2Header(),
cbindData, serverFirstMessage.getNonce());
return sb.toString();
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/ScramMechanism.java 0000664 0000000 0000000 00000021360 15210312475 0032050 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import com.ongres.scram.common.exception.ScramRuntimeException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.Unmodifiable;
/**
* SCRAM Mechanisms supported by this library. At least, {@code SCRAM-SHA-1} and
* {@code SCRAM-SHA-256} are provided, since both the hash and the HMAC implementations are provided
* by the Java JDK version 8 or greater.
*
*
*
*
* @implNote {@code extensions} are not supported.
* @see [RFC5802] Section 7
*/
public final class ServerFinalMessage extends AbstractScramMessage {
private final byte @Nullable [] verifier;
private final @Nullable String serverError;
/**
* Constructs a server-final-message with no errors, and the provided server verifier.
*
* @param verifier The bytes of the computed signature
* @throws IllegalArgumentException If the verifier is null
*/
public ServerFinalMessage(byte @NotNull [] verifier) {
this.verifier = checkNotNull(verifier, "verifier");
this.serverError = null;
}
/**
* Constructs a server-final-message which represents a SCRAM error.
*
* @param serverError The error message
* @throws IllegalArgumentException If the error is null
*/
public ServerFinalMessage(@NotNull String serverError) {
this.serverError = validateServerErrorType(serverError);
this.verifier = null;
}
/**
* Whether this server-final-message contains an error.
*
* @return True if it contains an error, false if it contains a verifier
*/
public boolean isError() {
return null != serverError;
}
/**
* Get the verifier value from the "v=" server-final-message.
*
* @return the {@code verifier}
*/
public byte @Nullable [] getVerifier() {
return verifier != null ? checkNotNull(verifier, "verifier").clone() : null;
}
/**
* Get the server-error-value from the "e=" server-final-message.
*
* @return the {@code server-error-value}
*/
public @Nullable String getServerError() {
return serverError;
}
/**
* Parses a server-final-message from a String.
*
* @param serverFinalMessage The message
* @return A constructed server-final-message instance
* @throws ScramParseException If the argument is not a valid server-final-message
* @throws IllegalArgumentException If the message is null or empty
*/
public static @NotNull ServerFinalMessage parseFrom(@NotNull String serverFinalMessage)
throws ScramParseException {
checkNotEmpty(serverFinalMessage, "serverFinalMessage");
@NotNull
String @NotNull [] attributeValues = StringWritableCsv.parseFrom(serverFinalMessage, 1, 0);
if (attributeValues.length != 1) {
throw new ScramParseException("Invalid server-final-message");
}
ScramAttributeValue attributeValue = ScramAttributeValue.parse(attributeValues[0]);
if (ScramAttributes.SERVER_SIGNATURE.getChar() == attributeValue.getChar()) {
byte[] verifier = ScramStringFormatting.base64Decode(attributeValue.getValue());
return new ServerFinalMessage(verifier);
} else if (ScramAttributes.ERROR.getChar() == attributeValue.getChar()) {
return new ServerFinalMessage(attributeValue.getValue());
} else {
throw new ScramParseException(
"Invalid server-final-message: it must contain either a verifier or an error attribute");
}
}
@Override
StringBuilder writeTo(StringBuilder sb) {
return StringWritableCsv.writeTo(
sb,
isError()
? new ScramAttributeValue(ScramAttributes.ERROR, castNonNull(serverError))
: new ScramAttributeValue(ScramAttributes.SERVER_SIGNATURE,
ScramStringFormatting.base64Encode(castNonNull(verifier))));
}
private static String validateServerErrorType(@NotNull String serverError) {
checkNotNull(serverError, "serverError");
if (ServerErrorValue.getErrorMessage(serverError) == null) {
throw new IllegalArgumentException(
"Invalid server-error-value '" + serverError + "'");
}
return serverError;
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/ServerFirstMessage.java 0000664 0000000 0000000 00000013432 15210312475 0032742 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.castNonNull;
import static com.ongres.scram.common.util.Preconditions.checkNotEmpty;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import static com.ongres.scram.common.util.Preconditions.gt0;
import com.ongres.scram.common.exception.ScramParseException;
import org.jetbrains.annotations.NotNull;
/**
* Constructs and parses {@code server-first-messages}.
*
*
*
* server-error
* "e=" server-error-value
*
*
* server-error-value
* "invalid-encoding" /
*
* "extensions-not-supported" / ; unrecognized 'm' value
* "invalid-proof" /
* "channel-bindings-dont-match" /
* "server-does-support-channel-binding" /
* ; server does not support channel binding
* "channel-binding-not-supported" /
* "unsupported-channel-binding-type" /
* "unknown-user" /
* "invalid-username-encoding" /
* ; invalid username encoding (invalid UTF-8 or
* ; SASLprep failed)
* "no-resources" /
* "other-error"
* ; Unrecognized errors should be treated as "other-error".
* ; In order to prevent information disclosure, the server
* ; may substitute the real reason with "other-error".
*
* verifier
* "v=" base64
*
* ;; base-64 encoded ServerSignature.
*
* server-final-message
* (server-error / verifier)
*
* ["," extensions]
*
*
* @implNote {@code extensions} are not supported.
* @see [RFC5802] Section 7
*/
public final class ServerFirstMessage extends AbstractScramMessage {
private final @NotNull String clientNonce;
private final @NotNull String serverNonce;
private final @NotNull String salt;
private final int iterationCount;
/**
* Constructs a server-first-message from a client-first-message and the additional required data.
*
*
*
* nonce
* "r=" c-nonce [s-nonce]
*
* ;; Second part provided by server.
*
* salt
* "s=" base64
*
*
* server-first-message
* [reserved-mext ","] nonce "," salt ",
*
* "iteration-count ["," extensions]
*
*
* @param clientNonce The c-nonce used in client-first-message
* @param serverNonce The s-nonce returned by the server
* @param salt The salt
* @param iterationCount The iteration count (must be positive)
* @throws IllegalArgumentException If clientFirstMessage, serverNonce or salt are null or empty,
* or iteration < 1
*/
public ServerFirstMessage(@NotNull String clientNonce, @NotNull String serverNonce,
@NotNull String salt, int iterationCount) {
this.clientNonce = checkNotEmpty(clientNonce, "clientNonce");
this.serverNonce = checkNotEmpty(serverNonce, "serverNonce");
this.salt = checkNotNull(salt, "salt");
this.iterationCount = gt0(iterationCount, "iterationCount");
}
/**
* The client nonce.
*
* @return The client nonce
*/
public @NotNull String getClientNonce() {
return clientNonce;
}
/**
* The server nonce.
*
* @return The server nonce
*/
public @NotNull String getServerNonce() {
return serverNonce;
}
/**
* The concatenation of the client nonce and the server nonce: {@code c-nonce [s-nonce]}.
*
* @return The nonce
*/
public @NotNull String getNonce() {
return clientNonce + serverNonce;
}
/**
* The salt in base64.
*
* @return The salt in base64.
*/
public String getSalt() {
return salt;
}
/**
* The number of iterations.
*
* @return The number of iterations.
*/
public int getIterationCount() {
return iterationCount;
}
/**
* Parses a server-first-message from a String.
*
* @param serverFirstMessage The string representing the server-first-message
* @param clientNonce The clientNonce that is present in the client-first-message
* @return The parsed instance
* @throws ScramParseException If the argument is not a valid server-first-message
* @throws IllegalArgumentException If either argument is empty or serverFirstMessage is not a
* valid message
*/
public static @NotNull ServerFirstMessage parseFrom(@NotNull String serverFirstMessage,
@NotNull String clientNonce) throws ScramParseException {
checkNotEmpty(serverFirstMessage, "serverFirstMessage");
checkNotEmpty(clientNonce, "clientNonce");
String[] attributeValues = StringWritableCsv.parseFrom(serverFirstMessage, 3, 0);
if (attributeValues.length != 3) {
throw new ScramParseException("Invalid server-first-message");
}
ScramAttributeValue nonce = ScramAttributeValue.parse(castNonNull(attributeValues[0]));
if (ScramAttributes.NONCE.getChar() != nonce.getChar()) {
throw new ScramParseException(
"nonce must be the 1st element of the server-first-message");
}
if (!nonce.getValue().startsWith(clientNonce)) {
throw new ScramParseException("parsed nonce does not start with client nonce");
}
ScramAttributeValue salt = ScramAttributeValue.parse(castNonNull(attributeValues[1]));
if (ScramAttributes.SALT.getChar() != salt.getChar()) {
throw new ScramParseException("salt must be the 2nd element of the server-first-message");
}
ScramAttributeValue iteration = ScramAttributeValue.parse(castNonNull(attributeValues[2]));
if (ScramAttributes.ITERATION.getChar() != iteration.getChar()) {
throw new ScramParseException(
"iteration must be the 3rd element of the server-first-message");
}
int iterationInt;
try {
iterationInt = Integer.parseInt(iteration.getValue());
} catch (NumberFormatException ex) {
throw new ScramParseException("invalid iteration", ex);
}
return new ServerFirstMessage(clientNonce, nonce.getValue().substring(clientNonce.length()),
salt.getValue(), iterationInt);
}
@Override
StringBuilder writeTo(StringBuilder sb) {
return StringWritableCsv.writeTo(
sb,
new ScramAttributeValue(ScramAttributes.NONCE, getNonce()),
new ScramAttributeValue(ScramAttributes.SALT, salt),
new ScramAttributeValue(ScramAttributes.ITERATION, Integer.toString(iterationCount)));
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/StringPreparation.java 0000664 0000000 0000000 00000006051 15210312475 0032631 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
/**
* StringPreparations enumerations to use in SCRAM.
*/
public enum StringPreparation {
/**
* Implementation of StringPreparation that performs no preparation. Non US-ASCII characters will
* produce an exception.
*
*
*
* server-error
* "e=" server-error-value
*
*
* verifier
* "v=" base64
*
* ;; base-64 encoded ServerSignature.
*
* server-final-message
* (server-error / verifier)
*
* ["," extensions]The SCRAM specification dictates that the password is also in UTF-8, and is
* processed with the {@code SASLprep} algorithm. PostgreSQL, however, does not require UTF-8 to
* be used for the password. When a user's password is set, it is processed with SASLprep as if it
* was in UTF-8, regardless of the actual encoding used. However, if it is not a legal UTF-8 byte
* sequence, or it contains UTF-8 byte sequences that are prohibited by the SASLprep algorithm,
* the raw password will be used without SASLprep processing, instead of throwing an error. This
* allows the password to be normalized when it is in UTF-8, but still allows a non-UTF-8 password
* to be used, and doesn't require the system to know which encoding the password is
* in.
*
* @see PostgreSQL
* SCRAM-SHA-256 Authentication
*/
POSTGRESQL_PREPARATION {
@Override
char[] doNormalize(char[] value) {
try {
return ScramStringFormatting.SASL_PREP.prepareStored(value);
} catch (IllegalArgumentException ex) {
// the raw password will be used without SASLprep processing
return value;
}
}
};
abstract char[] doNormalize(char[] value);
/**
* Normalize acording the selected preparation.
*
* @param value array of chars to normalize
* @return the normalized array of chars
* @throws IllegalArgumentException if the string is null or empty
*/
public char[] normalize(char[] value) {
if (null == value || value.length == 0) {
throw new IllegalArgumentException("Empty string for value");
}
char[] normalized = doNormalize(value);
if (null == normalized || normalized.length == 0) {
throw new IllegalArgumentException("null or empty value after normalization");
}
return normalized;
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/StringWritable.java 0000664 0000000 0000000 00000000763 15210312475 0032122 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import org.jetbrains.annotations.NotNull;
/**
* Abstract class to denote classes which can write to a StringBuffer.
*/
abstract class StringWritable {
/**
* Write the class information to the given StringBuffer.
*
* @param sb Where to write the data.
* @return The same StringBuffer.
*/
abstract @NotNull StringBuilder writeTo(@NotNull StringBuilder sb);
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/StringWritableCsv.java 0000664 0000000 0000000 00000007524 15210312475 0032600 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import java.util.Arrays;
import com.ongres.scram.common.util.Preconditions;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* Helper class to generate Comma Separated Values of StringWritables.
*/
final class StringWritableCsv {
private StringWritableCsv() {
throw new IllegalStateException("Utility class");
}
/**
* Write a sequence of StringWritableCsv to a StringBuffer. Null StringWritables are not printed,
* but separator is still used. Separator is a comma (',')
*
* @param sb The sb to write to
* @param values Zero or more attribute-value pairs to write
* @return The same sb, with data filled in (if any)
* @throws IllegalArgumentException If sb is null
*/
static @NotNull StringBuilder writeTo(@NotNull StringBuilder sb,
@Nullable StringWritable... values) {
checkNotNull(sb, "sb");
if (null == values || values.length == 0) {
return sb;
}
if (null != values[0]) {
Preconditions.castNonNull(values[0]).writeTo(sb);
}
int i = 1;
while (i < values.length) {
sb.append(',');
if (null != values[i]) {
Preconditions.castNonNull(values[i]).writeTo(sb);
}
i++;
}
return sb;
}
/**
* Parse a String with a StringWritableCsv into its composing Strings represented as Strings. No
* validation is performed on the individual attribute-values returned.
*
* @param value The String with the set of attribute-values
* @param n Number of entries to return (entries will be null of there were not enough). 0 means
* unlimited
* @param offset How many entries to skip before start returning
* @return An array of Strings which represent the individual attribute-values
* @throws IllegalArgumentException If value is null or either n or offset are negative
*/
static @NotNull String @NotNull [] parseFrom(@NotNull String value, int n, int offset) {
checkNotNull(value, "value");
if (n < 0 || offset < 0) {
throw new IllegalArgumentException("Limit and offset have to be >= 0");
}
if (value.isEmpty()) {
return new String[0];
}
String[] split = value.split(",", -1);
if (split.length < offset) {
throw new IllegalArgumentException("Not enough items for the given offset");
}
return Arrays.copyOfRange(
split,
offset,
(n == 0 ? split.length : n) + offset);
}
/**
* Parse a String with a StringWritableCsv into its composing Strings represented as Strings. No
* validation is performed on the individual attribute-values returned. Elements are returned
* starting from the first available attribute-value.
*
* @param value The String with the set of attribute-values
* @param n Number of entries to return (entries will be null of there were not enough). 0 means
* unlimited
* @return An array of Strings which represent the individual attribute-values
* @throws IllegalArgumentException If value is null or n is negative
*/
static @NotNull String @NotNull [] parseFrom(@NotNull String value, int n) {
return parseFrom(value, n, 0);
}
/**
* Parse a String with a StringWritableCsv into its composing Strings represented as Strings. No
* validation is performed on the individual attribute-values returned. All the available
* attribute-values will be returned.
*
* @param value The String with the set of attribute-values
* @return An array of Strings which represent the individual attribute-values
* @throws IllegalArgumentException If value is null
*/
static @NotNull String @NotNull [] parseFrom(@NotNull String value) {
return parseFrom(value, 0, 0);
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/UsAsciiUtils.java 0000664 0000000 0000000 00000003340 15210312475 0031535 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common;
import static com.ongres.scram.common.util.Preconditions.checkNotNull;
import java.nio.CharBuffer;
/**
* Utility to remove non-printable characters from the US-ASCII String.
*/
final class UsAsciiUtils {
private UsAsciiUtils() {
throw new IllegalStateException("Utility class");
}
/**
* Removes non-printable characters from the US-ASCII String.
*
* @param value The original String
* @return The possibly modified String, without non-printable US-ASCII characters.
* @throws IllegalArgumentException If the String is null or contains non US-ASCII characters.
*/
static char[] toPrintable(final char[] value) {
checkNotNull(value, "value");
CharBuffer charBuffer = CharBuffer.allocate(value.length);
for (char ch : value) {
if (ch >= 127) {
throw new IllegalArgumentException(
"value contains character '" + ch + "' which is non US-ASCII");
} else if (ch >= 32) {
charBuffer.put(ch);
}
}
// Flip the buffer to prepare for reading
charBuffer.flip();
char[] charArray = new char[charBuffer.remaining()];
charBuffer.get(charArray);
return charArray;
}
/**
* Removes non-printable characters from the US-ASCII String.
*
* @param value The original String
* @return The possibly modified String, without non-printable US-ASCII characters.
* @throws IllegalArgumentException If the String is null or contains non US-ASCII characters.
*/
static String toPrintable(final String value) {
char[] charArray = checkNotNull(value, "value").toCharArray();
return new String(toPrintable(charArray));
}
}
ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/exception/ 0000775 0000000 0000000 00000000000 15210312475 0030307 5 ustar 00root root 0000000 0000000 ScramException.java 0000664 0000000 0000000 00000001505 15210312475 0034020 0 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/exception /*
* Copyright (c) 2017 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common.exception;
/**
* This class represents an generic error when using SCRAM, which is a SASL method.
*/
public class ScramException extends Exception {
private static final long serialVersionUID = 1L;
/**
* Constructs a new instance of ScramException with a detailed message.
*
* @param detail A String containing details about the exception
*/
public ScramException(String detail) {
super(detail);
}
/**
* Constructs a new instance of ScramException with a detailed message and a root cause.
*
* @param detail A String containing details about the exception
* @param ex The root exception
*/
public ScramException(String detail, Throwable ex) {
super(detail, ex);
}
}
ScramInterruptedException.java 0000664 0000000 0000000 00000002623 15210312475 0036250 0 ustar 00root root 0000000 0000000 ongres-scram-f6bd6e2/scram-common/src/main/java/com/ongres/scram/common/exception /*
* Copyright (c) 2026 OnGres, Inc.
* SPDX-License-Identifier: BSD-2-Clause
*/
package com.ongres.scram.common.exception;
/**
* Thrown when a SCRAM authentication process is interrupted, typically during
* CPU-intensive PBKDF2 computation.
*
*