Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

17.7 KB
Raw Blame
package api

import (
	"context"
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/base64"
	"encoding/pem"
	"errors"
	"fmt"
	"math/big"
	"net/http"
	"strings"
	"testing"
	"time"

	"github.com/beevik/etree"
	"github.com/crewjam/saml"
	"github.com/rcourtman/pulse-go-rewrite/internal/config"
)

func generateTestCert(t *testing.T) (certPEM, keyPEM []byte, key *rsa.PrivateKey) {
	t.Helper()
	priv, err := rsa.GenerateKey(rand.Reader, 2048)
	if err != nil {
		t.Fatalf("generate key: %v", err)
	}
	template := x509.Certificate{
		SerialNumber:          big.NewInt(1),
		NotBefore:             time.Now().Add(-time.Hour),
		NotAfter:              time.Now().Add(time.Hour),
		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
		BasicConstraintsValid: true,
		IsCA:                  true,
	}
	der, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
	if err != nil {
		t.Fatalf("create cert: %v", err)
	}
	certPEM = pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
	keyPEM = pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)})
	return certPEM, keyPEM, priv
}

func TestParseIDPMetadataXML(t *testing.T) {
	xml := `<?xml version="1.0"?>
<EntityDescriptor xmlns="urn:oasis:names:tc:SAML:2.0:metadata" entityID="idp-1">
  <IDPSSODescriptor protocolSupportEnumeration="urn:oasis:names:tc:SAML:2.0:protocol">
    <SingleSignOnService Binding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect" Location="https://idp/sso"/>
  </IDPSSODescriptor>
</EntityDescriptor>`

	metadata, err := parseIDPMetadataXML([]byte(xml))
	if err != nil {
		t.Fatalf("parse metadata: %v", err)
	}
	if metadata.EntityID != "idp-1" {
		t.Fatalf("unexpected entity id: %s", metadata.EntityID)
	}

	wrapped := `<?xml version="1.0"?>
<EntitiesDescriptor xmlns="urn:oasis:names:tc:SAML:2.0:metadata">
  <EntityDescriptor entityID="idp-2">
    <IDPSSODescriptor protocolSupportEnumeration="urn:oasis:names:tc:SAML:2.0:protocol"></IDPSSODescriptor>
  </EntityDescriptor>
</EntitiesDescriptor>`
	metadata, err = parseIDPMetadataXML([]byte(wrapped))
	if err != nil {
		t.Fatalf("parse wrapped metadata: %v", err)
	}
	if metadata.EntityID != "idp-2" {
		t.Fatalf("unexpected entity id: %s", metadata.EntityID)
	}

	if _, err := parseIDPMetadataXML([]byte("<bad")); err == nil {
		t.Fatal("expected error for invalid xml")
	}
}

func TestBuildManualMetadataAndCertificate(t *testing.T) {
	cfg := &config.SAMLProviderConfig{}
	service := &SAMLService{config: cfg}
	if _, err := service.buildManualMetadata(); err == nil {
		t.Fatal("expected error for missing SSO URL")
	}

	cfg.IDPSSOURL = "http://idp/sso"
	cfg.IDPSLOURL = "http://idp/slo"
	cfg.IDPIssuer = "issuer"
	certPEM, _, _ := generateTestCert(t)
	cfg.IDPCertificate = string(certPEM)
	certBlock, _ := pem.Decode(certPEM)

	metadata, err := service.buildManualMetadata()
	if err != nil {
		t.Fatalf("build metadata: %v", err)
	}
	if metadata.EntityID != "issuer" {
		t.Fatalf("unexpected entity id: %s", metadata.EntityID)
	}
	if len(metadata.IDPSSODescriptors) == 0 || len(metadata.IDPSSODescriptors[0].SingleLogoutServices) == 0 {
		t.Fatal("expected SLO service in metadata")
	}
	if len(metadata.IDPSSODescriptors[0].KeyDescriptors) == 0 {
		t.Fatal("expected key descriptor with certificate")
	}
	// crewjam/saml reads <X509Certificate> content: base64 DER, never PEM.
	certs := metadata.IDPSSODescriptors[0].KeyDescriptors[0].KeyInfo.X509Data.X509Certificates
	if len(certs) != 1 {
		t.Fatalf("expected one signing certificate, got %d", len(certs))
	}
	if certs[0].Data != base64.StdEncoding.EncodeToString(certBlock.Bytes) {
		t.Fatalf("expected the signing certificate as base64 DER, got %.40q", certs[0].Data)
	}

	cfg.IDPSSOURL = "https://user:[email protected]/sso"
	if _, err := service.buildManualMetadata(); err == nil {
		t.Fatal("expected error for idp sso URL with embedded credentials")
	}

	cfg.IDPSSOURL = "https://idp.example.com/sso"
	cfg.IDPSLOURL = "https://user:[email protected]/slo"
	if _, err := service.buildManualMetadata(); err == nil {
		t.Fatal("expected error for idp slo URL with embedded credentials")
	}
}

func TestLoadSPCredentials(t *testing.T) {
	cfg := &config.SAMLProviderConfig{}
	service := &SAMLService{config: cfg}
	if _, _, err := service.loadSPCredentials(); err == nil {
		t.Fatal("expected error for missing cert/key")
	}

	certPEM, keyPEM, _ := generateTestCert(t)
	cfg.SPCertificate = string(certPEM)
	if _, _, err := service.loadSPCredentials(); err == nil {
		t.Fatal("expected error for missing key")
	}
	cfg.SPCertificate = "bad"
	cfg.SPPrivateKey = "bad"
	if _, _, err := service.loadSPCredentials(); err == nil {
		t.Fatal("expected error for invalid pem")
	}

	ecKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		t.Fatalf("generate ec key: %v", err)
	}
	pkcs8, err := x509.MarshalPKCS8PrivateKey(ecKey)
	if err != nil {
		t.Fatalf("marshal pkcs8: %v", err)
	}
	cfg.SPCertificate = string(certPEM)
	cfg.SPPrivateKey = string(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: pkcs8}))
	if _, _, err := service.loadSPCredentials(); err == nil {
		t.Fatal("expected error for non-rsa key")
	}

	cfg.SPPrivateKey = string(keyPEM)
	cert, key, err := service.loadSPCredentials()
	if err != nil {
		t.Fatalf("load credentials: %v", err)
	}
	if cert == nil || key == nil {
		t.Fatal("expected cert and key")
	}
}

func TestSAMLServiceBasicFlows(t *testing.T) {
	certPEM, _, _ := generateTestCert(t)
	cfg := &config.SAMLProviderConfig{
		IDPMetadataXML: `<?xml version="1.0"?>
<EntityDescriptor xmlns="urn:oasis:names:tc:SAML:2.0:metadata" entityID="idp">
  <IDPSSODescriptor protocolSupportEnumeration="urn:oasis:names:tc:SAML:2.0:protocol">
    <SingleSignOnService Binding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect" Location="https://idp/sso"/>
    <SingleLogoutService Binding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect" Location="https://idp/slo"/>
  </IDPSSODescriptor>
</EntityDescriptor>`,
		IDPCertificate: string(certPEM),
	}

	service, err := NewSAMLService(context.Background(), "idp", cfg, "http://localhost:8080")
	if err != nil {
		t.Fatalf("new service: %v", err)
	}

	url, err := service.MakeAuthRequest("", sessionHash("login-token"))
	if err != nil || !strings.Contains(url, "SAMLRequest") {
		t.Fatalf("unexpected auth url: %v %s", err, url)
	}

	if _, err := service.GetMetadata(); err != nil {
		t.Fatalf("metadata error: %v", err)
	}

	logoutURL, err := service.MakeLogoutRequest("user", "sess", sessionHash("session-token"))
	if err != nil || !strings.Contains(logoutURL, "SAMLRequest") {
		t.Fatalf("unexpected logout url: %v %s", err, logoutURL)
	}

	service = &SAMLService{config: &config.SAMLProviderConfig{}}
	if _, err := service.MakeAuthRequest("", sessionHash("login-token")); err == nil {
		t.Fatal("expected error when sp missing")
	}
	if _, err := service.GetMetadata(); err == nil {
		t.Fatal("expected error when sp missing")
	}
	if _, err := service.MakeLogoutRequest("user", "sess", sessionHash("session-token")); err == nil {
		t.Fatal("expected error when sp missing")
	}
	if err := service.RefreshMetadata(context.Background()); err == nil {
		t.Fatal("expected refresh error without url")
	}
}

// Outstanding SLO requests expire after samlRequestTTL, and the store keeps
// at most maxSAMLRequestEntries by dropping the oldest.
func TestSAMLLogoutRequestStoreExpiresAndEvictsOldest(t *testing.T) {
	var store samlRequestStore
	now := time.Now()
	key := sessionHash("session-token")
	record := samlRequestRecord{bindingKey: key}

	store.put("id-expired", record, now)
	if err := store.consume("id-expired", key, now.Add(samlRequestTTL)); !errors.Is(err, errSAMLLogoutResponseUnbound) {
		t.Fatalf("expected an expired request to be refused, got %v", err)
	}
	store.put("id-live", record, now)
	if err := store.consume("id-live", "", now.Add(samlRequestTTL-time.Second)); err != nil {
		t.Fatalf("expected a live request to be accepted, got %v", err)
	}

	for i := 0; i <= maxSAMLRequestEntries; i++ {
		store.put(fmt.Sprintf("id-%04d", i), record, now.Add(time.Duration(i)*time.Millisecond))
	}
	if len(store.entries) != maxSAMLRequestEntries {
		t.Fatalf("expected %d outstanding requests, got %d", maxSAMLRequestEntries, len(store.entries))
	}
	if err := store.consume("id-0000", key, now); !errors.Is(err, errSAMLLogoutResponseUnbound) {
		t.Fatalf("expected the oldest request to be evicted, got %v", err)
	}
	if err := store.consume(fmt.Sprintf("id-%04d", maxSAMLRequestEntries), key, now); err != nil {
		t.Fatalf("expected the newest request to be kept, got %v", err)
	}
}

// Outstanding AuthnRequests are spent only by the browser they are bound to. A
// request presented by another browser stays outstanding for its owner, and
// each request is spent once and only before it expires.
func TestSAMLAuthnRequestStoreSpendsOnlyForItsBrowser(t *testing.T) {
	var store samlRequestStore
	now := time.Now()
	alice, bob := sessionHash("alice-login"), sessionHash("bob-login")

	store.put("id-alice-2", samlRequestRecord{bindingKey: alice, returnTo: "/alerts"}, now)
	store.put("id-alice-1", samlRequestRecord{bindingKey: alice, returnTo: "/"}, now)
	store.put("id-bob", samlRequestRecord{bindingKey: bob, returnTo: "/"}, now)

	if got, bound := store.outstanding(alice, now); strings.Join(got, ",") != "id-alice-1,id-alice-2,id-bob" || !bound {
		t.Fatalf("outstanding(alice) = %v, %v; want every request, bound", got, bound)
	}
	if _, bound := store.outstanding("", now); bound {
		t.Fatal("a browser without a login token has no request bound to it")
	}
	if _, err := store.spend("id-bob", alice, now); !errors.Is(err, errSAMLResponseUnbound) {
		t.Fatalf("expected another browser's request to be refused, got %v", err)
	}
	if _, err := store.spend("id-bob", "", now); !errors.Is(err, errSAMLResponseUnbound) {
		t.Fatalf("expected a browser without a login token to be refused, got %v", err)
	}
	if record, err := store.spend("id-bob", bob, now); err != nil || record.returnTo != "/" {
		t.Fatalf("refusing other browsers must leave the request for its owner, got %+v %v", record, err)
	}
	record, err := store.spend("id-alice-2", alice, now)
	if err != nil || record.returnTo != "/alerts" {
		t.Fatalf("spend(id-alice-2) = %+v %v, want its recorded returnTo", record, err)
	}
	if _, err := store.spend("id-alice-2", alice, now); !errors.Is(err, errSAMLResponseUnbound) {
		t.Fatalf("expected a spent request to be refused, got %v", err)
	}
	if got, bound := store.outstanding(alice, now.Add(samlRequestTTL)); len(got) != 0 || bound {
		t.Fatalf("expired requests must not be outstanding, got %v, %v", got, bound)
	}
	if _, err := store.spend("id-alice-1", alice, now.Add(samlRequestTTL)); !errors.Is(err, errSAMLResponseUnbound) {
		t.Fatalf("expected an expired request to be refused, got %v", err)
	}
}

// The binding decision reads InResponseTo from the canonical content of the
// signature that covers the assertion crewjam returned, taking only the
// attribute written without a prefix: the signed Response's when the message
// is signed, otherwise the returned assertion's own subject confirmations.
func TestSAMLSignedContentInResponseTo(t *testing.T) {
	parse := func(doc string) *etree.Element {
		t.Helper()
		parsed := etree.NewDocument()
		if err := parsed.ReadFromString(doc); err != nil {
			t.Fatalf("parse %s: %v", doc, err)
		}
		return parsed.Root()
	}
	assertion := func(id, subject, advice string) string {
		return `<saml:Assertion xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" ID="` + id + `"><saml:Subject>` + subject + `</saml:Subject>` + advice + `</saml:Assertion>`
	}
	confirmation := func(attrs string) string {
		return `<saml:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer"><saml:SubjectConfirmationData ` + attrs + `/></saml:SubjectConfirmation>`
	}
	response := func(attrs, body string) string {
		return `<samlp:Response xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol" ` + attrs + `>` + body + `</samlp:Response>`
	}
	own, other := `InResponseTo="id-own"`, `InResponseTo="id-other"`
	advice := `<saml:Advice>` + assertion("a9", confirmation(other), "") + `</saml:Advice>`

	for _, tc := range []struct {
		name   string
		signed []string
		want   string
	}{
		{name: "signed Response", signed: []string{response(`xmlns:InResponseTo="id-other" `+own, assertion("a1", confirmation(other), ""))}, want: "id-own"},
		{name: "signed Response with encrypted Assertion", signed: []string{response(own, `<saml:EncryptedAssertion xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion"/>`)}, want: "id-own"},
		{name: "signed ArtifactResponse", signed: []string{`<samlp:ArtifactResponse xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol" InResponseTo="id-artifact">` + response(own, "") + `</samlp:ArtifactResponse>`}, want: "id-own"},
		{name: "signed Assertion", signed: []string{assertion("a1", confirmation(`xmlns:InResponseTo="id-other" `+own), advice)}, want: "id-own"},
		{name: "signed Response answering no request", signed: []string{response(`xmlns:InResponseTo="id-own"`, assertion("a1", confirmation(own), ""))}},
		{name: "subject confirmations disagree", signed: []string{assertion("a1", confirmation(own)+confirmation(other), "")}},
		{name: "subject confirmation naming no request", signed: []string{assertion("a1", confirmation(own)+confirmation(`Recipient="x"`), "")}},
		{name: "subject confirmation without data", signed: []string{assertion("a1", confirmation(own)+`<saml:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer"/>`, "")}},
		{name: "one subject confirmation with conflicting data", signed: []string{assertion("a1", `<saml:SubjectConfirmation><saml:SubjectConfirmationData `+own+`/><saml:SubjectConfirmationData `+other+`/></saml:SubjectConfirmation>`, "")}},
		{name: "assertion without subject confirmation", signed: []string{assertion("a1", "", advice)}},
		{name: "another signed assertion names the request", signed: []string{assertion("a1", "", ""), assertion("a2", confirmation(own), "")}},
		{name: "returned assertion not signed", signed: []string{assertion("a2", confirmation(own), "")}},
		{name: "two signed assertions share the returned ID", signed: []string{assertion("a1", confirmation(own), ""), assertion("a1", confirmation(own), "")}},
	} {
		t.Run(tc.name, func(t *testing.T) {
			content := &samlSignedContent{}
			for _, doc := range tc.signed {
				content.elements = append(content.elements, parse(doc))
			}
			got, err := content.inResponseTo("a1")
			if tc.want == "" {
				if err == nil {
					t.Fatalf("expected a refusal, got %q", got)
				}
				return
			}
			if err != nil || got != tc.want {
				t.Fatalf("inResponseTo() = %q, %v; want %q", got, err, tc.want)
			}
		})
	}
}

// Signed content may not carry a prefixed attribute or namespace declaration
// named like an un-namespaced attribute crewjam/saml reads; the declarations
// and namespaced attributes real IdPs write are untouched.
func TestSAMLShadowingAttribute(t *testing.T) {
	for _, name := range []string{"ID", "InResponseTo", "IssueInstant", "Destination", "NotBefore", "NotOnOrAfter", "Recipient", "SessionIndex"} {
		if !samlBoundAttributeNames[name] {
			t.Fatalf("expected %s among the attributes crewjam/saml reads, got %v", name, samlBoundAttributeNames)
		}
	}
	for _, prefix := range []string{"saml", "samlp", "saml2", "saml2p", "ds", "dsig", "xs", "xsd", "xsi", "xenc", "ec", "md", "type"} {
		if samlBoundAttributeNames[prefix] {
			t.Fatalf("%q, a namespace prefix or namespaced attribute real IdPs write, is refused", prefix)
		}
	}

	const ns = `xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ext="urn:example"`
	for _, tc := range []struct {
		doc, want string
	}{
		{doc: `<saml:Assertion ` + ns + ` ID="a1"><saml:Conditions xmlns:NotOnOrAfter="2999-01-01T00:00:00Z"/></saml:Assertion>`, want: "xmlns:NotOnOrAfter"},
		{doc: `<saml:Assertion ` + ns + ` ID="a1" ext:ID="a2"/>`, want: "ext:ID"},
		{doc: `<saml:Assertion ` + ns + ` ID="a1"><saml:AttributeStatement><saml:Attribute Name="mail"><saml:AttributeValue xsi:type="xs:string">[email protected]</saml:AttributeValue></saml:Attribute></saml:AttributeStatement></saml:Assertion>`},
	} {
		doc := etree.NewDocument()
		if err := doc.ReadFromString(tc.doc); err != nil {
			t.Fatalf("parse %s: %v", tc.doc, err)
		}
		if got := samlShadowingAttribute(doc.Root()); got != tc.want {
			t.Fatalf("samlShadowingAttribute(%s) = %q, want %q", tc.doc, got, tc.want)
		}
	}
}

func TestValidateSAMLRedirectTarget(t *testing.T) {
	allowed := []saml.Endpoint{
		{Location: "https://idp.example.com/sso"},
	}

	got, err := validateSAMLRedirectTarget("https://idp.example.com/sso?SAMLRequest=test", allowed)
	if err != nil {
		t.Fatalf("validate redirect: %v", err)
	}
	if !strings.Contains(got, "SAMLRequest=test") {
		t.Fatalf("unexpected validated redirect: %s", got)
	}

	if _, err := validateSAMLRedirectTarget("https://evil.example.com/sso?SAMLRequest=test", allowed); err == nil {
		t.Fatal("expected error for unexpected redirect target")
	}
}

func TestFetchMetadataFromURL(t *testing.T) {
	server := newIPv4HTTPServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`<?xml version="1.0"?>
<EntityDescriptor xmlns="urn:oasis:names:tc:SAML:2.0:metadata" entityID="idp-url">
  <IDPSSODescriptor protocolSupportEnumeration="urn:oasis:names:tc:SAML:2.0:protocol"></IDPSSODescriptor>
</EntityDescriptor>`))
	}))
	defer server.Close()

	cfg := &config.SAMLProviderConfig{IDPMetadataURL: server.URL}
	service := &SAMLService{config: cfg, httpClient: newSAMLHTTPClient()}
	metadata, err := service.fetchIDPMetadataFromURL(context.Background(), server.URL)
	if err != nil {
		t.Fatalf("fetch metadata: %v", err)
	}
	if metadata.EntityID != "idp-url" {
		t.Fatalf("unexpected entity id: %s", metadata.EntityID)
	}
}