NodeJS: InitToken - Nieprawidłowo zaszyfrowana treść

[magicwrites]

Cześć wszystkim 👋

Od kilku dni próbuję przebić się do środowiska demo/test KSEF i spróbować rozpocząć pracę z systemem. Udało mi się skomunikować poprzez HTTP i rozpocząć "authorisation challenge" oraz przebrnąć przez wysyłkę XML. Niestety, albo nie rozumiem jak działa token autoryzacyjny, albo nie potrafię poprawnie odwzorować jego szyfrowania RSA w środowisku NodeJS.

Będę wdzięczny za pomoc:

• analizę kodu?
• jakiś dobry zestaw zmiennych + wyniku ich zaszyfrowania do testów, żebym mógł zweryfikować mój kod, widziałem, że pojawiła się implementacja w innych językach
• podpowiedź w sprawie komunikatu z błędem? Może źle go rozumiem

Błąd

Nieprawidłowo zaszyfrowana treść 😕

POST na https://ksef-demo.mf.gov.pl/api/online/Session/InitToken
Bad Request
{"exception":{"serviceCtx":"srvTRMFB","serviceCode":"20230923-EX-9B3075C62B-22379C523C-55","serviceName":"online.session.session.token.init","timestamp":"2023-09-23T15:40:10.836Z","referenceNumber":"20230923-SE-DF9AE01C94-FBC172A00A-99","exceptionDetailList":[{"exceptionCode":20005,"exceptionDescription":"Nieprawidłowo zaszyfrowana treść."}]}}

Kod

Szyfrowanie tokena, zapewne gdzieś tutaj jest błąd:

import crypto from 'crypto'
import fs from 'fs/promises'
import path from 'path'

export const getRsaPublicKey = async (keyLocation: string) => {
    const absolutePath = path.resolve(keyLocation);

    return await fs.readFile(absolutePath, "utf8");
}

// two functions below as per interface specification v1.3 which expects:
// Base64(encrypt(public_key, bytes(token + ‘|’ + challengeTime)))

export const calculateTokenBase = async (authorisationToken: string, challengeTimestamp: string) => {
    const challengeTime = new Date(challengeTimestamp).getTime()

    return Buffer.from(authorisationToken + '|' + challengeTime)
}

export const encryptTokenBase = (base: Buffer, key: string) => {
    const encrypted = crypto.publicEncrypt(key, base);

    return encrypted.toString("base64");
};

export const calculateToken = async (publicKeyLocation: string, authorisationToken: string, challengeTimestamp: string) => {
    const publicKey = await getRsaPublicKey(publicKeyLocation)
    const base = await calculateTokenBase(authorisationToken, challengeTimestamp)
    const token = encryptTokenBase(base, publicKey)

    return token
}

Ciało zapytania HTTP wedle źródeł ze strony, serwis KSEF wydaje się być zadowolony z formatu bo nie marudzi na niepoprawną treść a jedynie na szyfrowanie:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ns3:InitSessionTokenRequest
	xmlns="http://ksef.mf.gov.pl/schema/gtw/svc/online/types/2021/10/01/0001"
	xmlns:ns2="http://ksef.mf.gov.pl/schema/gtw/svc/types/2021/10/01/0001"
	xmlns:ns3="http://ksef.mf.gov.pl/schema/gtw/svc/online/auth/request/2021/10/01/0001">
	<ns3:Context>
		<Challenge>${challenge}</Challenge>
		<Identifier xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="ns2:SubjectIdentifierByCompanyType">
			<ns2:Identifier>${identifier}</ns2:Identifier>
		</Identifier>
		<DocumentType>
			<ns2:Service>KSeF</ns2:Service>
			<ns2:FormCode>
				<ns2:SystemCode>FA (1)</ns2:SystemCode>
				<ns2:SchemaVersion>1-0E</ns2:SchemaVersion>
				<ns2:TargetNamespace>http://crd.gov.pl/wzor/2021/11/29/11089/</ns2:TargetNamespace>
				<ns2:Value>FA</ns2:Value>
			</ns2:FormCode>
		</DocumentType>
		<Token>${token}</Token>
	</ns3:Context>
</ns3:InitSessionTokenRequest>

I wysyłka, zakładam, że również OK:

  const url = `${KSEF_URL}/online/Session/InitToken`
  const method = 'POST'

  const headers = new Headers({
    'content-type': 'application/octet-stream',
    'accept': 'application/json',
  })

  const publicKeyLocation = process.cwd() + '/static/' + KSEF_PUBLIC_KEY
  const token = await calculateToken(publicKeyLocation, KSEF_TOKEN, timestamp)

  const body = sessionXml
    .replace('${challenge}', challenge) // id uzyskane z online/Session/AuthorisationChallenge
    .replace('${identifier}', identifier) // NIP firmy posiadacza authorisationToken, ktora bedzie wystawiac faktury
    .replace('${token}', token) // authorisation token z panelu KSEF, zaszyfrowany wyzej

  const response = await fetch(url, { method, headers, body });

[magicwrites]

Okej, udało mi się odnaleźć rozwiązanie.

Nie mam pewności, czego dokładnie zabrakło, ale przy bardziej precyzyjnej konfiguracji:

    const encrypted = crypto.publicEncrypt({
        key,
        padding: crypto.constants.RSA_PKCS1_PADDING,
        oaepHash: "sha256",
    }, base);

Zapytanie przeszło poprawnie i otrzymałem autoryzację. 👍
Temat zamknięty, mam nadzieję, że komuś pomoże.