BankID B2B 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 are 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 come in different flavors: parameters containing only hashes of the documents to be signed or parameters containing documents to be signed.

SDOs returned will contain the signed document for the document case, and for the hash case, this document will of course be missing.

Access token requirements for BankID B2B Signing API¶

To access the B2B signing API, the security demands are higher than for starting a signing process for an individual. The security requirements are strengthened in two directions:

A stolen access token should not be usable to start B2B signing.
OIDC clients must prove that they own their client_id in a more secure way than client_secret

To meet these demands, the B2B API requires use of the DPoP protocol and the private_key_jwt authentication method:

To access the BankID B2B Signing API, the client must use the DPoP protocol, which is a security protocol that provides proof of possession of the access token.
The access token must be obtained using the DPoP flow, and when used in the B2B Signing API, it must be accompanied by a DPoP proof.
The access token must be obtained using the private_key_jwt method.

Using the DPoP protocol to obtain the access token is a requirement that is connected to the BankID OIDC client, and not the scopes asked for. The DPoP requirement will be registered on the OIDC client.

This implies that if the client is allowed to use the esign/b2b scope, all other scopes also require the access token to be obtained using the DPoP flow.

BankID OIDC sets the type of the access token in the access token's typ attribute, "typ":"DPOP" or "typ":"Bearer", depending on the method used to obtain it.

See RFC9449 for more information about the DPoP protocol.

private_key_jwt requirements are described in https://developer.bankid.no/bankid-oidc-provider/core-concepts/private-key-jwt/

Must DPoP be used against the Pades Signing API?¶

You may use the DPoP protocol for both Pades and B2B APIs, but it is only required for the B2B API.
The B2B signing API requires that the access token is sent in the Authorization header as a DPoP token together with a DPoP header for the proof.
The Pades Signing API allows the access token to be sent in the Authorization header as a Bearer token, even if it internally has "typ":"DPoP".

Do I need one OIDC `client_id` for B2B and one for other operations?¶

Since B2B raises new security demands and there may be other applications working with Bearer and client_secret instead of DPoP and private_key_jwt, it is certainly a solution to order one separate BankID OIDC client to be used for B2B. There is a possibility that some resource servers which depend on the access token will fail when receiving a DPoP token or a DPoP-based access token; this must be checked with the resource server provider.

Example code¶

bankid-esign-b2b repository demonstrates how to use the BankID B2B Signing API.

Validation of SDOs¶

The NETS SDO validator will be able to validate SDOs produced containing the signed document. Validation will fail if the signed document is not 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 outlines 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>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</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 text, PDF, or bidxml based documents from the documents in the following ways:

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 strings are wrapped into a string as shown below, and then the bytes are extracted using the ISO_8859_1 charset.

For PAdES, the bytes to sign must be calculated using a PDF library that supports PAdES such as EU's DSS or Apache PDFBox or similar.

    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>");
    }

OpenAPI Specification¶

Please refer to the B2B BankID Signer OpenAPI for detailed API endpoints, request/response schemas, and examples.