Merge pull request #172 from timlegge/authnstatement

Draft: Authnstatement as an object

Author: waterkip

lib/Net/SAML2/Protocol/Assertion.pm

@@ -48,6 +48,13 @@ has 'nameid_object' => (
     init_arg  => 'nameid',
     predicate => 'has_nameid',
 );
+has 'authnstatement_object' => (
+    isa       => 'XML::LibXML::Element',
+    is        => 'ro',
+    required  => 0,
+    init_arg  => 'authnstatement',
+    predicate => 'has_authnstatement',
+);
 
 =head1 METHODS
 
@@ -172,6 +179,11 @@ sub new_from_xml {
         $nameid = $global->get_node(1);
     }
 
+    my $authnstatement;
+    if (my $node = $xpath->findnodes('/samlp:Response/saml:Assertion/saml:AuthnStatement')) {
+        $authnstatement = $node->get_node(1);
+    }
+
     my $nodeset = $xpath->findnodes('/samlp:Response/samlp:Status/samlp:StatusCode|/samlp:ArtifactResponse/samlp:Status/samlp:StatusCode');
 
     croak("Unable to parse status from assertion") unless $nodeset->size;
@@ -198,6 +210,7 @@ sub new_from_xml {
         in_response_to => $xpath->findvalue('//saml:Subject/saml:SubjectConfirmation/saml:SubjectConfirmationData/@InResponseTo'),
         response_status => $status,
         $sub_status ? (response_substatus => $sub_status) : (),
+        $authnstatement ? (authnstatement => $authnstatement) : (),
     );
 
     return $self;
@@ -285,6 +298,131 @@ sub nameid_sp_provided_id {
     return $self->nameid_object->getAttribute('SPProvidedID');
 }
 
+=head2 authnstatement
+
+Returns the AuthnStatement
+
+=cut
+
+sub authnstatement {
+    my $self = shift;
+    return unless $self->has_authnstatement;
+    return $self->authnstatement_object->textContent;
+}
+
+=head2 authnstatement_authninstant
+
+Returns the AuthnStatement AuthnInstant
+
+=cut
+
+sub authnstatement_authninstant {
+    my $self = shift;
+    return unless $self->has_authnstatement;
+    return $self->authnstatement_object->getAttribute('AuthnInstant');
+}
+
+=head2 authnstatement_sessionindex
+
+Returns the AuthnStatement SessionIndex
+
+=cut
+
+sub authnstatement_sessionindex {
+    my $self = shift;
+    return unless $self->has_authnstatement;
+    return $self->authnstatement_object->getAttribute('SessionIndex');
+}
+
+=head2 authnstatement_subjectlocality
+
+Returns the AuthnStatement SubjectLocality
+
+=cut
+
+sub authnstatement_subjectlocality {
+    my $self = shift;
+    return unless $self->has_authnstatement;
+
+    my $xpc = XML::LibXML::XPathContext->new;
+    $xpc->registerNs('saml',  'urn:oasis:names:tc:SAML:2.0:assertion');
+    my $subjectlocality;
+    my $xpath_base = '//saml:AuthnStatement/saml:SubjectLocality';
+    if (my $nodes = $xpc->find($xpath_base, $self->authnstatement_object)) {
+        my $node = $nodes->get_node(1);
+        $subjectlocality = $node;
+    }
+    return $subjectlocality;
+}
+
+=head2 subjectlocality_address
+
+Returns the SubjectLocality Address
+
+=cut
+
+sub subjectlocality_address {
+    my $self = shift;
+    return unless $self->has_authnstatement;
+    my $subjectlocality = $self->authnstatement_subjectlocality;
+    return unless $subjectlocality;
+    return $subjectlocality->getAttribute('Address');
+}
+
+=head2 subjectlocality_dnsname
+
+Returns the SubjectLocality DNSName
+
+=cut
+
+sub subjectlocality_dnsname {
+    my $self = shift;
+    return unless $self->has_authnstatement;
+    my $subjectlocality = $self->authnstatement_subjectlocality;
+    return unless $subjectlocality;
+    return $subjectlocality->getAttribute('DNSName');
+}
+
+=head2 authnstatement_authncontext
+
+Returns the AuthnContext for the AuthnStatement
+
+=cut
+
+sub authnstatement_authncontext {
+    my $self = shift;
+    return unless $self->has_authnstatement;
+
+    my $xpc = XML::LibXML::XPathContext->new;
+    $xpc->registerNs('saml',  'urn:oasis:names:tc:SAML:2.0:assertion');
+    my $authncontext;
+    my $xpath_base = '//saml:AuthnStatement/saml:AuthnContext';
+    if (my $nodes = $xpc->find($xpath_base, $self->authnstatement_object)) {
+        my $node = $nodes->get_node(1);
+        $authncontext = $node;
+    }
+    return $authncontext;
+}
+
+=head2 contextclass_authncontextclassref
+
+Returns the ContextClass AuthnContextClassRef
+
+=cut
+
+sub contextclass_authncontextclassref {
+    my $self = shift;
+    return unless $self->has_authnstatement;
+    my $authncontextclassref = $self->authnstatement_authncontext;
+    return unless $authncontextclassref;
+    my $xpc = XML::LibXML::XPathContext->new;
+    $xpc->registerNs('saml',  'urn:oasis:names:tc:SAML:2.0:assertion');
+    if (my $value = $xpc->findvalue('//saml:AuthnContextClassRef', $self->authnstatement_object)) {
+        $authncontextclassref = $value;
+    }
+    return $authncontextclassref;
+}
+
 =head2 valid( $audience, $in_response_to )
 
 Returns true if this Assertion is currently valid for the given audience.

t/03-assertions.t

@@ -114,6 +114,22 @@ $assertion->{not_before} = DateTime->now->add(minutes => 5);
 is($assertion->valid('http://ct.local'), 0, "and invalid again - InResponseTo not Checked");
 is($assertion->valid('http://ct.local', 'N3k95Hg41WCHdwc9mqXynLPhB'), 0, "and invalid again - InResponseTo Checked");
 
+is($assertion->authnstatement_authninstant,
+    '2010-10-12T12:58:34Z',
+    "AuthnStatement AuthnInstant is ok");
+is($assertion->authnstatement_sessionindex,
+    's2b087bdce06dbbf9cd4662af82b8b853d4d285c01',
+    "AuthnStatement SessionIndex is ok");
+is($assertion->subjectlocality_address,
+    undef,
+    "SubjectLocality Address is ok");
+is($assertion->subjectlocality_dnsname,
+    undef,
+    "SubjectLocality DNSName is ok");
+is($assertion->contextclass_authncontextclassref,
+    'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport',
+    "AuthnContext AuthnContextClassRef is ok");
+
 my $assertion_b64 = <<'BASE64';
 <?xml version="1.0" encoding="UTF-8"?><saml2p:Response xmlns:saml2p="urn:oasis:names:tc:SAML:2.0:protocol" Destination="https://netsaml2-testapp.local/consumer-post" ID="_b160e710ec868cb78e7d303b8db9b536" InResponseTo="NETSAML2_743421ef5c9302186d8050c4c5bab7e76a8b8fd4e329b0f9a39a182356760de1" IssueInstant="2023-01-14T14:37:15.814Z" Version="2.0"><saml2:Issuer xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion">https://idp.shibboleth.local/idp/shibboleth</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="#_b160e710ec868cb78e7d303b8db9b536"><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>cfQgrmymQlljx+6+XKgETRKrMrV0gfa2kbUJkVvba1E=</ds:DigestValue></ds:Reference></ds:SignedInfo><ds:SignatureValue>CKBNQ0Ri+dYtUfrU+uhPHsGbpJsXzVe0JAkm2hEQzGcSYGLs/qLgA+SdBqfikOAKaJoX8CM8kvZhpzri7R+pTUQMwvVBLqbbBt2oSifyTXn4I9LCwAlNXvfL+YXdfDd5tkLqO213DYIBr7WKSVFOdfciksKfiWRMP3QT/qvcae6KO7U8NjqDKRs+V2TZKA+Ty4IdcLzsWqwyfDYhJwDChGlfna06YV5fYfLfyBzMS5E73570Ku6ncH27lGHjGNqMqTh8VfT3aeVCROrB2JDgJIfyWivRY/Ghi7L0YRIufWqn4YufO0FDJwHMuLtmEp5ZNj5g7JpfssQx9dCfctoGs27/3kjeHUTrvEQhQ4wdWj0eEfyms5GMjZb9ZH95EOpCS3z8MhPd/FidSRQHBoyNtUcs8ACwcgE2E2EKtDY8azbnF+rBoRgaXkoKpiOkJmTXuo1cGvUMvWnChY2v60lYfLW/9KYkR7JPJGTUsdFBhZBPhZ+epkHMP9JzCDxb+9c5</ds:SignatureValue><ds:KeyInfo><ds:X509Data><ds:X509Certificate>MIIEOzCCAqOgAwIBAgIUU2fynUQZS+sXRqj0Oc4YgF4mIOowDQYJKoZIhvcNAQELBQAwHzEdMBsG
A1UEAwwUaWRwLnNoaWJib2xldGgubG9jYWwwHhcNMjIxMjI1MjIzMjA4WhcNNDIxMjI1MjIzMjA4
WjAfMR0wGwYDVQQDDBRpZHAuc2hpYmJvbGV0aC5sb2NhbDCCAaIwDQYJKoZIhvcNAQEBBQADggGP
ADCCAYoCggGBAKv1cHr62t1KN7CM6pBi4E78F7djkO3ASQjP5smPuZisB4KQQ/oMKNcJ0BRJ2f2m
5KNRj8RnT2nrD1ychwYqtbTAfQdfUMc+rVdhg8FnsN/e41f8XcBh5f74vnt9AcHeCSV/GGlde/MI
pzl7fSyHzM9B5BeZpV9IvaX75dyeWpHJO64z9QvYfLM3ZrBGubKaUDKE+42dpOgj7HQo7NcpOeDo
6lmhaUseAHx6juL63IXWyjKGKlUhc7yYo+Alu+9VcfWH4O/UT59lzzajFdMxbdkqr/FP2LTKWYpo
Te9fxzTphcTNylrv8XyhtFFqP572x85HqbLx3wyUxvK7A6XwEDQniMatEoHRp620Uf+4Z1RZYaUy
KRmWilOcMToXMOxBx68y/z7OrOYLFjbixZeej7tlVEMz7pwUL7I/dZA4/SIFyUEPdj8tHw313IHD
00NMZBfq/1u41LBsYbZ2b8YzRc6fhzqKr+SgR1eqkOePNYHENA44NnWtRrOQPJHdxKxzDQIDAQAB
o28wbTAdBgNVHQ4EFgQUhlv49y3eVyyEQs4fFoSai52/INwwTAYDVR0RBEUwQ4IUaWRwLnNoaWJi
b2xldGgubG9jYWyGK2h0dHBzOi8vaWRwLnNoaWJib2xldGgubG9jYWwvaWRwL3NoaWJib2xldGgw
DQYJKoZIhvcNAQELBQADggGBAKWWexRPg3WMe0m6v9JkJkX3luPQvSY5MJmw32ogEMQJiaRa3JZT
YuL5z5zeBhidTQ+IZQbt2bi6mw5MySi/JMuiW69N9sh28IgcvGSY7sSry5HVr2qEByd0PMVm6xez
puL9mHD50AlfC5hwW19c4C2HvjLqcz79XKtL09Fd8QLbjc1vM9Ekpt15H55KzsFS5GbXAUjZYhzG
IW6xWoGR22kd+dIbP7l55LD8Ldr8fJLdFdEDAZ7FpxsZCIek+5bKrPRv75seaE2hxO/Z+TuBSuMm
9q1LhHRUQUy9CKAEw4fFFqeSTg/Nnw3lnmAF/T00A5eKCW4uk1VeTOU65ywvxGyOm0OUfkOTqsQR
8tqz/4FY+qJIksf0ZpCZztH+7jqRdv8nQ7lIleetUamPe2hB/hOS9+xrADc4bd53b1vs/UzxZPhH
WRtV/102e7SLITBll5bV/cNPEiFzXA9WeWGToP4+QnYBdao/AlPhokHHidyzGngTAguXx84i08+F
e+kMqQ==</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 xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion" ID="_61f377717caad87ce2af0e7946cb97b1" IssueInstant="2023-01-14T14:37:15.814Z" Version="2.0"><saml2:Issuer>https://idp.shibboleth.local/idp/shibboleth</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="#_61f377717caad87ce2af0e7946cb97b1"><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>MwBFLs34YYkMRe3q1DkWgMjqi6V8bHbT3JCTfxyZLJk=</ds:DigestValue></ds:Reference></ds:SignedInfo><ds:SignatureValue>oqevIAEnWLQwSZx8hxiSApNBVrWZLoF1Z4KOTRbvOGdYvgqw7meBvdoRUlGupy3C/jn0UQPB5ZSoUWwPgebLmF5OayWKAcC6MYoQ+Zttq+4kOTJ+DKPaKO2fEsCzCS+HX8ac+LuajHfKvqtd1mKP9U1TQ63Z1joDo2H1EXMQdOZnRwWXgKFeXAWPJab0vfvVfYauVUrn1ZC20QaNLzBjRDC0d6loXL3g7CTy/YNf2mJNcRjWF4ER4cqOdUwDdtBgXVFGjQs345rK3/oN8lO5T7Timgl1aMPxCof+EivsWjkbiAxTs9M05QEWRj/BWzKGYGyu9srDZMid+Z5BacCQIzFZ1/8kKGI6+UYVDxaUCLT9aQow4lEuT10k2l4LXqjaXA/ymOih4nIKJ1AsGH13UMul4BOEyLO5AFAXz57H3oxrdlvW7CaSwby0yhxyTcK54VoL2lC0hFaz9XLvsh1jSHwyZfN+63VBu8w50S5egn4eAYBezYLwzLukHXRwIazC</ds:SignatureValue><ds:KeyInfo><ds:X509Data><ds:X509Certificate>MIIEOzCCAqOgAwIBAgIUU2fynUQZS+sXRqj0Oc4YgF4mIOowDQYJKoZIhvcNAQELBQAwHzEdMBsG
A1UEAwwUaWRwLnNoaWJib2xldGgubG9jYWwwHhcNMjIxMjI1MjIzMjA4WhcNNDIxMjI1MjIzMjA4
WjAfMR0wGwYDVQQDDBRpZHAuc2hpYmJvbGV0aC5sb2NhbDCCAaIwDQYJKoZIhvcNAQEBBQADggGP
ADCCAYoCggGBAKv1cHr62t1KN7CM6pBi4E78F7djkO3ASQjP5smPuZisB4KQQ/oMKNcJ0BRJ2f2m
5KNRj8RnT2nrD1ychwYqtbTAfQdfUMc+rVdhg8FnsN/e41f8XcBh5f74vnt9AcHeCSV/GGlde/MI
pzl7fSyHzM9B5BeZpV9IvaX75dyeWpHJO64z9QvYfLM3ZrBGubKaUDKE+42dpOgj7HQo7NcpOeDo
6lmhaUseAHx6juL63IXWyjKGKlUhc7yYo+Alu+9VcfWH4O/UT59lzzajFdMxbdkqr/FP2LTKWYpo
Te9fxzTphcTNylrv8XyhtFFqP572x85HqbLx3wyUxvK7A6XwEDQniMatEoHRp620Uf+4Z1RZYaUy
KRmWilOcMToXMOxBx68y/z7OrOYLFjbixZeej7tlVEMz7pwUL7I/dZA4/SIFyUEPdj8tHw313IHD
00NMZBfq/1u41LBsYbZ2b8YzRc6fhzqKr+SgR1eqkOePNYHENA44NnWtRrOQPJHdxKxzDQIDAQAB
o28wbTAdBgNVHQ4EFgQUhlv49y3eVyyEQs4fFoSai52/INwwTAYDVR0RBEUwQ4IUaWRwLnNoaWJi
b2xldGgubG9jYWyGK2h0dHBzOi8vaWRwLnNoaWJib2xldGgubG9jYWwvaWRwL3NoaWJib2xldGgw
DQYJKoZIhvcNAQELBQADggGBAKWWexRPg3WMe0m6v9JkJkX3luPQvSY5MJmw32ogEMQJiaRa3JZT
YuL5z5zeBhidTQ+IZQbt2bi6mw5MySi/JMuiW69N9sh28IgcvGSY7sSry5HVr2qEByd0PMVm6xez
puL9mHD50AlfC5hwW19c4C2HvjLqcz79XKtL09Fd8QLbjc1vM9Ekpt15H55KzsFS5GbXAUjZYhzG
IW6xWoGR22kd+dIbP7l55LD8Ldr8fJLdFdEDAZ7FpxsZCIek+5bKrPRv75seaE2hxO/Z+TuBSuMm
9q1LhHRUQUy9CKAEw4fFFqeSTg/Nnw3lnmAF/T00A5eKCW4uk1VeTOU65ywvxGyOm0OUfkOTqsQR
8tqz/4FY+qJIksf0ZpCZztH+7jqRdv8nQ7lIleetUamPe2hB/hOS9+xrADc4bd53b1vs/UzxZPhH
WRtV/102e7SLITBll5bV/cNPEiFzXA9WeWGToP4+QnYBdao/AlPhokHHidyzGngTAguXx84i08+F
e+kMqQ==</ds:X509Certificate></ds:X509Data></ds:KeyInfo></ds:Signature><saml2:Subject><saml2:NameID Format="urn:oasis:names:tc:SAML:2.0:nameid-format:persistent" NameQualifier="https://idp.shibboleth.local/idp/shibboleth" SPNameQualifier="https://netsaml2-testapp.local" xmlns:saml2="urn:oasis:names:tc:SAML:2.0:assertion">7VTBH4WVXMCYOKWXKVAFJLMTMGNIIGMX</saml2:NameID><saml2:SubjectConfirmation Method="urn:oasis:names:tc:SAML:2.0:cm:bearer"><saml2:SubjectConfirmationData Address="192.168.122.1" InResponseTo="NETSAML2_743421ef5c9302186d8050c4c5bab7e76a8b8fd4e329b0f9a39a182356760de1" NotOnOrAfter="2023-01-14T14:42:15.826Z" Recipient="https://netsaml2-testapp.local/consumer-post"/></saml2:SubjectConfirmation></saml2:Subject><saml2:Conditions NotBefore="2023-01-14T14:37:15.814Z" NotOnOrAfter="2023-01-14T14:42:15.814Z"><saml2:AudienceRestriction><saml2:Audience>https://netsaml2-testapp.local</saml2:Audience></saml2:AudienceRestriction></saml2:Conditions><saml2:AuthnStatement AuthnInstant="2023-01-14T14:37:15.781Z" SessionIndex="_121cef54191d57f90753619ff81856bd"><saml2:SubjectLocality Address="192.168.122.1"/><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="schacHomeOrganization" Name="urn:oid:1.3.6.1.4.1.25178.1.2.9" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri"><saml2:AttributeValue>shibboleth.local</saml2:AttributeValue></saml2:Attribute></saml2:AttributeStatement></saml2:Assertion></saml2p:Response>
 BASE64
@@ -132,6 +148,22 @@ is($assertion->nameid_sp_provided_id,
     undef,
     "nameid_sp_provided_id undefined as expected");
 
+is($assertion->authnstatement_authninstant,
+    '2023-01-14T14:37:15.781Z',
+    "AuthnStatement AuthnInstant is ok");
+is($assertion->authnstatement_sessionindex,
+    '_121cef54191d57f90753619ff81856bd',
+    "AuthnStatement SessionIndex is ok");
+is($assertion->subjectlocality_address,
+    '192.168.122.1',
+    "SubjectLocality Address is ok");
+is($assertion->subjectlocality_dnsname,
+    undef,
+    "SubjectLocality DNSName is ok");
+is($assertion->contextclass_authncontextclassref,
+    'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport',
+    "AuthnContext AuthnContextClassRef is ok");
+
 is($assertion->id,
     "_61f377717caad87ce2af0e7946cb97b1",
     "Assertion id is as expected");
@@ -186,4 +218,20 @@ is(
     isa_ok($assertion, 'Net::SAML2::Protocol::Assertion');
 }
 
+is($assertion->authnstatement_authninstant,
+    '2018-07-25T07:54:35.599Z',
+    "AuthnStatement AuthnInstant is ok");
+is($assertion->authnstatement_sessionindex,
+    undef,
+    "AuthnStatement SessionIndex is ok");
+is($assertion->subjectlocality_address,
+    undef,
+    "SubjectLocality Address is ok");
+is($assertion->subjectlocality_dnsname,
+    undef,
+    "SubjectLocality DNSName is ok");
+is($assertion->contextclass_authncontextclassref,
+    'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport',
+    "AuthnContext AuthnContextClassRef is ok");
+
 done_testing;