Skip to content
Merged
2 changes: 1 addition & 1 deletion benchmarks/pom.xml
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@
<parent>
<groupId>io.hstore</groupId>
<artifactId>hstore-parent</artifactId>
<version>0.1.0</version>
<version>0.2.0</version>
</parent>

<artifactId>hstore-benchmarks</artifactId>
Expand Down
2 changes: 1 addition & 1 deletion benchmarks/src/main/java/io/hstore/bench/HStoreStore.java
Original file line number Diff line number Diff line change
Expand Up @@ -67,7 +67,7 @@ public String name() {

@Override
public String version() {
return "0.1.0";
return "0.2.0";
}

@Override
Expand Down
2 changes: 1 addition & 1 deletion database/pom.xml
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@
<parent>
<groupId>io.hstore</groupId>
<artifactId>hstore-parent</artifactId>
<version>0.1.0</version>
<version>0.2.0</version>
</parent>

<artifactId>hstore-db</artifactId>
Expand Down
76 changes: 75 additions & 1 deletion database/src/main/java/io/hstore/db/HypergraphDatabase.java
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@
import io.hstore.db.security.Principal;
import io.hstore.db.security.Quota.Usage;
import io.hstore.db.security.Security;
import io.hstore.db.security.Scram;
import io.hstore.db.security.SignIns;
import io.hstore.db.semantic.Embedding;
import io.hstore.db.semantic.SemanticPlane;
Expand All @@ -31,14 +32,22 @@
import java.nio.file.Path;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Stream;

public final class HypergraphDatabase implements AutoCloseable {

private static final System.Logger LOG = System.getLogger("hstore.security");
private static final long LEGACY_WARNING_INTERVAL_NANOS = Duration.ofMinutes(10).toNanos();
public static final String LEGACY_PASSWORD = "user \"{0}\" has a password stored by HStore 0.1, which cannot be used with SCRAM-SHA-256; "
+ "it can sign in once through Studio to convert it, or an administrator can set a new one with ALTER USER";

private static final int MAX_ATTEMPTS = 8;

private final DatabaseOptions options;
Expand All @@ -49,6 +58,8 @@ public final class HypergraphDatabase implements AutoCloseable {
private final Statistics statistics;
private final MaterializedViews views;
private final SignIns signIns = new SignIns();
private final byte[] scramSecret;
private final Map<String, Long> legacyWarnings = new ConcurrentHashMap<>();

private HypergraphDatabase(Path directory, DatabaseOptions options) {
this.options = options;
Expand All @@ -62,6 +73,52 @@ private HypergraphDatabase(Path directory, DatabaseOptions options) {
engine.onCheckpoint(semantic::persist);
this.statistics = new Statistics(engine);
this.views = new MaterializedViews(this);
this.scramSecret = prepareSignIns();
}

private byte[] prepareSignIns() {
if (read(reader -> Security.scramSecret(reader.view())).isEmpty()) {
write(writer -> {
if (Security.scramSecret(writer.transaction()).isEmpty()) {
Security.createScramSecret(writer.transaction());
}
return null;
});
}
return read(reader -> Security.scramSecret(reader.view())).orElseThrow();
}

public Scram.Server scram(Optional<byte[]> channelBinding) {
return scram(channelBinding, _ -> { });
}

public Scram.Server scram(Optional<byte[]> channelBinding, Consumer<Security.User> used) {
return new Scram.Server(name -> read(reader -> Security.user(reader.view(), name)).flatMap(user -> {
if (Security.legacy(user)) {
warnLegacy(user.name());
return Optional.empty();
}
Optional<Scram.Verifier> verifier = Security.verifier(user);
verifier.ifPresent(_ -> used.accept(user));
return verifier;
}), scramSecret, Security.ITERATIONS, channelBinding);
}

private void warnLegacy(String user) {
long now = System.nanoTime();
Long last = legacyWarnings.get(user);
if (last == null || now - last > LEGACY_WARNING_INTERVAL_NANOS) {
legacyWarnings.put(user, now);
LOG.log(System.Logger.Level.WARNING, LEGACY_PASSWORD, user);
}
}

public List<String> usersWithOldPasswords() {
return read(reader -> Security.legacyUsers(reader.view()));
}

public SignIns signIns() {
return signIns;
}

public static List<Slot<?>> extensionSlots() {
Expand Down Expand Up @@ -170,7 +227,24 @@ public Optional<Principal> authenticate(String user, String password) {
}

public Optional<Principal> authenticate(String user, String password, Optional<String> origin) {
return signIns.attempt(user, origin, () -> read(reader -> Security.authenticate(reader.view(), user, password)));
return signIn(user, password, origin).map(Security::principal);
}

public Optional<Security.User> signIn(String user, String password, Optional<String> origin) {
return signIns.attempt(user, origin, () -> read(reader -> Security.signIn(reader.view(), user, password)))
.map(found -> Security.legacy(found) ? convert(found, password) : found);
}

private Security.User convert(Security.User legacy, String password) {
try {
Security.User converted = write(writer -> Security.replaceLegacy(writer.transaction(), legacy, password));
LOG.log(System.Logger.Level.INFO, "the password of user \"{0}\" is now stored as a SCRAM-SHA-256 verifier", legacy.name());
return converted;
} catch (HStoreException changed) {
LOG.log(System.Logger.Level.INFO, "the password of user \"{0}\" changed while it was being converted: {1}", legacy.name(),
changed.getMessage());
return legacy;
}
}

void chargePayload(int tenant, long bytes) {
Expand Down
19 changes: 17 additions & 2 deletions database/src/main/java/io/hstore/db/query/Parser.java
Original file line number Diff line number Diff line change
Expand Up @@ -89,6 +89,21 @@ public static Statement parse(String source) {
return statements.getFirst();
}

public static boolean mentionsAuthenticate(String source) {
try {
return Lexer.tokenize(source).stream().anyMatch(token -> token.is("AUTHENTICATE"));
} catch (HStoreException unlexable) {
return source.toUpperCase(Locale.ROOT).matches("(?s).*\\bAUTHENTICATE\\b.*");
}
}

private static Statement historical(Statement inner) {
if (inner instanceof Statement.Authenticate) {
throw HStoreException.invalid("AUTHENTICATE cannot run at a past generation");
}
return inner;
}

private Statement statement() {
if (accept("BEGIN")) {
return new Statement.Begin(accept("SERIALIZABLE"));
Expand All @@ -111,11 +126,11 @@ private Statement statement() {
}
if (accept("AT")) {
expect("GENERATION");
return new Statement.At(longValue(), statement());
return new Statement.At(longValue(), historical(statement()));
}
if (peek().is("AS") && peek(1).is("OF")) {
index += 2;
return new Statement.AsOf(instant(), statement());
return new Statement.AsOf(instant(), historical(statement()));
}
if (accept("CREATE")) {
return create();
Expand Down
83 changes: 75 additions & 8 deletions database/src/main/java/io/hstore/db/query/Session.java
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,9 @@
import io.hstore.db.Writer;
import io.hstore.db.query.Ast.Statement;
import io.hstore.db.security.Principal;
import io.hstore.db.security.Scram;
import io.hstore.db.security.Security;
import io.hstore.db.security.SignIns;
import io.hstore.engine.HStoreException;
import io.hstore.engine.catalog.Branch;
import io.hstore.engine.txn.Isolation;
Expand All @@ -22,6 +24,7 @@
import java.util.Map;
import java.util.Optional;
import java.util.OptionalLong;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;

public final class Session implements AutoCloseable {
Expand All @@ -38,6 +41,12 @@ public final class Session implements AutoCloseable {
private boolean renewing;
private Optional<String> origin = Optional.empty();
private int failedAuthentications;
private Optional<ScramAttempt> scram = Optional.empty();
private Optional<String> scramUser = Optional.empty();
private Optional<String> clearTextRefusal = Optional.empty();

private record ScramAttempt(Scram.Server server, SignIns.Reservation reservation, Optional<Security.User> user) {
}
private Format format = Format.TABLE;

public enum Format { TABLE, JSON }
Expand Down Expand Up @@ -70,24 +79,77 @@ public String render(QueryResult result) {
}

public boolean authenticate(String user, String password) {
requireCanAuthenticate();
Optional<Security.User> found = database.signIn(user, password, origin);
if (found.isEmpty()) {
failedAuthentications++;
return false;
}
signIn(found.get());
return true;
}

public String scramFirst(String mechanism, String clientFirst, Optional<byte[]> channelBinding) {
requireCanAuthenticate();
scram.ifPresent(pending -> pending.reservation().failed());
scram = Optional.empty();
AtomicReference<Security.User> used = new AtomicReference<>();
Scram.Server server = database.scram(channelBinding, used::set);
String serverFirst = server.first(mechanism, clientFirst);
scramUser = Optional.of(server.user());
SignIns.Reservation reservation = database.signIns().reserve(server.user(), origin);
scram = Optional.of(new ScramAttempt(server, reservation, Optional.ofNullable(used.get())));
return serverFirst;
}

public Optional<String> scramFinal(String clientFinal) {
ScramAttempt attempt = scram.orElseThrow(() -> HStoreException.invalid("malformed SCRAM message: no exchange in progress"));
scram = Optional.empty();
Scram.Outcome outcome;
try {
outcome = attempt.server().last(clientFinal);
} catch (RuntimeException malformed) {
attempt.reservation().failed();
failedAuthentications++;
throw malformed;
}
Optional<Security.User> found = outcome instanceof Scram.Outcome.Accepted(String user, String _)
? database.read(reader -> Security.user(reader.view(), user)).filter(current -> attempt.user().equals(Optional.of(current)))
: Optional.empty();
if (found.isEmpty()) {
attempt.reservation().failed();
failedAuthentications++;
return Optional.empty();
}
attempt.reservation().succeeded();
signIn(found.get());
return Optional.of(((Scram.Outcome.Accepted) outcome).serverFinal());
}

public Optional<String> scramUser() {
return scramUser;
}

public void refuseClearTextPasswords(String reason) {
clearTextRefusal = Optional.of(reason);
}

private void requireCanAuthenticate() {
if (transaction.isPresent()) {
throw HStoreException.invalid("cannot authenticate inside a transaction");
}
if (failedAuthentications >= MAX_FAILED_AUTHENTICATIONS) {
throw HStoreException.invalid("too many failed authentication attempts in this session");
}
Optional<Principal> found = database.authenticate(user, password, origin);
if (found.isEmpty()) {
failedAuthentications++;
return false;
}
principal = found.get();
}

private void signIn(Security.User found) {
principal = Security.principal(found);
authenticated = true;
credentials = database.read(reader -> Security.user(reader.view(), user));
credentials = Optional.of(found);
renewing = false;
variables.clear();
branch = Branch.MAIN;
return true;
}

public boolean authenticated() {
Expand Down Expand Up @@ -164,6 +226,9 @@ private QueryResult dispatch(Statement statement) {
yield QueryResult.message("using tenant " + tenant.name());
}
case Statement.Authenticate(String user, String password) -> {
if (clearTextRefusal.isPresent()) {
throw HStoreException.invalid(clearTextRefusal.get());
}
if (!authenticate(user, password)) {
throw HStoreException.invalid("authentication failed for user " + user);
}
Expand Down Expand Up @@ -289,5 +354,7 @@ public boolean inTransaction() {
public void close() {
transaction.ifPresent(Transaction::abort);
transaction = Optional.empty();
scram.ifPresent(pending -> pending.reservation().failed());
scram = Optional.empty();
}
}
Loading
Loading