GODRIVER-216 Add SCRAM-SHA-256 and negotiation testing

Change-Id: Ie0fbcad1c6c3b4253a29735dd764b635ad507ac6

Author: xdg

core/auth/auth.go

@@ -25,6 +25,7 @@ var authFactories = make(map[string]AuthenticatorFactory)
 func init() {
 	RegisterAuthenticatorFactory("", newDefaultAuthenticator)
 	RegisterAuthenticatorFactory(SCRAMSHA1, newScramSHA1Authenticator)
+	RegisterAuthenticatorFactory(SCRAMSHA256, newScramSHA256Authenticator)
 	RegisterAuthenticatorFactory(MONGODBCR, newMongoDBCRAuthenticator)
 	RegisterAuthenticatorFactory(PLAIN, newPlainAuthenticator)
 	RegisterAuthenticatorFactory(GSSAPI, newGSSAPIAuthenticator)
@@ -90,19 +91,23 @@ func RegisterAuthenticatorFactory(name string, factory AuthenticatorFactory) {
 // 	})
 // }
 
-// HandshakeOptions packages options that can be passed to the Handshaker() function
+// HandshakeOptions packages options that can be passed to the Handshaker()
+// function.  DBUser is optional but must be of the form <dbname.username>;
+// if non-empty, then the connection will do SASL mechanism negotiation.
 type HandshakeOptions struct {
 	AppName       string
 	Authenticator Authenticator
 	Compressors   []string
+	DBUser        string
 }
 
 // Handshaker creates a connection handshaker for the given authenticator.
 func Handshaker(h connection.Handshaker, options *HandshakeOptions) connection.Handshaker {
 	return connection.HandshakerFunc(func(ctx context.Context, addr address.Address, rw wiremessage.ReadWriter) (description.Server, error) {
 		desc, err := (&command.Handshake{
-			Client:      command.ClientDoc(options.AppName),
-			Compressors: options.Compressors,
+			Client:             command.ClientDoc(options.AppName),
+			Compressors:        options.Compressors,
+			SaslSupportedMechs: options.DBUser,
 		}).Handshake(ctx, addr, rw)
 
 		if err != nil {

core/auth/auth_test.go

@@ -26,6 +26,7 @@ func TestCreateAuthenticator(t *testing.T) {
 	}{
 		{name: "", auther: &DefaultAuthenticator{}},
 		{name: "SCRAM-SHA-1", auther: &ScramSHA1Authenticator{}},
+		{name: "SCRAM-SHA-256", auther: &ScramSHA256Authenticator{}},
 		{name: "MONGODB-CR", auther: &MongoDBCRAuthenticator{}},
 		{name: "PLAIN", auther: &PlainAuthenticator{}},
 		{name: "MONGODB-X509", auther: &MongoDBX509Authenticator{}},

core/auth/default.go

@@ -29,10 +29,14 @@ type DefaultAuthenticator struct {
 func (a *DefaultAuthenticator) Auth(ctx context.Context, desc description.Server, rw wiremessage.ReadWriter) error {
 	var actual Authenticator
 	var err error
-	if err = description.ScramSHA1Supported(desc.WireVersion); err != nil {
-		actual, err = newMongoDBCRAuthenticator(a.Cred)
-	} else {
+
+	switch chooseAuthMechanism(desc) {
+	case SCRAMSHA256:
+		actual, err = newScramSHA256Authenticator(a.Cred)
+	case SCRAMSHA1:
 		actual, err = newScramSHA1Authenticator(a.Cred)
+	default:
+		actual, err = newMongoDBCRAuthenticator(a.Cred)
 	}
 
 	if err != nil {
@@ -41,3 +45,23 @@ func (a *DefaultAuthenticator) Auth(ctx context.Context, desc description.Server
 
 	return actual.Auth(ctx, desc, rw)
 }
+
+// If a server provides a list of supported mechanisms, we choose
+// SCRAM-SHA-256 if it exists or else MUST use SCRAM-SHA-1.
+// Otherwise, we decide based on what is supported.
+func chooseAuthMechanism(desc description.Server) string {
+	if desc.SaslSupportedMechs != nil {
+		for _, v := range desc.SaslSupportedMechs {
+			if v == SCRAMSHA256 {
+				return v
+			}
+		}
+		return SCRAMSHA1
+	}
+
+	if err := description.ScramSHA1Supported(desc.WireVersion); err == nil {
+		return SCRAMSHA1
+	}
+
+	return MONGODBCR
+}

core/auth/scramsha256.go

@@ -0,0 +1,76 @@
+// Copyright (C) MongoDB, Inc. 2018-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package auth
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/mongodb/mongo-go-driver/core/description"
+	"github.com/mongodb/mongo-go-driver/core/wiremessage"
+	"github.com/xdg/scram"
+	"github.com/xdg/stringprep"
+)
+
+// SCRAMSHA256 is the mechanism name for SCRAM-SHA-256.
+const SCRAMSHA256 = "SCRAM-SHA-256"
+
+func newScramSHA256Authenticator(cred *Cred) (Authenticator, error) {
+	passprep, err := stringprep.SASLprep.Prepare(cred.Password)
+	if err != nil {
+		return nil, newAuthError(fmt.Sprintf("error SASLprepping password '%s'", cred.Password), err)
+	}
+	client, err := scram.SHA256.NewClientUnprepped(cred.Username, passprep, "")
+	if err != nil {
+		return nil, newAuthError("error initializing SCRAM-SHA-256 client", err)
+	}
+	client.WithMinIterations(4096)
+	return &ScramSHA256Authenticator{
+		DB:     cred.Source,
+		client: client,
+	}, nil
+}
+
+// ScramSHA256Authenticator uses the SCRAM-SHA-256 algorithm over SASL to authenticate a connection.
+type ScramSHA256Authenticator struct {
+	DB     string
+	client *scram.Client
+}
+
+// Auth authenticates the connection.
+func (a *ScramSHA256Authenticator) Auth(ctx context.Context, desc description.Server, rw wiremessage.ReadWriter) error {
+	adapter := &scramSaslAdapter{conversation: a.client.NewConversation()}
+	err := ConductSaslConversation(ctx, desc, rw, a.DB, adapter)
+	if err != nil {
+		return newAuthError("sasl conversation error", err)
+	}
+	return nil
+}
+
+type scramSaslAdapter struct {
+	conversation *scram.ClientConversation
+}
+
+func (a *scramSaslAdapter) Start() (string, []byte, error) {
+	step, err := a.conversation.Step("")
+	if err != nil {
+		return SCRAMSHA256, nil, err
+	}
+	return SCRAMSHA256, []byte(step), nil
+}
+
+func (a *scramSaslAdapter) Next(challenge []byte) ([]byte, error) {
+	step, err := a.conversation.Step(string(challenge))
+	if err != nil {
+		return nil, err
+	}
+	return []byte(step), nil
+}
+
+func (a *scramSaslAdapter) Completed() bool {
+	return a.conversation.Done()
+}

core/command/handshake.go

@@ -23,8 +23,9 @@ import (
 //
 // The isMaster and buildInfo commands are used to build a server description.
 type Handshake struct {
-	Client      *bson.Document
-	Compressors []string
+	Client             *bson.Document
+	Compressors        []string
+	SaslSupportedMechs string
 
 	ismstr result.IsMaster
 	err    error
@@ -33,7 +34,11 @@ type Handshake struct {
 // Encode will encode the handshake commands into a wire message containing isMaster
 func (h *Handshake) Encode() (wiremessage.WireMessage, error) {
 	var wm wiremessage.WireMessage
-	ismstr, err := (&IsMaster{Client: h.Client, Compressors: h.Compressors}).Encode()
+	ismstr, err := (&IsMaster{
+		Client:             h.Client,
+		Compressors:        h.Compressors,
+		SaslSupportedMechs: h.SaslSupportedMechs,
+	}).Encode()
 	if err != nil {
 		return wm, err
 	}

core/command/ismaster.go

@@ -22,8 +22,9 @@ import (
 //
 // Since IsMaster can only be run on a connection, there is no Dispatch method.
 type IsMaster struct {
-	Client      *bson.Document
-	Compressors []string
+	Client             *bson.Document
+	Compressors        []string
+	SaslSupportedMechs string
 
 	err error
 	res result.IsMaster
@@ -35,6 +36,9 @@ func (im *IsMaster) Encode() (wiremessage.WireMessage, error) {
 	if im.Client != nil {
 		cmd.Append(bson.EC.SubDocument("client", im.Client))
 	}
+	if im.SaslSupportedMechs != "" {
+		cmd.Append(bson.EC.String("saslSupportedMechs", im.SaslSupportedMechs))
+	}
 
 	// always send compressors even if empty slice
 	array := bson.NewArray()

core/connstring/connstring_test.go

@@ -48,6 +48,7 @@ func TestAuthMechanism(t *testing.T) {
 		err      bool
 	}{
 		{s: "authMechanism=scram-sha-1", expected: "scram-sha-1"},
+		{s: "authMechanism=scram-sha-256", expected: "scram-sha-256"},
 		{s: "authMechanism=mongodb-CR", expected: "mongodb-CR"},
 		{s: "authMechanism=plain", expected: "plain"},
 	}

core/description/server.go

@@ -50,6 +50,8 @@ type Server struct {
 	Tags                  tag.Set
 	Kind                  ServerKind
 	WireVersion           *VersionRange
+
+	SaslSupportedMechs []string // user-specific from server handshake
 }
 
 // NewServer creates a new server description from the given parameters.
@@ -65,6 +67,7 @@ func NewServer(addr address.Address, isMaster result.IsMaster) Server {
 		MaxBatchCount:         isMaster.MaxWriteBatchSize,
 		MaxDocumentSize:       isMaster.MaxBSONObjectSize,
 		MaxMessageSize:        isMaster.MaxMessageSizeBytes,
+		SaslSupportedMechs:    isMaster.SaslSupportedMechs,
 		SessionTimeoutMinutes: isMaster.LogicalSessionTimeoutMinutes,
 		SetName:               isMaster.SetName,
 		SetVersion:            isMaster.SetVersion,

core/integration/main_test.go

@@ -16,6 +16,7 @@ import (
 	"sync"
 	"testing"
 
+	"github.com/mongodb/mongo-go-driver/core/auth"
 	"github.com/mongodb/mongo-go-driver/core/connection"
 	"github.com/mongodb/mongo-go-driver/core/connstring"
 )
@@ -52,11 +53,21 @@ func TestMain(m *testing.M) {
 func noerr(t *testing.T, err error) {
 	if err != nil {
 		t.Helper()
-		t.Errorf("Unepexted error: %v", err)
+		t.Errorf("Unexpected error: %v", err)
 		t.FailNow()
 	}
 }
 
+func autherr(t *testing.T, err error) {
+	t.Helper()
+	switch err.(type) {
+	case *auth.Error:
+		return
+	default:
+		t.Fatal("Expected auth error and didn't get one")
+	}
+}
+
 // addTLSConfigToURI checks for the environmental variable indicating that the tests are being run
 // on an SSL-enabled server, and if so, returns a new URI with the necessary configuration.
 func addTLSConfigToURI(uri string) string {