[ 
https://issues.apache.org/jira/browse/DRILL-4280?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=15877143#comment-15877143
 ] 

ASF GitHub Bot commented on DRILL-4280:
---------------------------------------

Github user laurentgo commented on a diff in the pull request:

    https://github.com/apache/drill/pull/578#discussion_r102348994
  
    --- Diff: 
exec/java-exec/src/main/java/org/apache/drill/exec/rpc/user/UserServer.java ---
    @@ -358,25 +291,59 @@ public BitToUserHandshake 
getHandshakeResponse(UserToBitHandshake inbound) throw
                 return handleFailure(respBuilder, 
HandshakeStatus.RPC_VERSION_MISMATCH, errMsg, null);
               }
     
    -          if (authenticator != null) {
    +          connection.setHandshake(inbound);
    +
    +          if (!config.isAuthEnabled()) {
    +            
connection.finalizeSession(inbound.getCredentials().getUserName());
    +            respBuilder.setStatus(HandshakeStatus.SUCCESS);
    +            return respBuilder.build();
    +          }
    +
    +          final boolean clientSupportsSasl = inbound.hasSaslSupport() &&
    +              (inbound.getSaslSupport().ordinal() >= 
SaslSupport.SASL_AUTH.ordinal());
    +          if (!clientSupportsSasl) { // for backward compatibility < 1.10
    +            final String userName = inbound.getCredentials().getUserName();
    +            if (logger.isTraceEnabled()) {
    +              logger.trace("User {} on connection {} is likely using an 
older client.",
    +                  userName, connection.getRemoteAddress());
    +            }
                 try {
                   String password = "";
                   final UserProperties props = inbound.getProperties();
                   for (int i = 0; i < props.getPropertiesCount(); i++) {
                     Property prop = props.getProperties(i);
    -                if (UserSession.PASSWORD.equalsIgnoreCase(prop.getKey())) {
    +                if 
(DrillProperties.PASSWORD.equalsIgnoreCase(prop.getKey())) {
                       password = prop.getValue();
                       break;
                     }
                   }
    -              
authenticator.authenticate(inbound.getCredentials().getUserName(), password);
    +              final PlainFactory plainFactory = 
config.getAuthProvider().getPlainFactory();
    +              if (plainFactory == null) {
    +                throw new UserAuthenticationException("The server no 
longer supports username/password" +
    +                    " based authentication. Please talk to your system 
administrator.");
    +              }
    +              plainFactory.getAuthenticator()
    +                  .authenticate(userName, password);
    +              connection.changeHandlerTo(config.getMessageHandler());
    +              connection.finalizeSession(userName);
    +              respBuilder.setStatus(HandshakeStatus.SUCCESS);
    +              if (logger.isTraceEnabled()) {
    +                logger.trace("Authenticated {} successfully using PLAIN 
from {}", userName,
    +                    connection.getRemoteAddress());
    +              }
    +              return respBuilder.build();
                 } catch (UserAuthenticationException ex) {
                   return handleFailure(respBuilder, 
HandshakeStatus.AUTH_FAILED, ex.getMessage(), ex);
                 }
               }
     
    -          connection.setUser(inbound);
    -          return respBuilder.setStatus(HandshakeStatus.SUCCESS).build();
    +          // mention server's authentication capabilities
    +          
respBuilder.addAllAuthenticationMechanisms(config.getAuthProvider().getAllFactoryNames());
    +
    +          // for now, this means PLAIN credentials will be sent over twice
    --- End diff --
    
    just a thought if this is something you're worried about. What prevents the 
server to detect the plain credentials from the user, and try to perform the 
authentication directly (if plain is supported)?


> Kerberos Authentication
> -----------------------
>
>                 Key: DRILL-4280
>                 URL: https://issues.apache.org/jira/browse/DRILL-4280
>             Project: Apache Drill
>          Issue Type: Improvement
>            Reporter: Keys Botzum
>            Assignee: Sudheesh Katkam
>              Labels: security
>
> Drill should support Kerberos based authentication from clients. This means 
> that both the ODBC and JDBC drivers as well as the web/REST interfaces should 
> support inbound Kerberos. For Web this would most likely be SPNEGO while for 
> ODBC and JDBC this will be more generic Kerberos.
> Since Hive and much of Hadoop supports Kerberos there is a potential for a 
> lot of reuse of ideas if not implementation.
> Note that this is related to but not the same as 
> https://issues.apache.org/jira/browse/DRILL-3584 



--
This message was sent by Atlassian JIRA
(v6.3.15#6346)

Reply via email to