package policy import ( "crypto/x509" "crypto/x509/pkix" "errors" "net" "net/url" "reflect" "testing" "github.com/google/go-cmp/cmp" "github.com/stretchr/testify/assert" "golang.org/x/crypto/ssh" ) // TODO(hs): the functionality in the policy engine is a nice candidate for trying fuzzing on // TODO(hs): more complex test use cases that combine multiple names and permitted/excluded entries? func TestNamePolicyEngine_matchDomainConstraint(t *testing.T) { tests := []struct { name string allowLiteralWildcardNames bool domain string constraint string want bool wantErr bool }{ { name: "fail/wildcard", domain: "host.local", constraint: ".example.com", // internally we're using the x509 period prefix as the indicator for exactly one subdomain want: false, wantErr: false, }, { name: "fail/wildcard-literal", domain: "*.example.com", constraint: ".example.com", // internally we're using the x509 period prefix as the indicator for exactly one subdomain want: false, wantErr: false, }, { name: "fail/specific-domain", domain: "www.example.com", constraint: "host.example.com", want: false, wantErr: false, }, { name: "fail/single-whitespace-domain", domain: " ", constraint: "host.example.com", want: false, wantErr: false, }, { name: "fail/period-domain", domain: ".host.example.com", constraint: ".example.com", want: false, wantErr: false, }, { name: "fail/wrong-asterisk-prefix", domain: "*Xexample.com", constraint: ".example.com", want: false, wantErr: false, }, { name: "fail/asterisk-in-domain", domain: "e*ample.com", constraint: ".com", want: false, wantErr: false, }, { name: "fail/asterisk-label", domain: "example.*.local", constraint: ".local", want: false, wantErr: false, }, { name: "fail/multiple-periods", domain: "example.local", constraint: "..local", want: false, wantErr: false, }, { name: "fail/error-parsing-domain", domain: string(byte(0)), constraint: ".local", want: false, wantErr: true, }, { name: "fail/error-parsing-constraint", domain: "example.local", constraint: string(byte(0)), want: false, wantErr: true, }, { name: "fail/no-subdomain", domain: "local", constraint: ".local", want: false, wantErr: false, }, { name: "fail/too-many-subdomains", domain: "www.example.local", constraint: ".local", want: false, wantErr: false, }, { name: "fail/wrong-domain", domain: "example.notlocal", constraint: ".local", want: false, wantErr: false, }, { name: "false/idna-internationalized-domain-name", domain: "JP納豆.例.jp", // Example value from https://www.w3.org/International/articles/idn-and-iri/ constraint: ".例.jp", want: false, wantErr: true, }, { name: "false/idna-internationalized-domain-name-constraint", domain: "xn--jp-cd2fp15c.xn--fsq.jp", // Example value from https://www.w3.org/International/articles/idn-and-iri/ constraint: ".例.jp", want: false, wantErr: true, }, { name: "ok/empty-constraint", domain: "www.example.com", constraint: "", want: true, wantErr: false, }, { name: "ok/wildcard", domain: "www.example.com", constraint: ".example.com", // internally we're using the x509 period prefix as the indicator for exactly one subdomain want: true, wantErr: false, }, { name: "ok/wildcard-literal", allowLiteralWildcardNames: true, domain: "*.example.com", // specifically allowed using an option on the NamePolicyEngine constraint: ".example.com", // internally we're using the x509 period prefix as the indicator for exactly one subdomain want: true, wantErr: false, }, { name: "ok/specific-domain", domain: "www.example.com", constraint: "www.example.com", want: true, wantErr: false, }, { name: "ok/different-case", domain: "WWW.EXAMPLE.com", constraint: "www.example.com", want: true, wantErr: false, }, { name: "ok/idna-internationalized-domain-name-punycode", domain: "xn--jp-cd2fp15c.xn--fsq.jp", // Example value from https://www.w3.org/International/articles/idn-and-iri/ constraint: ".xn--fsq.jp", want: true, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { engine := NamePolicyEngine{ allowLiteralWildcardNames: tt.allowLiteralWildcardNames, } got, err := engine.matchDomainConstraint(tt.domain, tt.constraint) if (err != nil) != tt.wantErr { t.Errorf("NamePolicyEngine.matchDomainConstraint() error = %v, wantErr %v", err, tt.wantErr) return } if got != tt.want { t.Errorf("NamePolicyEngine.matchDomainConstraint() = %v, want %v", got, tt.want) } }) } } func Test_matchIPConstraint(t *testing.T) { nat64IP, nat64Net, err := net.ParseCIDR("64:ff9b::/96") assert.NoError(t, err) tests := []struct { name string ip net.IP constraint *net.IPNet want bool wantErr bool }{ { name: "false/ipv4-in-ipv6-nat64", ip: net.ParseIP("192.0.2.128"), constraint: nat64Net, want: false, wantErr: false, }, { name: "ok/ipv4", ip: net.ParseIP("127.0.0.1"), constraint: &net.IPNet{ IP: net.ParseIP("127.0.0.0"), Mask: net.IPv4Mask(255, 255, 255, 0), }, want: true, wantErr: false, }, { name: "ok/ipv6", ip: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7335"), constraint: &net.IPNet{ IP: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), Mask: net.CIDRMask(120, 128), }, want: true, wantErr: false, }, { name: "ok/ipv4-in-ipv6", // ipv4 in ipv6 addresses are considered the same in the current implementation, because Go parses them as IPv4 ip: net.ParseIP("::ffff:192.0.2.128"), constraint: &net.IPNet{ IP: net.ParseIP("192.0.2.0"), Mask: net.IPv4Mask(255, 255, 255, 0), }, want: true, wantErr: false, }, { name: "ok/ipv4-in-ipv6-nat64-fixed-ip", ip: nat64IP, constraint: nat64Net, want: true, wantErr: false, }, { name: "ok/ipv4-in-ipv6-nat64", ip: net.ParseIP("64:ff9b::192.0.2.129"), constraint: nat64Net, want: true, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := matchIPConstraint(tt.ip, tt.constraint) if (err != nil) != tt.wantErr { t.Errorf("matchIPConstraint() error = %v, wantErr %v", err, tt.wantErr) return } if got != tt.want { t.Errorf("matchIPConstraint() = %v, want %v", got, tt.want) } }) } } func TestNamePolicyEngine_matchEmailConstraint(t *testing.T) { tests := []struct { name string engine *NamePolicyEngine mailbox rfc2821Mailbox constraint string want bool wantErr bool }{ { name: "fail/asterisk-prefix", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "*@example.com", want: false, wantErr: true, }, { name: "fail/asterisk-label", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "@host.*.example.com", want: false, wantErr: true, }, { name: "fail/asterisk-inside-local", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "m*il@local", want: false, wantErr: true, }, { name: "fail/asterisk-inside-domain", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "@h*st.example.com", want: false, wantErr: true, }, { name: "fail/parse-email", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "@example.com", want: false, wantErr: true, }, { name: "fail/wildcard", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "example.com", want: false, wantErr: false, }, { name: "fail/wildcard-x509-period", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: ".local", // "wildcard" for the local domain; requires exactly 1 subdomain want: false, wantErr: false, }, { name: "fail/specific-mail-wrong-domain", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "mail@example.com", want: false, wantErr: false, }, { name: "fail/specific-mail-wrong-local", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "root", domain: "example.com", }, constraint: "mail@example.com", want: false, wantErr: false, }, { name: "ok/wildcard", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "local", // "wildcard" for the local domain want: true, wantErr: false, }, { name: "ok/wildcard-x509-period", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "example.local", }, constraint: ".local", // "wildcard" for the local domain; requires exactly 1 subdomain want: true, wantErr: false, }, { name: "ok/specific-mail", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "local", }, constraint: "mail@local", want: true, wantErr: false, }, { name: "ok/wildcard-tld", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "example.com", }, constraint: "example.com", // "wildcard" for 'example.com' want: true, wantErr: false, }, { name: "ok/different-case", engine: &NamePolicyEngine{}, mailbox: rfc2821Mailbox{ local: "mail", domain: "EXAMPLE.com", }, constraint: "example.com", // "wildcard" for 'example.com' want: true, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := tt.engine.matchEmailConstraint(tt.mailbox, tt.constraint) if (err != nil) != tt.wantErr { t.Errorf("NamePolicyEngine.matchEmailConstraint() error = %v, wantErr %v", err, tt.wantErr) return } if got != tt.want { t.Errorf("NamePolicyEngine.matchEmailConstraint() = %v, want %v", got, tt.want) } }) } } func TestNamePolicyEngine_matchURIConstraint(t *testing.T) { tests := []struct { name string engine *NamePolicyEngine uri *url.URL constraint string want bool wantErr bool }{ { name: "fail/empty-host", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "", }, constraint: ".local", want: false, wantErr: true, }, { name: "fail/host-with-asterisk-prefix", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "*.local", }, constraint: ".local", want: false, wantErr: true, }, { name: "fail/host-with-asterisk-label", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "host.*.local", }, constraint: ".local", want: false, wantErr: true, }, { name: "fail/host-with-asterisk-inside", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "h*st.local", }, constraint: ".local", want: false, wantErr: true, }, { name: "fail/wildcard", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "www.example.notlocal", }, constraint: ".example.local", // using x509 period as the "wildcard"; expects a single subdomain want: false, wantErr: false, }, { name: "fail/wildcard-subdomains-too-deep", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "www.sub.example.local", }, constraint: ".example.local", // using x509 period as the "wildcard"; expects a single subdomain want: false, wantErr: false, }, { name: "fail/host-with-port-split-error", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "www.example.local::8080", }, constraint: ".example.local", // using x509 period as the "wildcard"; expects a single subdomain want: false, wantErr: true, }, { name: "fail/host-with-ipv4", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "127.0.0.1", }, constraint: ".example.local", // using x509 period as the "wildcard"; expects a single subdomain want: false, wantErr: true, }, { name: "fail/host-with-ipv6", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", }, constraint: ".example.local", // using x509 period as the "wildcard"; expects a single subdomain want: false, wantErr: true, }, { name: "ok/wildcard", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "www.example.local", }, constraint: ".example.local", // using x509 period as the "wildcard"; expects a single subdomain want: true, wantErr: false, }, { name: "ok/host-with-port", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "www.example.local:8080", }, constraint: ".example.local", // using x509 period as the "wildcard"; expects a single subdomain want: true, wantErr: false, }, { name: "ok/different-case", engine: &NamePolicyEngine{}, uri: &url.URL{ Scheme: "https", Host: "www.EXAMPLE.local", }, constraint: ".example.local", // using x509 period as the "wildcard"; expects a single subdomain want: true, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := tt.engine.matchURIConstraint(tt.uri, tt.constraint) if (err != nil) != tt.wantErr { t.Errorf("NamePolicyEngine.matchURIConstraint() error = %v, wantErr %v", err, tt.wantErr) return } if got != tt.want { t.Errorf("NamePolicyEngine.matchURIConstraint() = %v, want %v", got, tt.want) } }) } } func TestNamePolicyEngine_X509_AllAllowed(t *testing.T) { tests := []struct { name string options []NamePolicyOption cert *x509.Certificate want bool wantErr *NamePolicyError }{ // SINGLE SAN TYPE PERMITTED FAILURE TESTS { name: "fail/dns-permitted", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ DNSNames: []string{"www.example.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "www.example.com", }, }, { name: "fail/dns-permitted-wildcard-literal-x509", options: []NamePolicyOption{ WithPermittedDNSDomains("*.x509local"), }, cert: &x509.Certificate{ DNSNames: []string{ "*.x509local", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "*.x509local", }, }, { name: "fail/dns-permitted-single-host", options: []NamePolicyOption{ WithPermittedDNSDomains("host.local"), }, cert: &x509.Certificate{ DNSNames: []string{"differenthost.local"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "differenthost.local", }, }, { name: "fail/dns-permitted-no-label", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ DNSNames: []string{"local"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "local", }, }, { name: "fail/dns-permitted-empty-label", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ DNSNames: []string{"www..local"}, }, want: false, wantErr: &NamePolicyError{ Reason: CannotParseDomain, NameType: DNSNameType, Name: "www..local", }, }, { name: "fail/dns-permitted-dot-domain", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ DNSNames: []string{ ".local", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: ".local", }, }, { name: "fail/dns-permitted-wildcard-multiple-subdomains", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ DNSNames: []string{ "sub.example.local", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "sub.example.local", }, }, { name: "fail/dns-permitted-wildcard-literal", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ DNSNames: []string{ "*.local", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "*.local", }, }, { name: "fail/dns-permitted-idna-internationalized-domain", options: []NamePolicyOption{ WithPermittedDNSDomains("*.豆.jp"), }, cert: &x509.Certificate{ DNSNames: []string{ string(byte(0)) + ".例.jp", }, }, want: false, wantErr: &NamePolicyError{ Reason: CannotParseDomain, NameType: DNSNameType, Name: string(byte(0)) + ".例.jp", }, }, { name: "fail/ipv4-permitted", options: []NamePolicyOption{ WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("1.1.1.1")}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "1.1.1.1", }, }, { name: "fail/ipv6-permitted", options: []NamePolicyOption{ WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), Mask: net.CIDRMask(120, 128), }, ), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("3001:0db8:85a3:0000:0000:8a2e:0370:7334")}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "3001:db8:85a3::8a2e:370:7334", // IPv6 is shortened internally }, }, { name: "fail/mail-permitted-wildcard", options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ EmailAddresses: []string{ "test@local.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "test@local.com", }, }, { name: "fail/mail-permitted-wildcard-x509", options: []NamePolicyOption{ WithPermittedEmailAddresses("example.com"), }, cert: &x509.Certificate{ EmailAddresses: []string{ "test@local.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "test@local.com", }, }, { name: "fail/mail-permitted-specific-mailbox", options: []NamePolicyOption{ WithPermittedEmailAddresses("test@local.com"), }, cert: &x509.Certificate{ EmailAddresses: []string{ "root@local.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "root@local.com", }, }, { name: "fail/mail-permitted-wildcard-subdomain", options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ EmailAddresses: []string{ "test@sub.example.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "test@sub.example.com", }, }, { name: "fail/mail-permitted-idna-internationalized-domain", options: []NamePolicyOption{ WithPermittedEmailAddresses("@例.jp"), }, cert: &x509.Certificate{ EmailAddresses: []string{"bücher@例.jp"}, }, want: false, wantErr: &NamePolicyError{ Reason: CannotParseRFC822Name, NameType: EmailNameType, Name: "bücher@例.jp", }, }, { name: "fail/mail-permitted-idna-internationalized-domain-rfc822", options: []NamePolicyOption{ WithPermittedEmailAddresses("@例.jp"), }, cert: &x509.Certificate{ EmailAddresses: []string{"bücher@例.jp" + string(byte(0))}, }, want: false, wantErr: &NamePolicyError{ Reason: CannotParseRFC822Name, NameType: EmailNameType, Name: "bücher@例.jp" + string(byte(0)), }, }, { name: "fail/mail-permitted-idna-internationalized-domain-ascii", options: []NamePolicyOption{ WithPermittedEmailAddresses("@例.jp"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@xn---bla.jp"}, }, want: false, wantErr: &NamePolicyError{ Reason: CannotParseDomain, NameType: EmailNameType, Name: "mail@xn---bla.jp", }, }, { name: "fail/uri-permitted-domain-wildcard", options: []NamePolicyOption{ WithPermittedURIDomains("*.local"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "example.com", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: URINameType, Name: "https://example.com", }, }, { name: "fail/uri-permitted", options: []NamePolicyOption{ WithPermittedURIDomains("test.local"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "bad.local", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: URINameType, Name: "https://bad.local", }, }, { name: "fail/uri-permitted-with-literal-wildcard", // don't allow literal wildcard in URI, e.g. xxxx://*.domain.tld options: []NamePolicyOption{ WithPermittedURIDomains("*.local"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "*.local", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: CannotMatchNameToConstraint, NameType: URINameType, Name: "https://*.local", }, }, { name: "fail/uri-permitted-idna-internationalized-domain", options: []NamePolicyOption{ WithPermittedURIDomains("*.bücher.example.com"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "abc.bücher.example.com", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: CannotMatchNameToConstraint, NameType: URINameType, Name: "https://abc.b%C3%BCcher.example.com", }, }, // SINGLE SAN TYPE EXCLUDED FAILURE TESTS { name: "fail/dns-excluded", options: []NamePolicyOption{ WithExcludedDNSDomains("*.example.com"), }, cert: &x509.Certificate{ DNSNames: []string{"www.example.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "www.example.com", }, }, { name: "fail/dns-excluded-single-host", options: []NamePolicyOption{ WithExcludedDNSDomains("host.example.com"), }, cert: &x509.Certificate{ DNSNames: []string{"host.example.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "host.example.com", }, }, { name: "fail/ipv4-excluded", options: []NamePolicyOption{ WithExcludedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "127.0.0.1", }, }, { name: "fail/ipv6-excluded", options: []NamePolicyOption{ WithExcludedIPRanges( &net.IPNet{ IP: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), Mask: net.CIDRMask(120, 128), }, ), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334")}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "2001:db8:85a3::8a2e:370:7334", }, }, { name: "fail/mail-excluded", options: []NamePolicyOption{ WithExcludedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@example.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "mail@example.com", }, }, { name: "fail/uri-excluded", options: []NamePolicyOption{ WithExcludedURIDomains("*.example.com"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: URINameType, Name: "https://www.example.com", }, }, { name: "fail/uri-excluded-with-literal-wildcard", // don't allow literal wildcard in URI, e.g. xxxx://*.domain.tld options: []NamePolicyOption{ WithExcludedURIDomains("*.local"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "*.local", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: CannotMatchNameToConstraint, NameType: URINameType, Name: "https://*.local", }, }, // SUBJECT FAILURE TESTS { name: "fail/subject-permitted-no-match", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedCommonNames("this name is allowed", "and this one too"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "some certificate name", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, // only permitted names allowed NameType: CNNameType, Name: "some certificate name", }, }, { name: "fail/subject-excluded-match", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedCommonNames("this name is not allowed"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "this name is not allowed", }, }, want: false, wantErr: &NamePolicyError{ Reason: CannotParseDomain, // CN cannot be parsed as DNS in this case NameType: CNNameType, Name: "this name is not allowed", }, }, { name: "fail/subject-dns-no-domain", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "name with space.local", }, }, want: false, wantErr: &NamePolicyError{ Reason: CannotParseDomain, NameType: CNNameType, Name: "name with space.local", }, }, { name: "fail/subject-dns-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "example.notlocal", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "example.notlocal", }, }, { name: "fail/subject-dns-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedDNSDomains("*.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "example.local", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "example.local", }, }, { name: "fail/subject-ipv4-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "10.10.10.10", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "10.10.10.10", }, }, { name: "fail/subject-ipv4-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "127.0.0.30", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "127.0.0.30", }, }, { name: "fail/subject-ipv6-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), Mask: net.CIDRMask(120, 128), }, ), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "2002:0db8:85a3:0000:0000:8a2e:0370:7339", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "2002:db8:85a3::8a2e:370:7339", }, }, { name: "fail/subject-ipv6-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedIPRanges( &net.IPNet{ IP: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), Mask: net.CIDRMask(120, 128), }, ), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "2001:0db8:85a3:0000:0000:8a2e:0370:7339", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "2001:db8:85a3::8a2e:370:7339", }, }, { name: "fail/subject-email-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedEmailAddresses("@example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "mail@smallstep.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "mail@smallstep.com", }, }, { name: "fail/subject-email-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedEmailAddresses("@example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "mail@example.local", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "mail@example.local", }, }, { name: "fail/subject-uri-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedURIDomains("*.example.com"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "https://www.google.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "https://www.google.com", }, }, { name: "fail/subject-uri-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedURIDomains("*.example.com"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "https://www.example.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "https://www.example.com", }, }, // DIFFERENT SAN PERMITTED FAILURE TESTS { name: "fail/dns-permitted-with-ip-name", // when only DNS is permitted, IPs are not allowed. options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "127.0.0.1", }, }, { name: "fail/dns-permitted-with-mail", // when only DNS is permitted, mails are not allowed. options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@smallstep.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "mail@smallstep.com", }, }, { name: "fail/dns-permitted-with-uri", // when only DNS is permitted, URIs are not allowed. options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: URINameType, Name: "https://www.example.com", }, }, { name: "fail/ip-permitted-with-dns-name", // when only IP is permitted, DNS names are not allowed. options: []NamePolicyOption{ WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ DNSNames: []string{"www.example.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "www.example.com", }, }, { name: "fail/ip-permitted-with-mail", // when only IP is permitted, mails are not allowed. options: []NamePolicyOption{ WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@smallstep.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "mail@smallstep.com", }, }, { name: "fail/ip-permitted-with-uri", // when only IP is permitted, URIs are not allowed. options: []NamePolicyOption{ WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: URINameType, Name: "https://www.example.com", }, }, { name: "fail/mail-permitted-with-dns-name", // when only mail is permitted, DNS names are not allowed. options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ DNSNames: []string{"www.example.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "www.example.com", }, }, { name: "fail/mail-permitted-with-ip", // when only mail is permitted, IPs are not allowed. options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{ net.ParseIP("127.0.0.1"), }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "127.0.0.1", }, }, { name: "fail/mail-permitted-with-uri", // when only mail is permitted, URIs are not allowed. options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: URINameType, Name: "https://www.example.com", }, }, { name: "fail/uri-permitted-with-dns-name", // when only URI is permitted, DNS names are not allowed. options: []NamePolicyOption{ WithPermittedURIDomains("*.local"), }, cert: &x509.Certificate{ DNSNames: []string{"host.local"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "host.local", }, }, { name: "fail/uri-permitted-with-ip-name", // when only URI is permitted, IPs are not allowed. options: []NamePolicyOption{ WithPermittedURIDomains("*.local"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{ net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "2001:db8:85a3::8a2e:370:7334", }, }, { name: "fail/uri-permitted-with-ip-name", // when only URI is permitted, mails are not allowed. options: []NamePolicyOption{ WithPermittedURIDomains("*.local"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@smallstep.com"}, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "mail@smallstep.com", }, }, // COMBINED FAILURE TESTS { name: "fail/combined-simple-all-badhost.local-common-name", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedDNSDomains("*.local"), WithPermittedCIDRs("127.0.0.1/24"), WithPermittedEmailAddresses("@example.local"), WithPermittedURIDomains("*.example.local"), WithExcludedDNSDomains("badhost.local"), WithExcludedCIDRs("127.0.0.128/25"), WithExcludedEmailAddresses("badmail@example.local"), WithExcludedURIDomains("badwww.example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "badhost.local", }, DNSNames: []string{"example.local"}, IPAddresses: []net.IP{net.ParseIP("127.0.0.40")}, EmailAddresses: []string{"mail@example.local"}, URIs: []*url.URL{ { Scheme: "https", Host: "www.example.local", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: CNNameType, Name: "badhost.local", }, }, { name: "fail/combined-simple-all-anotherbadhost.local-dns", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), WithPermittedCIDRs("127.0.0.1/24"), WithPermittedEmailAddresses("@example.local"), WithPermittedURIDomains("*.example.local"), WithExcludedDNSDomains("anotherbadhost.local"), WithExcludedCIDRs("127.0.0.128/25"), WithExcludedEmailAddresses("badmail@example.local"), WithExcludedURIDomains("badwww.example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "badhost.local", }, DNSNames: []string{"anotherbadhost.local"}, IPAddresses: []net.IP{net.ParseIP("127.0.0.40")}, EmailAddresses: []string{"mail@example.local"}, URIs: []*url.URL{ { Scheme: "https", Host: "www.example.local", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "anotherbadhost.local", }, }, { name: "fail/combined-simple-all-badmail@example.local", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), WithPermittedCIDRs("127.0.0.1/24"), WithPermittedEmailAddresses("@example.local"), WithPermittedURIDomains("*.example.local"), WithExcludedDNSDomains("badhost.local"), WithExcludedCIDRs("127.0.0.128/25"), WithExcludedEmailAddresses("badmail@example.local"), WithExcludedURIDomains("badwww.example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "badhost.local", }, DNSNames: []string{"example.local"}, IPAddresses: []net.IP{net.ParseIP("127.0.0.40")}, EmailAddresses: []string{"mail@example.local", "badmail@example.local"}, URIs: []*url.URL{ { Scheme: "https", Host: "www.example.local", }, }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "badmail@example.local", }, }, // NO CONSTRAINT SUCCESS TESTS { name: "ok/dns-no-constraints", options: []NamePolicyOption{}, cert: &x509.Certificate{ DNSNames: []string{"www.example.com"}, }, want: true, }, { name: "ok/ipv4-no-constraints", options: []NamePolicyOption{}, cert: &x509.Certificate{ IPAddresses: []net.IP{ net.ParseIP("127.0.0.1"), }, }, want: true, }, { name: "ok/ipv6-no-constraints", options: []NamePolicyOption{}, cert: &x509.Certificate{ IPAddresses: []net.IP{ net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), }, }, want: true, }, { name: "ok/mail-no-constraints", options: []NamePolicyOption{}, cert: &x509.Certificate{ EmailAddresses: []string{"mail@smallstep.com"}, }, want: true, }, { name: "ok/uri-no-constraints", options: []NamePolicyOption{}, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: true, }, { name: "ok/subject-no-constraints", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "www.example.com", }, }, want: true, }, { name: "ok/subject-empty-no-constraints", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "", }, }, want: true, }, { name: "ok/subject-permitted-match", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedCommonNames("this name is allowed"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "this name is allowed", }, }, want: true, }, { name: "ok/subject-excluded-match", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedCommonNames("this name is not allowed"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "some other name", }, }, want: true, }, // SINGLE SAN TYPE PERMITTED SUCCESS TESTS { name: "ok/dns-permitted", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ DNSNames: []string{"example.local"}, }, want: true, }, { name: "ok/dns-permitted-wildcard", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local", "*.x509local"), WithAllowLiteralWildcardNames(), }, cert: &x509.Certificate{ DNSNames: []string{ "host.local", "test.x509local", }, }, want: true, }, { name: "ok/dns-permitted-wildcard-literal", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local", "*.x509local"), WithAllowLiteralWildcardNames(), }, cert: &x509.Certificate{ DNSNames: []string{ "*.local", "*.x509local", }, }, want: true, }, { name: "ok/dns-permitted-combined", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local", "*.x509local", "host.example.com"), }, cert: &x509.Certificate{ DNSNames: []string{ "example.local", "example.x509local", "host.example.com", }, }, want: true, }, { name: "ok/dns-permitted-idna-internationalized-domain", options: []NamePolicyOption{ WithPermittedDNSDomains("*.例.jp"), }, cert: &x509.Certificate{ DNSNames: []string{ "JP納豆.例.jp", // Example value from https://www.w3.org/International/articles/idn-and-iri/ }, }, want: true, }, { name: "ok/ipv4-permitted", options: []NamePolicyOption{ WithPermittedCIDRs("127.0.0.1/24"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("127.0.0.20")}, }, want: true, }, { name: "ok/ipv6-permitted", options: []NamePolicyOption{ WithPermittedCIDRs("2001:0db8:85a3:0000:0000:8a2e:0370:7334/120"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7339")}, }, want: true, }, { name: "ok/mail-permitted-wildcard", options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ EmailAddresses: []string{ "test@example.com", }, }, want: true, }, { name: "ok/mail-permitted-plain-domain", options: []NamePolicyOption{ WithPermittedEmailAddresses("example.com"), }, cert: &x509.Certificate{ EmailAddresses: []string{ "test@example.com", }, }, want: true, }, { name: "ok/mail-permitted-specific-mailbox", options: []NamePolicyOption{ WithPermittedEmailAddresses("test@local.com"), }, cert: &x509.Certificate{ EmailAddresses: []string{ "test@local.com", }, }, want: true, }, { name: "ok/mail-permitted-idna-internationalized-domain", options: []NamePolicyOption{ WithPermittedEmailAddresses("@例.jp"), }, cert: &x509.Certificate{ EmailAddresses: []string{}, }, want: true, }, { name: "ok/uri-permitted-domain-wildcard", options: []NamePolicyOption{ WithPermittedURIDomains("*.local"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "example.local", }, }, }, want: true, }, { name: "ok/uri-permitted-specific-uri", options: []NamePolicyOption{ WithPermittedURIDomains("test.local"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "test.local", }, }, }, want: true, }, { name: "ok/uri-permitted-with-port", options: []NamePolicyOption{ WithPermittedURIDomains("*.example.com"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com:8080", }, }, }, want: true, }, { name: "ok/uri-permitted-idna-internationalized-domain", options: []NamePolicyOption{ WithPermittedURIDomains("*.bücher.example.com"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "abc.xn--bcher-kva.example.com", }, }, }, want: true, }, { name: "ok/uri-permitted-idna-internationalized-domain", options: []NamePolicyOption{ WithPermittedURIDomains("bücher.example.com"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "xn--bcher-kva.example.com", }, }, }, want: true, }, // SINGLE SAN TYPE EXCLUDED SUCCESS TESTS { name: "ok/dns-excluded", options: []NamePolicyOption{ WithExcludedDNSDomains("*.notlocal"), }, cert: &x509.Certificate{ DNSNames: []string{"example.local"}, }, want: true, }, { name: "ok/ipv4-excluded", options: []NamePolicyOption{ WithExcludedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("10.10.10.10")}, }, want: true, }, { name: "ok/ipv6-excluded", options: []NamePolicyOption{ WithExcludedCIDRs("2001:0db8:85a3:0000:0000:8a2e:0370:7334/120"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("2003:0db8:85a3:0000:0000:8a2e:0370:7334")}, }, want: true, }, { name: "ok/mail-excluded", options: []NamePolicyOption{ WithExcludedEmailAddresses("@notlocal"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@local"}, }, want: true, }, { name: "ok/mail-excluded-with-subdomain", options: []NamePolicyOption{ WithExcludedEmailAddresses("@local"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@example.local"}, }, want: true, }, { name: "ok/uri-excluded", options: []NamePolicyOption{ WithExcludedURIDomains("*.google.com"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: true, }, // SUBJECT SUCCESS TESTS { name: "ok/subject-empty", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "", }, DNSNames: []string{"example.local"}, }, want: true, }, { name: "ok/subject-dns-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedDNSDomains("*.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "example.local", }, }, want: true, }, { name: "ok/subject-dns-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedDNSDomains("*.notlocal"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "example.local", }, }, want: true, }, { name: "ok/subject-ipv4-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "127.0.0.20", }, }, want: true, }, { name: "ok/subject-ipv4-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedIPRanges( &net.IPNet{ IP: net.ParseIP("128.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, ), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "127.0.0.1", }, }, want: true, }, { name: "ok/subject-ipv6-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedIPRanges( &net.IPNet{ IP: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), Mask: net.CIDRMask(120, 128), }, ), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "2001:0db8:85a3:0000:0000:8a2e:0370:7339", }, }, want: true, }, { name: "ok/subject-ipv6-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedIPRanges( &net.IPNet{ IP: net.ParseIP("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), Mask: net.CIDRMask(120, 128), }, ), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "2009:0db8:85a3:0000:0000:8a2e:0370:7339", }, }, want: true, }, { name: "ok/subject-email-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedEmailAddresses("@example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "mail@example.local", }, }, want: true, }, { name: "ok/subject-email-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedEmailAddresses("@example.notlocal"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "mail@example.local", }, }, want: true, }, { name: "ok/subject-uri-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedURIDomains("*.example.com"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "https://www.example.com", }, }, want: true, }, { name: "ok/subject-uri-excluded", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedURIDomains("*.smallstep.com"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "https://www.example.com", }, }, want: true, }, // DIFFERENT SAN TYPE EXCLUDED SUCCESS TESTS { name: "ok/dns-excluded-with-ip-name", // when only DNS is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedDNSDomains("*.local"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, }, want: true, }, { name: "ok/dns-excluded-with-mail", // when only DNS is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedDNSDomains("*.local"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@example.com"}, }, want: true, }, { name: "ok/dns-excluded-with-mail", // when only DNS is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedDNSDomains("*.local"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: true, }, { name: "ok/ip-excluded-with-dns", // when only IP is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedCIDRs("127.0.0.1/24"), }, cert: &x509.Certificate{ DNSNames: []string{"test.local"}, }, want: true, }, { name: "ok/ip-excluded-with-mail", // when only IP is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedCIDRs("127.0.0.1/24"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@example.com"}, }, want: true, }, { name: "ok/ip-excluded-with-mail", // when only IP is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedCIDRs("127.0.0.1/24"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: true, }, { name: "ok/mail-excluded-with-dns", // when only mail is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ DNSNames: []string{"test.local"}, }, want: true, }, { name: "ok/mail-excluded-with-ip", // when only mail is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, }, want: true, }, { name: "ok/mail-excluded-with-uri", // when only mail is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedEmailAddresses("@example.com"), }, cert: &x509.Certificate{ URIs: []*url.URL{ { Scheme: "https", Host: "www.example.com", }, }, }, want: true, }, { name: "ok/uri-excluded-with-dns", // when only URI is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedURIDomains("*.example.local"), }, cert: &x509.Certificate{ DNSNames: []string{"test.example.local"}, }, want: true, }, { name: "ok/uri-excluded-with-dns", // when only URI is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedURIDomains("*.example.local"), }, cert: &x509.Certificate{ IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, }, want: true, }, { name: "ok/uri-excluded-with-mail", // when only URI is exluded, we allow anything else options: []NamePolicyOption{ WithExcludedURIDomains("*.example.local"), }, cert: &x509.Certificate{ EmailAddresses: []string{"mail@example.local"}, }, want: true, }, { name: "ok/dns-excluded-with-subject-ip-name", // when only DNS is exluded, we allow anything else options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithExcludedDNSDomains("*.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "127.0.0.1", }, IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, }, want: true, }, // COMBINED SUCCESS TESTS { name: "ok/combined-simple-permitted", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedDNSDomains("*.local"), WithPermittedCIDRs("127.0.0.1/24"), WithPermittedEmailAddresses("@example.local"), WithPermittedURIDomains("*.example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "somehost.local", }, DNSNames: []string{"example.local"}, IPAddresses: []net.IP{net.ParseIP("127.0.0.15")}, EmailAddresses: []string{"mail@example.local"}, URIs: []*url.URL{ { Scheme: "https", Host: "www.example.local", }, }, }, want: true, }, { name: "ok/combined-simple-permitted-without-subject-verification", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), WithPermittedCIDRs("127.0.0.1/24"), WithPermittedEmailAddresses("@example.local"), WithPermittedURIDomains("*.example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "forbidden-but-non-verified-domain.example.com", }, DNSNames: []string{"example.local"}, IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, EmailAddresses: []string{"mail@example.local"}, URIs: []*url.URL{ { Scheme: "https", Host: "www.example.local", }, }, }, want: true, }, { name: "ok/combined-simple-all", options: []NamePolicyOption{ WithSubjectCommonNameVerification(), WithPermittedDNSDomains("*.local"), WithPermittedCIDRs("127.0.0.1/24"), WithPermittedEmailAddresses("@example.local"), WithPermittedURIDomains("*.example.local"), WithExcludedDNSDomains("badhost.local"), WithExcludedCIDRs("127.0.0.128/25"), WithExcludedEmailAddresses("badmail@example.local"), WithExcludedURIDomains("badwww.example.local"), }, cert: &x509.Certificate{ Subject: pkix.Name{ CommonName: "somehost.local", }, DNSNames: []string{"example.local"}, IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, EmailAddresses: []string{"mail@example.local"}, URIs: []*url.URL{ { Scheme: "https", Host: "www.example.local", }, }, }, want: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { engine, err := New(tt.options...) assert.NoError(t, err) gotErr := engine.IsX509CertificateAllowed(tt.cert) wantErr := tt.wantErr != nil if (gotErr != nil) != wantErr { t.Errorf("NamePolicyEngine.IsX509CertificateAllowed() error = %v, wantErr %v", gotErr, tt.wantErr) return } if gotErr != nil { var npe *NamePolicyError assert.True(t, errors.As(gotErr, &npe)) assert.NotEqual(t, "", npe.Error()) assert.Equal(t, tt.wantErr.Reason, npe.Reason) assert.Equal(t, tt.wantErr.NameType, npe.NameType) assert.Equal(t, tt.wantErr.Name, npe.Name) assert.NotEqual(t, "", npe.Detail()) //assert.Equals(t, tt.err.Reason, npe.Reason) // NOTE: reason detail is skipped; it's a detail } // Perform the same tests for a CSR, which are similar to Certificates csr := &x509.CertificateRequest{ Subject: tt.cert.Subject, DNSNames: tt.cert.DNSNames, EmailAddresses: tt.cert.EmailAddresses, IPAddresses: tt.cert.IPAddresses, URIs: tt.cert.URIs, } gotErr = engine.IsX509CertificateRequestAllowed(csr) wantErr = tt.wantErr != nil if (gotErr != nil) != wantErr { t.Errorf("NamePolicyEngine.AreCSRNamesAllowed() error = %v, wantErr %v", gotErr, tt.wantErr) return } if gotErr != nil { var npe *NamePolicyError assert.True(t, errors.As(gotErr, &npe)) assert.NotEqual(t, "", npe.Error()) assert.Equal(t, tt.wantErr.Reason, npe.Reason) assert.Equal(t, tt.wantErr.NameType, npe.NameType) assert.Equal(t, tt.wantErr.Name, npe.Name) assert.NotEqual(t, "", npe.Detail()) //assert.Equals(t, tt.err.Reason, npe.Reason) // NOTE: reason detail is skipped; it's a detail } }) } } func TestNamePolicyEngine_SSH_ArePrincipalsAllowed(t *testing.T) { tests := []struct { name string options []NamePolicyOption cert *ssh.Certificate want bool wantErr *NamePolicyError }{ { name: "fail/host-with-permitted-dns-domain", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "host.example.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "host.example.com", }, }, { name: "fail/host-with-excluded-dns-domain", options: []NamePolicyOption{ WithExcludedDNSDomains("*.local"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "host.local", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "host.local", }, }, { name: "fail/host-with-permitted-cidr", options: []NamePolicyOption{ WithPermittedCIDRs("127.0.0.1/24"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "192.168.0.22", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "192.168.0.22", }, }, { name: "fail/host-with-excluded-cidr", options: []NamePolicyOption{ WithExcludedCIDRs("127.0.0.1/24"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "127.0.0.0", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: IPNameType, Name: "127.0.0.0", }, }, { name: "fail/user-with-permitted-email", options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "mail@local", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "mail@local", }, }, { name: "fail/user-with-excluded-email", options: []NamePolicyOption{ WithExcludedEmailAddresses("@example.com"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "mail@example.com", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "mail@example.com", }, }, { name: "fail/host-with-permitted-principals", options: []NamePolicyOption{ WithPermittedPrincipals("localhost"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "host", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "host", }, }, { name: "fail/user-with-permitted-principals", options: []NamePolicyOption{ WithPermittedPrincipals("user"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "root", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: PrincipalNameType, Name: "root", }, }, { name: "fail/user-with-excluded-principals", options: []NamePolicyOption{ WithExcludedPrincipals("user"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "user", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: PrincipalNameType, Name: "user", }, }, { name: "fail/user-with-permitted-principal-as-mail", options: []NamePolicyOption{ WithPermittedPrincipals("ops"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "ops@work", // this is (currently) parsed as an email-like principal; not allowed with just "ops" as the permitted principal }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "ops@work", }, }, { name: "fail/host-principal-with-permitted-dns-domain", // when only DNS is permitted, username principals are not allowed. options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "user", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "user", }, }, { name: "fail/host-principal-with-permitted-ip-range", // when only IPs are permitted, username principals are not allowed. options: []NamePolicyOption{ WithPermittedCIDRs("127.0.0.1/24"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "user", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "user", }, }, { name: "fail/user-principal-with-permitted-email", // when only emails are permitted, username principals are not allowed. options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "user", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: PrincipalNameType, Name: "user", }, }, { name: "fail/combined-user", options: []NamePolicyOption{ WithPermittedEmailAddresses("@smallstep.com"), WithExcludedEmailAddresses("root@smallstep.com"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "someone@smallstep.com", "someone", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: PrincipalNameType, Name: "someone", }, }, { name: "fail/combined-user-with-excluded-user-principal", options: []NamePolicyOption{ WithPermittedEmailAddresses("@smallstep.com"), WithExcludedPrincipals("root"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "someone@smallstep.com", "root", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: PrincipalNameType, Name: "root", }, }, { name: "fail/host-with-permitted-user-principals", options: []NamePolicyOption{ WithPermittedEmailAddresses("@work"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "example.work", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: DNSNameType, Name: "example.work", }, }, { name: "fail/user-with-permitted-user-principals", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "herman@work", }, }, want: false, wantErr: &NamePolicyError{ Reason: NotAllowed, NameType: EmailNameType, Name: "herman@work", }, }, { name: "ok/host-with-permitted-dns-domain", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "host.local", }, }, want: true, }, { name: "ok/host-with-excluded-dns-domain", options: []NamePolicyOption{ WithExcludedDNSDomains("*.example.com"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "host.local", }, }, want: true, }, { name: "ok/host-with-permitted-ip", options: []NamePolicyOption{ WithPermittedCIDRs("127.0.0.1/24"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "127.0.0.33", }, }, want: true, }, { name: "ok/host-with-excluded-ip", options: []NamePolicyOption{ WithExcludedCIDRs("127.0.0.1/24"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "192.168.0.35", }, }, want: true, }, { name: "ok/host-with-excluded-principals", options: []NamePolicyOption{ WithExcludedPrincipals("localhost"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "localhost", }, }, want: true, }, { name: "ok/user-with-permitted-email", options: []NamePolicyOption{ WithPermittedEmailAddresses("@example.com"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "mail@example.com", }, }, want: true, }, { name: "ok/user-with-excluded-email", options: []NamePolicyOption{ WithExcludedEmailAddresses("@example.com"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "mail@local", }, }, want: true, }, { name: "ok/user-with-permitted-principals", options: []NamePolicyOption{ WithPermittedPrincipals("*"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "user", }, }, want: true, }, { name: "ok/user-with-excluded-principals", options: []NamePolicyOption{ WithExcludedPrincipals("user"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "root", }, }, want: true, }, { name: "ok/combined-user", options: []NamePolicyOption{ WithPermittedEmailAddresses("@smallstep.com"), WithPermittedPrincipals("*"), // without specifying the wildcard, "someone" would not be allowed. WithExcludedEmailAddresses("root@smallstep.com"), }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "someone@smallstep.com", "someone", }, }, want: true, }, { name: "ok/combined-user-with-excluded-user-principal", options: []NamePolicyOption{ WithPermittedEmailAddresses("@smallstep.com"), WithExcludedEmailAddresses("root@smallstep.com"), WithExcludedPrincipals("root"), // unlike the previous test, this implicitly allows any other username principal }, cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{ "someone@smallstep.com", "someone", }, }, want: true, }, { name: "ok/combined-host", options: []NamePolicyOption{ WithPermittedDNSDomains("*.local"), WithPermittedCIDRs("127.0.0.1/24"), WithExcludedDNSDomains("badhost.local"), WithExcludedCIDRs("127.0.0.128/25"), }, cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{ "example.local", "127.0.0.31", }, }, want: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { engine, err := New(tt.options...) assert.NoError(t, err) gotErr := engine.IsSSHCertificateAllowed(tt.cert) wantErr := tt.wantErr != nil if (gotErr != nil) != wantErr { t.Errorf("NamePolicyEngine.IsSSHCertificateAllowed() error = %v, wantErr %v", gotErr, tt.wantErr) return } if gotErr != nil { var npe *NamePolicyError assert.True(t, errors.As(gotErr, &npe)) assert.NotEqual(t, "", npe.Error()) assert.Equal(t, tt.wantErr.Reason, npe.Reason) assert.Equal(t, tt.wantErr.NameType, npe.NameType) assert.Equal(t, tt.wantErr.Name, npe.Name) assert.NotEqual(t, "", npe.Detail()) //assert.Equals(t, tt.err.Reason, npe.Reason) // NOTE: reason detail is skipped; it's a detail } }) } } type result struct { wantDNSNames []string wantIps []net.IP wantEmails []string wantUsernames []string } func emptyResult() result { return result{ wantDNSNames: []string{}, wantIps: []net.IP{}, wantEmails: []string{}, wantUsernames: []string{}, } } func Test_splitSSHPrincipals(t *testing.T) { type test struct { cert *ssh.Certificate r result wantErr bool } var tests = map[string]func(t *testing.T) test{ "fail/unexpected-cert-type": func(t *testing.T) test { r := emptyResult() return test{ cert: &ssh.Certificate{ CertType: uint32(0), }, r: r, wantErr: true, } }, "fail/user-ip": func(t *testing.T) test { r := emptyResult() r.wantIps = []net.IP{net.ParseIP("127.0.0.1")} return test{ cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{"127.0.0.1"}, }, r: r, wantErr: true, } }, "fail/user-uri": func(t *testing.T) test { r := emptyResult() return test{ cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{"https://host.local/"}, }, r: r, wantErr: true, } }, "fail/host-uri": func(t *testing.T) test { r := emptyResult() return test{ cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{"https://host.local/"}, }, r: r, wantErr: true, } }, "ok/host-dns": func(t *testing.T) test { r := emptyResult() r.wantDNSNames = []string{"host.example.com"} return test{ cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{"host.example.com"}, }, r: r, wantErr: false, } }, "ok/host-ip": func(t *testing.T) test { r := emptyResult() r.wantIps = []net.IP{net.ParseIP("127.0.0.1")} return test{ cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{"127.0.0.1"}, }, r: r, wantErr: false, } }, "ok/host-email": func(t *testing.T) test { r := emptyResult() r.wantEmails = []string{"ops@work"} return test{ cert: &ssh.Certificate{ CertType: ssh.HostCert, ValidPrincipals: []string{"ops@work"}, }, r: r, wantErr: false, } }, "ok/user-localhost": func(t *testing.T) test { r := emptyResult() r.wantUsernames = []string{"localhost"} // when type is User cert, this is considered a username; not a DNS return test{ cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{"localhost"}, }, r: r, wantErr: false, } }, "ok/user-username-with-period": func(t *testing.T) test { r := emptyResult() r.wantUsernames = []string{"x.joe"} return test{ cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{"x.joe"}, }, r: r, wantErr: false, } }, "ok/user-maillike": func(t *testing.T) test { r := emptyResult() r.wantEmails = []string{"ops@work"} return test{ cert: &ssh.Certificate{ CertType: ssh.UserCert, ValidPrincipals: []string{"ops@work"}, }, r: r, wantErr: false, } }, } for name, prep := range tests { tt := prep(t) t.Run(name, func(t *testing.T) { gotDNSNames, gotIps, gotEmails, gotUsernames, err := splitSSHPrincipals(tt.cert) if (err != nil) != tt.wantErr { t.Errorf("splitSSHPrincipals() error = %v, wantErr %v", err, tt.wantErr) return } if !cmp.Equal(tt.r.wantDNSNames, gotDNSNames) { t.Errorf("splitSSHPrincipals() DNS names diff =\n%s", cmp.Diff(tt.r.wantDNSNames, gotDNSNames)) } if !cmp.Equal(tt.r.wantIps, gotIps) { t.Errorf("splitSSHPrincipals() IPs diff =\n%s", cmp.Diff(tt.r.wantIps, gotIps)) } if !cmp.Equal(tt.r.wantEmails, gotEmails) { t.Errorf("splitSSHPrincipals() Emails diff =\n%s", cmp.Diff(tt.r.wantEmails, gotEmails)) } if !cmp.Equal(tt.r.wantUsernames, gotUsernames) { t.Errorf("splitSSHPrincipals() Usernames diff =\n%s", cmp.Diff(tt.r.wantUsernames, gotUsernames)) } }) } } func Test_removeDuplicates(t *testing.T) { tests := []struct { name string input []string want []string }{ { name: "empty-slice", input: []string{}, want: []string{}, }, { name: "single-item", input: []string{"x"}, want: []string{"x"}, }, { name: "ok", input: []string{"x", "y", "x", "z", "x", "z", "y"}, want: []string{"x", "y", "z"}, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if got := removeDuplicates(tt.input); !reflect.DeepEqual(got, tt.want) { t.Errorf("removeDuplicates() = %v, want %v", got, tt.want) } }) } } func Test_removeDuplicateIPNets(t *testing.T) { tests := []struct { name string input []*net.IPNet want []*net.IPNet }{ { name: "empty-slice", input: []*net.IPNet{}, want: []*net.IPNet{}, }, { name: "single-item", input: []*net.IPNet{ { IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 255), }, }, want: []*net.IPNet{ { IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 255), }, }, }, { name: "multiple", input: []*net.IPNet{ { IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 255), }, { IP: net.ParseIP("192.168.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, { IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 255), }, { IP: net.ParseIP("10.10.0.0"), Mask: net.IPv4Mask(255, 255, 0, 0), }, { IP: net.ParseIP("192.168.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, { IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 255), }, { IP: net.ParseIP("192.168.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, }, want: []*net.IPNet{ { IP: net.ParseIP("127.0.0.1"), Mask: net.IPv4Mask(255, 255, 255, 255), }, { IP: net.ParseIP("192.168.0.1"), Mask: net.IPv4Mask(255, 255, 255, 0), }, { IP: net.ParseIP("10.10.0.0"), Mask: net.IPv4Mask(255, 255, 0, 0), }, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if gotRet := removeDuplicateIPNets(tt.input); !reflect.DeepEqual(gotRet, tt.want) { t.Errorf("removeDuplicateIPNets() = %v, want %v", gotRet, tt.want) } }) } } func TestNamePolicyError_Error(t *testing.T) { type fields struct { Reason NamePolicyReason NameType NameType Name string detail string } tests := []struct { name string fields fields want string }{ { name: "dns-not-allowed", fields: fields{ Reason: NotAllowed, NameType: DNSNameType, Name: "www.example.com", }, want: "dns name \"www.example.com\" not allowed", }, { name: "dns-cannot-parse-domain", fields: fields{ Reason: CannotParseDomain, NameType: DNSNameType, Name: "www.example.com", }, want: "cannot parse dns domain \"www.example.com\"", }, { name: "email-cannot-parse", fields: fields{ Reason: CannotParseRFC822Name, NameType: EmailNameType, Name: "mail@example.com", }, want: "cannot parse email rfc822Name \"mail@example.com\"", }, { name: "uri-cannot-match", fields: fields{ Reason: CannotMatchNameToConstraint, NameType: URINameType, Name: "https://*.local", }, want: "error matching uri name \"https://*.local\" to constraint", }, { name: "unknown", fields: fields{ Reason: -1, NameType: DNSNameType, Name: "some name", detail: "detail string", }, want: "unknown error reason (-1): detail string", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { e := &NamePolicyError{ Reason: tt.fields.Reason, NameType: tt.fields.NameType, Name: tt.fields.Name, detail: tt.fields.detail, } if got := e.Error(); got != tt.want { t.Errorf("NamePolicyError.Error() = %v, want %v", got, tt.want) } }) } }