@ripwords/myinvois-client 0.0.10 → 0.1.0

package/test/populateFinalDocument.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect } from 'vitest'
+import { DOMParserImpl } from 'xmldom-ts'
+import * as xpath from 'xpath-ts'
+import { populateFinalDocument } from '../src/utils/signature/populateFinalDocument'
+import type { FinalDocumentData } from '../src/utils/signature/populateFinalDocument'
+
+// Define namespaces matching those in the function
+const ns = {
+  inv: 'urn:oasis:names:specification:ubl:schema:xsd:Invoice-2',
+  ext: 'urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2',
+  sig: 'urn:oasis:names:specification:ubl:schema:xsd:CommonSignatureComponents-2',
+  sac: 'urn:oasis:names:specification:ubl:schema:xsd:SignatureAggregateComponents-2',
+  ds: 'http://www.w3.org/2000/09/xmldsig#',
+}
+const select = xpath.useNamespaces(ns)
+
+// Sample XML structure mimicking the final signature part
+const sampleXmlTemplate = `
+<inv:Invoice xmlns:inv="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
+             xmlns:ext="urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2"
+             xmlns:sig="urn:oasis:names:specification:ubl:schema:xsd:CommonSignatureComponents-2"
+             xmlns:cac="urn:oasis:names:specification:ubl:schema:xsd:CommonAggregateComponents-2"
+             xmlns:cbc="urn:oasis:names:specification:ubl:schema:xsd:CommonBasicComponents-2"
+             xmlns:sac="urn:oasis:names:specification:ubl:schema:xsd:SignatureAggregateComponents-2"
+             xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
+             xmlns:xades="http://uri.etsi.org/01903/v1.3.2#">
+    <ext:UBLExtensions>
+        <ext:UBLExtension>
+            <ext:ExtensionContent>
+                <sig:UBLDocumentSignatures>
+                    <sac:SignatureInformation>
+                        <ds:Signature>
+                            <ds:SignedInfo>
+                                <ds:Reference URI="#id-xades-signed-props">
+                                    <ds:DigestValue></ds:DigestValue>
+                                </ds:Reference>
+                                <ds:Reference Id="id-doc-signed-data">
+                                    <ds:DigestValue></ds:DigestValue>
+                                </ds:Reference>
+                            </ds:SignedInfo>
+                            <ds:SignatureValue></ds:SignatureValue>
+                            <ds:KeyInfo>
+                                <ds:X509Data>
+                                    <ds:X509Certificate></ds:X509Certificate>
+                                </ds:X509Data>
+                            </ds:KeyInfo>
+                            <!-- ds:Object containing xades:QualifyingProperties would normally be here -->
+                        </ds:Signature>
+                    </sac:SignatureInformation>
+                </sig:UBLDocumentSignatures>
+            </ext:ExtensionContent>
+        </ext:UBLExtension>
+    </ext:UBLExtensions>
+    <!-- Required cac:Signature element that populateFinalDocument populates -->
+    <cac:Signature>
+        <cbc:ID></cbc:ID>
+        <cbc:SignatureMethod></cbc:SignatureMethod>
+    </cac:Signature>
+</inv:Invoice>
+`
+
+// Sample PEM for testing cleaning
+const sampleCertificatePem = `
+-----BEGIN CERTIFICATE-----
+SAMPLEBASE64DATA
+LINE2OFDATA
+-----END CERTIFICATE-----
+`
+const expectedCleanedCertificate = 'SAMPLEBASE64DATALINE2OFDATA'
+
+describe('populateFinalDocument', () => {
+  const parser = new DOMParserImpl()
+
+  it('should populate all final signature fields correctly', () => {
+    const doc = parser.parseFromString(sampleXmlTemplate, 'application/xml')
+    const testData: FinalDocumentData = {
+      signatureValue: 'TEST_SIGNATURE_VALUE==',
+      propsDigest: 'TEST_PROPS_DIGEST==',
+      docDigest: 'TEST_DOC_DIGEST==',
+      certificatePem: sampleCertificatePem,
+    }
+
+    populateFinalDocument(doc, testData)
+
+    // Verify each populated value using XPath
+    const signatureValueNodes = select('//ds:SignatureValue', doc) as Node[]
+    expect(signatureValueNodes).toHaveLength(1)
+    expect(signatureValueNodes[0].textContent).toBe(testData.signatureValue)
+
+    const x509CertNodes = select('//ds:X509Certificate', doc) as Node[]
+    expect(x509CertNodes).toHaveLength(1)
+    expect(x509CertNodes[0].textContent).toBe(expectedCleanedCertificate) // Verify cleaned cert
+
+    const propsDigestNodes = select(
+      "//ds:Reference[@URI='#id-xades-signed-props']/ds:DigestValue",
+      doc,
+    ) as Node[]
+    expect(propsDigestNodes).toHaveLength(1)
+    expect(propsDigestNodes[0].textContent).toBe(testData.propsDigest)
+
+    const docDigestNodes = select(
+      "//ds:Reference[@Id='id-doc-signed-data']/ds:DigestValue",
+      doc,
+    ) as Node[]
+    expect(docDigestNodes).toHaveLength(1)
+    expect(docDigestNodes[0].textContent).toBe(testData.docDigest)
+  })
+
+  it('should throw error if SignatureValue element is missing', () => {
+    const modifiedXml = sampleXmlTemplate.replace(
+      '<ds:SignatureValue></ds:SignatureValue>',
+      '',
+    )
+    const doc = parser.parseFromString(modifiedXml, 'application/xml')
+    const testData: FinalDocumentData = {
+      signatureValue: 's',
+      propsDigest: 'p',
+      docDigest: 'd',
+      certificatePem: 'c',
+    }
+
+    expect(() => populateFinalDocument(doc, testData)).toThrow(
+      /^Failed to set value for XPath .*ds:SignatureValue: Element not found/,
+    )
+  })
+
+  it('should throw error if X509Certificate element is missing', () => {
+    const modifiedXml = sampleXmlTemplate.replace(
+      '<ds:X509Certificate></ds:X509Certificate>',
+      '',
+    )
+    const doc = parser.parseFromString(modifiedXml, 'application/xml')
+    const testData: FinalDocumentData = {
+      signatureValue: 's',
+      propsDigest: 'p',
+      docDigest: 'd',
+      certificatePem: 'c',
+    }
+
+    expect(() => populateFinalDocument(doc, testData)).toThrow(
+      /^Failed to set value for XPath .*ds:X509Certificate: Element not found/,
+    )
+  })
+
+  it('should throw error if propsDigest Reference element is missing', () => {
+    // Parse the original XML
+    const doc = parser.parseFromString(sampleXmlTemplate, 'application/xml')
+
+    // Find and remove the target node using DOM manipulation
+    const propsRefXPath = "//ds:Reference[@URI='#id-xades-signed-props']"
+    const nodesToRemove = select(propsRefXPath, doc) as any[]
+    expect(nodesToRemove).toHaveLength(1) // Ensure we found the node to remove
+    const nodeToRemove = nodesToRemove[0]
+    if (nodeToRemove.parentNode) {
+      nodeToRemove.parentNode.removeChild(nodeToRemove)
+    } else {
+      throw new Error('Failed to find parent node for removal in test setup')
+    }
+
+    const testData: FinalDocumentData = {
+      signatureValue: 's',
+      propsDigest: 'p',
+      docDigest: 'd',
+      certificatePem: 'c',
+    }
+
+    // Regex adjusted slightly for flexibility (kept from previous step)
+    expect(() => populateFinalDocument(doc, testData)).toThrow(
+      /^Failed to set value for XPath .*@URI='#id-xades-signed-props'.*\/ds:DigestValue: Element not found for XPath: .*@URI='#id-xades-signed-props'.*\/ds:DigestValue$/,
+    )
+  })
+
+  it('should throw error if docDigest Reference element is missing', () => {
+    // Parse the original XML
+    const doc = parser.parseFromString(sampleXmlTemplate, 'application/xml')
+
+    // Find and remove the target node using DOM manipulation
+    const docRefXPath = "//ds:Reference[@Id='id-doc-signed-data']"
+    const nodesToRemove = select(docRefXPath, doc) as any[]
+    expect(nodesToRemove).toHaveLength(1) // Ensure we found the node to remove
+    const nodeToRemove = nodesToRemove[0]
+    if (nodeToRemove.parentNode) {
+      nodeToRemove.parentNode.removeChild(nodeToRemove)
+    } else {
+      throw new Error('Failed to find parent node for removal in test setup')
+    }
+
+    const testData: FinalDocumentData = {
+      signatureValue: 's',
+      propsDigest: 'p',
+      docDigest: 'd',
+      certificatePem: 'c',
+    }
+
+    // Regex adjusted slightly for flexibility (kept from previous step)
+    expect(() => populateFinalDocument(doc, testData)).toThrow(
+      /^Failed to set value for XPath .*@Id='id-doc-signed-data'.*\/ds:DigestValue: Element not found for XPath: .*@Id='id-doc-signed-data'.*\/ds:DigestValue$/,
+    )
+  })
+
+  it('should throw error if multiple SignatureValue elements are found', () => {
+    const modifiedXml = sampleXmlTemplate.replace(
+      '<ds:SignatureValue></ds:SignatureValue>',
+      '<ds:SignatureValue>1</ds:SignatureValue><ds:SignatureValue>2</ds:SignatureValue>',
+    )
+    const doc = parser.parseFromString(modifiedXml, 'application/xml')
+    const testData: FinalDocumentData = {
+      signatureValue: 's',
+      propsDigest: 'p',
+      docDigest: 'd',
+      certificatePem: 'c',
+    }
+
+    expect(() => populateFinalDocument(doc, testData)).toThrow(
+      /^Failed to set value for XPath .*ds:SignatureValue: Multiple elements found/,
+    )
+  })
+})

package/test/populateSignedProperties.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect } from 'vitest'
+import { DOMParserImpl } from 'xmldom-ts'
+import * as xpath from 'xpath-ts'
+import { populateSignedProperties } from '../src/utils/signature/populateSignedProperties'
+import type { SignedPropertiesData } from '../src/utils/signature/populateSignedProperties'
+
+// Define namespaces matching those in the function
+const ns = {
+  inv: 'urn:oasis:names:specification:ubl:schema:xsd:Invoice-2',
+  ext: 'urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2',
+  sig: 'urn:oasis:names:specification:ubl:schema:xsd:CommonSignatureComponents-2',
+  sac: 'urn:oasis:names:specification:ubl:schema:xsd:SignatureAggregateComponents-2',
+  ds: 'http://www.w3.org/2000/09/xmldsig#',
+  xades: 'http://uri.etsi.org/01903/v1.3.2#',
+}
+const select = xpath.useNamespaces(ns)
+
+// Sample XML structure mimicking the UBL signature part
+// Needs to include the full path for the properties to be populated.
+const sampleXmlTemplate = `
+<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2"
+         xmlns:ext="urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2"
+         xmlns:sig="urn:oasis:names:specification:ubl:schema:xsd:CommonSignatureComponents-2"
+         xmlns:sac="urn:oasis:names:specification:ubl:schema:xsd:SignatureAggregateComponents-2"
+         xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
+         xmlns:xades="http://uri.etsi.org/01903/v1.3.2#">
+    <ext:UBLExtensions>
+        <ext:UBLExtension>
+            <ext:ExtensionContent>
+                <sig:UBLDocumentSignatures>
+                    <sac:SignatureInformation>
+                        <ds:Signature>
+                            <ds:Object>
+                                <xades:QualifyingProperties>
+                                    <xades:SignedProperties>
+                                        <xades:SignedSignatureProperties>
+                                            <xades:SigningTime></xades:SigningTime>
+                                            <xades:SigningCertificate>
+                                                <xades:Cert>
+                                                    <xades:CertDigest>
+                                                        <ds:DigestValue></ds:DigestValue>
+                                                    </xades:CertDigest>
+                                                    <xades:IssuerSerial>
+                                                        <ds:X509IssuerName></ds:X509IssuerName>
+                                                        <ds:X509SerialNumber></ds:X509SerialNumber>
+                                                    </xades:IssuerSerial>
+                                                </xades:Cert>
+                                            </xades:SigningCertificate>
+                                        </xades:SignedSignatureProperties>
+                                    </xades:SignedProperties>
+                                </xades:QualifyingProperties>
+                            </ds:Object>
+                        </ds:Signature>
+                    </sac:SignatureInformation>
+                </sig:UBLDocumentSignatures>
+            </ext:ExtensionContent>
+        </ext:UBLExtension>
+    </ext:UBLExtensions>
+    <!-- Other Invoice Content -->
+</Invoice>
+`
+
+describe('populateSignedProperties', () => {
+  const parser = new DOMParserImpl()
+
+  it('should populate all specified properties correctly', () => {
+    const doc = parser.parseFromString(sampleXmlTemplate, 'application/xml')
+    const testData: SignedPropertiesData = {
+      certDigest: 'TEST_CERT_DIGEST==',
+      signingTime: '2024-01-01T12:00:00Z',
+      issuerName: 'CN=Test Issuer, O=Test Org',
+      serialNumber: '1234567890',
+    }
+
+    populateSignedProperties(doc, testData)
+
+    // Verify each populated value using XPath
+    const certDigestNodes = select(
+      '//ds:DigestValue[ancestor::xades:CertDigest]',
+      doc,
+    ) as Node[]
+    expect(certDigestNodes).toHaveLength(1)
+    expect(certDigestNodes[0].textContent).toBe(testData.certDigest)
+
+    const signingTimeNodes = select('//xades:SigningTime', doc) as Node[]
+    expect(signingTimeNodes).toHaveLength(1)
+    expect(signingTimeNodes[0].textContent).toBe(testData.signingTime)
+
+    const issuerNameNodes = select('//ds:X509IssuerName', doc) as Node[]
+    expect(issuerNameNodes).toHaveLength(1)
+    expect(issuerNameNodes[0].textContent).toBe(testData.issuerName)
+
+    const serialNumberNodes = select('//ds:X509SerialNumber', doc) as Node[]
+    expect(serialNumberNodes).toHaveLength(1)
+    expect(serialNumberNodes[0].textContent).toBe(testData.serialNumber)
+  })
+
+  it('should throw error if CertDigest element is missing', () => {
+    // Create XML missing the target element
+    const modifiedXml = sampleXmlTemplate.replace(
+      '<ds:DigestValue></ds:DigestValue>',
+      '',
+    )
+    const doc = parser.parseFromString(modifiedXml, 'application/xml')
+    const testData: SignedPropertiesData = {
+      certDigest: 'd',
+      signingTime: 't',
+      issuerName: 'i',
+      serialNumber: 's',
+    }
+
+    expect(() => populateSignedProperties(doc, testData)).toThrow(
+      /^Failed to set value for XPath .*ds:DigestValue: Element not found/,
+    )
+  })
+
+  it('should throw error if SigningTime element is missing', () => {
+    const modifiedXml = sampleXmlTemplate.replace(
+      '<xades:SigningTime></xades:SigningTime>',
+      '',
+    )
+    const doc = parser.parseFromString(modifiedXml, 'application/xml')
+    const testData: SignedPropertiesData = {
+      certDigest: 'd',
+      signingTime: 't',
+      issuerName: 'i',
+      serialNumber: 's',
+    }
+
+    expect(() => populateSignedProperties(doc, testData)).toThrow(
+      /^Failed to set value for XPath .*xades:SigningTime: Element not found/,
+    )
+  })
+
+  // Add similar tests for missing IssuerName and SerialNumber if desired
+
+  it('should throw error if multiple CertDigest elements are found', () => {
+    // Create XML with duplicate target elements
+    const modifiedXml = sampleXmlTemplate.replace(
+      '<ds:DigestValue></ds:DigestValue>',
+      '<ds:DigestValue>1</ds:DigestValue><ds:DigestValue>2</ds:DigestValue>',
+    )
+    const doc = parser.parseFromString(modifiedXml, 'application/xml')
+    const testData: SignedPropertiesData = {
+      certDigest: 'd',
+      signingTime: 't',
+      issuerName: 'i',
+      serialNumber: 's',
+    }
+
+    expect(() => populateSignedProperties(doc, testData)).toThrow(
+      /^Failed to set value for XPath .*ds:DigestValue: Multiple elements found/,
+    )
+  })
+})

package/test/sign.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest'
+import * as crypto from 'crypto'
+import { signDocumentDigest } from '../src/utils/signature/sign'
+
+// Generate a test RSA key pair for signing/verifying
+const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
+  modulusLength: 2048, // Standard length
+  publicKeyEncoding: {
+    type: 'spki',
+    format: 'pem',
+  },
+  privateKeyEncoding: {
+    type: 'pkcs8',
+    format: 'pem',
+  },
+})
+
+describe('signDocumentDigest', () => {
+  const sampleDocDigestBase64 = 'SampleDigestValueAsBase64=='
+  const sampleDocDigestRaw = Buffer.from(sampleDocDigestBase64, 'base64')
+
+  it('should generate a valid RSA-SHA256 signature in Base64 format', () => {
+    const signatureBase64 = signDocumentDigest(
+      sampleDocDigestBase64,
+      privateKey,
+    )
+
+    // Verify the signature using the public key
+    const verifier = crypto.createVerify('RSA-SHA256')
+    verifier.update(sampleDocDigestRaw)
+    verifier.end()
+
+    const isValid = verifier.verify(publicKey, signatureBase64, 'base64')
+
+    expect(isValid).toBe(true)
+    // Check if the output is a valid Base64 string
+    expect(() => Buffer.from(signatureBase64, 'base64')).not.toThrow()
+  })
+
+  it('should throw an error if the private key is invalid', () => {
+    const invalidPrivateKey =
+      '-----BEGIN INVALID KEY-----\nINVALID\n-----END INVALID KEY-----'
+    expect(() =>
+      signDocumentDigest(sampleDocDigestBase64, invalidPrivateKey),
+    ).toThrow(/Failed to sign document digest/)
+    // The specific internal crypto error message might vary, so we match our wrapper message
+  })
+
+  it('should handle Buffer as private key input', () => {
+    const privateKeyBuffer = Buffer.from(privateKey)
+    const signatureBase64 = signDocumentDigest(
+      sampleDocDigestBase64,
+      privateKeyBuffer,
+    )
+
+    const verifier = crypto.createVerify('RSA-SHA256')
+    verifier.update(sampleDocDigestRaw)
+    verifier.end()
+    const isValid = verifier.verify(publicKey, signatureBase64, 'base64')
+    expect(isValid).toBe(true)
+  })
+
+  it('should throw an error if the digest is not valid Base64', () => {
+    const invalidBase64Digest = 'This is not base64'
+    expect(() => signDocumentDigest(invalidBase64Digest, privateKey)).toThrow(
+      'Invalid Base64 characters detected in document digest.',
+    )
+    // Error likely occurs during Buffer.from() or the preceding regex check
+  })
+})