2014-11-18 16:03:36 +00:00
|
|
|
package tlsutil
|
2014-04-07 20:05:43 +00:00
|
|
|
|
|
|
|
import (
|
2019-03-13 09:29:06 +00:00
|
|
|
"bytes"
|
2014-04-07 20:05:43 +00:00
|
|
|
"crypto/tls"
|
2014-05-26 17:58:57 +00:00
|
|
|
"crypto/x509"
|
2019-03-13 09:29:06 +00:00
|
|
|
"fmt"
|
2014-06-30 01:11:32 +00:00
|
|
|
"io"
|
|
|
|
"io/ioutil"
|
2019-03-13 09:29:06 +00:00
|
|
|
"log"
|
2014-06-30 01:11:32 +00:00
|
|
|
"net"
|
2017-04-27 08:29:39 +00:00
|
|
|
"reflect"
|
|
|
|
"strings"
|
2014-04-07 20:05:43 +00:00
|
|
|
"testing"
|
2015-05-11 23:05:39 +00:00
|
|
|
|
|
|
|
"github.com/hashicorp/yamux"
|
2018-12-17 17:56:18 +00:00
|
|
|
"github.com/stretchr/testify/require"
|
2014-04-07 20:05:43 +00:00
|
|
|
)
|
|
|
|
|
2014-06-30 01:11:32 +00:00
|
|
|
func startTLSServer(config *Config) (net.Conn, chan error) {
|
|
|
|
errc := make(chan error, 1)
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c, err := NewConfigurator(*config, nil)
|
2014-06-30 01:11:32 +00:00
|
|
|
if err != nil {
|
|
|
|
errc <- err
|
|
|
|
return nil, errc
|
|
|
|
}
|
2019-03-13 09:29:06 +00:00
|
|
|
tlsConfigServer := c.IncomingRPCConfig()
|
2014-06-30 01:11:32 +00:00
|
|
|
client, server := net.Pipe()
|
2015-05-11 23:05:39 +00:00
|
|
|
|
|
|
|
// Use yamux to buffer the reads, otherwise it's easy to deadlock
|
|
|
|
muxConf := yamux.DefaultConfig()
|
|
|
|
serverSession, _ := yamux.Server(server, muxConf)
|
|
|
|
clientSession, _ := yamux.Client(client, muxConf)
|
|
|
|
clientConn, _ := clientSession.Open()
|
|
|
|
serverConn, _ := serverSession.Accept()
|
|
|
|
|
2014-06-30 01:11:32 +00:00
|
|
|
go func() {
|
2015-05-11 23:05:39 +00:00
|
|
|
tlsServer := tls.Server(serverConn, tlsConfigServer)
|
2014-06-30 01:11:32 +00:00
|
|
|
if err := tlsServer.Handshake(); err != nil {
|
|
|
|
errc <- err
|
|
|
|
}
|
|
|
|
close(errc)
|
2016-11-08 02:15:26 +00:00
|
|
|
|
2014-06-30 01:11:32 +00:00
|
|
|
// Because net.Pipe() is unbuffered, if both sides
|
|
|
|
// Close() simultaneously, we will deadlock as they
|
|
|
|
// both send an alert and then block. So we make the
|
|
|
|
// server read any data from the client until error or
|
|
|
|
// EOF, which will allow the client to Close(), and
|
|
|
|
// *then* we Close() the server.
|
|
|
|
io.Copy(ioutil.Discard, tlsServer)
|
|
|
|
tlsServer.Close()
|
|
|
|
}()
|
2015-05-11 23:05:39 +00:00
|
|
|
return clientConn, errc
|
|
|
|
}
|
|
|
|
|
2019-02-26 15:52:07 +00:00
|
|
|
func TestConfigurator_outgoingWrapper_OK(t *testing.T) {
|
2019-03-13 09:29:06 +00:00
|
|
|
config := Config{
|
2015-05-11 23:05:39 +00:00
|
|
|
CAFile: "../test/hostname/CertAuth.crt",
|
|
|
|
CertFile: "../test/hostname/Alice.crt",
|
|
|
|
KeyFile: "../test/hostname/Alice.key",
|
|
|
|
VerifyServerHostname: true,
|
2018-12-06 21:51:49 +00:00
|
|
|
VerifyOutgoing: true,
|
2015-05-11 23:05:39 +00:00
|
|
|
Domain: "consul",
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
client, errc := startTLSServer(&config)
|
|
|
|
if client == nil {
|
|
|
|
t.Fatalf("startTLSServer err: %v", <-errc)
|
|
|
|
}
|
|
|
|
|
|
|
|
c, err := NewConfigurator(config, nil)
|
|
|
|
require.NoError(t, err)
|
|
|
|
wrap := c.OutgoingRPCWrapper()
|
|
|
|
require.NotNil(t, wrap)
|
|
|
|
|
|
|
|
tlsClient, err := wrap("dc1", client)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
defer tlsClient.Close()
|
|
|
|
err = tlsClient.(*tls.Conn).Handshake()
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
err = <-errc
|
|
|
|
require.NoError(t, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestConfigurator_outgoingWrapper_noverify_OK(t *testing.T) {
|
|
|
|
config := Config{
|
|
|
|
CAFile: "../test/hostname/CertAuth.crt",
|
|
|
|
CertFile: "../test/hostname/Alice.crt",
|
|
|
|
KeyFile: "../test/hostname/Alice.key",
|
|
|
|
Domain: "consul",
|
|
|
|
}
|
|
|
|
|
|
|
|
client, errc := startTLSServer(&config)
|
2015-05-11 23:05:39 +00:00
|
|
|
if client == nil {
|
|
|
|
t.Fatalf("startTLSServer err: %v", <-errc)
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c, err := NewConfigurator(config, nil)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
wrap := c.OutgoingRPCWrapper()
|
|
|
|
require.NotNil(t, wrap)
|
2015-05-11 23:05:39 +00:00
|
|
|
|
|
|
|
tlsClient, err := wrap("dc1", client)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2015-05-11 23:05:39 +00:00
|
|
|
defer tlsClient.Close()
|
2019-02-26 15:52:07 +00:00
|
|
|
err = tlsClient.(*tls.Conn).Handshake()
|
|
|
|
require.NoError(t, err)
|
2015-05-11 23:05:39 +00:00
|
|
|
|
|
|
|
err = <-errc
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2015-05-11 23:05:39 +00:00
|
|
|
}
|
|
|
|
|
2019-02-26 15:52:07 +00:00
|
|
|
func TestConfigurator_outgoingWrapper_BadDC(t *testing.T) {
|
2019-03-13 09:29:06 +00:00
|
|
|
config := Config{
|
2015-05-11 23:05:39 +00:00
|
|
|
CAFile: "../test/hostname/CertAuth.crt",
|
|
|
|
CertFile: "../test/hostname/Alice.crt",
|
|
|
|
KeyFile: "../test/hostname/Alice.key",
|
|
|
|
VerifyServerHostname: true,
|
2018-12-06 21:51:49 +00:00
|
|
|
VerifyOutgoing: true,
|
2015-05-11 23:05:39 +00:00
|
|
|
Domain: "consul",
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
client, errc := startTLSServer(&config)
|
2015-05-11 23:05:39 +00:00
|
|
|
if client == nil {
|
|
|
|
t.Fatalf("startTLSServer err: %v", <-errc)
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c, err := NewConfigurator(config, nil)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
wrap := c.OutgoingRPCWrapper()
|
2015-05-11 23:05:39 +00:00
|
|
|
|
|
|
|
tlsClient, err := wrap("dc2", client)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2015-05-11 23:05:39 +00:00
|
|
|
err = tlsClient.(*tls.Conn).Handshake()
|
2019-02-26 15:52:07 +00:00
|
|
|
_, ok := err.(x509.HostnameError)
|
|
|
|
require.True(t, ok)
|
2016-11-08 02:15:26 +00:00
|
|
|
tlsClient.Close()
|
2015-05-11 23:05:39 +00:00
|
|
|
|
|
|
|
<-errc
|
|
|
|
}
|
|
|
|
|
2019-02-26 15:52:07 +00:00
|
|
|
func TestConfigurator_outgoingWrapper_BadCert(t *testing.T) {
|
2019-03-13 09:29:06 +00:00
|
|
|
config := Config{
|
2015-05-11 23:05:39 +00:00
|
|
|
CAFile: "../test/ca/root.cer",
|
|
|
|
CertFile: "../test/key/ourdomain.cer",
|
|
|
|
KeyFile: "../test/key/ourdomain.key",
|
|
|
|
VerifyServerHostname: true,
|
2018-12-06 21:51:49 +00:00
|
|
|
VerifyOutgoing: true,
|
2015-05-11 23:05:39 +00:00
|
|
|
Domain: "consul",
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
client, errc := startTLSServer(&config)
|
2015-05-11 23:05:39 +00:00
|
|
|
if client == nil {
|
|
|
|
t.Fatalf("startTLSServer err: %v", <-errc)
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c, err := NewConfigurator(config, nil)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
wrap := c.OutgoingRPCWrapper()
|
2015-05-11 23:05:39 +00:00
|
|
|
|
|
|
|
tlsClient, err := wrap("dc1", client)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2015-05-11 23:05:39 +00:00
|
|
|
err = tlsClient.(*tls.Conn).Handshake()
|
|
|
|
if _, ok := err.(x509.HostnameError); !ok {
|
|
|
|
t.Fatalf("should get hostname err: %v", err)
|
|
|
|
}
|
2016-11-08 02:15:26 +00:00
|
|
|
tlsClient.Close()
|
2015-05-11 23:05:39 +00:00
|
|
|
|
|
|
|
<-errc
|
2014-06-30 01:11:32 +00:00
|
|
|
}
|
|
|
|
|
2019-02-26 15:52:07 +00:00
|
|
|
func TestConfigurator_wrapTLS_OK(t *testing.T) {
|
2019-03-13 09:29:06 +00:00
|
|
|
config := Config{
|
2014-06-30 01:11:32 +00:00
|
|
|
CAFile: "../test/ca/root.cer",
|
|
|
|
CertFile: "../test/key/ourdomain.cer",
|
|
|
|
KeyFile: "../test/key/ourdomain.key",
|
|
|
|
VerifyOutgoing: true,
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
client, errc := startTLSServer(&config)
|
2014-06-30 01:11:32 +00:00
|
|
|
if client == nil {
|
|
|
|
t.Fatalf("startTLSServer err: %v", <-errc)
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c, err := NewConfigurator(config, nil)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2014-06-30 01:11:32 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
tlsClient, err := c.wrapTLSClient("dc1", client)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
tlsClient.Close()
|
2014-06-30 01:11:32 +00:00
|
|
|
err = <-errc
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2014-06-30 01:11:32 +00:00
|
|
|
}
|
|
|
|
|
2019-02-26 15:52:07 +00:00
|
|
|
func TestConfigurator_wrapTLS_BadCert(t *testing.T) {
|
2014-06-30 01:11:32 +00:00
|
|
|
serverConfig := &Config{
|
|
|
|
CertFile: "../test/key/ssl-cert-snakeoil.pem",
|
|
|
|
KeyFile: "../test/key/ssl-cert-snakeoil.key",
|
|
|
|
}
|
|
|
|
|
|
|
|
client, errc := startTLSServer(serverConfig)
|
|
|
|
if client == nil {
|
|
|
|
t.Fatalf("startTLSServer err: %v", <-errc)
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
clientConfig := Config{
|
2014-06-30 01:11:32 +00:00
|
|
|
CAFile: "../test/ca/root.cer",
|
|
|
|
VerifyOutgoing: true,
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c, err := NewConfigurator(clientConfig, nil)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
tlsClient, err := c.wrapTLSClient("dc1", client)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.Error(t, err)
|
|
|
|
require.Nil(t, tlsClient)
|
2014-06-30 01:11:32 +00:00
|
|
|
|
|
|
|
err = <-errc
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2017-02-01 20:52:04 +00:00
|
|
|
}
|
2017-04-27 08:29:39 +00:00
|
|
|
|
|
|
|
func TestConfig_ParseCiphers(t *testing.T) {
|
|
|
|
testOk := strings.Join([]string{
|
2018-03-13 16:50:41 +00:00
|
|
|
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305",
|
|
|
|
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305",
|
|
|
|
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
|
2017-04-27 08:29:39 +00:00
|
|
|
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
|
2018-03-13 16:50:41 +00:00
|
|
|
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
|
2017-04-27 08:29:39 +00:00
|
|
|
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
|
2018-03-13 16:50:41 +00:00
|
|
|
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
|
2017-04-27 08:29:39 +00:00
|
|
|
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
|
2018-03-13 16:50:41 +00:00
|
|
|
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
|
|
|
|
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
|
2017-04-27 08:29:39 +00:00
|
|
|
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
|
2018-03-13 16:50:41 +00:00
|
|
|
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
|
2017-04-27 08:29:39 +00:00
|
|
|
"TLS_RSA_WITH_AES_128_GCM_SHA256",
|
|
|
|
"TLS_RSA_WITH_AES_256_GCM_SHA384",
|
2018-03-13 16:50:41 +00:00
|
|
|
"TLS_RSA_WITH_AES_128_CBC_SHA256",
|
|
|
|
"TLS_RSA_WITH_AES_128_CBC_SHA",
|
|
|
|
"TLS_RSA_WITH_AES_256_CBC_SHA",
|
|
|
|
"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
|
|
|
|
"TLS_RSA_WITH_3DES_EDE_CBC_SHA",
|
|
|
|
"TLS_RSA_WITH_RC4_128_SHA",
|
|
|
|
"TLS_ECDHE_RSA_WITH_RC4_128_SHA",
|
2018-03-13 17:30:18 +00:00
|
|
|
"TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
|
2017-04-27 08:29:39 +00:00
|
|
|
}, ",")
|
|
|
|
ciphers := []uint16{
|
2018-03-13 16:50:41 +00:00
|
|
|
tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
|
|
|
|
tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
|
|
|
|
tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
|
2017-04-27 08:29:39 +00:00
|
|
|
tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
|
2018-03-13 16:50:41 +00:00
|
|
|
tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
|
2017-04-27 08:29:39 +00:00
|
|
|
tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
|
2018-03-13 16:50:41 +00:00
|
|
|
tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
|
2017-04-27 08:29:39 +00:00
|
|
|
tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
|
2018-03-13 16:50:41 +00:00
|
|
|
tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
|
|
|
|
tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
|
2017-04-27 08:29:39 +00:00
|
|
|
tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
|
2018-03-13 16:50:41 +00:00
|
|
|
tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
|
2017-04-27 08:29:39 +00:00
|
|
|
tls.TLS_RSA_WITH_AES_128_GCM_SHA256,
|
|
|
|
tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
|
2018-03-13 16:50:41 +00:00
|
|
|
tls.TLS_RSA_WITH_AES_128_CBC_SHA256,
|
|
|
|
tls.TLS_RSA_WITH_AES_128_CBC_SHA,
|
|
|
|
tls.TLS_RSA_WITH_AES_256_CBC_SHA,
|
|
|
|
tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
|
|
|
|
tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
|
|
|
|
tls.TLS_RSA_WITH_RC4_128_SHA,
|
|
|
|
tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA,
|
2018-03-13 17:30:18 +00:00
|
|
|
tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
|
2017-04-27 08:29:39 +00:00
|
|
|
}
|
|
|
|
v, err := ParseCiphers(testOk)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.NoError(t, err)
|
2017-04-27 08:29:39 +00:00
|
|
|
if got, want := v, ciphers; !reflect.DeepEqual(got, want) {
|
|
|
|
t.Fatalf("got ciphers %#v want %#v", got, want)
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
_, err = ParseCiphers("TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,cipherX")
|
|
|
|
require.Error(t, err)
|
2019-02-26 15:52:07 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
v, err = ParseCiphers("")
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Equal(t, []uint16{}, v)
|
2019-02-26 15:52:07 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_loadKeyPair(t *testing.T) {
|
|
|
|
type variant struct {
|
|
|
|
cert, key string
|
|
|
|
shoulderr bool
|
|
|
|
isnil bool
|
2019-02-26 15:52:07 +00:00
|
|
|
}
|
2019-03-13 09:29:06 +00:00
|
|
|
variants := []variant{
|
|
|
|
{"", "", false, true},
|
|
|
|
{"bogus", "", false, true},
|
|
|
|
{"", "bogus", false, true},
|
|
|
|
{"../test/key/ourdomain.cer", "", false, true},
|
|
|
|
{"", "../test/key/ourdomain.key", false, true},
|
|
|
|
{"bogus", "bogus", true, true},
|
|
|
|
{"../test/key/ourdomain.cer", "../test/key/ourdomain.key",
|
|
|
|
false, false},
|
2019-02-26 15:52:07 +00:00
|
|
|
}
|
2019-03-13 09:29:06 +00:00
|
|
|
for _, v := range variants {
|
|
|
|
cert1, err1 := loadKeyPair(v.cert, v.key)
|
|
|
|
config := &Config{CertFile: v.cert, KeyFile: v.key}
|
|
|
|
cert2, err2 := config.KeyPair()
|
|
|
|
if v.shoulderr {
|
|
|
|
require.Error(t, err1)
|
|
|
|
require.Error(t, err2)
|
|
|
|
} else {
|
|
|
|
require.NoError(t, err1)
|
|
|
|
require.NoError(t, err2)
|
|
|
|
}
|
|
|
|
if v.isnil {
|
|
|
|
require.Nil(t, cert1)
|
|
|
|
require.Nil(t, cert2)
|
|
|
|
} else {
|
|
|
|
require.NotNil(t, cert1)
|
|
|
|
require.NotNil(t, cert2)
|
|
|
|
}
|
2019-02-26 15:52:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfig_SpecifyDC(t *testing.T) {
|
|
|
|
require.Nil(t, SpecificDC("", nil))
|
|
|
|
dcwrap := func(dc string, conn net.Conn) (net.Conn, error) { return nil, nil }
|
|
|
|
wrap := SpecificDC("", dcwrap)
|
|
|
|
require.NotNil(t, wrap)
|
|
|
|
conn, err := wrap(nil)
|
2019-02-26 15:52:07 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Nil(t, conn)
|
2019-02-26 15:52:07 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_NewConfigurator(t *testing.T) {
|
|
|
|
buf := bytes.Buffer{}
|
|
|
|
logger := log.New(&buf, "logger: ", log.Lshortfile)
|
|
|
|
c, err := NewConfigurator(Config{}, logger)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.NotNil(t, c)
|
|
|
|
require.Equal(t, logger, c.logger)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c, err = NewConfigurator(Config{VerifyOutgoing: true}, nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.Error(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Nil(t, c)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestConfigurator_ErrorPropagation(t *testing.T) {
|
|
|
|
type variant struct {
|
|
|
|
config Config
|
|
|
|
shouldErr bool
|
|
|
|
excludeCheck bool
|
|
|
|
}
|
|
|
|
cafile := "../test/ca/root.cer"
|
|
|
|
capath := "../test/ca_path"
|
|
|
|
certfile := "../test/key/ourdomain.cer"
|
|
|
|
keyfile := "../test/key/ourdomain.key"
|
|
|
|
variants := []variant{
|
|
|
|
{Config{}, false, false},
|
|
|
|
{Config{TLSMinVersion: "tls9"}, true, false},
|
|
|
|
{Config{TLSMinVersion: ""}, false, false},
|
|
|
|
{Config{TLSMinVersion: "tls10"}, false, false},
|
|
|
|
{Config{TLSMinVersion: "tls11"}, false, false},
|
|
|
|
{Config{TLSMinVersion: "tls12"}, false, false},
|
|
|
|
{Config{VerifyOutgoing: true, CAFile: "", CAPath: ""}, true, false},
|
|
|
|
{Config{VerifyOutgoing: false, CAFile: "", CAPath: ""}, false, false},
|
|
|
|
{Config{VerifyOutgoing: false, CAFile: cafile, CAPath: ""},
|
|
|
|
false, false},
|
|
|
|
{Config{VerifyOutgoing: false, CAFile: "", CAPath: capath},
|
|
|
|
false, false},
|
|
|
|
{Config{VerifyOutgoing: false, CAFile: cafile, CAPath: capath},
|
|
|
|
false, false},
|
|
|
|
{Config{VerifyOutgoing: true, CAFile: cafile, CAPath: ""},
|
|
|
|
false, false},
|
|
|
|
{Config{VerifyOutgoing: true, CAFile: "", CAPath: capath},
|
|
|
|
false, false},
|
|
|
|
{Config{VerifyOutgoing: true, CAFile: cafile, CAPath: capath},
|
|
|
|
false, false},
|
|
|
|
{Config{VerifyIncoming: true, CAFile: "", CAPath: ""}, true, false},
|
|
|
|
{Config{VerifyIncomingRPC: true, CAFile: "", CAPath: ""},
|
|
|
|
true, false},
|
|
|
|
{Config{VerifyIncomingHTTPS: true, CAFile: "", CAPath: ""},
|
|
|
|
true, false},
|
|
|
|
{Config{VerifyIncoming: true, CAFile: cafile, CAPath: ""}, true, false},
|
|
|
|
{Config{VerifyIncoming: true, CAFile: "", CAPath: capath}, true, false},
|
|
|
|
{Config{VerifyIncoming: true, CAFile: "", CAPath: capath,
|
|
|
|
CertFile: certfile, KeyFile: keyfile}, false, false},
|
|
|
|
{Config{CertFile: "bogus", KeyFile: "bogus"}, true, true},
|
|
|
|
{Config{CAFile: "bogus"}, true, true},
|
|
|
|
{Config{CAPath: "bogus"}, true, true},
|
|
|
|
}
|
|
|
|
|
|
|
|
c := &Configurator{}
|
|
|
|
for i, v := range variants {
|
|
|
|
info := fmt.Sprintf("case %d", i)
|
|
|
|
_, err1 := NewConfigurator(v.config, nil)
|
|
|
|
err2 := c.Update(v.config)
|
|
|
|
|
|
|
|
var err3 error
|
|
|
|
if !v.excludeCheck {
|
|
|
|
cert, err := v.config.KeyPair()
|
|
|
|
require.NoError(t, err, info)
|
|
|
|
cas, _ := loadCAs(v.config.CAFile, v.config.CAPath)
|
|
|
|
require.NoError(t, err, info)
|
|
|
|
err3 = c.check(v.config, cas, cert)
|
|
|
|
}
|
|
|
|
if v.shouldErr {
|
|
|
|
require.Error(t, err1, info)
|
|
|
|
require.Error(t, err2, info)
|
|
|
|
if !v.excludeCheck {
|
|
|
|
require.Error(t, err3, info)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
require.NoError(t, err1, info)
|
|
|
|
require.NoError(t, err2, info)
|
|
|
|
if !v.excludeCheck {
|
|
|
|
require.NoError(t, err3, info)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestConfigurator_CommonTLSConfigServerNameNodeName(t *testing.T) {
|
|
|
|
type variant struct {
|
2019-03-13 09:29:06 +00:00
|
|
|
config Config
|
2019-02-27 09:14:59 +00:00
|
|
|
result string
|
|
|
|
}
|
|
|
|
variants := []variant{
|
2019-03-13 09:29:06 +00:00
|
|
|
{config: Config{NodeName: "node", ServerName: "server"},
|
2019-02-27 09:14:59 +00:00
|
|
|
result: "server"},
|
2019-03-13 09:29:06 +00:00
|
|
|
{config: Config{ServerName: "server"},
|
2019-02-27 09:14:59 +00:00
|
|
|
result: "server"},
|
2019-03-13 09:29:06 +00:00
|
|
|
{config: Config{NodeName: "node"},
|
2019-02-27 09:14:59 +00:00
|
|
|
result: "node"},
|
|
|
|
}
|
|
|
|
for _, v := range variants {
|
2019-03-13 09:29:06 +00:00
|
|
|
c, err := NewConfigurator(v.config, nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
tlsConf := c.commonTLSConfig(false)
|
2019-03-05 20:35:43 +00:00
|
|
|
require.Empty(t, tlsConf.ServerName)
|
2019-02-26 15:52:07 +00:00
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_loadCAs(t *testing.T) {
|
|
|
|
type variant struct {
|
|
|
|
cafile, capath string
|
|
|
|
shouldErr bool
|
|
|
|
isNil bool
|
|
|
|
count int
|
|
|
|
}
|
|
|
|
variants := []variant{
|
|
|
|
{"", "", false, true, 0},
|
|
|
|
{"bogus", "", true, true, 0},
|
|
|
|
{"", "bogus", true, true, 0},
|
|
|
|
{"", "../test/bin", true, true, 0},
|
|
|
|
{"../test/ca/root.cer", "", false, false, 1},
|
|
|
|
{"", "../test/ca_path", false, false, 2},
|
|
|
|
{"../test/ca/root.cer", "../test/ca_path", false, false, 1},
|
|
|
|
}
|
|
|
|
for i, v := range variants {
|
|
|
|
cas, err := loadCAs(v.cafile, v.capath)
|
|
|
|
info := fmt.Sprintf("case %d", i)
|
|
|
|
if v.shouldErr {
|
|
|
|
require.Error(t, err, info)
|
|
|
|
} else {
|
|
|
|
require.NoError(t, err, info)
|
|
|
|
}
|
|
|
|
if v.isNil {
|
|
|
|
require.Nil(t, cas, info)
|
|
|
|
} else {
|
|
|
|
require.NotNil(t, cas, info)
|
|
|
|
require.Len(t, cas.Subjects(), v.count, info)
|
|
|
|
}
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_CommonTLSConfigInsecureSkipVerify(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{}, nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
tlsConf := c.commonTLSConfig(false)
|
|
|
|
require.True(t, tlsConf.InsecureSkipVerify)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
require.NoError(t, c.Update(Config{VerifyServerHostname: false}))
|
|
|
|
tlsConf = c.commonTLSConfig(false)
|
|
|
|
require.True(t, tlsConf.InsecureSkipVerify)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
require.NoError(t, c.Update(Config{VerifyServerHostname: true}))
|
|
|
|
tlsConf = c.commonTLSConfig(false)
|
|
|
|
require.False(t, tlsConf.InsecureSkipVerify)
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_CommonTLSConfigPreferServerCipherSuites(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{}, nil)
|
|
|
|
require.NoError(t, err)
|
|
|
|
tlsConf := c.commonTLSConfig(false)
|
|
|
|
require.False(t, tlsConf.PreferServerCipherSuites)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
require.NoError(t, c.Update(Config{PreferServerCipherSuites: false}))
|
|
|
|
tlsConf = c.commonTLSConfig(false)
|
|
|
|
require.False(t, tlsConf.PreferServerCipherSuites)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
require.NoError(t, c.Update(Config{PreferServerCipherSuites: true}))
|
|
|
|
tlsConf = c.commonTLSConfig(false)
|
|
|
|
require.True(t, tlsConf.PreferServerCipherSuites)
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_CommonTLSConfigCipherSuites(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{}, nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
tlsConf := c.commonTLSConfig(false)
|
|
|
|
require.Empty(t, tlsConf.CipherSuites)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
conf := Config{CipherSuites: []uint16{
|
|
|
|
tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305}}
|
|
|
|
require.NoError(t, c.Update(conf))
|
|
|
|
tlsConf = c.commonTLSConfig(false)
|
|
|
|
require.Equal(t, conf.CipherSuites, tlsConf.CipherSuites)
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_CommonTLSConfigGetClientCertificate(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{}, nil)
|
|
|
|
require.NoError(t, err)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
cert, err := c.commonTLSConfig(false).GetCertificate(nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Nil(t, cert)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c.cert = &tls.Certificate{}
|
|
|
|
cert, err = c.commonTLSConfig(false).GetCertificate(nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Equal(t, c.cert, cert)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
cert, err = c.commonTLSConfig(false).GetClientCertificate(nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Equal(t, c.cert, cert)
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_CommonTLSConfigCAs(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{}, nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Nil(t, c.commonTLSConfig(false).ClientCAs)
|
|
|
|
require.Nil(t, c.commonTLSConfig(false).RootCAs)
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
c.cas = &x509.CertPool{}
|
|
|
|
require.Equal(t, c.cas, c.commonTLSConfig(false).ClientCAs)
|
|
|
|
require.Equal(t, c.cas, c.commonTLSConfig(false).RootCAs)
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_CommonTLSConfigTLSMinVersion(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{TLSMinVersion: ""}, nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Equal(t, c.commonTLSConfig(false).MinVersion, TLSLookup["tls10"])
|
2019-03-05 20:35:43 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
tlsVersions := []string{"tls10", "tls11", "tls12"}
|
|
|
|
for _, version := range tlsVersions {
|
|
|
|
require.NoError(t, c.Update(Config{TLSMinVersion: version}))
|
|
|
|
require.Equal(t, c.commonTLSConfig(false).MinVersion,
|
|
|
|
TLSLookup[version])
|
|
|
|
}
|
2019-03-05 20:35:43 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Error(t, c.Update(Config{TLSMinVersion: "tlsBOGUS"}))
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_CommonTLSConfigVerifyIncoming(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{}}
|
|
|
|
type variant struct {
|
|
|
|
verify bool
|
|
|
|
additional bool
|
|
|
|
expected tls.ClientAuthType
|
|
|
|
}
|
|
|
|
variants := []variant{
|
|
|
|
{false, false, tls.NoClientCert},
|
|
|
|
{true, false, tls.RequireAndVerifyClientCert},
|
|
|
|
{false, true, tls.RequireAndVerifyClientCert},
|
|
|
|
{true, true, tls.RequireAndVerifyClientCert},
|
|
|
|
}
|
|
|
|
for _, v := range variants {
|
|
|
|
c.base.VerifyIncoming = v.verify
|
|
|
|
require.Equal(t, v.expected,
|
|
|
|
c.commonTLSConfig(v.additional).ClientAuth)
|
|
|
|
}
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_OutgoingRPCTLSDisabled(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{}}
|
|
|
|
type variant struct {
|
|
|
|
verify bool
|
|
|
|
file string
|
|
|
|
path string
|
|
|
|
expected bool
|
|
|
|
}
|
|
|
|
cafile := "../test/ca/root.cer"
|
|
|
|
capath := "../test/ca_path"
|
|
|
|
variants := []variant{
|
|
|
|
{false, "", "", true},
|
|
|
|
{false, cafile, "", false},
|
|
|
|
{false, "", capath, false},
|
|
|
|
{false, cafile, capath, false},
|
|
|
|
{true, "", "", false},
|
|
|
|
{true, cafile, "", false},
|
|
|
|
{true, "", capath, false},
|
|
|
|
{true, cafile, capath, false},
|
|
|
|
}
|
|
|
|
for i, v := range variants {
|
|
|
|
info := fmt.Sprintf("case %d", i)
|
|
|
|
cas, err := loadCAs(v.file, v.path)
|
|
|
|
require.NoError(t, err, info)
|
|
|
|
c.cas = cas
|
|
|
|
c.base.VerifyOutgoing = v.verify
|
|
|
|
require.Equal(t, v.expected, c.outgoingRPCTLSDisabled(), info)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestConfigurator_SomeValuesFromConfig(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{
|
|
|
|
VerifyServerHostname: true,
|
|
|
|
VerifyOutgoing: true,
|
|
|
|
Domain: "abc.de",
|
|
|
|
}}
|
|
|
|
one, two, three := c.someValuesFromConfig()
|
|
|
|
require.Equal(t, c.base.VerifyServerHostname, one)
|
|
|
|
require.Equal(t, c.base.VerifyOutgoing, two)
|
|
|
|
require.Equal(t, c.base.Domain, three)
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_VerifyIncomingRPC(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{
|
|
|
|
VerifyIncomingRPC: true,
|
|
|
|
}}
|
|
|
|
verify := c.verifyIncomingRPC()
|
|
|
|
require.Equal(t, c.base.VerifyIncomingRPC, verify)
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_VerifyIncomingHTTPS(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{
|
|
|
|
VerifyIncomingHTTPS: true,
|
|
|
|
}}
|
|
|
|
verify := c.verifyIncomingHTTPS()
|
|
|
|
require.Equal(t, c.base.VerifyIncomingHTTPS, verify)
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_EnableAgentTLSForChecks(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{
|
|
|
|
EnableAgentTLSForChecks: true,
|
|
|
|
}}
|
|
|
|
enabled := c.enableAgentTLSForChecks()
|
|
|
|
require.Equal(t, c.base.EnableAgentTLSForChecks, enabled)
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_IncomingRPCConfig(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{
|
|
|
|
VerifyIncomingRPC: true,
|
|
|
|
CAFile: "../test/ca/root.cer",
|
|
|
|
CertFile: "../test/key/ourdomain.cer",
|
|
|
|
KeyFile: "../test/key/ourdomain.key",
|
|
|
|
}, nil)
|
|
|
|
require.NoError(t, err)
|
|
|
|
tlsConf := c.IncomingRPCConfig()
|
2019-02-27 09:14:59 +00:00
|
|
|
require.Equal(t, tls.RequireAndVerifyClientCert, tlsConf.ClientAuth)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.NotNil(t, tlsConf.GetConfigForClient)
|
|
|
|
tlsConf, err = tlsConf.GetConfigForClient(nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, tls.RequireAndVerifyClientCert, tlsConf.ClientAuth)
|
|
|
|
}
|
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_IncomingHTTPSConfig(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{}}
|
|
|
|
require.Equal(t, []string{"h2", "http/1.1"}, c.IncomingHTTPSConfig().NextProtos)
|
2019-02-27 09:14:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestConfigurator_OutgoingTLSConfigForChecks(t *testing.T) {
|
2019-03-13 09:29:06 +00:00
|
|
|
c := Configurator{base: &Config{
|
|
|
|
TLSMinVersion: "tls12",
|
|
|
|
EnableAgentTLSForChecks: false,
|
|
|
|
}}
|
|
|
|
tlsConf := c.OutgoingTLSConfigForCheck(true)
|
|
|
|
require.Equal(t, true, tlsConf.InsecureSkipVerify)
|
|
|
|
require.Equal(t, uint16(0), tlsConf.MinVersion)
|
|
|
|
|
|
|
|
c.base.EnableAgentTLSForChecks = true
|
|
|
|
c.base.ServerName = "servername"
|
|
|
|
tlsConf = c.OutgoingTLSConfigForCheck(true)
|
|
|
|
require.Equal(t, true, tlsConf.InsecureSkipVerify)
|
|
|
|
require.Equal(t, TLSLookup[c.base.TLSMinVersion], tlsConf.MinVersion)
|
|
|
|
require.Equal(t, c.base.ServerName, tlsConf.ServerName)
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_OutgoingRPCConfig(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{}}
|
|
|
|
require.Nil(t, c.OutgoingRPCConfig())
|
|
|
|
c.base.VerifyOutgoing = true
|
|
|
|
require.NotNil(t, c.OutgoingRPCConfig())
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_OutgoingRPCWrapper(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{}}
|
|
|
|
require.Nil(t, c.OutgoingRPCWrapper())
|
|
|
|
c.base.VerifyOutgoing = true
|
|
|
|
wrap := c.OutgoingRPCWrapper()
|
|
|
|
require.NotNil(t, wrap)
|
|
|
|
t.Log("TODO: actually call wrap here eventually")
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_UpdateChecks(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{}, nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.NoError(t, c.Update(Config{}))
|
|
|
|
require.Error(t, c.Update(Config{VerifyOutgoing: true}))
|
|
|
|
require.Error(t, c.Update(Config{VerifyIncoming: true,
|
|
|
|
CAFile: "../test/ca/root.cer"}))
|
|
|
|
require.False(t, c.base.VerifyIncoming)
|
|
|
|
require.False(t, c.base.VerifyOutgoing)
|
|
|
|
require.Equal(t, c.version, 2)
|
|
|
|
}
|
2019-02-27 09:14:59 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_UpdateSetsStuff(t *testing.T) {
|
|
|
|
c, err := NewConfigurator(Config{}, nil)
|
2019-02-27 09:14:59 +00:00
|
|
|
require.NoError(t, err)
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Nil(t, c.cas)
|
|
|
|
require.Nil(t, c.cert)
|
|
|
|
require.Equal(t, c.base, &Config{})
|
|
|
|
require.Equal(t, 1, c.version)
|
2019-03-05 20:35:43 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
require.Error(t, c.Update(Config{VerifyOutgoing: true}))
|
|
|
|
require.Equal(t, c.version, 1)
|
2019-03-05 20:35:43 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
config := Config{
|
|
|
|
CAFile: "../test/ca/root.cer",
|
|
|
|
CertFile: "../test/key/ourdomain.cer",
|
|
|
|
KeyFile: "../test/key/ourdomain.key",
|
|
|
|
}
|
|
|
|
require.NoError(t, c.Update(config))
|
|
|
|
require.NotNil(t, c.cas)
|
|
|
|
require.Len(t, c.cas.Subjects(), 1)
|
|
|
|
require.NotNil(t, c.cert)
|
|
|
|
require.Equal(t, c.base, &config)
|
|
|
|
require.Equal(t, 2, c.version)
|
|
|
|
}
|
2019-03-05 20:35:43 +00:00
|
|
|
|
2019-03-13 09:29:06 +00:00
|
|
|
func TestConfigurator_ServerNameOrNodeName(t *testing.T) {
|
|
|
|
c := Configurator{base: &Config{}}
|
|
|
|
type variant struct {
|
|
|
|
server, node, expected string
|
|
|
|
}
|
|
|
|
variants := []variant{
|
|
|
|
{"", "", ""},
|
|
|
|
{"a", "", "a"},
|
|
|
|
{"", "b", "b"},
|
|
|
|
{"a", "b", "a"},
|
|
|
|
}
|
|
|
|
for _, v := range variants {
|
|
|
|
c.base.ServerName = v.server
|
|
|
|
c.base.NodeName = v.node
|
|
|
|
require.Equal(t, v.expected, c.serverNameOrNodeName())
|
|
|
|
}
|
2019-02-26 15:52:07 +00:00
|
|
|
}
|