diff --git a/saml/error.go b/saml/error.go index 43ed33e..82e8bb8 100644 --- a/saml/error.go +++ b/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") ) diff --git a/saml/response.go b/saml/response.go index 894d0e8..49c03cc 100644 --- a/saml/response.go +++ b/saml/response.go @@ -12,6 +12,7 @@ import ( "github.com/jonboulle/clockwork" saml2 "github.com/russellhaering/gosaml2" + "github.com/russellhaering/gosaml2/types" dsig "github.com/russellhaering/goxmldsig" "github.com/hashicorp/cap/saml/models/core" @@ -109,6 +110,8 @@ func (sp *ServiceProvider) ParseResponse( // This will validate the response and all assertions. response, err := ip.ValidateEncodedResponse(samlResp) + + switch { case err != nil: return nil, fmt.Errorf("%s: unable to validate encoded response: %w", op, err) @@ -151,6 +154,14 @@ func (sp *ServiceProvider) ParseResponse( } } + if !opts.skipSignatureValidation { + // func ip.ValidateEncodedResponse(...) above only requires either response or all its assertions are signed, + // but does not require both. Adding another check to validate that both of these are signed always. + if err := validateSignature(response, op); err != nil { + return nil, err + } + } + return &core.Response{Response: *response}, nil } @@ -245,3 +256,22 @@ func parsePEMCertificate(cert []byte) (*x509.Certificate, error) { return x509.ParseCertificate(block.Bytes) } + +func validateSignature(response *types.Response, op string) (error) { + + // validate child attr assertions + for _, assert := range response.Assertions { + if !assert.SignatureValidated{ + // note: at one time func ip.ValidateEncodedResponse(...) above allows all signed or all unsigned + // assertions, and will give error if there are both. We are still looping on all assertions instead of + // retrieving value for one assertion, so we do not depend on dependency implementation. + return fmt.Errorf("%s: %w", op, ErrInvalidSignature) + } + } + + // validate root response attr + if !response.SignatureValidated{ + return fmt.Errorf("%s: %w", op, ErrInvalidSignature) + } + return nil +} \ No newline at end of file diff --git a/saml/response_test.go b/saml/response_test.go index 840d886..4fdfef2 100644 --- a/saml/response_test.go +++ b/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 ( @@ -62,10 +61,50 @@ func TestServiceProvider_ParseResponse(t *testing.T) { { name: "success", sp: testSp, - samlResp: base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithResponseSigned()))), + samlResp: base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithCompleteResponseSigned()))), opts: []saml.Option{}, 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", + sp: testSp, + samlResp: base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustResponseElemSigned()))), + opts: []saml.Option{}, + requestID: testRequestId, + wantErrContains: "invalid signature", + }, + { + name: "error-invalid-signature", + sp: testSp, + samlResp: base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, testprovider.WithJustResponseElemSigned()))), + opts: []saml.Option{}, + requestID: testRequestId, + wantErrContains: "invalid signature", + }, + { + name: "error 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", + sp: testSp, + samlResp: base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t))), + opts: []saml.Option{}, + requestID: testRequestId, + wantErrContains: "response and/or assertions must be signed", + }, { name: "err-assertion-missing-attribute-stmt", sp: testSp, @@ -144,7 +183,7 @@ 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.WithCompleteResponseSigned()))), requestID: "invalid-request-id", wantErrContains: "doesn't match the expected requestID (invalid-request-id)", }, @@ -152,7 +191,7 @@ func TestServiceProvider_ParseResponse(t *testing.T) { name: "expired", sp: testSp, samlResp: base64.StdEncoding.EncodeToString([]byte(tp.SamlResponse(t, - testprovider.WithResponseSigned(), + testprovider.WithCompleteResponseSigned(), testprovider.WithResponseExpired(), ))), requestID: "request-id", diff --git a/saml/test/provider.go b/saml/test/provider.go index 025577d..9cbe45f 100644 --- a/saml/test/provider.go +++ b/saml/test/provider.go @@ -431,7 +431,8 @@ func (p *TestProvider) parseRequestPost(request string) *core.AuthnRequest { } type responseOptions struct { - sign bool + signResponseElem bool + signAssertionElem bool expired bool } @@ -450,9 +451,22 @@ func defaultResponseOptions() *responseOptions { return &responseOptions{} } -func WithResponseSigned() ResponseOption { +func WithCompleteResponseSigned() ResponseOption { return func(o *responseOptions) { - o.sign = true + o.signResponseElem = true + o.signAssertionElem = true + } +} + +func WithJustAssertionElemSigned() ResponseOption { + return func(o *responseOptions) { + o.signAssertionElem = true + } +} + +func WithJustResponseElemSigned() ResponseOption { + return func(o *responseOptions) { + o.signResponseElem = true } } @@ -544,13 +558,28 @@ 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 attr assertions + if opt.signAssertionElem{ + responseEl := doc.SelectElement("Response") + for _, assert := range responseEl.FindElements("Assertion") { + signedAssert, err := signCtx.SignEnveloped(assert) + r.NoError(err) + + // replace signed assert element + responseEl.RemoveChildAt(assert.Index()) + responseEl.AddChild(signedAssert) + } + } - doc.SetRoot(signed) + // sign root attr response + if opt.signResponseElem{ + signed, err := signCtx.SignEnveloped(doc.Root()) + r.NoError(err) + doc.SetRoot(signed) + } } result, err := doc.WriteToString()