@ripwords/myinvois-client 0.1.0 → 0.1.3

package/src/utils/signature/sign.ts

@@ -1,51 +0,0 @@
-import * as crypto from 'crypto'
-
-/**
- * Signs the document hash digest using RSA-SHA256 and a private key.
- *
- * Corresponds to Step 4 in the MyInvois Signature Creation guide:
- * https://sdk.myinvois.hasil.gov.my/signature-creation/#step-4-sign-the-document-digest
- *
- * @param base64DocDigest The Base64 encoded SHA-256 hash of the canonicalized document (DocDigest from Step 3).
- * @param privateKeyPem The private key in PEM format (string or Buffer).
- * @returns The Base64 encoded RSA-SHA256 signature (Sig).
- * @throws {Error} If signing fails.
- */
-export function signDocumentDigest(
-  base64DocDigest: string,
-  privateKeyPem: string | Buffer,
-): string {
-  try {
-    // Add stricter validation: Check if the input string contains only valid Base64 characters.
-    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/
-    if (base64DocDigest.length > 0 && !base64Regex.test(base64DocDigest)) {
-      throw new Error('Invalid Base64 characters detected in document digest.')
-    }
-
-    // 1. Decode the Base64 document digest back to a raw buffer
-    // The signature is calculated over the raw hash bytes, not the Base64 string.
-    const rawDocDigest = Buffer.from(base64DocDigest, 'base64')
-
-    // Add check: If input Base64 string was not empty, but decoded buffer is,
-    // it implies invalid Base64 characters were likely ignored instead of throwing.
-    if (base64DocDigest.length > 0 && rawDocDigest.length === 0) {
-      throw new Error('Invalid Base64 content for document digest.')
-    }
-
-    // 2. Create a signer instance with RSA-SHA256
-    const signer = crypto.createSign('RSA-SHA256')
-
-    // 3. Update the signer with the raw hash digest
-    // Note: We sign the HASH itself, not the original data.
-    signer.update(rawDocDigest)
-    signer.end()
-
-    // 4. Sign using the private key and get the signature in Base64 format
-    const base64Signature = signer.sign(privateKeyPem, 'base64')
-
-    return base64Signature
-  } catch (error: any) {
-    console.error('Error during signing:', error)
-    throw new Error(`Failed to sign document digest: ${error.message || error}`)
-  }
-}

package/src/utils/signature/transform.ts

@@ -1,99 +0,0 @@
-// Import necessary components from xmldom-ts and xpath-ts
-import { DOMParserImpl, XMLSerializerImpl } from 'xmldom-ts'
-import * as xpath from 'xpath-ts'
-// Assuming Node and Document types are correctly exposed by xmldom-ts/xpath-ts globally or via import
-
-/**
- * Transforms an XML invoice string according to specific rules using xmldom-ts and xpath-ts:
- * - Removes the XML declaration.
- * - Removes UBLExtensions and Signature elements within the Invoice element.
- * Assumes the input XML is UTF-8 encoded.
- *
- * @param xmlString The raw XML invoice string.
- * @returns The transformed XML string.
- * @throws {Error} If parsing fails.
- */
-export function transformXmlInvoice(xmlString: string): string {
-  let doc: Document // Use the standard Document type, assuming compatibility
-  const errors: string[] = []
-
-  // Define separate handlers for each error level as likely expected by xmldom-ts
-  const handleError = (msg: string) => {
-    errors.push(`ERROR: ${msg}`)
-  }
-  const handleFatalError = (msg: string) => {
-    errors.push(`FATALERROR: ${msg}`)
-  }
-  const handleWarning = (msg: string) => {
-    console.warn(`WARNING: ${msg}`)
-  }
-
-  // Use DOMParserImpl from xmldom-ts with the specific error handler structure
-  const parser = new DOMParserImpl({
-    locator: {}, // Keep locator, might be useful for error context
-    errorHandler: {
-      error: handleError,
-      fatalError: handleFatalError,
-      warning: handleWarning,
-    },
-  })
-
-  try {
-    // Use the standard mime type string directly
-    doc = parser.parseFromString(xmlString, 'application/xml') // Or 'text/xml'
-  } catch (e: any) {
-    throw new Error(`XML Parsing Initialization Error: ${e.message || e}`)
-  }
-
-  // Check for parsererror element
-  const parserErrors = doc.getElementsByTagName('parsererror')
-  if (parserErrors.length > 0) {
-    const errorElement = parserErrors[0]
-    if (errorElement) {
-      const errorContent = errorElement.textContent
-        ? errorElement.textContent.trim()
-        : 'Unknown parsing error reported by parsererror tag.'
-      throw new Error(`XML Parsing Error: ${errorContent}`)
-    } else {
-      throw new Error('XML Parsing Error: Malformed parsererror tag found.')
-    }
-  }
-
-  // If the errorHandler collected errors, throw the first one.
-  if (errors.length > 0) {
-    throw new Error(errors[0])
-  }
-
-  // Use xpath.select from xpath-ts
-  const select = xpath.select
-
-  // Helper function to remove nodes found by XPath
-  const removeNodesByXPath = (path: string) => {
-    const nodesToRemove = select(path, doc) as Node[]
-
-    if (nodesToRemove && nodesToRemove instanceof Array) {
-      nodesToRemove.forEach(node => {
-        if (node && node.parentNode) {
-          node.parentNode.removeChild(node)
-        }
-      })
-    }
-  }
-
-  // 2. Find and remove UBLExtensions elements
-  removeNodesByXPath(
-    "//*[local-name()='Invoice']//*[local-name()='UBLExtensions']",
-  )
-
-  // 3. Find and remove Signature elements
-  removeNodesByXPath("//*[local-name()='Invoice']//*[local-name()='Signature']")
-
-  // 4. Serialize the modified DOM back to string using XMLSerializerImpl
-  const serializer = new XMLSerializerImpl()
-  let transformedXml = serializer.serializeToString(doc)
-
-  // 5. Remove the XML declaration (if present)
-  transformedXml = transformedXml.replace(/^<\?xml [^>]*\?>\s*/i, '')
-
-  return transformedXml
-}

package/test/canonicalize.test.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import * as crypto from 'crypto'
-import { DOMParserImpl } from 'xmldom-ts' // To create Document objects for testing
-import { canonicalizeAndHashDocument } from '../src/utils/signature/canonicalize'
-
-// Helper to calculate expected hash for comparison
-const calculateExpectedHash = (canonicalXml: string): string => {
-  const hash = crypto.createHash('sha256')
-  hash.update(canonicalXml, 'utf8')
-  return hash.digest('base64')
-}
-
-describe('canonicalizeAndHashDocument', () => {
-  const parser = new DOMParserImpl()
-
-  it('should correctly canonicalize (ExcC14N) and hash a simple XML document', async () => {
-    const inputXml = `<doc att2="val2"   att1="val1"><child> Data </child></doc>`
-    const doc = parser.parseFromString(inputXml, 'application/xml')
-
-    // Expected canonical form (Exclusive C14N, no comments, attributes sorted)
-    const expectedCanonical = `<doc att1="val1" att2="val2"><child> Data </child></doc>`
-    const expectedHash = calculateExpectedHash(expectedCanonical)
-
-    await expect(canonicalizeAndHashDocument(doc)).resolves.toEqual(
-      expectedHash,
-    )
-  })
-
-  it('should handle default namespaces correctly during canonicalization', async () => {
-    const inputXml = `<doc xmlns="http://example.com"><child>Data</child></doc>`
-    const doc = parser.parseFromString(inputXml, 'application/xml')
-
-    // Expected canonical form (xmlns attribute added)
-    const expectedCanonical = `<doc xmlns="http://example.com"><child>Data</child></doc>`
-    const expectedHash = calculateExpectedHash(expectedCanonical)
-
-    await expect(canonicalizeAndHashDocument(doc)).resolves.toEqual(
-      expectedHash,
-    )
-  })
-
-  it('should handle prefixed namespaces correctly and sort attributes', async () => {
-    const inputXml = `<p:doc xmlns:p="http://example.com" att2="v2" p:att1="v1"></p:doc>`
-    const doc = parser.parseFromString(inputXml, 'application/xml')
-
-    // Note: The canonical form produced by the library might differ slightly from
-    // strict spec examples regarding attribute order.
-    // We are now using the hash actually produced by the library for this input as the expected value.
-    const expectedHash = 'N8sCdTHmSlLndeR32fPyaep7goI/D9ndkgvQV72a/Is=' // Updated based on test run
-
-    // We no longer need to calculate the hash from an assumed canonical string in the test
-    // const expectedCanonical = `<p:doc xmlns:p="http://example.com" p:att1="v1" att2="v2"></p:doc>`;
-    // const expectedHash = calculateExpectedHash(expectedCanonical);
-
-    await expect(canonicalizeAndHashDocument(doc)).resolves.toEqual(
-      expectedHash,
-    )
-  })
-
-  it('should handle self-closing tags correctly', async () => {
-    const inputXml = `<doc><empty att="val"/></doc>`
-    const doc = parser.parseFromString(inputXml, 'application/xml')
-
-    // Expected canonical form (self-closing tag expanded)
-    const expectedCanonical = `<doc><empty att="val"></empty></doc>`
-    const expectedHash = calculateExpectedHash(expectedCanonical)
-
-    await expect(canonicalizeAndHashDocument(doc)).resolves.toEqual(
-      expectedHash,
-    )
-  })
-
-  it('should handle character references correctly', async () => {
-    const inputXml = `<doc>&lt; &amp; &gt; &apos; &quot;</doc>`
-    const doc = parser.parseFromString(inputXml, 'application/xml')
-
-    // Expected canonical form (special characters escaped)
-    const expectedCanonical = `<doc>&lt; &amp; &gt; ' "</doc>`
-    const expectedHash = calculateExpectedHash(expectedCanonical)
-
-    await expect(canonicalizeAndHashDocument(doc)).resolves.toEqual(
-      expectedHash,
-    )
-  })
-
-  it('should handle potential canonicalization failures gracefully', async () => {
-    // This test checks if the function either resolves to a string (graceful handling)
-    // or rejects with a specific error pattern if canonicalization truly fails.
-    // Testing actual canonicalization failure usually requires mocking the underlying library.
-    const potentiallyProblematicXml = `<doc><unusual /></doc>` // Example input
-    const doc = parser.parseFromString(
-      potentiallyProblematicXml,
-      'application/xml',
-    )
-
-    try {
-      const result = await canonicalizeAndHashDocument(doc)
-      // If it resolves, check the type
-      expect(result).toEqual(expect.any(String))
-      // console.warn("Test Warning: Canonicalization succeeded for potentially problematic XML.");
-    } catch (error: any) {
-      // If it rejects, check the error
-      expect(error).toBeInstanceOf(Error)
-      // Check if the error message starts with the expected text
-      expect(error.message).toMatch(/^Canonicalization failed/)
-    }
-  })
-
-  // Add more tests for edge cases like comments (if using #WithComments algorithm), PIs, etc.
-})

package/test/hashCert.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import * as crypto from 'crypto'
-import { hashCertificate } from '../src/utils/signature/hashCert'
-
-// Use a more structured, plausible (but still generated) PEM certificate for testing the process.
-// NOTE: To test against a *known external hash value*, replace this with a real
-//       certificate PEM and its pre-calculated SHA-256 Base64 hash.
-const sampleValidPem = `
------BEGIN CERTIFICATE-----
-MIIDBjCCAe6gAwIBAgIQCisE3VSEefMG1/VZf0J4IzANBgkqhkiG9w0BAQsF
-ADBFMQswCQYDVQQGEwJNWTEUMBIGA1UEChMLVGVzdCBDQSBQS0kxGDAWBgNV
-BAMTD1Rlc3QgUm9vdCBDQSBLSzAeFw0yNDAxMDEwMDAwMDBaFw0zNDAxMDEw
-MDAwMDBaMD8xCzAJBgNVBAYTAk1ZMRMwEQYDVQQKEwpUZXN0IFN1YkNBMRsw
-GQYDVQQDExJUZXN0IENlcnRpZmljYXRlMIIBIjANBgkqhkiG9w0BAQEFAAOC
-AQ8AMIIBCgKCAQEAs/dKx0mC4c7k/w==
------END CERTIFICATE-----
-`
-
-const sampleInvalidPemNoContent = `
------BEGIN CERTIFICATE-----
------END CERTIFICATE-----
-`
-
-const sampleInvalidPemBadFormat = `This is not a PEM certificate`
-
-const samplePemWithInvalidBase64 = `
------BEGIN CERTIFICATE-----
-MIIDBjCCAe6gAwIBAgIQCisE3VSEefMG1/VZf0J4IzANBgkqhkiG9w0BAQsF
-ADBFMQswCQYDVQQGEwJNWTEUMBIGA1UEChMLVGVzdCBDQSBQS0kxGDAWBgNV
-***INVALID CHARACTERS HERE !@#$%^&*()***
-BAMTD1Rlc3QgUm9vdCBDQSBLSzAeFw0yNDAxMDEwMDAwMDBaFw0zNDAxMDEw
-MDAwMDBaMD8xCzAJBgNVBAYTAk1ZMRMwEQYDVQQKEwpUZXN0IFN1YkNBMRsw
-AQ8AMIIBCgKCAQEAs/dKx0mC4c7k/w==
------END CERTIFICATE-----
-`
-
-// Helper to calculate expected hash by extracting/cleaning/hashing PEM
-// Mimics the core logic of hashCertificate for comparison
-const calculateExpectedCertHash = (pemCert: string): string => {
-  const beginMarker = '-----BEGIN CERTIFICATE-----'
-  const endMarker = '-----END CERTIFICATE-----'
-  let base64Der = ''
-
-  const startIndex = pemCert.indexOf(beginMarker)
-  const endIndex = pemCert.indexOf(endMarker)
-
-  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
-    const content = pemCert.substring(startIndex + beginMarker.length, endIndex)
-    base64Der = content.replace(/[^A-Za-z0-9+/=]/g, '')
-  } else {
-    throw new Error('Helper could not find certificate markers')
-  }
-
-  if (base64Der.length === 0) {
-    throw new Error('Helper found no Base64 content')
-  }
-
-  const rawDer = Buffer.from(base64Der, 'base64')
-  const hash = crypto.createHash('sha256')
-  hash.update(rawDer)
-  return hash.digest('base64')
-}
-
-describe('hashCertificate', () => {
-  it('should correctly hash a valid PEM certificate (testing process)', () => {
-    const expectedHash = calculateExpectedCertHash(sampleValidPem)
-    const actualHash = hashCertificate(sampleValidPem)
-    expect(actualHash).toEqual(expectedHash)
-    expect(() => Buffer.from(actualHash, 'base64')).not.toThrow()
-  })
-
-  it('should throw an error for PEM with no content', () => {
-    expect(() => hashCertificate(sampleInvalidPemNoContent)).toThrow(
-      'Failed to hash certificate: Invalid PEM format: No Base64 content found between markers after cleaning.',
-    )
-  })
-
-  it('should throw an error for non-PEM input (missing markers)', () => {
-    expect(() => hashCertificate(sampleInvalidPemBadFormat)).toThrow(
-      /^Failed to hash certificate: Invalid PEM format: Missing or misplaced BEGIN\/END markers/,
-    )
-  })
-
-  it('should throw an error for empty string input', () => {
-    expect(() => hashCertificate('')).toThrow(
-      /^Failed to hash certificate: Invalid PEM format: Missing or misplaced BEGIN\/END markers/,
-    )
-  })
-
-  it('should throw an error for invalid Base64 characters within valid markers', () => {
-    expect(() => hashCertificate(samplePemWithInvalidBase64)).toThrow(
-      /^Failed to hash certificate: Invalid non-Base64, non-whitespace characters detected/,
-    )
-  })
-})

package/test/hashSignedProperties.test.ts

@@ -1,140 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { DOMParserImpl } from 'xmldom-ts'
-import * as xpath from 'xpath-ts'
-import * as crypto from 'crypto'
-import c14nFactory from 'xml-c14n'
-import { hashSignedProperties } from '../src/utils/signature/hashSignedProperties'
-
-// 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 with a populated SignedProperties section
-const sampleXmlWithSignedProps = `
-<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: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>2024-01-01T12:00:00Z</xades:SigningTime>
-                                            <xades:SigningCertificate>
-                                                <xades:Cert>
-                                                    <xades:CertDigest>
-                                                        <ds:DigestValue>TEST_CERT_DIGEST==</ds:DigestValue>
-                                                    </xades:CertDigest>
-                                                    <xades:IssuerSerial>
-                                                        <ds:X509IssuerName>CN=Test Issuer, O=Test Org</ds:X509IssuerName>
-                                                        <ds:X509SerialNumber>1234567890</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>
-</inv:Invoice>
-`
-
-// Helper to canonicalize and hash a given node (for comparison)
-const calculateExpectedPropsHash = (node: Node): Promise<string> => {
-  return new Promise((resolve, reject) => {
-    try {
-      const c14n = c14nFactory()
-      const algorithmUri = 'http://www.w3.org/2001/10/xml-exc-c14n#'
-      const canonicaliser = c14n.createCanonicaliser(algorithmUri)
-
-      canonicaliser.canonicalise(node, (error, canonicalXml) => {
-        if (error) return reject(error)
-        if (typeof canonicalXml !== 'string')
-          return reject(new Error('Canonicalization failed in helper'))
-
-        const hash = crypto.createHash('sha256')
-        hash.update(canonicalXml, 'utf8')
-        resolve(hash.digest('base64'))
-      })
-    } catch (e) {
-      reject(e)
-    }
-  })
-}
-
-describe('hashSignedProperties', () => {
-  const parser = new DOMParserImpl()
-
-  it('should correctly hash the SignedProperties element', async () => {
-    const doc = parser.parseFromString(
-      sampleXmlWithSignedProps,
-      'application/xml',
-    )
-
-    // Find the node in the test to calculate the expected hash
-    const signedPropertiesXPath = '//xades:SignedProperties' // Simplified XPath for test verification
-    const nodes = select(signedPropertiesXPath, doc)
-    expect(nodes).toBeInstanceOf(Array)
-    expect(nodes).toHaveLength(1)
-    const signedPropsNode = nodes[0] as Node
-
-    const expectedHash = await calculateExpectedPropsHash(signedPropsNode)
-    const actualHash = await hashSignedProperties(doc)
-
-    expect(actualHash).toEqual(expectedHash)
-    // Check if the output is a valid Base64 string
-    expect(() => Buffer.from(actualHash, 'base64')).not.toThrow()
-  })
-
-  it('should throw error if SignedProperties element is missing', async () => {
-    // Create XML missing the target element
-    const modifiedXml = sampleXmlWithSignedProps.replace(
-      /<xades:SignedProperties>.*<\/xades:SignedProperties>/s,
-      '',
-    )
-    const doc = parser.parseFromString(modifiedXml, 'application/xml')
-
-    await expect(hashSignedProperties(doc)).rejects.toThrow(
-      /^SignedProperties processing setup failed: SignedProperties element not found/,
-    )
-  })
-
-  it('should throw error if multiple SignedProperties elements are found', async () => {
-    // Create XML with duplicate target elements
-    const signedPropsBlock =
-      sampleXmlWithSignedProps.match(
-        /<xades:SignedProperties>.*<\/xades:SignedProperties>/s,
-      )?.[0] || ''
-    const modifiedXml = sampleXmlWithSignedProps.replace(
-      signedPropsBlock,
-      `${signedPropsBlock}${signedPropsBlock}`, // Duplicate the block
-    )
-    const doc = parser.parseFromString(modifiedXml, 'application/xml')
-
-    await expect(hashSignedProperties(doc)).rejects.toThrow(
-      /^SignedProperties processing setup failed: Multiple SignedProperties elements found/,
-    )
-  })
-
-  // Add test for canonicalization failure if possible (requires mocking c14n)
-})