B2B-Bankid-Signer¶
Introduction¶
The B2B BankID Signer API is a RESTful API that allows you to sign documents using BankID merchant certificates. The API is designed for businesses that need to sign documents on behalf of their customers.
The merchant certificates is under the control of the BankID OIDC, an access token built from the BankID OIDC token endpoint with the scope "esign/b2b" is required to sign documents.
The API is versioned, and the current version is v0
The operations on the API comes in different flavours, parameters containing only hashes of the documents to be signed or parameters containing documents to be signed.
SDOs returned will for the document case contain the signed document, and for the hash case this document will of course be missing.
Validation of SDOs¶
The NETS SDO validator will be able to validate SDOs produced containing the document signed. Validation will fail if the document signed is not a part of the SDO.
The document itself is not part of the sealed or signed data in the SDO, only the hash of the document is. Therefore it is possible to add the document to the SDO after it has been signed.
To add the document to the SDO the following outline a solution (and the document should then validate in the NETS SDO validator):
public class Main {
static String[] bytesSigned = "ueaouea".getBytes(StandardCharsets.ISO_8859_1);
static String sdoWithoutDocumentB64 = "<?xml version="1.0" encoding="utf-8"?><SDOList xmlns="http://www.npt.no/seid/xmlskjema/SDO_v1.0" xmlns:XAdES="http://uri.etsi.org/01903/v1.2.2#" xmlns:ds="http://www.w3.org/2000/09/xmldsig#" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><SDO><SEIDSDOVersion>1.0</SEIDSDOVersion><SDODataPart><SignatureElement><CMSSignatureElement><SDOProfile>SEID-SDO-Basic-V</SDOProfile><SignaturePolicyIdentifier><SignaturePolicyId><SigPolicyId><XAdES:Identifier>urn:oid:2.16.578.1.16.4.1</XAdES:Identifier></SigPolicyId></SignaturePolicyId></SignaturePolicyIdentifier><SignersDocumentFormat><MimeType>text/plain</MimeType></SignersDocumentFormat><HashedData><ds:DigestMethod Algorithm="SHA-256"/><ds:DigestValue>seZEDYbr2HD7DciU8AQef9mLpt+/g9e1LYh/BtKiCLc=</ds:DigestValue></HashedData><CMSSignature>MIIOBAYJKoZIhvcNAQcCoIIN9TCCDfECAQExDTALBglghkgBZQMEAgEwCwYJKoZIhvcNAQcBoIILhzCCBRkwggMBoAMCAQICAyHg4DANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJOTzEVMBMGA1UECgwMVGVzdEJhbmsxIEFTMRIwEAYDVQQLDAkxMjM0NTY3ODkxJzAlBgNVBAMMHkJhbmtJRCAtIFRlc3RCYW5rMSAtIEJhbmsgQ0EgMzAeFw0yMjA1MTIxMDQ4MTRaFw0yNjA1MTIxMDQ4MTRaMGkxGDAWBgNVBGEMD05UUk5PLTc3Nzc3Nzc3NzELMAkGA1UEBhMCTk8xFTATBgNVBAoMDEJhbmtJRCBUb29sczESMBAGA1UEBRMJNzc3Nzc3Nzc3MRUwEwYDVQQDDAxCYW5rSUQgVG9vbHMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC7BpOPgLsau5PNmfqnZm2kI76UFeO7SiZ53d03vH2jE5g1lb/RtO7nrbNfx2vnHIh3THLRAG78C5O5e+giLWwgJ8Cx1vIPYUKNLXu1rTtphRm73Qx3tjY0H9BPEMEowOcyMpHXozcRzTX/sZb+ogp3VJK6DpuDlQqv5W8zdYMhcgd9ry8kEZTaX/0mUeZ9sWfiNmqs9Ji4D3Gr+n3Ktj7x4x7VizZc6vF2YzbsKzPT2wOG0xRZdYWmNWppEj/FzPhGmjxdToVNm2GNVcGjrQF3LsfH9CXtenLVOw6U4UUYdsrN7iD6jZrCdhJpvoi/yKA6343x1ePHpkodLVDmRbwpAgMBAAGjgdEwgc4wEwYHYIRCARACAQQIMAYEBDk5ODAwFAYHYIRCARACAgQJMAcEBUJJTkFTMDkGCCsGAQUFBwEBBC0wKzApBggrBgEFBQcwAYYdaHR0cHM6Ly92YS1wcmVwcm9kMS5iYW5raWQubm8wFgYDVR0gBA8wDTALBglghEIBEAEGAQEwDgYDVR0PAQH/BAQDAgZAMB8GA1UdIwQYMBaAFAFpkyCcGDUFOxzm5syzPCypWoXuMB0GA1UdDgQWBBT4v8NqVu8isz8tnWaBVQ2ZPoRW+DANBgkqhkiG9w0BAQsFAAOCAgEAIsLxPkSbHWTjOrQdn7xMz+EX+ltgh6CQurWyrgfrH3NiPa8gkg3LBXSrO3Y19hFghffFsV30bGgSylR3b1nuBS03SAPLHB20bCOR5z4HH0SEsmTia0jX0qA9afnII5/PWgIfJrcX1GYBFpkt9dC4Y+viOaJi/gtuGWdGr0KQiX8TAMbKZ9eFrMIN8W31QL3j22CuNYbW5MVBu8J3TDK3TD4u/UeqF9NUdlEnqYzqhsG4GlDgXZWLMQROWYaHFBBYoOup4c6BO7RC2uds3/fc1sQismphifBZEMPGdQ9QW5EQPWQlH/SwJjDD9Ca+3SBxbF/jcTCjvxD0bylOMz8RlpPccYuKY6IKS6BEYcdAbpiV+X4SaLSNEfrPiWZttHTgPGc1Gl3nQjAQg0p9GYgvFwlD+SAfIKe7MYGZOuHGkLd5xrBJ9qsBlrEt/GqH/dwFC685VTpX4FZH/x05EWmxo2v7bnIqDaN5eQLQFsaucDqrhd5hBIU8Z1q4e4KP/Z92/4xIp3F34miqy2TI85C7IjeNFdjppKNH1tcqCuC57XTM52Hv0NGGl0ph96gBx1iyEu0Lj2k8g87jtS5B0CzSCYTEC/j8Uq7mq3v5+5pH6dSxcra9IXPY4au+WYY1nn3d3vVfGfbIlZ22zfW9K43QrdwdD20+Q+P0Kqyl4/+MZuowggZmMIIETqADAgECAgIF3zANBgkqhkiG9w0BAQsFADBxMQswCQYDVQQGEwJOTzEqMCgGA1UECgwhVEVTVCAtIEZOSCBvZyBTcGFyZWJhbmtmb3JlbmluZ2VuMRYwFAYDVQQLDA1URVNUIC0gQmFua0lEMR4wHAYDVQQDDBVURVNUIC0gQmFua0lEIFJvb3QgQ0EwHhcNMTgxMTIwMDkyNjQyWhcNMzAxMTIwMDkyNjQyWjBhMQswCQYDVQQGEwJOTzEVMBMGA1UECgwMVGVzdEJhbmsxIEFTMRIwEAYDVQQLDAkxMjM0NTY3ODkxJzAlBgNVBAMMHkJhbmtJRCAtIFRlc3RCYW5rMSAtIEJhbmsgQ0EgMzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAOLBJ9zETaJGAJfh3/Zzk5XpXuizXZE60eUQkLxKepvRmHhsmQJCzkWCe+DtrCgnKpWaQlUz9XvBXwJZhCri8RG0g+STO81r6sbbCtJlBdetTfiv69gy+ElwOQ1DQnGQnh79ybY3whb2q0G7YnuGJo8DAjUG1EXoxjKJZqxcucR1FHzZbPJ0/NRA7eauv7q77cKf1gFV4nu5/yMpKk4pHhdj5R0tw6wptWK1B5aSUZw63hwUwKXIv5jwQh919qEwY+zyj/hFI5CuLZAgmOTLypUoWrn4t0wCyQ+11XFZZAdikiGv15Yu+euw0Qkj+H0ymASsh+SNIv4eQjYaWgzLBdBvD1FyYms8LR58ZPxMACoOn4zfSAnH3x1z8bou13h+8o9YLdyUKZETfI+fu+K1eYJvD2yLLhXheFDWd9Lpaqv7MtyEc4kRGOMtuquU2i5H4SyOclw+TYd+Gwp0Er+1jO9Fy3IGVSrzt5iNPHA7dVRSj9+VXpYrA6l6gVvq8LA0Z/aagHQzUz+56BzjyTJkBe05lu2lbCMA4P4K82ESUp6cXJf/x6X1HXqSZsQOaVWtYCErMGkhWS3X8Hvd9vX8lJ0Xk3nW+CgMGvjf36zT53m5SlVgyo0OvHUXvYyTCTtR2LRW3gdaMgyFEbosyNgr4z099mzWeABly0F+HNbMIrF/AgMBAAGjggEWMIIBEjASBgNVHRMBAf8ECDAGAQH/AgEAMBUGA1UdIAQOMAwwCgYIYIRCARABAwEwTwYIKwYBBQUHAQEEQzBBMD8GCCsGAQUFBzAChjNodHRwczovL2NydC1wcmVwcm9kLmJhbmtpZC5uby90ZXN0LWJhbmtpZHJvb3RjYS5jcnQwDgYDVR0PAQH/BAQDAgEGMB8GA1UdIwQYMBaAFNNGVyt30mLva8wzxxxcfjOVKqIeMEQGA1UdHwQ9MDswOaA3oDWGM2h0dHBzOi8vY3JsLXByZXByb2QuYmFua2lkLm5vL3Rlc3QtYmFua2lkcm9vdGNhLmNybDAdBgNVHQ4EFgQUAWmTIJwYNQU7HObmzLM8LKlahe4wDQYJKoZIhvcNAQELBQADggIBAGYEI/Z/n6zN3uh5r0ioIRJEnz7jfZVXr5jPr+yK+9T1CeHL7uNXp8tlLP+gVoH+huil7L8uqnSGg4q0XdUGeHrLFPRXjHGSITqC6bgjnjaLqgpH3vqWKLkEbQ73mPp8VBf5dMd5TMbxEiUnzpofDYtQFXagTcyYId0iTlnqy1tq/ZGaFPNfQtYRQUBFT34UXOPsmvSgu6xCRN4khXe5b+43JyrI4btikrKMNQ0Nga2Hh4PrwVwklB5ieY7OKiTHO2Y0Ts6+LUhkitw9PWJOM3h9zS1vBBSdK614cmjCzLn3Ap9kUl3pBPED0wlRQin7IajXXfn7zVCEByQWX8xLTNUCj4wIfPjjnyc5OBrNqB5iO6TlSPwGgAV6/8i4EwCYMrdjed8P43MKEf9VXyGQhfC18XPASYjolHDPhplUYcYBX6VXRV2yaLLlxqAwg/XRFTDCY1JQ2v6WnIn3H0jAYONgESaf4mdisitqJwUkk7p9cy0NBP6D55EvsqGzxmCF9tJNt0B5G5juAdeR65ikojN0scr7Faq/Ye0BBymFHUApI1ePQBPf3OL0j5yQd+/VUlobXkNQ1q10+WGBAfiCvyW5ZIDDy2M3ORTmkxtz/UnStSNBLeoQnCSMBQLoHz7rpgJq4c0PJshkANkGFPKU9rl1oAnU9Rx1QUPk0bRGwI/GMYICQzCCAj8CAQEwaDBhMQswCQYDVQQGEwJOTzEVMBMGA1UECgwMVGVzdEJhbmsxIEFTMRIwEAYDVQQLDAkxMjM0NTY3ODkxJzAlBgNVBAMMHkJhbmtJRCAtIFRlc3RCYW5rMSAtIEJhbmsgQ0EgMwIDIeDgMAsGCWCGSAFlAwQCAaCBsTAYBgkqhkiG9w0BCQMxCwYJKoZIhvcNAQcBMBwGCSqGSIb3DQEJBTEPFw0yNTAyMjcxMTIwNTlaMC8GCSqGSIb3DQEJBDEiBCCx5kQNhuvYcPsNyJTwBB5/2Yum37+D17UtiH8G0qIItzBGBgsqhkiG9w0BCRACEzE3MDUwMzAxMC8wCwYJYIZIAWUDBAIBBCCyYs/tzyPl6JAb3nq/0wtN2Wx4RwACAokbUDYIi/5hVTALBgkqhkiG9w0BAQEEggEAoyAjolqdQG0qo0nfNQuW55XbH4wY2+q/Lv+C487MrhY1bsD8yjrfsr6KKAMvGhBCBQpENZWLiNbTBXeMpy2QhXzFpoWTv3gRyzx4O6E+qkPuys/NUYWURBpKCh0yBx33+AB243T+W1CJMn57WKJraXBsH5JVcEDSSdQIOId4Jbc2P62tuhAIt12G97UhdkiFo9ZNYJI1kDkOz5chZnGMbKhYJgIVpXZy4tPiRYrm7//3dBQ8xWEWEEUiHEauDYaNPpbmQVWn0nL5A1V4GQT4nR2j7XO6yPIu4HzGFx8SHi0DRDcpK7ovNEw0FER2W1AMYt+eNbfB+qeLpU47SH/oqg==</CMSSignature><UserCertificateAndRevocationData><RevocationValues><XAdES:OCSPValues><XAdES:EncapsulatedOCSPValue>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</XAdES:EncapsulatedOCSPValue></XAdES:OCSPValues></RevocationValues></UserCertificateAndRevocationData></CMSSignatureElement></SignatureElement></SDODataPart><SDOSeal><SDOSignature><CMSSignatureElement><SDOProfile>SEID-SDO-Basic-V</SDOProfile><SignaturePolicyIdentifier><SignaturePolicyId><SigPolicyId><XAdES:Identifier>urn:oid:2.16.578.1.16.4.1</XAdES:Identifier></SigPolicyId></SignaturePolicyId></SignaturePolicyIdentifier><SignersDocumentFormat><MimeType>text/plain</MimeType></SignersDocumentFormat><HashedData><ds:DigestMethod Algorithm="SHA-256"/><ds:DigestValue>LQzvjV1n+9wiu3PAyFa71YNZ7mjkeh6z5rOFRPlFLlg=</ds:DigestValue></HashedData><CMSSignature>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</CMSSignature><UserCertificateAndRevocationData><RevocationValues><XAdES:OCSPValues><XAdES:EncapsulatedOCSPValue>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</XAdES:EncapsulatedOCSPValue></XAdES:OCSPValues></RevocationValues></UserCertificateAndRevocationData></CMSSignatureElement></SDOSignature></SDOSeal><Metadata><ValuePair><Name>MerchantDesc</Name><Value>hashToSign</Value></ValuePair></Metadata></SDO></SDOList>";
public static void main(String[] args) {
System.out.println("sdo document with added: ");
System.out.println(
addDocumentDataToSDO(
bytesSigned,
sdoWithoutDocumentB64));
}
static String addDocumentDataToSDO(byte[] documentBytesSigned, String sdoWithoutDocumentB64) {
try {
String xml = new String(
Base64.getDecoder().decode(sdoWithoutDocumentB64), StandardCharsets.UTF_8);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8)));
// Use XPath to find the desired node
XPathFactory xPathFactory = XPathFactory.newInstance();
XPath xpath = xPathFactory.newXPath();
XPathExpression expr = xpath.compile("/SDOList/SDO");
Node sdoNode = (Node) expr.evaluate(document, XPathConstants.NODE);
if (sdoNode != null) {
// Add the SignedObject node with SignersDocument content to the SDO node
Element signersDocument = document.createElement("SignersDocument");
// The document data should be added as the Base64 encoded bytes of the signed bytes
signersDocument.setTextContent(Base64.getEncoder().encodeToString(documentBytesSigned));
Element signedObject = document.createElement("SignedObject");
signedObject.appendChild(signersDocument);
sdoNode.appendChild(signedObject);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource source = new DOMSource(document);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
StreamResult result = new StreamResult(outputStream);
transformer.transform(source, result);
// The output will be the updated XML document with the SignedObject node added. Should pass the NETS SDO validation.
return outputStream.toString();
} else {
throw new IllegalArgumentException("SDO node not found in the XML document");
}
} catch (ParserConfigurationException | SAXException | IOException | XPathExpressionException |
TransformerException e) {
throw new RuntimeException("Some XML error", e);
}
}
}
Computing SHA256 hashes¶
When the client is sending hashes of documents instead of the documents themselves, the client must compute the hash in the same way as BankID would have done. BankID extracts the bytes for computing the sha256 hash for a text, PDF or bidxml based from the documents the following ways below:
- For text, the bytes are extracted from the text string using the ISO_8859_1 charset
- For PDF, the bytes are the bytes read from the PDF file as is.
- For bidxml, the XML and XSL string are wrapped into a string as below, and then the bytes are extracted using the ISO_8859_1 charset.
import java.util.Base64;
/**
* Compute the sha256 hash of the given byte array and return it as a base64 encoded string
*/
private static String sha256B64(byte[] tbs) {
try {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hash = digest.digest(tbs);
return Base64.getEncoder().encodeToString(hash);
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
/**
* Compute the sha256 hash by converting the text to bytes using the ISO_8859_1 charset
*/
public static String sha256ForTextB64(String textDocument) {
return sha256B64(textDocument.getBytes(StandardCharsets.ISO_8859_1));
}
/**
* Compute the sha256 hash by using the pdf bytes as is
*/
public static String sha256ForPdf(byte[] pdfDoc) {
return sha256B64(pdfDoc);
}
/**
* Compute the sha256 hash by wrapping the xml and xsl parts into a BankIDXML structure and then converting the string to bytes using the ISO_8859_1 charset
*/
public static String sha256ForBidXml(String xmlDocument, String xslDocument) {
return sha256forTextB64(
"<BankIDXML><BIDXML>" + xmlDocument + "</BIDXML><BIDXSL>" + xslDocument + "</BIDXSL></BankIDXML>");
}