package io.vertx.ext.auth.jdbc.impl;
import java.util.Objects;
import io.vertx.core.AsyncResult;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.core.Vertx;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.auth.AuthProvider;
import io.vertx.ext.auth.User;
import io.vertx.ext.auth.authentication.CredentialValidationException;
import io.vertx.ext.auth.authentication.Credentials;
import io.vertx.ext.auth.authentication.UsernamePasswordCredentials;
import io.vertx.ext.auth.jdbc.JDBCAuth;
import io.vertx.ext.auth.jdbc.JDBCAuthentication;
import io.vertx.ext.auth.jdbc.JDBCAuthenticationOptions;
import io.vertx.ext.auth.jdbc.JDBCAuthorization;
import io.vertx.ext.auth.jdbc.JDBCAuthorizationOptions;
import io.vertx.ext.auth.jdbc.JDBCHashStrategy;
import io.vertx.ext.jdbc.JDBCClient;
public class JDBCAuthImpl implements AuthProvider, JDBCAuth {
private JDBCClient client;
private JDBCAuthentication authenticationProvider;
private JDBCAuthenticationOptions authenticationOptions;
private JDBCAuthorization authorizationProvider;
private JDBCAuthorizationOptions authorizationOptions;
private JDBCHashStrategy hashStrategy;
public JDBCAuthImpl(Vertx vertx, JDBCClient client) {
this.client = client;
this.hashStrategy = JDBCHashStrategy.createSHA512(vertx);
this.authenticationOptions = new JDBCAuthenticationOptions();
this.authorizationOptions = new JDBCAuthorizationOptions();
this.authenticationProvider = JDBCAuthentication.create(client, hashStrategy, authenticationOptions);
this.authorizationProvider = JDBCAuthorization.create("jdbc-auth", client, authorizationOptions);
}
@Override
public void authenticate(JsonObject authInfo, Handler<AsyncResult<User>> resultHandler) {
authenticate(new UsernamePasswordCredentials(authInfo), resultHandler);
}
@Override
public void authenticate(Credentials credentials, Handler<AsyncResult<User>> resultHandler) {
try {
UsernamePasswordCredentials authInfo = (UsernamePasswordCredentials) credentials;
authInfo.checkValid(null);
authenticationProvider.authenticate(credentials, authenticationResult -> {
if (authenticationResult.failed()) {
resultHandler.handle(Future.failedFuture(authenticationResult.cause()));
} else {
User user = authenticationResult.result();
authorizationProvider.getAuthorizations(user, userAuthorizationResult -> {
if (userAuthorizationResult.failed()) {
resultHandler.handle(Future.failedFuture(userAuthorizationResult.cause()));
}
else {
resultHandler.handle(Future.succeededFuture(user));
}
});
}
});
} catch (ClassCastException | CredentialValidationException e) {
resultHandler.handle(Future.failedFuture(e));
}
}
@Override
public JDBCAuth setAuthenticationQuery(String authenticationQuery) {
this.authenticationOptions.setAuthenticationQuery(authenticationQuery);
return this;
}
@Override
public JDBCAuth setRolesQuery(String rolesQuery) {
this.authorizationOptions.setRolesQuery(rolesQuery);
return this;
}
@Override
public JDBCAuth setPermissionsQuery(String permissionsQuery) {
this.authorizationOptions.setPermissionsQuery(permissionsQuery);
return this;
}
@Override
public JDBCAuth setRolePrefix(String rolePrefix) {
return this;
}
@Override
public JDBCAuth setHashStrategy(JDBCHashStrategy strategy) {
this.hashStrategy = Objects.requireNonNull(strategy);
this.authenticationProvider = JDBCAuthentication.create(client, strategy, authenticationOptions);
return this;
}
@Override
public String computeHash(String password, String salt, int version) {
return hashStrategy.computeHash(password, salt, version);
}
@Override
public String generateSalt() {
return hashStrategy.generateSalt();
}
@Override
public JDBCAuth setNonces(JsonArray nonces) {
hashStrategy.setNonces(nonces);
return this;
}
String getRolesQuery() {
return authorizationOptions.getRolesQuery();
}
String getPermissionsQuery() {
return authorizationOptions.getPermissionsQuery();
}
}