You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by rc...@apache.org on 2023/07/28 03:26:08 UTC

[james-project] 01/07: JAMES-3930 ReadOnlyUsersLDAPRepository::test should allow authentication using localPart as login username

This is an automated email from the ASF dual-hosted git repository.

rcordier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git

commit 7c7eb07abd9284579bcca9f373a3206cce2d1137
Author: Quan Tran <hq...@linagora.com>
AuthorDate: Thu Jul 20 17:18:52 2023 +0700

    JAMES-3930 ReadOnlyUsersLDAPRepository::test should allow authentication using localPart as login username
---
 .../org/apache/james/mailbox/Authenticator.java    |  8 +--
 .../mailbox/spring/AnonymousAuthenticator.java     |  6 ++-
 .../james/mailbox/store/FakeAuthenticator.java     |  9 ++--
 .../james/mailbox/store/SessionProviderImpl.java   | 30 ++++++------
 .../core/PlainAuthenticationProcessor.java         |  2 +-
 .../mailbox/UserRepositoryAuthenticator.java       |  4 +-
 .../mailbox/UserRepositoryAuthenticatorTest.java   | 14 +++---
 .../org/apache/james/user/api/DelegationStore.java |  2 +-
 .../org/apache/james/user/api/UsersRepository.java |  9 ++--
 .../java/org/apache/james/user/api/model/User.java |  6 +--
 .../org/apache/james/user/jpa/model/JPAUser.java   |  1 +
 .../user/ldap/LdapRepositoryConfiguration.java     | 28 ++++++++++-
 .../apache/james/user/ldap/ReadOnlyLDAPUser.java   |  2 +-
 .../james/user/ldap/ReadOnlyLDAPUsersDAO.java      | 19 +++++---
 .../user/ldap/ReadOnlyUsersLDAPRepositoryTest.java | 18 +++----
 .../apache/james/user/lib/UsersRepositoryImpl.java | 28 +++++------
 .../james/user/lib/UsersRepositoryContract.java    | 57 ++++++++++------------
 .../user/memory/UsersRepositoryManagementTest.java | 10 ++--
 .../james/jmap/http/AuthenticationRoutes.java      | 16 +++---
 .../jmap/http/BasicAuthenticationStrategy.scala    | 11 +++--
 .../mailbox/DistributedPop3ServerTest.java         |  4 +-
 .../apache/james/pop3server/POP3ServerTest.java    |  3 +-
 .../james/smtpserver/UsersRepositoryAuthHook.java  |  5 +-
 .../apache/james/webadmin/service/UserService.java |  3 +-
 24 files changed, 166 insertions(+), 129 deletions(-)

diff --git a/mailbox/api/src/main/java/org/apache/james/mailbox/Authenticator.java b/mailbox/api/src/main/java/org/apache/james/mailbox/Authenticator.java
index e9173c3d72..590157f3cd 100644
--- a/mailbox/api/src/main/java/org/apache/james/mailbox/Authenticator.java
+++ b/mailbox/api/src/main/java/org/apache/james/mailbox/Authenticator.java
@@ -19,6 +19,8 @@
 
 package org.apache.james.mailbox;
 
+import java.util.Optional;
+
 import org.apache.james.core.Username;
 import org.apache.james.mailbox.exception.MailboxException;
 
@@ -32,8 +34,8 @@ public interface Authenticator {
      * 
      * @param userid not null
      * @param passwd not null
-     * @return true when the user is authentic,
-     * false otherwise
+     * @return Optional of Username when the user is authentic,
+     * empty Optional otherwise
      */
-    boolean isAuthentic(Username userid, CharSequence passwd) throws MailboxException;
+    Optional<Username> isAuthentic(Username userid, CharSequence passwd) throws MailboxException;
 }
diff --git a/mailbox/spring/src/main/java/org/apache/james/mailbox/spring/AnonymousAuthenticator.java b/mailbox/spring/src/main/java/org/apache/james/mailbox/spring/AnonymousAuthenticator.java
index 2daf54d94c..4941fc55e7 100644
--- a/mailbox/spring/src/main/java/org/apache/james/mailbox/spring/AnonymousAuthenticator.java
+++ b/mailbox/spring/src/main/java/org/apache/james/mailbox/spring/AnonymousAuthenticator.java
@@ -18,14 +18,16 @@
  ****************************************************************/
 package org.apache.james.mailbox.spring;
 
+import java.util.Optional;
+
 import org.apache.james.core.Username;
 import org.apache.james.mailbox.Authenticator;
 
 public class AnonymousAuthenticator implements Authenticator {
 
     @Override
-    public boolean isAuthentic(Username userid, CharSequence passwd) {
-        return true;
+    public Optional<Username> isAuthentic(Username userid, CharSequence passwd) {
+        return Optional.of(userid);
     }
 
 }
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/FakeAuthenticator.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/FakeAuthenticator.java
index a65a02f64e..7feb9df6cc 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/FakeAuthenticator.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/FakeAuthenticator.java
@@ -20,6 +20,7 @@ package org.apache.james.mailbox.store;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 
 import org.apache.james.core.Username;
 import org.apache.james.mailbox.Authenticator;
@@ -29,12 +30,12 @@ public class FakeAuthenticator implements Authenticator {
     private final Map<String, String> users = new HashMap<>();
 
     @Override
-    public boolean isAuthentic(Username userid, CharSequence passwd) {
+    public Optional<Username> isAuthentic(Username userid, CharSequence passwd) {
         String pass = users.get(userid.asString());
-        if (pass != null) {
-            return passwd.toString().equals(pass);
+        if (passwd.toString().equals(pass)) {
+            return Optional.of(userid);
         }
-        return false;
+        return Optional.empty();
     }
     
     public void addUser(Username user, String password) {
diff --git a/mailbox/store/src/main/java/org/apache/james/mailbox/store/SessionProviderImpl.java b/mailbox/store/src/main/java/org/apache/james/mailbox/store/SessionProviderImpl.java
index 901d25d477..c6e96c1640 100644
--- a/mailbox/store/src/main/java/org/apache/james/mailbox/store/SessionProviderImpl.java
+++ b/mailbox/store/src/main/java/org/apache/james/mailbox/store/SessionProviderImpl.java
@@ -37,8 +37,6 @@ import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.mailbox.exception.UserDoesNotExistException;
 import org.apache.james.mailbox.model.MailboxConstants;
 
-import com.github.fge.lambdas.Throwing;
-
 public class SessionProviderImpl implements SessionProvider {
     private final MailboxSessionIdGenerator idGenerator;
     private final Authenticator authenticator;
@@ -57,20 +55,22 @@ public class SessionProviderImpl implements SessionProvider {
     }
 
     @Override
-    public AuthorizationStep authenticate(Username thisUserId, String passwd) {
+    public AuthorizationStep authenticate(Username loginUsername, String passwd) {
         return new AuthorizationStep() {
             @Override
             public MailboxSession as(Username otherUserId) throws MailboxException {
-                if (!isValidLogin(thisUserId, passwd)) {
+                Optional<Username> loggedInUser = isValidLogin(loginUsername, passwd);
+                if (loggedInUser.isEmpty()) {
                     throw new BadCredentialsException();
                 }
-                return authenticate(thisUserId).as(otherUserId);
+                return authenticate(loggedInUser.get()).as(otherUserId);
             }
 
             @Override
             public MailboxSession withoutDelegation() throws MailboxException {
-                if (isValidLogin(thisUserId, passwd)) {
-                    return createSession(thisUserId, Optional.ofNullable(thisUserId), MailboxSession.SessionType.User);
+                Optional<Username> loggedInUser = isValidLogin(loginUsername, passwd);
+                if (loggedInUser.isPresent()) {
+                    return createSession(loggedInUser.get(), loggedInUser, MailboxSession.SessionType.User);
                 } else {
                     throw new BadCredentialsException();
                 }
@@ -78,17 +78,15 @@ public class SessionProviderImpl implements SessionProvider {
 
             @Override
             public MailboxSession forMatchingUser(Predicate<Username> otherPredicate) throws MailboxException {
-                return authorizator.delegatedUsers(thisUserId)
+                Username loggedInUser = isValidLogin(loginUsername, passwd)
+                    .orElseThrow(BadCredentialsException::new);
+
+                return authorizator.delegatedUsers(loggedInUser)
                     .stream()
                     .filter(otherPredicate)
                     .findFirst()
-                    .map(Throwing.<Username, MailboxSession>function(otherUserId -> {
-                        if (!isValidLogin(thisUserId, passwd)) {
-                            throw new BadCredentialsException();
-                        }
-                        return createSession(otherUserId, Optional.of(thisUserId), MailboxSession.SessionType.System);
-                    }).sneakyThrow())
-                    .orElseThrow(() -> new ForbiddenDelegationException(thisUserId));
+                    .map(otherUserId -> createSession(otherUserId, Optional.of(loggedInUser), MailboxSession.SessionType.System))
+                    .orElseThrow(() -> new ForbiddenDelegationException(loggedInUser));
             }
         };
     }
@@ -147,7 +145,7 @@ public class SessionProviderImpl implements SessionProvider {
      * @param passwd the password
      * @return success true if login success false otherwise
      */
-    private boolean isValidLogin(Username userid, String passwd) throws MailboxException {
+    private Optional<Username> isValidLogin(Username userid, String passwd) throws MailboxException {
         return authenticator.isAuthentic(userid, passwd);
     }
 }
diff --git a/protocols/managesieve/src/main/java/org/apache/james/managesieve/core/PlainAuthenticationProcessor.java b/protocols/managesieve/src/main/java/org/apache/james/managesieve/core/PlainAuthenticationProcessor.java
index 4c94818f91..f59daedb9a 100644
--- a/protocols/managesieve/src/main/java/org/apache/james/managesieve/core/PlainAuthenticationProcessor.java
+++ b/protocols/managesieve/src/main/java/org/apache/james/managesieve/core/PlainAuthenticationProcessor.java
@@ -83,7 +83,7 @@ public class PlainAuthenticationProcessor implements AuthenticationProcessor {
         try {
             User user = usersRepository.getUserByName(userName);
             if (user != null && user.verifyPassword(password)) {
-                return userName;
+                return user.getUserName();
             } else {
                 return null;
             }
diff --git a/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/UserRepositoryAuthenticator.java b/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/UserRepositoryAuthenticator.java
index 6d346e1e0b..53914448fd 100644
--- a/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/UserRepositoryAuthenticator.java
+++ b/server/container/mailbox-adapter/src/main/java/org/apache/james/adapter/mailbox/UserRepositoryAuthenticator.java
@@ -19,6 +19,8 @@
 
 package org.apache.james.adapter.mailbox;
 
+import java.util.Optional;
+
 import javax.inject.Inject;
 
 import org.apache.james.core.Username;
@@ -41,7 +43,7 @@ public class UserRepositoryAuthenticator implements Authenticator {
     }
 
     @Override
-    public boolean isAuthentic(Username userid, CharSequence passwd) throws MailboxException {
+    public Optional<Username> isAuthentic(Username userid, CharSequence passwd) throws MailboxException {
         try {
             return repos.test(userid, passwd.toString());
         } catch (UsersRepositoryException e) {
diff --git a/server/container/mailbox-adapter/src/test/java/org/apache/james/adapter/mailbox/UserRepositoryAuthenticatorTest.java b/server/container/mailbox-adapter/src/test/java/org/apache/james/adapter/mailbox/UserRepositoryAuthenticatorTest.java
index 7cf075ea77..3d02a2ee7f 100644
--- a/server/container/mailbox-adapter/src/test/java/org/apache/james/adapter/mailbox/UserRepositoryAuthenticatorTest.java
+++ b/server/container/mailbox-adapter/src/test/java/org/apache/james/adapter/mailbox/UserRepositoryAuthenticatorTest.java
@@ -24,6 +24,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import java.util.Optional;
+
 import org.apache.james.core.Username;
 import org.apache.james.mailbox.exception.MailboxException;
 import org.apache.james.user.api.UsersRepository;
@@ -48,23 +50,23 @@ public class UserRepositoryAuthenticatorTest {
 
     @Test
     void isAuthenticShouldReturnTrueWhenGoodLoginPassword() throws Exception {
-        when(usersRepository.test(USER, PASSWORD)).thenReturn(true);
+        when(usersRepository.test(USER, PASSWORD)).thenReturn(Optional.of(USER));
 
-        assertThat(testee.isAuthentic(USER, PASSWORD)).isTrue();
+        assertThat(testee.isAuthentic(USER, PASSWORD)).isPresent();
     }
 
     @Test
     void isAuthenticShouldReturnFalseWhenWrongPassword() throws Exception {
-        when(usersRepository.test(USER, BAD_PASSWORD)).thenReturn(false);
+        when(usersRepository.test(USER, BAD_PASSWORD)).thenReturn(Optional.empty());
 
-        assertThat(testee.isAuthentic(USER, BAD_PASSWORD)).isFalse();
+        assertThat(testee.isAuthentic(USER, BAD_PASSWORD)).isEmpty();
     }
 
     @Test
     void isAuthenticShouldReturnFalseWhenBadUser() throws Exception {
-        when(usersRepository.test(USER, BAD_PASSWORD)).thenReturn(false);
+        when(usersRepository.test(USER, BAD_PASSWORD)).thenReturn(Optional.empty());
 
-        assertThat(testee.isAuthentic(BAD_USER, BAD_PASSWORD)).isFalse();
+        assertThat(testee.isAuthentic(BAD_USER, BAD_PASSWORD)).isEmpty();
     }
 
     @Test
diff --git a/server/data/data-api/src/main/java/org/apache/james/user/api/DelegationStore.java b/server/data/data-api/src/main/java/org/apache/james/user/api/DelegationStore.java
index 25d86eae4c..64a647ae3e 100644
--- a/server/data/data-api/src/main/java/org/apache/james/user/api/DelegationStore.java
+++ b/server/data/data-api/src/main/java/org/apache/james/user/api/DelegationStore.java
@@ -30,7 +30,7 @@ public interface DelegationStore {
     /**
      * @return Lists of the users authorized to impersonnate to baseUser.
      */
-    Publisher<Username> authorizedUsers(Username baseUser);
+    Publisher<Username> authorizedUsers(Username baseUser); // delegatees list
 
     Publisher<Void> clear(Username baseUser);
 
diff --git a/server/data/data-api/src/main/java/org/apache/james/user/api/UsersRepository.java b/server/data/data-api/src/main/java/org/apache/james/user/api/UsersRepository.java
index 4a3e67523b..943f2ac63c 100644
--- a/server/data/data-api/src/main/java/org/apache/james/user/api/UsersRepository.java
+++ b/server/data/data-api/src/main/java/org/apache/james/user/api/UsersRepository.java
@@ -20,6 +20,7 @@
 package org.apache.james.user.api;
 
 import java.util.Iterator;
+import java.util.Optional;
 
 import org.apache.james.core.Domain;
 import org.apache.james.core.MailAddress;
@@ -94,20 +95,20 @@ public interface UsersRepository {
     Publisher<Boolean> containsReactive(Username name);
 
     /**
-     * Test if user with name 'name' has password 'password'.
+     * Test if user with login name 'name' has password 'password'.
      * 
      * @param name
-     *            the name of the user to be tested
+     *            the login name of the user to be tested
      * @param password
      *            the password to be tested
      * 
-     * @return true if the test is successful, false if the user doesn't exist
+     * @return Optional of a Username if the test is successful, an empty Optional if the user doesn't exist
      *         or if the password is incorrect
      * @throws UsersRepositoryException
      *             if error
      * 
      */
-    boolean test(Username name, String password) throws UsersRepositoryException;
+    Optional<Username> test(Username name, String password) throws UsersRepositoryException;
 
     /**
      * Returns a count of the users in the repository.
diff --git a/server/data/data-api/src/main/java/org/apache/james/user/api/model/User.java b/server/data/data-api/src/main/java/org/apache/james/user/api/model/User.java
index 191bfe8e14..271baa54cf 100644
--- a/server/data/data-api/src/main/java/org/apache/james/user/api/model/User.java
+++ b/server/data/data-api/src/main/java/org/apache/james/user/api/model/User.java
@@ -27,15 +27,15 @@ import org.apache.james.core.Username;
 public interface User {
 
     /**
-     * Return the user name of this user
+     * Return the translated username of this user
      * 
-     * @return the user name for this user
+     * @return the translated username for this user
      */
     Username getUserName();
 
     /**
      * Return true if pass matches password of this user.
-     * 
+     *
      * @param pass
      *            the password to test
      * @return whether the password being tested is valid
diff --git a/server/data/data-jpa/src/main/java/org/apache/james/user/jpa/model/JPAUser.java b/server/data/data-jpa/src/main/java/org/apache/james/user/jpa/model/JPAUser.java
index dad1fa0965..8a5cad22ef 100644
--- a/server/data/data-jpa/src/main/java/org/apache/james/user/jpa/model/JPAUser.java
+++ b/server/data/data-jpa/src/main/java/org/apache/james/user/jpa/model/JPAUser.java
@@ -151,6 +151,7 @@ public class JPAUser implements User {
         } else {
             result = password != null && password.equals(hashPassword(pass, name, alg));
         }
+
         return result;
     }
 
diff --git a/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/LdapRepositoryConfiguration.java b/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/LdapRepositoryConfiguration.java
index 8afd9b0089..2b30ec3ecc 100644
--- a/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/LdapRepositoryConfiguration.java
+++ b/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/LdapRepositoryConfiguration.java
@@ -54,6 +54,7 @@ public class LdapRepositoryConfiguration {
         private Optional<String> credentials;
         private Optional<String> userBase;
         private Optional<String> userIdAttribute;
+        private Optional<String> resolveLocalPartAttribute;
         private Optional<String> userObjectClass;
         private Optional<Integer> poolSize;
         private Optional<Boolean> trustAllCerts;
@@ -65,6 +66,7 @@ public class LdapRepositoryConfiguration {
             credentials = Optional.empty();
             userBase = Optional.empty();
             userIdAttribute = Optional.empty();
+            resolveLocalPartAttribute = Optional.empty();
             userObjectClass = Optional.empty();
             poolSize = Optional.empty();
             trustAllCerts = Optional.empty();
@@ -96,6 +98,11 @@ public class LdapRepositoryConfiguration {
             return this;
         }
 
+        public Builder resolveLocalPartAttribute(String resolveLocalPartAttribute) {
+            this.resolveLocalPartAttribute = Optional.of(resolveLocalPartAttribute);
+            return this;
+        }
+
         public Builder userObjectClass(String userObjectClass) {
             this.userObjectClass = Optional.of(userObjectClass);
             return this;
@@ -130,6 +137,7 @@ public class LdapRepositoryConfiguration {
                 credentials.get(),
                 userBase.get(),
                 userIdAttribute.get(),
+                resolveLocalPartAttribute,
                 userObjectClass.get(),
                 NO_CONNECTION_TIMEOUT,
                 NO_READ_TIME_OUT,
@@ -160,6 +168,7 @@ public class LdapRepositoryConfiguration {
         String credentials = configuration.getString("[@credentials]", "");
         String userBase = configuration.getString("[@userBase]");
         String userIdAttribute = configuration.getString("[@userIdAttribute]");
+        Optional<String> resolveLocalPartAttribute = Optional.ofNullable(configuration.getString("[@resolveLocalPartAttribute]", null));
         String userObjectClass = configuration.getString("[@userObjectClass]");
         // Default is to use connection pooling
         int connectionTimeout = configuration.getInt("[@connectionTimeout]", NO_CONNECTION_TIMEOUT);
@@ -201,6 +210,7 @@ public class LdapRepositoryConfiguration {
             credentials,
             userBase,
             userIdAttribute,
+            resolveLocalPartAttribute,
             userObjectClass,
             connectionTimeout,
             readTimeout,
@@ -252,6 +262,14 @@ public class LdapRepositoryConfiguration {
      */
     private final String userIdAttribute;
 
+    /**
+     * The value of this field is taken from the configuration attribute
+     * &quot;resolveLocalPartAttribute&quot;. This is the LDAP attribute type which enables
+     * user authentication using local part as login username while Virtual Hosting is on.
+     * Default to empty, which disables login with local part as username.
+     */
+    private final Optional<String> resolveLocalPartAttribute;
+
     /**
      * The value of this field is taken from the configuration attribute
      * &quot;userObjectClass&quot;. This is the LDAP object class to use in the
@@ -294,7 +312,7 @@ public class LdapRepositoryConfiguration {
     private final ImmutableMap<Domain, String> perDomainBaseDN;
 
     private LdapRepositoryConfiguration(List<URI> ldapHosts, String principal, String credentials, String userBase, String userIdAttribute,
-                                        String userObjectClass, int connectionTimeout, int readTimeout,
+                                        Optional<String> resolveLocalPartAttribute, String userObjectClass, int connectionTimeout, int readTimeout,
                                         boolean supportsVirtualHosting, int poolSize, ReadOnlyLDAPGroupRestriction restriction, String filter,
                                         Optional<String> administratorId, boolean trustAllCerts,
                                         ImmutableMap<Domain, String> perDomainBaseDN) throws ConfigurationException {
@@ -303,6 +321,7 @@ public class LdapRepositoryConfiguration {
         this.credentials = credentials;
         this.userBase = userBase;
         this.userIdAttribute = userIdAttribute;
+        this.resolveLocalPartAttribute = resolveLocalPartAttribute;
         this.userObjectClass = userObjectClass;
         this.connectionTimeout = connectionTimeout;
         this.readTimeout = readTimeout;
@@ -349,6 +368,10 @@ public class LdapRepositoryConfiguration {
         return userIdAttribute;
     }
 
+    public Optional<String> getResolveLocalPartAttribute() {
+        return resolveLocalPartAttribute;
+    }
+
     public String getUserObjectClass() {
         return userObjectClass;
     }
@@ -402,6 +425,7 @@ public class LdapRepositoryConfiguration {
                 && Objects.equals(this.credentials, that.credentials)
                 && Objects.equals(this.userBase, that.userBase)
                 && Objects.equals(this.userIdAttribute, that.userIdAttribute)
+                && Objects.equals(this.resolveLocalPartAttribute, that.resolveLocalPartAttribute)
                 && Objects.equals(this.userObjectClass, that.userObjectClass)
                 && Objects.equals(this.restriction, that.restriction)
                 && Objects.equals(this.filter, that.filter)
@@ -415,7 +439,7 @@ public class LdapRepositoryConfiguration {
 
     @Override
     public final int hashCode() {
-        return Objects.hash(ldapHosts, principal, credentials, userBase, userIdAttribute, userObjectClass,
+        return Objects.hash(ldapHosts, principal, credentials, userBase, userIdAttribute, resolveLocalPartAttribute, userObjectClass,
             connectionTimeout, readTimeout, supportsVirtualHosting, restriction, filter, administratorId, poolSize,
             trustAllCerts, perDomainBaseDN);
     }
diff --git a/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUser.java b/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUser.java
index 5ef72647f8..9c7c83c18a 100644
--- a/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUser.java
+++ b/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUser.java
@@ -93,7 +93,7 @@ public class ReadOnlyLDAPUser implements User {
      * the field . This is generally the value from which the
      * user email address is built, by appending the domain name to it.
      * 
-     * @return The user's identifier or name.
+     * @return The user's identifier or translated username.
      */
     @Override
     public Username getUserName() {
diff --git a/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAO.java b/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAO.java
index d1c0fa5e20..0717a8326b 100644
--- a/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAO.java
+++ b/server/data/data-ldap/src/main/java/org/apache/james/user/ldap/ReadOnlyLDAPUsersDAO.java
@@ -188,8 +188,8 @@ public class ReadOnlyLDAPUsersDAO implements UsersDAO, Configurable {
         ldapConnectionPool.close();
     }
 
-    private Filter createFilter(String username) {
-        Filter specificUserFilter = Filter.createEqualityFilter(ldapConfiguration.getUserIdAttribute(), username);
+    private Filter createFilter(String retrievalName, String ldapUserRetrievalAttribute) {
+        Filter specificUserFilter = Filter.createEqualityFilter(ldapUserRetrievalAttribute, retrievalName);
         return userExtraFilter
             .map(extraFilter -> Filter.createANDFilter(objectClassFilter, specificUserFilter, extraFilter))
             .orElseGet(() -> Filter.createANDFilter(objectClassFilter, specificUserFilter));
@@ -297,11 +297,15 @@ public class ReadOnlyLDAPUsersDAO implements UsersDAO, Configurable {
         return results;
     }
 
-    private Optional<ReadOnlyLDAPUser> searchAndBuildUser(Username name) throws LDAPException {
-        SearchResult searchResult = ldapConnectionPool.search(userBase(name),
+    private Optional<ReadOnlyLDAPUser> searchAndBuildUser(Username retrievalName) throws LDAPException {
+        Optional<String> resolveLocalPartAttribute = ldapConfiguration.getResolveLocalPartAttribute();
+        String ldapUserRetrievalAttribute = resolveLocalPartAttribute.orElse(ldapConfiguration.getUserIdAttribute());
+        String[] returnedAttributes = { ldapConfiguration.getUserIdAttribute() };
+
+        SearchResult searchResult = ldapConnectionPool.search(userBase(retrievalName),
             SearchScope.SUB,
-            createFilter(name.asString()),
-            ldapConfiguration.getUserIdAttribute());
+            createFilter(retrievalName.asString(), ldapUserRetrievalAttribute),
+            returnedAttributes);
 
         SearchResultEntry result = searchResult.getSearchEntries()
             .stream()
@@ -315,7 +319,8 @@ public class ReadOnlyLDAPUsersDAO implements UsersDAO, Configurable {
         if (!ldapConfiguration.getRestriction().isActivated()
             || userInGroupsMembershipList(result.getParsedDN(), ldapConfiguration.getRestriction().getGroupMembershipLists(ldapConnectionPool))) {
 
-            return Optional.of(new ReadOnlyLDAPUser(name, result.getParsedDN(), ldapConnectionPool));
+            Username translatedUsername = Username.of(result.getAttributeValue(ldapConfiguration.getUserIdAttribute()));
+            return Optional.of(new ReadOnlyLDAPUser(translatedUsername, result.getParsedDN(), ldapConnectionPool));
         }
         return Optional.empty();
     }
diff --git a/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyUsersLDAPRepositoryTest.java b/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyUsersLDAPRepositoryTest.java
index ab87a3b618..99f2beb9a0 100644
--- a/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyUsersLDAPRepositoryTest.java
+++ b/server/data/data-ldap/src/test/java/org/apache/james/user/ldap/ReadOnlyUsersLDAPRepositoryTest.java
@@ -214,7 +214,7 @@ class ReadOnlyUsersLDAPRepositoryTest {
 
         @Test
         void knownUserShouldBeAbleToLogInWhenPasswordIsCorrectWithVirtualHosting() throws Exception {
-            assertThat(usersRepository.test(JAMES_USER_MAIL, PASSWORD)).isTrue();
+            assertThat(usersRepository.test(JAMES_USER_MAIL, PASSWORD)).isEqualTo(Optional.of(JAMES_USER_MAIL));
         }
 
         @Test
@@ -249,24 +249,24 @@ class ReadOnlyUsersLDAPRepositoryTest {
             }
             ldapContainer.unpause();
 
-            assertThat(usersRepository.test(JAMES_USER_MAIL, PASSWORD)).isTrue();
+            assertThat(usersRepository.test(JAMES_USER_MAIL, PASSWORD)).isEqualTo(Optional.of(JAMES_USER_MAIL));
         }
 
         @Test
         void knownUserShouldNotBeAbleToLogInWhenPasswordIsNotCorrectWithVirtualHosting() throws Exception {
-            assertThat(usersRepository.test(JAMES_USER, BAD_PASSWORD)).isFalse();
+            assertThat(usersRepository.test(JAMES_USER, BAD_PASSWORD)).isEmpty();
         }
 
         @Test
         void unknownUserShouldNotBeAbleToLogInWhenPasswordIsCorrectWithVirtualHosting() throws Exception {
-            assertThat(usersRepository.test(UNKNOWN, PASSWORD)).isFalse();
+            assertThat(usersRepository.test(UNKNOWN, PASSWORD)).isEmpty();
         }
 
         @Test
         void specialCharacterInUserInputShouldBeSanitized() throws Exception {
             Username patternMatchingMultipleUsers = Username.of("j*");
 
-            assertThat(usersRepository.test(patternMatchingMultipleUsers, PASSWORD)).isFalse();
+            assertThat(usersRepository.test(patternMatchingMultipleUsers, PASSWORD)).isEmpty();
         }
 
         @Test
@@ -315,7 +315,7 @@ class ReadOnlyUsersLDAPRepositoryTest {
 
         @Test
         void knownUserShouldBeAbleToLogInWhenPasswordIsCorrect() throws Exception {
-            assertThat(usersRepository.test(JAMES_USER, PASSWORD)).isTrue();
+            assertThat(usersRepository.test(JAMES_USER, PASSWORD)).isEqualTo(Optional.of(JAMES_USER));
         }
 
         @Test
@@ -340,17 +340,17 @@ class ReadOnlyUsersLDAPRepositoryTest {
 
         @Test
         void knownUserShouldNotBeAbleToLogInWhenPasswordIsNotCorrect() throws Exception {
-            assertThat(usersRepository.test(JAMES_USER, BAD_PASSWORD)).isFalse();
+            assertThat(usersRepository.test(JAMES_USER, BAD_PASSWORD)).isEmpty();
         }
 
         @Test
         void unknownUserShouldNotBeAbleToLogIn() throws Exception {
-            assertThat(usersRepository.test(UNKNOWN, BAD_PASSWORD)).isFalse();
+            assertThat(usersRepository.test(UNKNOWN, BAD_PASSWORD)).isEmpty();
         }
 
         @Test
         void unknownUserShouldNotBeAbleToLogInWhenPasswordIsCorrect() throws Exception {
-            assertThat(usersRepository.test(UNKNOWN, PASSWORD)).isFalse();
+            assertThat(usersRepository.test(UNKNOWN, PASSWORD)).isEmpty();
         }
 
         @Test
diff --git a/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersRepositoryImpl.java b/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersRepositoryImpl.java
index 826371edba..ffc313e909 100644
--- a/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersRepositoryImpl.java
+++ b/server/data/data-library/src/main/java/org/apache/james/user/lib/UsersRepositoryImpl.java
@@ -148,23 +148,23 @@ public class UsersRepositoryImpl<T extends UsersDAO> implements UsersRepository,
     }
 
     @Override
-    public boolean test(Username name, String password) throws UsersRepositoryException {
-        boolean isVerified = usersDAO.getUserByName(name)
-            .map(x -> x.verifyPassword(password))
-            .orElseGet(() -> {
-                LOGGER.info("Could not retrieve user {}. Password is unverified.", name);
-                return false;
-            });
-
-        if (!isVerified && verifyFailureDelay > 0L) {
-            try {
-                Thread.sleep(verifyFailureDelay);
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
+    public Optional<Username> test(Username name, String password) throws UsersRepositoryException {
+        Optional<Username> translatedUsername = usersDAO.getUserByName(name)
+            .filter(user -> user.verifyPassword(password))
+            .map(User::getUserName);
+
+        if (translatedUsername.isEmpty()) {
+            LOGGER.info("Could not retrieve user {}. Password is unverified.", name);
+            if (verifyFailureDelay > 0L) {
+                try {
+                    Thread.sleep(verifyFailureDelay);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
             }
         }
 
-        return isVerified;
+        return translatedUsername;
     }
 
     @Override
diff --git a/server/data/data-library/src/test/java/org/apache/james/user/lib/UsersRepositoryContract.java b/server/data/data-library/src/test/java/org/apache/james/user/lib/UsersRepositoryContract.java
index f13dfa473f..5e0e1ffc14 100644
--- a/server/data/data-library/src/test/java/org/apache/james/user/lib/UsersRepositoryContract.java
+++ b/server/data/data-library/src/test/java/org/apache/james/user/lib/UsersRepositoryContract.java
@@ -179,11 +179,8 @@ public interface UsersRepositoryContract {
         }
 
         @Test
-        default void testShouldReturnFalseWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
-            //When
-            boolean actual = testee().test(testSystem.user1, "password");
-            //Then
-            assertThat(actual).isFalse();
+        default void testShouldReturnEmptyWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
+            assertThat(testee().test(testSystem.user1, "password")).isEmpty();
         }
 
         @ParameterizedTest
@@ -341,7 +338,7 @@ public interface UsersRepositoryContract {
             testee().addUser(testSystem.user1CaseVariation, password);
 
             assertThat(testee().test(testSystem.user1, password))
-                .isTrue();
+                .isEqualTo(Optional.of(testSystem.user1));
         }
 
         @Test
@@ -350,7 +347,7 @@ public interface UsersRepositoryContract {
             testee().addUser(testSystem.user1, password);
 
             assertThat(testee().test(testSystem.user1CaseVariation, password))
-                .isTrue();
+                .isEqualTo(Optional.of(testSystem.user1CaseVariation));
         }
 
         @Test
@@ -404,65 +401,65 @@ public interface UsersRepositoryContract {
         }
 
         @Test
-        default void testShouldReturnTrueWhenAUserHasACorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
+        default void testShouldReturnUsernameWhenAUserHasACorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
             //Given
             testee().addUser(testSystem.user1, "password");
             //When
-            boolean actual = testee().test(testSystem.user1, "password");
+            Optional<Username> loggedInUser = testee().test(testSystem.user1, "password");
             //Then
-            assertThat(actual).isTrue();
+            assertThat(loggedInUser).isEqualTo(Optional.of(testSystem.user1));
         }
 
         @Test
-        default void testShouldReturnFalseWhenAUserHasAnIncorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
+        default void testShouldReturnEmptyWhenAUserHasAnIncorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
             //Given
             testee().addUser(testSystem.user1, "password");
             //When
-            boolean actual = testee().test(testSystem.user1, "password2");
+            Optional<Username> loggedInUser = testee().test(testSystem.user1, "password2");
             //Then
-            assertThat(actual).isFalse();
+            assertThat(loggedInUser).isEmpty();
         }
 
         @Test
-        default void testShouldReturnFalseWhenAUserHasAnIncorrectCasePassword(TestSystem testSystem) throws UsersRepositoryException {
+        default void testShouldReturnEmptyWhenAUserHasAnIncorrectCasePassword(TestSystem testSystem) throws UsersRepositoryException {
             //Given
             testee().addUser(testSystem.user1, "password");
             //When
-            boolean actual = testee().test(testSystem.user1, "Password");
+            Optional<Username> loggedInUser = testee().test(testSystem.user1, "Password");
             //Then
-            assertThat(actual).isFalse();
+            assertThat(loggedInUser).isEmpty();
         }
 
         @Test
-        default void testShouldReturnFalseWhenAUserIsNotInRepository(TestSystem testSystem) throws UsersRepositoryException {
+        default void testShouldReturnEmptyWhenAUserIsNotInRepository(TestSystem testSystem) throws UsersRepositoryException {
             //Given
             testee().addUser(testSystem.toUsername("username"), "password");
             //When
-            boolean actual = testee().test(testSystem.toUsername("username2"), "password");
+            Optional<Username> loggedInUser = testee().test(testSystem.toUsername("username2"), "password");
             //Then
-            assertThat(actual).isFalse();
+            assertThat(loggedInUser).isEmpty();
         }
 
         @Test
-        default void testShouldReturnTrueWhenAUserHasAnIncorrectCaseName(TestSystem testSystem) throws UsersRepositoryException {
+        default void testShouldReturnUsernameWhenAUserHasAnIncorrectCaseName(TestSystem testSystem) throws UsersRepositoryException {
             //Given
             testee().addUser(testSystem.toUsername("username"), "password");
             //When
-            boolean actual = testee().test(testSystem.toUsername("userName"), "password");
+            Optional<Username> loggedInUser = testee().test(testSystem.toUsername("userName"), "password");
             //Then
-            assertThat(actual).isTrue();
+            assertThat(loggedInUser).isEqualTo(Optional.of(testSystem.toUsername("userName")));
         }
 
 
         @Test
-        default void testShouldReturnFalseWhenAUserIsRemovedFromRepository(TestSystem testSystem) throws UsersRepositoryException {
+        default void testShouldReturnEmptyWhenAUserIsRemovedFromRepository(TestSystem testSystem) throws UsersRepositoryException {
             //Given
             testee().addUser(testSystem.user1, "password");
             testee().removeUser(testSystem.user1);
             //When
-            boolean actual = testee().test(testSystem.user1, "password");
+            Optional<Username> loggedInUser = testee().test(testSystem.user1, "password");
             //Then
-            assertThat(actual).isFalse();
+            assertThat(loggedInUser).isEmpty();
         }
 
         @Test
@@ -484,7 +481,7 @@ public interface UsersRepositoryContract {
             //When
             testee().updateUser(user);
             //Then
-            assertThat(testee().test(testSystem.user1, "newpass")).isTrue();
+            assertThat(testee().test(testSystem.user1, "newpass")).isEqualTo(Optional.of(testSystem.user1));
         }
 
         @Test
@@ -496,7 +493,7 @@ public interface UsersRepositoryContract {
             //When
             testee().updateUser(user);
             //Then
-            assertThat(testee().test(testSystem.user1, "password")).isFalse();
+            assertThat(testee().test(testSystem.user1, "password")).isEmpty();
         }
 
         @Test
@@ -542,15 +539,15 @@ public interface UsersRepositoryContract {
     interface WithVirtualHostingReadWriteContract extends ReadWriteContract {
 
         @Test
-        default void testShouldReturnTrueWhenAUserHasACorrectPasswordAndOtherCaseInDomain(TestSystem testSystem) throws Exception {
+        default void testShouldReturnUsernameWhenAUserHasACorrectPasswordAndOtherCaseInDomain(TestSystem testSystem) throws Exception {
             testSystem.domainList.addDomain(Domain.of("Domain.OrG"));
             String username = "myuser";
             String password = "password";
             testee().addUser(Username.of(username + "@Domain.OrG"), password);
 
-            boolean actual = testee().test(Username.of(username + "@domain.org"), password);
+            Optional<Username> loggedInUser = testee().test(Username.of(username + "@domain.org"), password);
 
-            assertThat(actual).isTrue();
+            assertThat(loggedInUser).isEqualTo(Optional.of(Username.of(username + "@domain.org")));
         }
 
         @Test
diff --git a/server/data/data-memory/src/test/java/org/apache/james/user/memory/UsersRepositoryManagementTest.java b/server/data/data-memory/src/test/java/org/apache/james/user/memory/UsersRepositoryManagementTest.java
index 89a998ec6b..8ab0e3a520 100644
--- a/server/data/data-memory/src/test/java/org/apache/james/user/memory/UsersRepositoryManagementTest.java
+++ b/server/data/data-memory/src/test/java/org/apache/james/user/memory/UsersRepositoryManagementTest.java
@@ -97,19 +97,19 @@ class UsersRepositoryManagementTest {
     void testSetPassword() throws Exception {
         userManagement.addUser("testpwduser", "pwd1");
 
-        assertThat(usersRepository.test(Username.of("testpwduser"), "pwd1")).describedAs("initial password").isTrue();
+        assertThat(usersRepository.test(Username.of("testpwduser"), "pwd1")).describedAs("initial password").isPresent();
 
         // set empty pwd
         userManagement.setPassword("testpwduser", "");
-        assertThat(usersRepository.test(Username.of("testpwduser"), "")).describedAs("password changed to empty").isTrue();
+        assertThat(usersRepository.test(Username.of("testpwduser"), "")).describedAs("password changed to empty").isPresent();
 
         // change pwd
         userManagement.setPassword("testpwduser", "pwd2");
-        assertThat(usersRepository.test(Username.of("testpwduser"), "pwd2")).describedAs("password not changed to pwd2").isTrue();
+        assertThat(usersRepository.test(Username.of("testpwduser"), "pwd2")).describedAs("password not changed to pwd2").isPresent();
 
         // assure case sensitivity
         userManagement.setPassword("testpwduser", "pWD2");
-        assertThat(usersRepository.test(Username.of("testpwduser"), "pwd2")).describedAs("password no longer pwd2").isFalse();
-        assertThat(usersRepository.test(Username.of("testpwduser"), "pWD2")).describedAs("password changed to pWD2").isTrue();
+        assertThat(usersRepository.test(Username.of("testpwduser"), "pwd2")).describedAs("password no longer pwd2").isEmpty();
+        assertThat(usersRepository.test(Username.of("testpwduser"), "pWD2")).describedAs("password changed to pWD2").isPresent();
     }
 }
diff --git a/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/http/AuthenticationRoutes.java b/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/http/AuthenticationRoutes.java
index 527bcf542e..971fe1a65a 100644
--- a/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/http/AuthenticationRoutes.java
+++ b/server/protocols/jmap-draft/src/main/java/org/apache/james/jmap/http/AuthenticationRoutes.java
@@ -38,6 +38,7 @@ import static org.apache.james.util.ReactorUtils.logOnError;
 
 import java.io.IOException;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.stream.Stream;
 
 import javax.inject.Inject;
@@ -266,23 +267,18 @@ public class AuthenticationRoutes implements JMAPRoutes {
         Username username = Username.of(request.getToken().getUsername());
 
         return authenticate(request, username)
-            .flatMap(success -> {
-                if (success) {
-                    return returnAccessTokenResponse(resp, username);
-                } else {
-                    return returnUnauthorizedResponse(resp)
-                        .doOnEach(log(() -> LOGGER.info("Authentication failure for {}", username)));
-                }
-            });
+            .flatMap(loggedInUser -> loggedInUser.map(value -> returnAccessTokenResponse(resp, value))
+                .orElseGet(() -> returnUnauthorizedResponse(resp)
+                    .doOnEach(log(() -> LOGGER.info("Authentication failure for {}", username)))));
     }
 
-    private Mono<Boolean> authenticate(AccessTokenRequest request, Username username) {
+    private Mono<Optional<Username>> authenticate(AccessTokenRequest request, Username username) {
         return Mono.fromCallable(() -> {
             try {
                 return usersRepository.test(username, request.getPassword());
             } catch (UsersRepositoryException e) {
                 LOGGER.error("Error while trying to validate authentication for user '{}'", username, e);
-                return false;
+                return Optional.<Username>empty();
             }
         }).subscribeOn(ReactorUtils.BLOCKING_CALL_WRAPPER);
     }
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/http/BasicAuthenticationStrategy.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/http/BasicAuthenticationStrategy.scala
index de235f22eb..876a1b4dbc 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/http/BasicAuthenticationStrategy.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/http/BasicAuthenticationStrategy.scala
@@ -38,6 +38,7 @@ import reactor.core.scala.publisher.SMono
 import reactor.netty.http.server.HttpServerRequest
 
 import scala.jdk.CollectionConverters._
+import scala.jdk.OptionConverters._
 import scala.util.{Failure, Success, Try}
 
 object UserCredential {
@@ -116,9 +117,9 @@ class BasicAuthenticationStrategy @Inject()(val usersRepository: UsersRepository
     SMono.fromCallable(() => authHeaders(httpRequest))
       .map(parseUserCredentials)
       .handle(publishNext)
-      .filterWhen(isValid)
-      .map(_.username)
-      .map(mailboxManager.authenticate(_).withoutDelegation())
+      .flatMap(getAuthenticatedUsername)
+      .filter(_.isDefined)
+      .map(loggedInUser => mailboxManager.authenticate(loggedInUser.get).withoutDelegation())
       .asJava()
 
 
@@ -128,7 +129,7 @@ class BasicAuthenticationStrategy @Inject()(val usersRepository: UsersRepository
   private def publishNext[T]: (Option[T], reactor.core.publisher.SynchronousSink[T]) => Unit =
     (maybeT, sink) => maybeT.foreach(t => sink.next(t))
 
-  private def isValid(userCredential: UserCredential): SMono[Boolean] =
-    SMono.fromCallable(() => usersRepository.test(userCredential.username, userCredential.password))
+  private def getAuthenticatedUsername(userCredential: UserCredential): SMono[Option[Username]] =
+    SMono.fromCallable(() => usersRepository.test(userCredential.username, userCredential.password).toScala)
       .subscribeOn(ReactorUtils.BLOCKING_CALL_WRAPPER)
 }
diff --git a/server/protocols/protocols-pop3-distributed/src/test/java/org/apache/james/pop3server/mailbox/DistributedPop3ServerTest.java b/server/protocols/protocols-pop3-distributed/src/test/java/org/apache/james/pop3server/mailbox/DistributedPop3ServerTest.java
index 987a0749ff..8d066f4069 100644
--- a/server/protocols/protocols-pop3-distributed/src/test/java/org/apache/james/pop3server/mailbox/DistributedPop3ServerTest.java
+++ b/server/protocols/protocols-pop3-distributed/src/test/java/org/apache/james/pop3server/mailbox/DistributedPop3ServerTest.java
@@ -19,6 +19,8 @@
 
 package org.apache.james.pop3server.mailbox;
 
+import java.util.Optional;
+
 import org.apache.james.UserEntityValidator;
 import org.apache.james.filesystem.api.FileSystem;
 import org.apache.james.mailbox.MailboxManager;
@@ -44,7 +46,7 @@ public class DistributedPop3ServerTest extends POP3ServerTest {
                     return usersRepository.test(userid, passwd.toString());
                 } catch (UsersRepositoryException e) {
                     e.printStackTrace();
-                    return false;
+                    return Optional.empty();
                 }
             })
             .fakeAuthorizator()
diff --git a/server/protocols/protocols-pop3/src/test/java/org/apache/james/pop3server/POP3ServerTest.java b/server/protocols/protocols-pop3/src/test/java/org/apache/james/pop3server/POP3ServerTest.java
index 46646e5e57..f5df2d54a7 100644
--- a/server/protocols/protocols-pop3/src/test/java/org/apache/james/pop3server/POP3ServerTest.java
+++ b/server/protocols/protocols-pop3/src/test/java/org/apache/james/pop3server/POP3ServerTest.java
@@ -29,6 +29,7 @@ import java.net.InetSocketAddress;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
@@ -935,7 +936,7 @@ public class POP3ServerTest {
                     return usersRepository.test(userid, passwd.toString());
                 } catch (UsersRepositoryException e) {
                     e.printStackTrace();
-                    return false;
+                    return Optional.empty();
                 }
             })
             .fakeAuthorizator()
diff --git a/server/protocols/protocols-smtp/src/main/java/org/apache/james/smtpserver/UsersRepositoryAuthHook.java b/server/protocols/protocols-smtp/src/main/java/org/apache/james/smtpserver/UsersRepositoryAuthHook.java
index 7c16adf3d7..421852fead 100644
--- a/server/protocols/protocols-smtp/src/main/java/org/apache/james/smtpserver/UsersRepositoryAuthHook.java
+++ b/server/protocols/protocols-smtp/src/main/java/org/apache/james/smtpserver/UsersRepositoryAuthHook.java
@@ -59,8 +59,9 @@ public class UsersRepositoryAuthHook implements AuthHook {
     @Override
     public HookResult doAuth(SMTPSession session, Username username, String password) {
         try {
-            if (users.test(username, password)) {
-                session.setUsername(username);
+            Optional<Username> loggedInUser = users.test(username, password);
+            if (loggedInUser.isPresent()) {
+                session.setUsername(loggedInUser.get());
                 session.setRelayingAllowed(true);
                 return HookResult.builder()
                     .hookReturnCode(HookReturnCode.ok())
diff --git a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/UserService.java b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/UserService.java
index 22d937042c..dabca512af 100644
--- a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/UserService.java
+++ b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/UserService.java
@@ -66,7 +66,8 @@ public class UserService {
     }
 
     public boolean verifyUser(Username username, String password) throws UsersRepositoryException {
-        return usersRepository.test(username, password);
+        return usersRepository.test(username, password)
+            .isPresent();
     }
 
     public boolean userExists(Username username) throws UsersRepositoryException {


---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org