Enhancing signature validation in SAML Response #144

saml/error.go

@@ -15,4 +15,5 @@ var (
 	ErrInvalidAudience      = errors.New("invalid audience")
 	ErrMissingSubject       = errors.New("subject missing")
 	ErrMissingAttributeStmt = errors.New("attribute statement missing")
+	ErrInvalidSignature     = errors.New("invalid signature")
 )

saml/response.go

@@ -24,6 +24,8 @@ type parseResponseOptions struct {
 	skipAssertionConditionValidation bool
 	skipSignatureValidation          bool
 	assertionConsumerServiceURL      string
+	validateResponseSignature        bool
+	validateAssertionSignature       bool
 }
 
 func parseResponseOptionsDefault() parseResponseOptions {
@@ -32,6 +34,8 @@ func parseResponseOptionsDefault() parseResponseOptions {
 		skipRequestIDValidation:          false,
 		skipAssertionConditionValidation: false,
 		skipSignatureValidation:          false,
+		validateResponseSignature:        false,
+		validateAssertionSignature:       false,
 	}
 }
 
@@ -73,6 +77,24 @@ func InsecureSkipSignatureValidation() Option {
 	}
 }
 
+// ValidateResponseSignature enables signature validation to ensure the response is at least signed
+func ValidateResponseSignature() Option {
+	return func(o interface{}) {
+		if o, ok := o.(*parseResponseOptions); ok {
+			o.validateResponseSignature = true
+		}
+	}
+}
+
+// ValidateAssertionSignature enables signature validation to ensure the assertion is at least signed
+func ValidateAssertionSignature() Option {
+	return func(o interface{}) {
+		if o, ok := o.(*parseResponseOptions); ok {
+			o.validateAssertionSignature = true
+		}
+	}
+}
+
 // ParseResponse parses and validates a SAML Reponse.
 //
 // Options:
@@ -87,15 +109,18 @@ func (sp *ServiceProvider) ParseResponse(
 	opt ...Option,
 ) (*core.Response, error) {
 	const op = "saml.(ServiceProvider).ParseResponse"
+	opts := getParseResponseOptions(opt...)
+
 	switch {
 	case sp == nil:
 		return nil, fmt.Errorf("%s: missing service provider %w", op, ErrInternal)
 	case samlResp == "":
 		return nil, fmt.Errorf("%s: missing saml response: %w", op, ErrInvalidParameter)
 	case requestID == "":
 		return nil, fmt.Errorf("%s: missing request ID: %w", op, ErrInvalidParameter)
+	case opts.skipSignatureValidation && (opts.validateResponseSignature || opts.validateAssertionSignature):
+		return nil, fmt.Errorf("%s: option `skip signature validation` cannot be true with any validate signature option : %w", op, ErrInvalidParameter)
 	}
-	opts := getParseResponseOptions(opt...)
 
 	// We use github.com/russellhaering/gosaml2 for SAMLResponse signature and condition validation.
 	ip, err := sp.internalParser(
@@ -151,7 +176,17 @@ func (sp *ServiceProvider) ParseResponse(
 		}
 	}
 
-	return &core.Response{Response: *response}, nil
+	samlResponse := core.Response{Response: *response}
+	if opts.validateResponseSignature || opts.validateAssertionSignature {
+		// func ip.ValidateEncodedResponse(...) above only requires either `response or all its `assertions` are signed,
+		// but does not require both. The validateSignature function will validate either response or assertion
+		// or both is surely signed depending on the parse response options given.
+		if err := validateSignature(&samlResponse, op, opts); err != nil {
+			return nil, err
+		}
+	}
+
+	return &samlResponse, nil
 }
 
 func (sp *ServiceProvider) internalParser(
@@ -245,3 +280,22 @@ func parsePEMCertificate(cert []byte) (*x509.Certificate, error) {
 
 	return x509.ParseCertificate(block.Bytes)
 }
+
+func validateSignature(response *core.Response, op string, opts parseResponseOptions) error {
+	// validate child object assertions
+	for _, assert := range response.Assertions() {
+		// note: at one time func ip.ValidateEncodedResponse(...) above allows all signed or all unsigned
+		// assertions, and will give error if there is a mix of both. We are still looping on all assertions
+		// instead of retrieving signature for one assertion, so we do not depend on dependency implementation.
+		if !assert.SignatureValidated && opts.validateAssertionSignature {
+			return fmt.Errorf("%s: %w", op, ErrInvalidSignature)
+		}
+	}
+
+	// validate root object response
+	if !response.SignatureValidated && opts.validateResponseSignature {
+		return fmt.Errorf("%s: %w", op, ErrInvalidSignature)
+	}
+
+	return nil
+}

saml/response_test.go

@@ -21,7 +21,6 @@ import (
 
 var testExpiredResp = `<?xml version="1.0" encoding="UTF-8"?>
<saml2p:Response Destination="http://localhost:8000/saml/acs" ID="_8849c2ee532fcdb781f2a1776eac3741" InResponseTo="bc5a5baa-94e0-58a8-872c-e51491d2b3ee" IssueInstant="2023-08-25T14:32:53.680Z" Version="2.0" xmlns:saml2p="urn:oasis:names:tc:SAML:2.0:protocol" xmlns:xsd="http://www.w3.org/2001/XMLSchema"><saml2:Issuer xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion">https://samltest.id/saml/idp</saml2:Issuer><ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><ds:SignedInfo><ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/><ds:SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/><ds:Reference URI="#_8849c2ee532fcdb781f2a1776eac3741"><ds:Transforms><ds:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/><ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"><ec:InclusiveNamespaces PrefixList="xsd" xmlns:ec="http://www.w3.org/2001/10/xml-exc-c14n#"/></ds:Transform></ds:Transforms><ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/><ds:DigestValue>RV485uKGJZmNA1o56gxxk+VZkvxMqtlHZA2iHH8ZU1Q=</ds:DigestValue></ds:Reference></ds:SignedInfo><ds:SignatureValue>d3Lpc6hcSB7bwCzMrO3wfZrNiGk5gZ8rKRKOQENDP2q+p3+LkDmSBt6zzyxn33MCSJt+dPHpF14YMAK/N3PnWwSSUp0j5kzOc9Ka5NdianE0NgYnU0qjhFJbThAQz7hRowS4J49hS/6MuSQ0Z7nBBCeDgeD6PYRApKMvlOtkBGPJaLT2mRy/gnQ+CC6udUdJyvSgb9n43lvxdaaZWrDK3Wga98YlkcRHLrmPAAM8KxYWnkopio6YINU4D5mZjsEsnUkH41WgcwgmS2xzP3ICnNc3WH9NHrVKp9at2DBwrYDIses6FXgYq+iUWK2191jWpIC3qVAB0cOilmRXwtEH7g==</ds:SignatureValue><ds:KeyInfo><ds:X509Data><ds:X509Certificate>MIIDEjCCAfqgAwIBAgIVAMECQ1tjghafm5OxWDh9hwZfxthWMA0GCSqGSIb3DQEBCwUAMBYxFDAS
BgNVBAMMC3NhbWx0ZXN0LmlkMB4XDTE4MDgyNDIxMTQwOVoXDTM4MDgyNDIxMTQwOVowFjEUMBIG
A1UEAwwLc2FtbHRlc3QuaWQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC0Z4QX1NFK
s71ufbQwoQoW7qkNAJRIANGA4iM0ThYghul3pC+FwrGv37aTxWXfA1UG9njKbbDreiDAZKngCgyj
xj0uJ4lArgkr4AOEjj5zXA81uGHARfUBctvQcsZpBIxDOvUUImAl+3NqLgMGF2fktxMG7kX3GEVN
c1klbN3dfYsaw5dUrw25DheL9np7G/+28GwHPvLb4aptOiONbCaVvh9UMHEA9F7c0zfF/cL5fOpd
Va54wTI0u12CsFKt78h6lEGG5jUs/qX9clZncJM7EFkN3imPPy+0HC8nspXiH/MZW8o2cqWRkrw3
MzBZW3Ojk5nQj40V6NUbjb7kfejzAgMBAAGjVzBVMB0GA1UdDgQWBBQT6Y9J3Tw/hOGc8PNV7JEE
4k2ZNTA0BgNVHREELTArggtzYW1sdGVzdC5pZIYcaHR0cHM6Ly9zYW1sdGVzdC5pZC9zYW1sL2lk
cDANBgkqhkiG9w0BAQsFAAOCAQEASk3guKfTkVhEaIVvxEPNR2w3vWt3fwmwJCccW98XXLWgNbu3
YaMb2RSn7Th4p3h+mfyk2don6au7Uyzc1Jd39RNv80TG5iQoxfCgphy1FYmmdaSfO8wvDtHTTNiL
ArAxOYtzfYbzb5QrNNH/gQEN8RJaEf/g/1GTw9x/103dSMK0RXtl+fRs2nblD1JJKSQ3AdhxK/we
P3aUPtLxVVJ9wMOQOfcy02l+hHMb6uAjsPOpOVKqi3M8XmcUZOpx4swtgGdeoSpeRyrtMvRwdcci
NBp9UZome44qZAYH1iqrpmmjsfI9pJItsgWu3kXPjhSfj1AJGR1l9JGvJrHki1iHTA==</ds:X509Certificate></ds:X509Data></ds:KeyInfo></ds:Signature><saml2p:Status><saml2p:StatusCode Value="urn:oasis:names:tc:SAML:2.0:status:Success"/></saml2p:Status><saml2:Assertion ID="_35ea90b711d6f385345f0dbdd7d0ed5b" IssueInstant="2023-08-25T14:32:53.680Z" Version="2.0" xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion"><saml2:Issuer>https://samltest.id/saml/idp</saml2:Issuer><saml2:Subject><saml2:NameID Format="urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress" NameQualifier="https://samltest.id/saml/idp" SPNameQualifier="http://saml.julz/example" xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion">msmith@samltest.id</saml2:NameID><saml2:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer"><saml2:SubjectConfirmationData Address="104.28.39.34" InResponseTo="bc5a5baa-94e0-58a8-872c-e51491d2b3ee" NotOnOrAfter="2023-08-25T14:37:53.693Z" Recipient="http://localhost:8000/saml/acs"/></saml2:SubjectConfirmation></saml2:Subject><saml2:Conditions NotBefore="2023-08-25T14:32:53.680Z" NotOnOrAfter="2023-08-25T14:37:53.680Z"><saml2:AudienceRestriction><saml2:Audience>http://saml.julz/example</saml2:Audience></saml2:AudienceRestriction></saml2:Conditions><saml2:AuthnStatement AuthnInstant="2023-08-25T14:31:56.064Z" SessionIndex="_f72a63ee3782b47c89f60e81adde0ab0"><saml2:SubjectLocality Address="104.28.39.34"/><saml2:AuthnContext><saml2:AuthnContextClassRef>urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport</saml2:AuthnContextClassRef></saml2:AuthnContext></saml2:AuthnStatement><saml2:AttributeStatement><saml2:Attribute FriendlyName="eduPersonEntitlement" Name="urn:oid:1.3.6.1.4.1.5923.1.1.1.7" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue>Ambassador</saml2:AttributeValue><saml2:AttributeValue>None</saml2:AttributeValue></saml2:Attribute><saml2:Attribute Name="urn:oasis:names:tc:SAML:attribute:subject-id" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xsd:string">msmith@samltest.id</saml2:AttributeValue></saml2:Attribute><saml2:Attribute FriendlyName="uid" Name="urn:oid:0.9.2342.19200300.100.1.1" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue>morty</saml2:AttributeValue></saml2:Attribute><saml2:Attribute FriendlyName="telephoneNumber" Name="urn:oid:2.5.4.20" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue>+1-555-555-5505</saml2:AttributeValue></saml2:Attribute><saml2:Attribute FriendlyName="role" Name="https://samltest.id/attributes/role" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="xsd:string">janitor@samltest.id</saml2:AttributeValue></saml2:Attribute><saml2:Attribute FriendlyName="mail" Name="urn:oid:0.9.2342.19200300.100.1.3" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue>msmith@samltest.id</saml2:AttributeValue></saml2:Attribute><saml2:Attribute FriendlyName="sn" Name="urn:oid:2.5.4.4" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue>Smith</saml2:AttributeValue></saml2:Attribute><saml2:Attribute FriendlyName="displayName" Name="urn:oid:2.16.840.1.113730.3.1.241" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue>Morty Smith</saml2:AttributeValue></saml2:Attribute><saml2:Attribute FriendlyName="givenName" Name="urn:oid:2.5.4.42" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue>Mortimer</saml2:AttributeValue></saml2:Attribute></saml2:AttributeStatement></saml2:Assertion></saml2p:Response>`
 
-// TODO: add the ability to sign requests, so we can write more complete unit tests
 func TestServiceProvider_ParseResponse(t *testing.T) {
 	t.Parallel()
 	const (
@@ -60,12 +59,87 @@ func TestServiceProvider_ParseResponse(t *testing.T) {
 		wantErrAs       error
 	}{
 		{
-			name:      "success",
+			name:      "success - with both response and assertion signed",
 			sp:        testSp,
-			samlResp:  base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithResponseSigned()))),
+			samlResp:  base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithResponseAndAssertionSigned()))),
 			opts:      []saml.Option{},
 			requestID: testRequestId,
 		},
+		{
+			name:      "success - with just response signed",
+			sp:        testSp,
+			samlResp:  base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustResponseSigned()))),
+			opts:      []saml.Option{},
+			requestID: testRequestId,
+		},
+		{
+			name:      "success - with just assertion signed",
+			sp:        testSp,
+			samlResp:  base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustAssertionSigned()))),
+			opts:      []saml.Option{},
+			requestID: testRequestId,
+		},
+		{
+			name:      "success - with both options enabled of validating both signatures & with both response and assertion signed",
+			sp:        testSp,
+			samlResp:  base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithResponseAndAssertionSigned()))),
+			opts:      []saml.Option{saml.ValidateResponseSignature(), saml.ValidateAssertionSignature()},
+			requestID: testRequestId,
+		},
+		{
+			name:      "success - with option of validate response signature & with only response signed",
+			sp:        testSp,
+			samlResp:  base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustResponseSigned()))),
+			opts:      []saml.Option{saml.ValidateResponseSignature()},
+			requestID: testRequestId,
+		},
+		{
+			name:      "success - with option of validate assertion signature & with only assertion signed",
+			sp:        testSp,
+			samlResp:  base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustAssertionSigned()))),
+			opts:      []saml.Option{saml.ValidateAssertionSignature()},
+			requestID: testRequestId,
+		},
+		{
+			name:            "missing signature",
+			sp:              testSp,
+			samlResp:        base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t))),
+			opts:            []saml.Option{},
+			requestID:       testRequestId,
+			wantErrContains: "response and/or assertions must be signed",
+		},
+		{
+			name:            "error-invalid-signature - with both options enabled of validating both signatures & with only response signed",
+			sp:              testSp,
+			samlResp:        base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustResponseSigned()))),
+			opts:            []saml.Option{saml.ValidateResponseSignature(), saml.ValidateAssertionSignature()},
+			requestID:       testRequestId,
+			wantErrContains: "invalid signature",
+		},
+		{
+			name:            "error-invalid-signature - with both options enabled of validating both signatures & with only assertion signed",
+			sp:              testSp,
+			samlResp:        base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustAssertionSigned()))),
+			opts:            []saml.Option{saml.ValidateResponseSignature(), saml.ValidateAssertionSignature()},
+			requestID:       testRequestId,
+			wantErrContains: "invalid signature",
+		},
+		{
+			name:            "error-invalid-signature - with option of validate response signature & with only assertion signed",
+			sp:              testSp,
+			samlResp:        base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustAssertionSigned()))),
+			opts:            []saml.Option{saml.ValidateResponseSignature()},
+			requestID:       testRequestId,
+			wantErrContains: "invalid signature",
+		},
+		{
+			name:            "error-invalid-signature - with option of validate assertion signature & with just response signed",
+			sp:              testSp,
+			samlResp:        base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustResponseSigned()))),
+			opts:            []saml.Option{saml.ValidateAssertionSignature()},
+			requestID:       testRequestId,
+			wantErrContains: "invalid signature",
+		},
 		{
 			name:     "err-assertion-missing-attribute-stmt",
 			sp:       testSp,
@@ -144,15 +218,15 @@ func TestServiceProvider_ParseResponse(t *testing.T) {
 		{
 			name:            "err-in-response-to",
 			sp:              testSp,
-			samlResp:        base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithResponseSigned()))),
+			samlResp:        base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithResponseAndAssertionSigned()))),
 			requestID:       "invalid-request-id",
 			wantErrContains: "doesn't match the expected requestID (invalid-request-id)",
 		},
 		{
 			name: "expired",
 			sp:   testSp,
 			samlResp: base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t,
-				testprovider.WithResponseSigned(),
+				testprovider.WithResponseAndAssertionSigned(),
 				testprovider.WithResponseExpired(),
 			))),
 			requestID:       "request-id",

saml/test/provider.go

@@ -431,8 +431,9 @@ func (p *TestProvider) parseRequestPost(request string) *core.AuthnRequest {
 }
 
 type responseOptions struct {
-	sign    bool
-	expired bool
+	signResponseElem  bool
+	signAssertionElem bool
+	expired           bool
 }
 
 type ResponseOption func(*responseOptions)
@@ -450,9 +451,22 @@ func defaultResponseOptions() *responseOptions {
 	return &responseOptions{}
 }
 
-func WithResponseSigned() ResponseOption {
+func WithResponseAndAssertionSigned() ResponseOption {
 	return func(o *responseOptions) {
-		o.sign = true
+		o.signResponseElem = true
+		o.signAssertionElem = true
+	}
+}
+
+func WithJustAssertionSigned() ResponseOption {
+	return func(o *responseOptions) {
+		o.signAssertionElem = true
+	}
+}
+
+func WithJustResponseSigned() ResponseOption {
+	return func(o *responseOptions) {
+		o.signResponseElem = true
 	}
 }
 
@@ -544,13 +558,30 @@ func (p *TestProvider) SamlResponse(t *testing.T, opts ...ResponseOption) string
 	err = doc.ReadFromBytes(resp)
 	r.NoError(err)
 
-	if opt.sign {
+	if opt.signResponseElem || opt.signAssertionElem {
 		signCtx := dsig.NewDefaultSigningContext(p.keystore)
 
-		signed, err := signCtx.SignEnveloped(doc.Root())
-		r.NoError(err)
+		// sign child object assertions
+		// note we will sign the `assertion` first and then only the parent `response`, because the `response`
+		// signature is based on the entire contents of `response` (including `assertion` signature)
+		if opt.signAssertionElem {
+			responseEl := doc.SelectElement("Response")
+			for _, assert := range responseEl.FindElements("Assertion") {
+				signedAssert, err := signCtx.SignEnveloped(assert)
+				r.NoError(err)
+
+				// replace signed assert object
+				responseEl.RemoveChildAt(assert.Index())
+				responseEl.AddChild(signedAssert)
+			}
+		}
 
-		doc.SetRoot(signed)
+		// sign root object response
+		if opt.signResponseElem {
+			signed, err := signCtx.SignEnveloped(doc.Root())
+			r.NoError(err)
+			doc.SetRoot(signed)
+		}
 	}
 
 	result, err := doc.WriteToString()