Autenticação

MongoCredential

Inclua as seguintes declarações de importação:

import org.mongodb.scala._
import scala.collection.JavaConverters._

Uma credencial de autenticação é representada como uma instância da classe MongoCredential . A classe MongoCredential inclui métodos auxiliares para cada um dos mecanismos de autenticação suportados.

Mecanismo de autenticação padrão

No MongoDB 3.0, O MongoDB alterou o mecanismo de autenticação padrão de MONGODB-CR para SCRAM-SHA-1. No MongoDB 4.0, o suporte para o mecanismo MONGODB-CR obsoleto foi removido e o suporte SCRAM-SHA-256 foi adicionado.

Para criar uma credencial que autentique usando o mecanismo de autenticação padrão, independentemente da versão do servidor, crie uma credencial usando o método auxiliar createCredential() :

val user: String = ...          // the user name
val source: String = ...        // the source where the user is defined
val password: Array[Char] = ... // the password as a character array
// ...
val credential = MongoCredential.createCredential(user, source, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string sem especificar explicitamente o mecanismo de autenticação:

val mongoClient: MongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1")

Para mecanismos de desafio e resposta, o uso do mecanismo de autenticação padrão é a abordagem recomendada, pois ele torna a atualização do MongoDB 2.6 para o MongoDB 3.0 mais simples, mesmo após a atualização do esquema de autenticação. Para usuários do MongoDB 4.0 , o uso do mecanismo de autenticação padrão também é recomendado, pois os mecanismos são verificados e o algoritmo de hash correto é usado.

Mecanismos baseados em SCRAM

Salted Challenge-Response Authentication Mechanism (SCRAM) has been the default authentication mechanism for MongoDB since 3.0. SCRAM is based on the IETF RFC 5802 standard that defines best practices for implementation of challenge-response mechanisms for authenticating users with passwords.

O MongoDB 3.0 introduziu suporte para SCRAM-SHA-1, que usa a função de hash SHA-1 . O MongoDB 4.0 introduziu suporte para SCRAM-SHA-256 que usa a função de hash SHA-256 .

val user: String = ...          // the user name
val source: String = ...        // the source where the user is defined
val password: Array[Char] = ... // the password as a character array
// ...
val credential = MongoCredential.createScramSha256Credential(user, source, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

val mongoClient: MongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1&authMechanism=SCRAM-SHA-256")

val user: String = ...          // the user name
val source: String = ...        // the source where the user is defined
val password: Array[Char] = ... // the password as a character array
// ...
val credential = MongoCredential.createScramSha1Credential(user, source, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

val mongoClient: MongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1&authMechanism=SCRAM-SHA-1")

MONGODB-CR

Para criar explicitamente uma credencial do tipo MONGODB-CR utilize o método assistente createMongCRCredential() :

val user: String = ...          // the user name
val source: String = ...        // the source where the user is defined
val password: Array[Char] = ... // the password as a character array
// ...
val credential = MongoCredential.createMongoCRCredential(user, database, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string que especifique explicitamente authMechanism=MONGODB-CR:

val mongoClient: MongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1&authMechanism=MONGODB-CR")

X.509

Com o mecanismo X.509 , o MongoDB usa o certificado X.509 apresentado durante a negociação SSL para autenticar um usuário cujo nome é derivado do nome distinto do certificado X.509 .

X. A autenticação 509 requer o uso de conexões SSL com validação de certificado. Para criar uma credencial deste tipo, use o método assistente createMongoX509Credential() :

val user: String = ...     // The X.509 certificate derived user name, e.g. "CN=user,OU=OrgUnit,O=myOrg,..."
// ...
val credential = MongoCredential.createMongoX509Credential(user)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string que especifique explicitamente authMechanism=MONGODB-X509:

val mongoClient: MongoClient = MongoClient("mongodb://subjectName@host1/?authMechanism=MONGODB-X509&ssl=true")

Veja Usar x.509 Tutorial de certificados para autenticação de clientes no manual do servidor MongoDB para saber mais sobre como determinar o nome do assunto a partir do certificado.

Kerberos (GSSAPI)

O MongoDB Enterprise oferece suporte à autenticação proxy por meio do serviço Kerberos. Para criar uma credencial do tipo Kerberos (GSSAPI), utilize o método auxiliar createGSSAPICredential() :

val user: String = ...   // The Kerberos user name, including the realm, e.g. "user1@MYREALM.ME"
// ...
val credential = MongoCredential.createGSSAPICredential(user)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string que especifique explicitamente authMechanism=GSSAPI:

val mongoClient: MongoClient = MongoClient("mongodb://username%40REALM.ME@host1/?authMechanism=GSSAPI")

Para autenticar com êxito usando o Kerberos, o aplicativo normalmente deve especificar várias propriedades do sistema para que as bibliotecas Java GSSAPI subjacentes possam adquirir um ticket Kerberos:

java.security.krb5.realm=MYREALM.ME
java.security.krb5.kdc=mykdc.myrealm.me

Dependendo da configuração do Kerberos, podem ser necessárias especificações de propriedade adicionais, dentro do código do aplicativo ou, em alguns casos, usando o método withMechanismProperty() da instância MongoCredential :

• SERVICE_NAME

• CANONICALIZE_HOST_NAME

• JAVA_SUBJECT

• JAVA_SASL_CLIENT_PROPERTIES

O seguinte código mostra como especificar a propriedade SERVICE_NAME dentro do objeto MongoCredential :

val credentialWithProperty = credential.withMechanismProperty(MongoCredential.SERVICE_NAME_KEY, "othername")

Ou você pode especificar a propriedade SERVICE_NAME dentro de ConnectionString:

val uri = "mongodb://username%40MYREALM.com@myserver/?authMechanism=GSSAPI&authMechanismProperties=SERVICE_NAME:othername"

LDAP (simples)

O MongoDB Enterprise oferece suporte à autenticação proxy por meio de um serviço Lightweight Directory Access Protocol (LDAP). Para criar uma credencial do tipo LDAP , use o método auxiliar createPlainCredential() :

val user: String = ...            // The LDAP user name
val password: Array[Char] = ...   // The LDAP password
// ...
val credential = MongoCredential.createPlainCredential(user, "$external", password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Ou você pode usar uma connection string que especifique explicitamente authMechanism=PLAIN:

val mongoClient: MongoClient = MongoClient("mongodb://user1@host1/?authSource=$external&authMechanism=PLAIN")