[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]
Subject: Re: AW: [dss-x] Verification Reports
Hi Detlef, Many thanks for your feedback. I already changed the way the signing certificate is communicated back as part of the DetailedSignatureReport. Now I'm using DetailedSignatureReport/CertificatePathValidity/PathValidityDetail/CertificateValue as you mention. In attachment you'll find an example of a real-world verification request and verification report using an XML document signed with my Belgian eID card. Feedback is always welcome. Indeed, the spec is not always that clear as to what fields to use exactly. FYI... a presentation about the eID DSS is available at: http://eid-dss.googlecode.com/files/fedict-eid-dss.pdf Kind Regards, Frank. On 11/22/2010 04:30 PM, Huehnlein, Detlef wrote: > Hallo Frank, > > thank you very much for mail. Sorry, that my answer took > that much time. > >> As part of an eID DSS implementation targeting the Belgian >> eID card, available at: >> http://code.google.com/p/eid-dss/ >> I've implemented OASIS DSS core and the VR profile. I'm >> looking for feedback on this to be sure that I've interpreted >> the VR profile correctly. A protocol run by example is >> available as part of the eID DSS developer's guide at: >> >> http://eid-dss.googlecode.com/files/eid-dss-dev-guide-15-09-2010.pdf >> under section "3. OASIS DSS Web Service". So here are my questions: >> Is it OK to use >> vr:VerificationReport/vr:IndividualReport/vr:SignedObjectIdent >> ifier/vr:SignedProperties/vr:SignedSignatureProperties/xades:S >> igningTime to uniquely identify the signature? > Yes. Using the xades:SigningTime-property to identify the signature is > usually a good idea, as using this element as identifier is very > natural for human consumers of a verification report. However if it > can not be guaranteed that the signing time alone is sufficient to > provide uniqueness, it is advisable to also use additional identifiers > (e.g. DigestAlgAndValue, SignatureValue) to ensure the unique identification > of signatures. > >> Is it OK to use >> vr:VerificationReport/vr:IndividualReport/vr:Details/vr:Indivi >> dualCertificateReport/vr:CertificateValue to get the signing >> certificate? > Concerning this question it is not entirely clear to me what > you exactly mean by "to get the signing certificate". > > If you ask whether vr:VerificationReport/vr:IndividualReport/vr:Details/vr:IndividualCertificateReport > is the "right place" to include the verification result for the "signing certificate" > (in the sense of the SigningCertificate-property of a XAdES-signature > according to Section 7.2.2 of http://uri.etsi.org/01903/v1.4.1/ts_101903v010401p.pdf), > which may contain the certificate itself in the CertificateValue-element, then > the answer is "no", because the verification result for a certificate on which an > advanced electronic signature is based SHOULD be reported in the > first vr:CertificateValidity-element within vr:DetailedSignatureReport/vr:CertificatePathValidity/vr:PathValidityDetail. > > The vr:IndividualCertificateReport-element is only meant to be used if a certificate is to > be verified WITHOUT a specific signature-related context. > > As this point is not yet clearly specified in the current version of the profile, > we will include a clarifying note as soon as possible. > > It would be great, if you could provide some more details about the second question. > > Best regards, > Detlef > >> Besides the VR profile implementation, section 2 of the same >> developer's guide also highlights the implementation of an >> "eID DSS Browser POST Protocol" for the creation of eID based >> signatures that require interaction with the web browser of >> the end-user. What I would like to do is to define a similar >> Browser POST profile on top of the OASIS DSS core. So where >> to get started? I just do some implementation, document it >> and send it over for review? >> >> >> Thanks in advance, >> Frank. >> --------------------------------------------------------------------- >> To unsubscribe from this mail list, you must leave the OASIS TC that >> generates this mail. Follow this link to all your TCs in OASIS at: >> https://www.oasis-open.org/apps/org/workgroup/portal/my_workgr > oups.php >>
<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/";><S:Body><ns3:VerifyRequest xmlns:ns3="urn:oasis:names:tc:dss:1.0:core:schema" xmlns="urn:oasis:names:tc:SAML:1.0:assertion" xmlns:ns2="http://www.w3.org/2000/09/xmldsig#"; RequestID="dss-request-be55100c-5268-4695-8765-dd794c3d475f"><ns3:OptionalInputs><ReturnVerificationReport:ReturnVerificationReport xmlns:ReturnVerificationReport="urn:oasis:names:tc:dss-x:1.0:profiles:verificationreport:schema#" xmlns="urn:oasis:names:tc:dss-x:1.0:profiles:verificationreport:schema#" xmlns:ns2="http://uri.etsi.org/01903/v1.3.2#"; xmlns:ns3="http://www.w3.org/2000/09/xmldsig#"; xmlns:ns4="http://uri.etsi.org/02231/v2#"; xmlns:ns5="urn:oasis:names:tc:dss:1.0:core:schema"><IncludeVerifier>false</IncludeVerifier><IncludeCertificateValues>true</IncludeCertificateValues><ReportDetailLevel>urn:oasis:names:tc:dss-x:1.0:profiles:verificationreport:reportdetail:noDetails</ReportDetailLevel></ReturnVerificationReport:ReturnVerificationReport></ns3:OptionalInputs><ns3:InputDocuments><ns3:Document><ns3:Base64XML><?xml version="1.0" encoding="UTF-8"?><test>
<data>hello world</data>
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#" Id="xmldsig-30c5bb79-8c43-46af-bce7-eba55bae9de9"><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-sha512"/><ds:Reference URI=""><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#sha512"/><ds:DigestValue>ZcO872duMKovpQGHGPLOdp9LkS/Evb4OP5RCcEtdc635H+ggbUh4kmaGgbiWTHQ2jGqsarxYczc2
7Ni8ldIsNg==</ds:DigestValue></ds:Reference><ds:Reference Type="http://uri.etsi.org/01903#SignedProperties" URI="#xmldsig-30c5bb79-8c43-46af-bce7-eba55bae9de9-xades"><ds:Transforms><ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/></ds:Transforms><ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha512"/><ds:DigestValue>qUIiiLGoS2Z8GJKnorLmKsAJbebQe28AftI4IoZsUhA6J65QD8XhmmRQREGAWY8do+kCLw2vYeS3
DJMPPhSKdA==</ds:DigestValue></ds:Reference></ds:SignedInfo><ds:SignatureValue Id="xmldsig-30c5bb79-8c43-46af-bce7-eba55bae9de9-signature-value">IZ+mYFsp9w6zlfDaK5bReO7Mmhdmgkmg05dC33pP//Uxg2xlFo5O2IAxJFWGIbxifjEHRXBIZsb8
Fk92GoaLjs2atlj/NVx3qQU/vROMz9btT1btY2WSsMXiyUTcJ4NZ2rnd1SSStYv6mtfGAAGD+sV0
oe1oN7jVM2B0XB5ndPk=</ds:SignatureValue><ds:KeyInfo><ds:X509Data><ds:X509Certificate>MIID/jCCAuagAwIBAgIQEAAAAAAAWeCXw4gx7baBGDANBgkqhkiG9w0BAQUFADAzMQswCQYDVQQG
EwJCRTETMBEGA1UEAxMKQ2l0aXplbiBDQTEPMA0GA1UEBRMGMjAwNjEyMB4XDTA2MTAwNTAxMTQz
MVoXDTExMDkyNjIzNTk1OVowcTELMAkGA1UEBhMCQkUxIzAhBgNVBAMTGkZyYW5rIENvcm5lbGlz
IChTaWduYXR1cmUpMREwDwYDVQQEEwhDb3JuZWxpczEUMBIGA1UEKhMLRnJhbmsgSGVucmkxFDAS
BgNVBAUTCzc5MTAyNTIwOTkxMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCF/MOxjVCtsQ3c
CfnnOmJLvgp9OKfQJHy95/IwxsdoAitUMGnOUvVmhPq5fVXd0RAJtdb+FoKqaRgNiuQZWAS3PUtN
5OhQgYgSZApZhiVcY05HRm6ak03+9t0DwaAe14tMMGatXm5hD0itAvlSMkow6lBGqEfwHU6Sx6mJ
vgIl9QIDAQABo4IBUjCCAU4wRAYDVR0gBD0wOzA5BgdgOAEBAQIBMC4wLAYIKwYBBQUHAgEWIGh0
dHA6Ly9yZXBvc2l0b3J5LmVpZC5iZWxnaXVtLmJlMA4GA1UdDwEB/wQEAwIGQDAfBgNVHSMEGDAW
gBSl/gnOjAV0/+JmWg78J0Cu7s72cDA5BgNVHR8EMjAwMC6gLKAqhihodHRwOi8vY3JsLmVpZC5i
ZWxnaXVtLmJlL2VpZGMyMDA2MTIuY3JsMBEGCWCGSAGG+EIBAQQEAwIFIDBtBggrBgEFBQcBAQRh
MF8wNQYIKwYBBQUHMAKGKWh0dHA6Ly9jZXJ0cy5laWQuYmVsZ2l1bS5iZS9iZWxnaXVtcnMuY3J0
MCYGCCsGAQUFBzABhhpodHRwOi8vb2NzcC5laWQuYmVsZ2l1bS5iZTAYBggrBgEFBQcBAwQMMAow
CAYGBACORgEBMA0GCSqGSIb3DQEBBQUAA4IBAQBZYThKtw4TsThTzB/CGKHpXAg25BlUp0lcSavI
gzdYZde9R1MYiExNZ/BGwyoHK70Jdx0Z6qt7IL9cLJBiU0znFM1p0+IOWJOoaz12nu6aETiG6pXg
RcdTuRBDZZgKbfXjKOrjYRaeu4jlvFfPR71ZQzSRFGeUNF2YHlEWiJiahoThFOiTI/C/f2OnH7aE
H0+DGDcK/ZsTG1Ypo4Oi85KOmCb6zZ3o6s2PbdgJ0XFMPRRDAhqE0fW9njmYQq3dPoKgi5t7Ed7p
dxCgOfxkwSkj6wgdfNJhnL/UUghaVc71SAOwiYQ9gmkVxK42OcaUS6OBSc6pZ8NqMRsNx0+ljgVZ</ds:X509Certificate><ds:X509Certificate>MIID3DCCAsSgAwIBAgIQH1QigD++OW5rhtkCQqNLVDANBgkqhkiG9w0BAQUFADAnMQswCQYDVQQG
EwJCRTEYMBYGA1UEAxMPQmVsZ2l1bSBSb290IENBMB4XDTA1MTIwMTExMDAwMFoXDTEyMDgwMTEw
MDAwMFowMzELMAkGA1UEBhMCQkUxEzARBgNVBAMTCkNpdGl6ZW4gQ0ExDzANBgNVBAUTBjIwMDYx
MjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALAQff7bieNQDqYKbM4fOnOPSwfs+ohf
ohnyXhDfjpFeKbneHcz7ylT6JH4t+2oW9Ip/K1TI1crB0hVBbfUbV9GDBFiQpKy58de+UtmiXcug
nbFzb7PUeYbmFRAzqQxtJyUpUBpL0iq9q3//LacjiCsI66M9XZzxLpMZXkCmJFIbzdT4DvuY6Qmo
7tUnFu8xh73Y68ul2a/u8wOz6Orw3xBT2LjoSlhlWR8sw3axYAO6/Pe42FiDjb5iXLoynJHynOHX
cRyaIwtY4Fx+V6+dH8w+BDiBtB39/41kEFrYZtgLAmG0n3rb0qNNEdkQcg9A9wPPmFO99pzv8sAC
4ui0g4sCAwEAAaOB9zCB9DAOBgNVHQ8BAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADBDBgNV
HSAEPDA6MDgGBmA4AQEBAjAuMCwGCCsGAQUFBwIBFiBodHRwOi8vcmVwb3NpdG9yeS5laWQuYmVs
Z2l1bS5iZTAdBgNVHQ4EFgQUpf4JzowFdP/iZloO/CdAru7O9nAwNgYDVR0fBC8wLTAroCmgJ4Yl
aHR0cDovL2NybC5laWQuYmVsZ2l1bS5iZS9iZWxnaXVtLmNybDARBglghkgBhvhCAQEEBAMCAAcw
HwYDVR0jBBgwFoAUEPAMVpth6lc6tjWXbZ/duRSO2+YwDQYJKoZIhvcNAQEFBQADggEBACXneQ7s
gFhBaE+nK5X2UQpyS7LZGsZmkd/MG/Nf7hhek6ZWl7z1HxeJzT1NBJobVsToJWbRxhLmt/f+bB8g
kM4ArAAoboytEdRwd6k15gqCiQmwh/dyJKr23xhEiYp2suaLX15B3IMPeEjUdozFZmC92W57jJzt
EJCq1oqPaaUg82YtkK2gttTpDSMrCC4iDvQFEnrgroIWKivlFmz7d7sEuz1w/lZY4YTOlEv6dWNP
0R9uUsul1lcIO82WSVLofE0sU/p5ApomkfqCbvSKgGD58jQxIuaj4pllxc6NUZJOVROEdeRKxZ4Q
kRgN6/SyZVnVnfJbdIdnIsCB4jNymKE=</ds:X509Certificate><ds:X509Certificate>MIIDlDCCAnygAwIBAgIQWAsFbFMk27JQVxhf+eWmUDANBgkqhkiG9w0BAQUFADAnMQswCQYDVQQG
EwJCRTEYMBYGA1UEAxMPQmVsZ2l1bSBSb290IENBMB4XDTAzMDEyNjIzMDAwMFoXDTE0MDEyNjIz
MDAwMFowJzELMAkGA1UEBhMCQkUxGDAWBgNVBAMTD0JlbGdpdW0gUm9vdCBDQTCCASIwDQYJKoZI
hvcNAQEBBQADggEPADCCAQoCggEBAMihcekcRkJ5eHFvna6pqKsot03HIOswkVp19eLSz8hMFJhC
WK3HEcVAQGpa+XQSJ4fpnOVxTiIs0RIYqjBeoiG52bv/9nTrMQHnO35YD5EWTXaJqAFPrSJmcPpL
HZXBMFjqvNll2Jq0iOtJRlLf0lMVdssUXRlJsW9q09P9vMIt7EU/CT9YvvzU7wCMgTVyv/cY6pZi
fSsofxVsY9LKyn0FrMhtB20yvmi4BUCuVJhWPmbxMOjvxKuTXgfeMo8SdKpbNCNUwOpszv42kqgJ
F+qhLc9s44Qd3ocuMws8dOIhUDiVLlzg5cYx+dtA+mqhpIqTm6chBocdJ9PEoclMsG8CAwEAAaOB
uzCBuDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBCBgNVHSAEOzA5MDcGBWA4AQEB
MC4wLAYIKwYBBQUHAgEWIGh0dHA6Ly9yZXBvc2l0b3J5LmVpZC5iZWxnaXVtLmJlMB0GA1UdDgQW
BBQQ8AxWm2HqVzq2NZdtn925FI7b5jARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAUEPAM
Vpth6lc6tjWXbZ/duRSO2+YwDQYJKoZIhvcNAQEFBQADggEBAMhtIlGKYfgPlm7VILKB+MbcoxYA
2s1q52sq+llIp0xJN9dzoWoBZV4yveeX09AuPHPTjHuD79ZCwT+oqV0PN7p20kC9zC0/00RBSZz9
Wyn0AiMiW3Ebv1jZKE4tRfTa57VjRUQRDSp/M382SbTObqkCMa5c/ciJv0J71/Fg8teH9lcuen5q
E4Ad3OPQYx49cTGxYNSeCMqr8JTHSHVUgfMbrXec6LKP24OsjzRr6L/D2fVDw2RV6xq9NoY2uiGM
lxoh1OotO6y67Kcdq765Sps1LxxcHVGnH1TtEpf/8m6HfUbJdNbv6z195lluBpQE5KJVhzgoaiJe
4r50ErAEQyo=</ds:X509Certificate></ds:X509Data></ds:KeyInfo><ds:Object><xades:QualifyingProperties xmlns:xades="http://uri.etsi.org/01903/v1.3.2#" Target="#xmldsig-30c5bb79-8c43-46af-bce7-eba55bae9de9" xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><xades:SignedProperties Id="xmldsig-30c5bb79-8c43-46af-bce7-eba55bae9de9-xades"><xades:SignedSignatureProperties><xades:SigningTime>2010-09-13T13:35:49.767Z</xades:SigningTime><xades:SigningCertificate><xades:Cert><xades:CertDigest><ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha512"/><ds:DigestValue>2XMaoIzZQb+W4m1ehceYsAp9uudZtwgV1kiVtBPeWQ4GiyBXKgdKwQTZYQCkB6Rh/IvI28ecw3mjg0nEP5ez5Q==</ds:DigestValue></xades:CertDigest><xades:IssuerSerial><ds:X509IssuerName>SERIALNUMBER=200612, CN=Citizen CA, C=BE</ds:X509IssuerName><ds:X509SerialNumber>21267647932559078400084294942057726232</ds:X509SerialNumber></xades:IssuerSerial></xades:Cert></xades:SigningCertificate></xades:SignedSignatureProperties></xades:SignedProperties><xades:UnsignedProperties xmlns:xadesv141="http://uri.etsi.org/01903/v1.4.1#"><xades:UnsignedSignatureProperties><xades:SignatureTimeStamp Id="time-stamp-bd35e922-0b0b-41f8-90fb-da77802956e8"><ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#WithComments"/><xades:EncapsulatedTimeStamp Id="time-stamp-token-91deebc8-1e5c-4134-acf6-58c5433d93b7">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</xades:EncapsulatedTimeStamp></xades:SignatureTimeStamp><xadesv141:TimeStampValidationData><xades:RevocationValues><xades:CRLValues><xades:EncapsulatedCRLValue>MIIB0TCBugIBATANBgkqhkiG9w0BAQUFADBXMQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTEQMA4GA1UECxMHUm9vdCBDQTEbMBkGA1UEAxMSR2xvYmFsU2lnbiBSb290IENBFw0xMDA3MDgwNjAwMDBaFw0xMTAxMDYwNjAwMDBaoC8wLTAKBgNVHRQEAwIBCzAfBgNVHSMEGDAWgBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0BAQUFAAOCAQEAq4VpuBVqASMuYcw5p3V2oQeaGAq/i6HuYpX+2VIlX4jDURkeIhGadofC8kSouIEKXV/XuX5TCobKodYHI5kdvL1eXmaD0kRuIkza9p/HfmOugNm8QnNiTouF7sAtb+rmEWlQ6KyD7W4KBFGRCm1Xi5VCDg5jXk2BNKaM67Y2CF2eeRFiTHvhtw8W/SUSlxPUC8VqTanmX4Va5h0i7Ua3KLo73YToXMRLaDjJcF3NdxRZI98G5Ne3Fa6ucgIiEdjKtDPicrA4IcfUYQY52hlTsOh+kOBa3uOLk0yRSu62BcXuLPskIwl5U3L9jemLeFFX4exqSsyV28cQQxHHtnD2UA==</xades:EncapsulatedCRLValue><xades:EncapsulatedCRLValue>MIIBbTBXMA0GCSqGSIb3DQEBBQUAMCgxCzAJBgNVBAYTAkJFMRkwFwYDVQQDExBCZWxnaXVtIFJvb3QgQ0EyFw0xMDA3MDExMjAwMDBaFw0xMTAxMzExMjAwMDBaMA0GCSqGSIb3DQEBBQUAA4IBAQCnQVBCpOUUQ2u5Pnaep+NtXqiJoLaKDD9VCLXr9ym9ooj9I2exYik0lMWVpVGqHcfoRoFzxnIraYQOh0MJbCBr+h4zeDVB+19hanN/e71UJYIkQSagefW/fGNEZWejUFCE4KWehmmZI2OjPMPeB6pEwfAmvVlOIfwFWQ2A+WTpA/nJLutLFDPGXbSUEnWJwIIiFFq9qxFIGEQFrQI08A29DUIIah7sM2HMCp5Q3EmbjeBnBVNdKGkPbexkjpOi+fKhIy9ZEoeZuHKewtnK5e8rNr5XN3KRDygJ0jBB2KDKcxR9KmvLtbv3uX7DBHeTxpuCTBo1i/STwhet84LxCJ/0</xades:EncapsulatedCRLValue></xades:CRLValues></xades:RevocationValues></xadesv141:TimeStampValidationData><xades:CompleteCertificateRefs><xades:CertRefs><xades:Cert><xades:CertDigest><ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha512"/><ds:DigestValue>DJXBFUmY4vCDGkmqacAjHkW/jvUezcb7s4iJItRZO0o+AHuw8F/+Rt/s6iExJ75QPKcj2LhBk98zaGIVIQl+3w==</ds:DigestValue></xades:CertDigest><xades:IssuerSerial><ds:X509IssuerName>CN=Belgium Root CA, C=BE</ds:X509IssuerName><ds:X509SerialNumber>41642920568308166299695216103866452820</ds:X509SerialNumber></xades:IssuerSerial></xades:Cert><xades:Cert><xades:CertDigest><ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha512"/><ds:DigestValue>ViuLbvkvTCRorQEqpCFaz7yDavcgt8t+AlO9dmBI4tyed3HQB/N9Kd42kTNi3kLHEET6HItj6vCCQGd+spRuNQ==</ds:DigestValue></xades:CertDigest><xades:IssuerSerial><ds:X509IssuerName>CN=Belgium Root CA, C=BE</ds:X509IssuerName><ds:X509SerialNumber>117029288888937864350596520176844645968</ds:X509SerialNumber></xades:IssuerSerial></xades:Cert></xades:CertRefs></xades:CompleteCertificateRefs><xades:CompleteRevocationRefs><xades:CRLRefs><xades:CRLRef><xades:DigestAlgAndValue><ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha512"/><ds:DigestValue>KErYlL/x28YD2hA/VbKlgnDHvWRF2mOAbozPdX5uq47ukJPphd4umDb7zFaBgEA0v3F7IW1vCIuaPAtek2DHmA==</ds:DigestValue></xades:DigestAlgAndValue><xades:CRLIdentifier><xades:Issuer>CN=Belgium Root CA, C=BE</xades:Issuer><xades:IssueTime>2010-07-01T14:00:00.000+02:00</xades:IssueTime></xades:CRLIdentifier></xades:CRLRef></xades:CRLRefs><xades:OCSPRefs><xades:OCSPRef><xades:OCSPIdentifier><xades:ResponderID><xades:ByName>CN=Belgium OCSP Responder,C=BE</xades:ByName></xades:ResponderID><xades:ProducedAt>2010-09-13T15:35:09.000+02:00</xades:ProducedAt></xades:OCSPIdentifier><xades:DigestAlgAndValue><ds:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha512"/><ds:DigestValue>Z/3rlheC6Zjv6c4GmUhW9I9E7zR/3FvhV6+0Kcv6/olTe1GfiZldQNVWuwg6SLaHBCkHPyHBEOkYCACxjYbyXA==</ds:DigestValue></xades:DigestAlgAndValue></xades:OCSPRef></xades:OCSPRefs></xades:CompleteRevocationRefs><xades:SigAndRefsTimeStamp Id="time-stamp-fae71ce9-7353-449b-9a51-5d4826e04570"><ds:CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#WithComments"/><xades:EncapsulatedTimeStamp Id="time-stamp-token-783b8aa0-ed60-486d-81a6-8b80a84691b3">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</xades:EncapsulatedTimeStamp></xades:SigAndRefsTimeStamp><xadesv141:TimeStampValidationData><xades:RevocationValues><xades:CRLValues><xades:EncapsulatedCRLValue>MIIB0TCBugIBATANBgkqhkiG9w0BAQUFADBXMQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTEQMA4GA1UECxMHUm9vdCBDQTEbMBkGA1UEAxMSR2xvYmFsU2lnbiBSb290IENBFw0xMDA3MDgwNjAwMDBaFw0xMTAxMDYwNjAwMDBaoC8wLTAKBgNVHRQEAwIBCzAfBgNVHSMEGDAWgBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0BAQUFAAOCAQEAq4VpuBVqASMuYcw5p3V2oQeaGAq/i6HuYpX+2VIlX4jDURkeIhGadofC8kSouIEKXV/XuX5TCobKodYHI5kdvL1eXmaD0kRuIkza9p/HfmOugNm8QnNiTouF7sAtb+rmEWlQ6KyD7W4KBFGRCm1Xi5VCDg5jXk2BNKaM67Y2CF2eeRFiTHvhtw8W/SUSlxPUC8VqTanmX4Va5h0i7Ua3KLo73YToXMRLaDjJcF3NdxRZI98G5Ne3Fa6ucgIiEdjKtDPicrA4IcfUYQY52hlTsOh+kOBa3uOLk0yRSu62BcXuLPskIwl5U3L9jemLeFFX4exqSsyV28cQQxHHtnD2UA==</xades:EncapsulatedCRLValue><xades:EncapsulatedCRLValue>MIIBbTBXMA0GCSqGSIb3DQEBBQUAMCgxCzAJBgNVBAYTAkJFMRkwFwYDVQQDExBCZWxnaXVtIFJvb3QgQ0EyFw0xMDA3MDExMjAwMDBaFw0xMTAxMzExMjAwMDBaMA0GCSqGSIb3DQEBBQUAA4IBAQCnQVBCpOUUQ2u5Pnaep+NtXqiJoLaKDD9VCLXr9ym9ooj9I2exYik0lMWVpVGqHcfoRoFzxnIraYQOh0MJbCBr+h4zeDVB+19hanN/e71UJYIkQSagefW/fGNEZWejUFCE4KWehmmZI2OjPMPeB6pEwfAmvVlOIfwFWQ2A+WTpA/nJLutLFDPGXbSUEnWJwIIiFFq9qxFIGEQFrQI08A29DUIIah7sM2HMCp5Q3EmbjeBnBVNdKGkPbexkjpOi+fKhIy9ZEoeZuHKewtnK5e8rNr5XN3KRDygJ0jBB2KDKcxR9KmvLtbv3uX7DBHeTxpuCTBo1i/STwhet84LxCJ/0</xades:EncapsulatedCRLValue></xades:CRLValues></xades:RevocationValues></xadesv141:TimeStampValidationData><xades:CertificateValues><xades:EncapsulatedX509Certificate>MIID/jCCAuagAwIBAgIQEAAAAAAAWeCXw4gx7baBGDANBgkqhkiG9w0BAQUFADAzMQswCQYDVQQGEwJCRTETMBEGA1UEAxMKQ2l0aXplbiBDQTEPMA0GA1UEBRMGMjAwNjEyMB4XDTA2MTAwNTAxMTQzMVoXDTExMDkyNjIzNTk1OVowcTELMAkGA1UEBhMCQkUxIzAhBgNVBAMTGkZyYW5rIENvcm5lbGlzIChTaWduYXR1cmUpMREwDwYDVQQEEwhDb3JuZWxpczEUMBIGA1UEKhMLRnJhbmsgSGVucmkxFDASBgNVBAUTCzc5MTAyNTIwOTkxMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCF/MOxjVCtsQ3cCfnnOmJLvgp9OKfQJHy95/IwxsdoAitUMGnOUvVmhPq5fVXd0RAJtdb+FoKqaRgNiuQZWAS3PUtN5OhQgYgSZApZhiVcY05HRm6ak03+9t0DwaAe14tMMGatXm5hD0itAvlSMkow6lBGqEfwHU6Sx6mJvgIl9QIDAQABo4IBUjCCAU4wRAYDVR0gBD0wOzA5BgdgOAEBAQIBMC4wLAYIKwYBBQUHAgEWIGh0dHA6Ly9yZXBvc2l0b3J5LmVpZC5iZWxnaXVtLmJlMA4GA1UdDwEB/wQEAwIGQDAfBgNVHSMEGDAWgBSl/gnOjAV0/+JmWg78J0Cu7s72cDA5BgNVHR8EMjAwMC6gLKAqhihodHRwOi8vY3JsLmVpZC5iZWxnaXVtLmJlL2VpZGMyMDA2MTIuY3JsMBEGCWCGSAGG+EIBAQQEAwIFIDBtBggrBgEFBQcBAQRhMF8wNQYIKwYBBQUHMAKGKWh0dHA6Ly9jZXJ0cy5laWQuYmVsZ2l1bS5iZS9iZWxnaXVtcnMuY3J0MCYGCCsGAQUFBzABhhpodHRwOi8vb2NzcC5laWQuYmVsZ2l1bS5iZTAYBggrBgEFBQcBAwQMMAowCAYGBACORgEBMA0GCSqGSIb3DQEBBQUAA4IBAQBZYThKtw4TsThTzB/CGKHpXAg25BlUp0lcSavIgzdYZde9R1MYiExNZ/BGwyoHK70Jdx0Z6qt7IL9cLJBiU0znFM1p0+IOWJOoaz12nu6aETiG6pXgRcdTuRBDZZgKbfXjKOrjYRaeu4jlvFfPR71ZQzSRFGeUNF2YHlEWiJiahoThFOiTI/C/f2OnH7aEH0+DGDcK/ZsTG1Ypo4Oi85KOmCb6zZ3o6s2PbdgJ0XFMPRRDAhqE0fW9njmYQq3dPoKgi5t7Ed7pdxCgOfxkwSkj6wgdfNJhnL/UUghaVc71SAOwiYQ9gmkVxK42OcaUS6OBSc6pZ8NqMRsNx0+ljgVZ</xades:EncapsulatedX509Certificate><xades:EncapsulatedX509Certificate>MIID3DCCAsSgAwIBAgIQH1QigD++OW5rhtkCQqNLVDANBgkqhkiG9w0BAQUFADAnMQswCQYDVQQGEwJCRTEYMBYGA1UEAxMPQmVsZ2l1bSBSb290IENBMB4XDTA1MTIwMTExMDAwMFoXDTEyMDgwMTEwMDAwMFowMzELMAkGA1UEBhMCQkUxEzARBgNVBAMTCkNpdGl6ZW4gQ0ExDzANBgNVBAUTBjIwMDYxMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALAQff7bieNQDqYKbM4fOnOPSwfs+ohfohnyXhDfjpFeKbneHcz7ylT6JH4t+2oW9Ip/K1TI1crB0hVBbfUbV9GDBFiQpKy58de+UtmiXcugnbFzb7PUeYbmFRAzqQxtJyUpUBpL0iq9q3//LacjiCsI66M9XZzxLpMZXkCmJFIbzdT4DvuY6Qmo7tUnFu8xh73Y68ul2a/u8wOz6Orw3xBT2LjoSlhlWR8sw3axYAO6/Pe42FiDjb5iXLoynJHynOHXcRyaIwtY4Fx+V6+dH8w+BDiBtB39/41kEFrYZtgLAmG0n3rb0qNNEdkQcg9A9wPPmFO99pzv8sAC4ui0g4sCAwEAAaOB9zCB9DAOBgNVHQ8BAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADBDBgNVHSAEPDA6MDgGBmA4AQEBAjAuMCwGCCsGAQUFBwIBFiBodHRwOi8vcmVwb3NpdG9yeS5laWQuYmVsZ2l1bS5iZTAdBgNVHQ4EFgQUpf4JzowFdP/iZloO/CdAru7O9nAwNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5laWQuYmVsZ2l1bS5iZS9iZWxnaXVtLmNybDARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAUEPAMVpth6lc6tjWXbZ/duRSO2+YwDQYJKoZIhvcNAQEFBQADggEBACXneQ7sgFhBaE+nK5X2UQpyS7LZGsZmkd/MG/Nf7hhek6ZWl7z1HxeJzT1NBJobVsToJWbRxhLmt/f+bB8gkM4ArAAoboytEdRwd6k15gqCiQmwh/dyJKr23xhEiYp2suaLX15B3IMPeEjUdozFZmC92W57jJztEJCq1oqPaaUg82YtkK2gttTpDSMrCC4iDvQFEnrgroIWKivlFmz7d7sEuz1w/lZY4YTOlEv6dWNP0R9uUsul1lcIO82WSVLofE0sU/p5ApomkfqCbvSKgGD58jQxIuaj4pllxc6NUZJOVROEdeRKxZ4QkRgN6/SyZVnVnfJbdIdnIsCB4jNymKE=</xades:EncapsulatedX509Certificate><xades:EncapsulatedX509Certificate>MIIDlDCCAnygAwIBAgIQWAsFbFMk27JQVxhf+eWmUDANBgkqhkiG9w0BAQUFADAnMQswCQYDVQQGEwJCRTEYMBYGA1UEAxMPQmVsZ2l1bSBSb290IENBMB4XDTAzMDEyNjIzMDAwMFoXDTE0MDEyNjIzMDAwMFowJzELMAkGA1UEBhMCQkUxGDAWBgNVBAMTD0JlbGdpdW0gUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMihcekcRkJ5eHFvna6pqKsot03HIOswkVp19eLSz8hMFJhCWK3HEcVAQGpa+XQSJ4fpnOVxTiIs0RIYqjBeoiG52bv/9nTrMQHnO35YD5EWTXaJqAFPrSJmcPpLHZXBMFjqvNll2Jq0iOtJRlLf0lMVdssUXRlJsW9q09P9vMIt7EU/CT9YvvzU7wCMgTVyv/cY6pZifSsofxVsY9LKyn0FrMhtB20yvmi4BUCuVJhWPmbxMOjvxKuTXgfeMo8SdKpbNCNUwOpszv42kqgJF+qhLc9s44Qd3ocuMws8dOIhUDiVLlzg5cYx+dtA+mqhpIqTm6chBocdJ9PEoclMsG8CAwEAAaOBuzCBuDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBCBgNVHSAEOzA5MDcGBWA4AQEBMC4wLAYIKwYBBQUHAgEWIGh0dHA6Ly9yZXBvc2l0b3J5LmVpZC5iZWxnaXVtLmJlMB0GA1UdDgQWBBQQ8AxWm2HqVzq2NZdtn925FI7b5jARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAUEPAMVpth6lc6tjWXbZ/duRSO2+YwDQYJKoZIhvcNAQEFBQADggEBAMhtIlGKYfgPlm7VILKB+MbcoxYA2s1q52sq+llIp0xJN9dzoWoBZV4yveeX09AuPHPTjHuD79ZCwT+oqV0PN7p20kC9zC0/00RBSZz9Wyn0AiMiW3Ebv1jZKE4tRfTa57VjRUQRDSp/M382SbTObqkCMa5c/ciJv0J71/Fg8teH9lcuen5qE4Ad3OPQYx49cTGxYNSeCMqr8JTHSHVUgfMbrXec6LKP24OsjzRr6L/D2fVDw2RV6xq9NoY2uiGMlxoh1OotO6y67Kcdq765Sps1LxxcHVGnH1TtEpf/8m6HfUbJdNbv6z195lluBpQE5KJVhzgoaiJe4r50ErAEQyo=</xades:EncapsulatedX509Certificate></xades:CertificateValues><xades:RevocationValues><xades:CRLValues><xades:EncapsulatedCRLValue>MIIBbDBWMA0GCSqGSIb3DQEBBQUAMCcxCzAJBgNVBAYTAkJFMRgwFgYDVQQDEw9CZWxnaXVtIFJvb3QgQ0EXDTEwMDcwMTEyMDAwMFoXDTExMDEzMTEyMDAwMFowDQYJKoZIhvcNAQEFBQADggEBAFX9tMBhJGDBxUTqEcVy4lxfQBfOLCf1VHOL8a1schDskp5UAmH6N/9Moj19RVpCozqqunxwrxsdf3BxhUcKKirZN+H9J00Eid98hQbOGhGobKyHIrTA2YdMkok3anNvRG1lY5FrmCyiPEA0ARizu9WkB7EJmhK2SMXu2LbpJ+b/fE0INfgOj8Zf0YoJGJmn+2iRTSOs5AhB0qSRq6rmQm0GnXZ2K8LqUf0VTXxc1Uvvgl98/f27Zj7jQdplBAzhyAvzC6G7K1k8Q7XVI7i9htup297pu3AIvoiq4RPmABZ8sbtqqYpioS/mcLG+E5GvH3QpF6DeC90ZCZ7yBP4NcqM=</xades:EncapsulatedCRLValue></xades:CRLValues><xades:OCSPValues><xades:EncapsulatedOCSPValue>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</xades:EncapsulatedOCSPValue></xades:OCSPValues></xades:RevocationValues></xades:UnsignedSignatureProperties></xades:UnsignedProperties></xades:QualifyingProperties></ds:Object></ds:Signature></test></ns3:Base64XML></ns3:Document></ns3:InputDocuments></ns3:VerifyRequest></S:Body></S:Envelope>
<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/";><S:Header/><S:Body><ns4:Response xmlns:ns4="urn:oasis:names:tc:dss:1.0:core:schema" xmlns:ns2="urn:oasis:names:tc:SAML:1.0:assertion" xmlns:ns3="http://www.w3.org/2000/09/xmldsig#"; RequestID="dss-request-be55100c-5268-4695-8765-dd794c3d475f" xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"; xmlns:xml="http://www.w3.org/XML/1998/namespace";><ns4:Result><ns4:ResultMajor>urn:oasis:names:tc:dss:1.0:resultmajor:Success</ns4:ResultMajor><ns4:ResultMinor>urn:oasis:names:tc:dss:1.0:resultminor:valid:signature:OnAllDocuments</ns4:ResultMinor></ns4:Result><ns4:OptionalOutputs><ns3:VerificationReport xmlns:ns3="urn:oasis:names:tc:dss-x:1.0:profiles:verificationreport:schema#" xmlns="http://uri.etsi.org/01903/v1.3.2#"; xmlns:ns2="http://www.w3.org/2000/09/xmldsig#"; xmlns:ns4="http://uri.etsi.org/02231/v2#"; xmlns:ns5="urn:oasis:names:tc:dss:1.0:core:schema"><ns3:IndividualReport><ns3:SignedObjectIdentifier><ns3:SignedProperties><ns3:SignedSignatureProperties><SigningTime>2010-09-13T15:35:49.767+02:00</SigningTime></ns3:SignedSignatureProperties></ns3:SignedProperties></ns3:SignedObjectIdentifier><ns5:Result><ns5:ResultMajor>urn:oasis:names:tc:dss:1.0:resultmajor:Success</ns5:ResultMajor><ns5:ResultMinor>urn:oasis:names:tc:dss:1.0:resultminor:valid:signature:OnAllDocuments</ns5:ResultMinor></ns5:Result><ns3:Details><ns3:DetailedSignatureReport><ns3:FormatOK><ns3:ResultMajor>urn:oasis:names:tc:dss:1.0:detail:valid</ns3:ResultMajor></ns3:FormatOK><ns3:SignatureOK><ns3:SigMathOK><ns3:ResultMajor>urn:oasis:names:tc:dss:1.0:detail:valid</ns3:ResultMajor></ns3:SigMathOK></ns3:SignatureOK><ns3:CertificatePathValidity><ns3:PathValiditySummary><ns3:ResultMajor>urn:oasis:names:tc:dss:1.0:detail:valid</ns3:ResultMajor></ns3:PathValiditySummary><ns3:CertificateIdentifier><ns2:X509IssuerName>SERIALNUMBER=200612, CN=Citizen CA, C=BE</ns2:X509IssuerName><ns2:X509SerialNumber>21267647932559078400084294942057726232</ns2:X509SerialNumber></ns3:CertificateIdentifier><ns3:PathValidityDetail><ns3:CertificateValidity><ns3:CertificateIdentifier><ns2:X509IssuerName>SERIALNUMBER=200612, CN=Citizen CA, C=BE</ns2:X509IssuerName><ns2:X509SerialNumber>21267647932559078400084294942057726232</ns2:X509SerialNumber></ns3:CertificateIdentifier><ns3:Subject>SERIALNUMBER=79102520991, GIVENNAME=Frank Henri, SURNAME=Cornelis, CN=Frank Cornelis (Signature), C=BE</ns3:Subject><ns3:ChainingOK><ns3:ResultMajor>urn:oasis:names:tc:dss:1.0:detail:valid</ns3:ResultMajor></ns3:ChainingOK><ns3:ValidityPeriodOK><ns3:ResultMajor>urn:oasis:names:tc:dss:1.0:detail:valid</ns3:ResultMajor></ns3:ValidityPeriodOK><ns3:ExtensionsOK><ns3:ResultMajor>urn:oasis:names:tc:dss:1.0:detail:valid</ns3:ResultMajor></ns3:ExtensionsOK><ns3:CertificateValue>MIID/jCCAuagAwIBAgIQEAAAAAAAWeCXw4gx7baBGDANBgkqhkiG9w0BAQUFADAzMQswCQYDVQQGEwJCRTETMBEGA1UEAxMKQ2l0aXplbiBDQTEPMA0GA1UEBRMGMjAwNjEyMB4XDTA2MTAwNTAxMTQzMVoXDTExMDkyNjIzNTk1OVowcTELMAkGA1UEBhMCQkUxIzAhBgNVBAMTGkZyYW5rIENvcm5lbGlzIChTaWduYXR1cmUpMREwDwYDVQQEEwhDb3JuZWxpczEUMBIGA1UEKhMLRnJhbmsgSGVucmkxFDASBgNVBAUTCzc5MTAyNTIwOTkxMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCF/MOxjVCtsQ3cCfnnOmJLvgp9OKfQJHy95/IwxsdoAitUMGnOUvVmhPq5fVXd0RAJtdb+FoKqaRgNiuQZWAS3PUtN5OhQgYgSZApZhiVcY05HRm6ak03+9t0DwaAe14tMMGatXm5hD0itAvlSMkow6lBGqEfwHU6Sx6mJvgIl9QIDAQABo4IBUjCCAU4wRAYDVR0gBD0wOzA5BgdgOAEBAQIBMC4wLAYIKwYBBQUHAgEWIGh0dHA6Ly9yZXBvc2l0b3J5LmVpZC5iZWxnaXVtLmJlMA4GA1UdDwEB/wQEAwIGQDAfBgNVHSMEGDAWgBSl/gnOjAV0/+JmWg78J0Cu7s72cDA5BgNVHR8EMjAwMC6gLKAqhihodHRwOi8vY3JsLmVpZC5iZWxnaXVtLmJlL2VpZGMyMDA2MTIuY3JsMBEGCWCGSAGG+EIBAQQEAwIFIDBtBggrBgEFBQcBAQRhMF8wNQYIKwYBBQUHMAKGKWh0dHA6Ly9jZXJ0cy5laWQuYmVsZ2l1bS5iZS9iZWxnaXVtcnMuY3J0MCYGCCsGAQUFBzABhhpodHRwOi8vb2NzcC5laWQuYmVsZ2l1bS5iZTAYBggrBgEFBQcBAwQMMAowCAYGBACORgEBMA0GCSqGSIb3DQEBBQUAA4IBAQBZYThKtw4TsThTzB/CGKHpXAg25BlUp0lcSavIgzdYZde9R1MYiExNZ/BGwyoHK70Jdx0Z6qt7IL9cLJBiU0znFM1p0+IOWJOoaz12nu6aETiG6pXgRcdTuRBDZZgKbfXjKOrjYRaeu4jlvFfPR71ZQzSRFGeUNF2YHlEWiJiahoThFOiTI/C/f2OnH7aEH0+DGDcK/ZsTG1Ypo4Oi85KOmCb6zZ3o6s2PbdgJ0XFMPRRDAhqE0fW9njmYQq3dPoKgi5t7Ed7pdxCgOfxkwSkj6wgdfNJhnL/UUghaVc71SAOwiYQ9gmkVxK42OcaUS6OBSc6pZ8NqMRsNx0+ljgVZ</ns3:CertificateValue><ns3:SignatureOK><ns3:SigMathOK><ns3:ResultMajor>urn:oasis:names:tc:dss:1.0:detail:valid</ns3:ResultMajor></ns3:SigMathOK></ns3:SignatureOK><ns3:CertificateStatus><ns3:CertStatusOK><ns3:ResultMajor>urn:oasis:names:tc:dss:1.0:detail:valid</ns3:ResultMajor></ns3:CertStatusOK></ns3:CertificateStatus></ns3:CertificateValidity></ns3:PathValidityDetail></ns3:CertificatePathValidity></ns3:DetailedSignatureReport></ns3:Details></ns3:IndividualReport></ns3:VerificationReport></ns4:OptionalOutputs></ns4:Response></S:Body></S:Envelope>
[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]