SAMLResponse with EncryptedAssertion

[anibale]

When the SAMLResponse contains an EncryptedAssertion, the attributes are not read.

[alex-jitbit]

Can you provide a response example?

[anibale]

Sure. This example is base64 encoded and contains "EncryptedAssertion" attribute.

<?xml version="1.0" encoding="UTF-8"?><saml2p:Response xmlns:saml2p="urn:oasis:names:tc:SAML:2.0:protocol" Destination="https://demo.encuestafacil.com/default.aspx" ID="_1a31fd07ff4cfadfce043bc6a14b975b" InResponseTo="_ab64e477-fe3e-413d-ba66-4853fb73cd67" IssueInstant="2020-07-14T09:41:43.713Z" Version="2.0"><saml2:Issuer xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion">https://preidp.work.global.platform.bbva.com/idp/metadata</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="#_1a31fd07ff4cfadfce043bc6a14b975b"><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#"/></ds:Transforms><ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/><ds:DigestValue>0vMV+Fdhc8HNDPfDox2+CMvQUZx76UkewfRhxlopCdA=</ds:DigestValue></ds:Reference></ds:SignedInfo><ds:SignatureValue>pLUUPijfvctVJv4XYfL7VF2I8zoKI1o5JVtjWmWXRuR0D9GgTyOzKEu7iZUNBkjQM5zIQ7hrs4sCezkrdw6bukypBk6wSOCrZiTSk/K2gVQSgSUB/3bfzVeV+eHo1VICNsZXGms/khr/sLnMBjolnqq4gqtje3/LpLsW4rGnH7IkDZFTijnyqGORND6K4YYel1rZYuMMJeStOArHnQs+jjS6RWyEjdhzhCKUT9g2raqopB+7NcmmibW00Bw6xfyW5nXMwkFw1upqPQ+ELMFoAdT5E+kxuXY6qZZr4Yx0dztBj9bOifxzq1REXnidRdvorkrVNz2ipJ3TjVyufEwKNA==</ds:SignatureValue><ds:KeyInfo><ds:X509Data><ds:X509Certificate>MIIGEzCCA/ugAwIBAgITJgcgExc02DzTuG79IgAAAAAAZTANBgkqhkiG9w0BAQsFADB5MQswCQYD
VQQGEwJFUzENMAsGA1UECgwEQkJWQTErMCkGA1UECwwiU2VjdXJpdHkgQXJjaGl0ZWN0dXJlIENy
eXB0b2dyYXBoeTEuMCwGA1UEAwwlR2xvYmFsIElzc3VpbmcgQ0EgSW5mcmFzdHJ1Y3R1cmUgV29y
azAeFw0xOTAyMjgxNTE0MzFaFw0yMTAyMjcxNTE0MzFaMDcxCzAJBgNVBAYTAkVTMQ0wCwYDVQQK
DARCQlZBMRkwFwYDVQQDDBBOYXV0aGlsdXNTaWduaW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
MIIBCgKCAQEA4HVrcdEuylcvPULxUePKceQhARGnp2p40bwrtUn0ReH8LFH/3HxjAc9oz+gAx3u9
GH0zlxjRYH7FJ2uWdxYp/Jq0AfjcPlJImel5LNtqsxUZhkB0PKClhjsC0wDgUENt8qjLGJm/bvSG
BOdWeXQgbvFRWbmxq1YhLq5+8HTBzcb7X65dxduJUWX3zRYYlpvV1ATg+S8DUAA2sPnuqMdfkQQi
IBGRgot2T9CAetra9HBJu8U68f0mmSH3kAmfFv7y0QAWgrERP9UuI/VFJBGvpuEs66VL2hnqMwJL
gO4noVccbD7Hir7xOSSxFptUZdGQOyBdNRoC2YV+K1eCUv1OQwIDAQABo4IB1DCCAdAwDgYDVR0P
AQH/BAQDAgTwMAwGA1UdEwEB/wQCMAAwHQYDVR0OBBYEFD3rQSolpy43hRO71weIGbwXRqKlMB8G
A1UdIwQYMBaAFKWnUvsuFm80J+qB+6aI/nAFNPltMFoGA1UdHwRTMFEwT6BNoEuGSWh0dHA6Ly9n
bG9iYWxwa2kucGxhdGZvcm0uYmJ2YS5jb20vd29yay9nbG9iYWxpc3N1aW5nY2FpbmZyYXN0cnVj
dHVyZS5jcmwwZQYIKwYBBQUHAQEEWTBXMFUGCCsGAQUFBzAChklodHRwOi8vZ2xvYmFscGtpLnBs
YXRmb3JtLmJidmEuY29tL3dvcmsvZ2xvYmFsaXNzdWluZ2NhaW5mcmFzdHJ1Y3R1cmUuY3J0MHMG
A1UdIARsMGowaAYKKwYBBAGC0SIBATBaMFgGCCsGAQUFBwIBFkxodHRwOi8vZ2xvYmFscGtpLnBs
YXRmb3JtLmJidmEuY29tL3BsYXkvY3BzZ2xvYmFsaXNzdWluZ2NhaW5mcmFzdHJ1Y3R1cmUucGRm
MBMGA1UdJQQMMAoGCCsGAQUFBwMBMCMGA1UdEQQcMBqBGG5hdXRoaWx1cy5ncm91cEBiYnZhLmNv
bTANBgkqhkiG9w0BAQsFAAOCAgEAqqLXwnrXiXVr+sdqnwoQacNpFSHYZswnW2cJJBVdPNf6YthN
LjJNM2qD42p39VCFj7WiwtXQhvBX8HUZWxLzJLGsv9+m6mx3DIQ8rzDvb5FUdPjYbppxc2qizlzy
5WUKNTfXLuPp77W1v+weHd4PGt9t21tuzk4VQehl7gwmQBx7uGtHwU38ht+qHyuVBPzkoUzo5eSD
WEZZ8fP8MZiF0tMJ+v+lWDHwzIZnE0CAJ6KdutN56Ah1Px3ciYuUHs1wZguT44iA2I3R4DNtnGUx
s46rfFMSR4c1FKH4ml4yU3jT6PthunNZ12kmlsYS9b/pyBF+YUWpqdHlmPgc2bCZR7j7s1NJjBpT
jnF5ieiWl2wuapl9HVBzuLsGgHmlxMfiDj2vUYiW3lRVa3Xf/V3Z3Bi+jsliHfQRl34HeQcMEDid
wZUt5AWx03ONZW2KcnOtXBgdcjR5luaQ0F9q41Ro+vIiEm5VgPHbQmfSVqRH89C7enOt/PwcJ1TZ
/dxlokN3TE6sCLq53CUGObpTy9oTEpRkoMlze8eVz484cfkp9uY+v1cuBB5xgWBta/yIvoJ6sona
lw0+6ZLdMiZCVTy1ceVYixIMbF5pW0uYc/Zs8A0pATVKD8jvHcLzY5DKqEBzGnR8mp4ZIA9mMrs4
qk+BvABqZL+RPTjdB+c9/Q0BcRE=</ds:X509Certificate></ds:X509Data></ds:KeyInfo></ds:Signature><saml2p:Status xmlns:saml2p="urn:oasis:names:tc:SAML:2.0:protocol"><saml2p:StatusCode Value="urn:oasis:names:tc:SAML:2.0:status:Success"/></saml2p:Status><saml2:EncryptedAssertion xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion"><xenc:EncryptedData xmlns:xenc="http://www.w3.org/2001/04/xmlenc#" Id="_6497ffc0b13d33c6e1bd5673f885f4f3" Type="http://www.w3.org/2001/04/xmlenc#Element"><xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc" xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"/><ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><xenc:EncryptedKey Id="_0d60783c8756a8f3598767e3188d0423" Recipient="bbva.encuestafacil.com" xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"><xenc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p" xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"><ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" xmlns:ds="http://www.w3.org/2000/09/xmldsig#"/></xenc:EncryptionMethod><ds:KeyInfo><ds:X509Data><ds:X509Certificate>MIIFZTCCBE2gAwIBAgISBMUh3L+Bxzqw1GtP3dAegxDJMA0GCSqGSIb3DQEBCwUAMEoxCzAJBgNV
BAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MSMwIQYDVQQDExpMZXQncyBFbmNyeXB0IEF1
dGhvcml0eSBYMzAeFw0yMDA2MTIwNzM1MzFaFw0yMDA5MTAwNzM1MzFaMCExHzAdBgNVBAMTFmRl
bW8uZW5jdWVzdGFmYWNpbC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDOZL2D
7FkcgSoO28eNHsqrepc/pFV18WUvSzQRoaMKVYKjhsU9SGa9MsFFIWTXgv5CpJ7Fs51+twT2ElVL
FuaJIHpnBBo2/4mvzcbiYWvy0XBUaThDjS9z0sERfHhxems4Yo+59QuBbTxTdldGEqM8FXQ1b/VX
XBLVdDBjKJp20rSDJin+w+x2Sprp57wbQOndqh3nRqsoLjQ2zK/vhsvTIg49uVn45Xi4N6c/v9dt
XWR+x6cA4ojz5PXxFI/4atiyEn8UOa2hcj3xQjpFHCnv1LVyRl7ViRndfOlxgwDZcRKofh1K0unD
dGwo5akbnktgtLToDmpWpth068L2boYZAgMBAAGjggJsMIICaDAOBgNVHQ8BAf8EBAMCBaAwHQYD
VR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMAwGA1UdEwEB/wQCMAAwHQYDVR0OBBYEFOr4r3bl
rem30jXN3uoE+jQwjJz2MB8GA1UdIwQYMBaAFKhKamMEfd265tE5t6ZFZe/zqOyhMG8GCCsGAQUF
BwEBBGMwYTAuBggrBgEFBQcwAYYiaHR0cDovL29jc3AuaW50LXgzLmxldHNlbmNyeXB0Lm9yZzAv
BggrBgEFBQcwAoYjaHR0cDovL2NlcnQuaW50LXgzLmxldHNlbmNyeXB0Lm9yZy8wIQYDVR0RBBow
GIIWZGVtby5lbmN1ZXN0YWZhY2lsLmNvbTBMBgNVHSAERTBDMAgGBmeBDAECATA3BgsrBgEEAYLf
EwEBATAoMCYGCCsGAQUFBwIBFhpodHRwOi8vY3BzLmxldHNlbmNyeXB0Lm9yZzCCAQUGCisGAQQB
1nkCBAIEgfYEgfMA8QB2AOcS8rA3fhpi+47JDGGE8ep7N8tWHREmW/Pg80vyQVRuAAABcqerdnwA
AAQDAEcwRQIhANuTUuV4eiZ7mvYoy803f9l60TnW/Nh6kmd4TjwiQ+5aAiB+Z0DYxv+rH3JIi2VK
2pcnmMqQHRkFYsNl3NvUHclg9AB3ALIeBcyLos2KIE6HZvkruYolIGdr2vpw57JJUy3vi5BeAAAB
cqerdnwAAAQDAEgwRgIhAOhEtnGqtV8gKvwKyM9FS/tClQORf30Dw6VUWHB7vhqHAiEAunfQB7f5
1aouQmcj2lUbiYSwuQnn+FvfVfuvIn4JUyUwDQYJKoZIhvcNAQELBQADggEBACJZJqosaL7W9o7J
J9XWreKbxZzbiFX7zATwa0kzv4w0x1him8jdyyPumzv9HG1y7jv/7177g8sDGsEsiNOX2z5LOmJX
TCjWXIBja3i/gHuysfdc/x8jXh0UWBN/eV1TyDhS3806Ckf7BYA3dgzRyfNjx729B0nVp4e6PaTu
3BVHsczlkNlHzXbG8vONljwbMLYPkBpng1Gpym6iZ5+kEp2CcGhl7wF7CZ7VpDT/5unSInSPcg0r
DyFpRfyfuvH8cGmvv+1YwHJOjSh/H2fOmeJ//mdbNr8+d0Dw+5dew811+fruHv+Kd0M8mghlOomG
BSIbd8CafnbMFFunzNzIjuM=</ds:X509Certificate></ds:X509Data></ds:KeyInfo><xenc:CipherData xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"><xenc:CipherValue>K4w1odmt8ihc6dOr01ziQBhrO+iRqHx/rOpGpGOpqssdKBTKAbaErgXR6yGV5wHv0bdOWxyfo9aJjhgDUfxN+13ZJloB+zcw0l2UZJ/y594XAxsVdQ4zlsSHc+m5C+5WtFuF3gijuGrBsMldu7+3R+pcpY3KLbveEBN3dUGk+YbV1Wp3EKN3ObXhY2yW4+mp/WWmdW4DPhqvgc0BZa19VbbHAq22Vyv9TM8ZZGIX09WNIME2sAmp9NrGsQbDoEVFSUZ60u/rDJSa/1hmwvYNwBsv40ICn7MhMQ4OYDIIkC91cu4PSqobLmdGgyLAMtiixCOAABcE3vRejfUXe1ChSw==</xenc:CipherValue></xenc:CipherData></xenc:EncryptedKey></ds:KeyInfo><xenc:CipherData xmlns:xenc="http://www.w3.org/2001/04/xmlenc#"><xenc:CipherValue>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</xenc:CipherValue></xenc:CipherData></xenc:EncryptedData></saml2:EncryptedAssertion></saml2p:Response>

[stricq]

My company's response also has the EncryptedAssertion. That makes this code useless to me. Sadly, so far, this is the only code I have found that actually shows how to use SAML2.

[stricq]

After further study, it seems the xpathing fails because the prefixes and attributes are different in this case. Just changing the code to match the new paths may be all that is needed. I can't test this yet, but once I am setup on my corporate SSO, I'll give it a try.

[QuestionsIHave]

hello, was this ever fixed to be able to work with encrypted assertions? if yes, are there any samples that can be provided?

[diegoclementedev]

Hi @alex-jitbit
Does this problem have a solution?

[alex-jitbit]

I'm not sure how to approach this, any help is appreciated

[ruialexrib]

I know this a bit old, but I have done an AssertionParserUtils class that "DecryptIfNeeded" when an assertion is encrypted... you may have a look and adapt for your code.... I also have other classes to handle the single logout (SP initiated or IDP initiated)
Take a look at: https://github.com/ruialexrib/Programatica.Auth.SAML.ServiceProviderUtils/blob/master/src/Utils/AssertionParserUtils.cs