Decrypt got error DATA_LEN_NOT_EQUAL_TO_MOD_LEN

[Xing1P]

Note1: I try decrypt in PGP Tool it works well.
Note2: got error only some file not all.
Error Message: Error: error:04000070:RSA routines:OPENSSL_internal:DATA_LEN_NOT_EQUAL_TO_MOD_LEN
OpenPGP: 5.5.0
File Encrypted: 63KB
My Function:

const openpgp = require('openpgp');
async({data:{blob, privateKey},ports:[port]})=>{
    try {
        const fileArray = await blob.arrayBuffer();
        const uint8 = new Uint8Array(fileArray);
        const privateKeyObj = await openpgp.readPrivateKey({ armoredKey: privateKey });
        const message = await openpgp.readMessage({binaryMessage: uint8});
        const { data: decrypted} = await openpgp.decrypt({
            message: message,
            decryptionKeys: privateKeyObj,
            format: 'binary'
        });
        port.postMessage({blob: new Blob([decrypted],{type: blob.type})})
    } catch (error) {
        port.postMessage({error: error})
    }
}

OpenPGP Function:

async function nodeDecrypt(data, n, e, d, p, q, u, randomPayload) {
  const { default: BN } = await Promise.resolve().then(function () { return bn$1; });

  const pBNum = new BN(p);
  const qBNum = new BN(q);
  const dBNum = new BN(d);
  const dq = dBNum.mod(qBNum.subn(1)); // d mod (q-1)
  const dp = dBNum.mod(pBNum.subn(1)); // d mod (p-1)
  const keyObject = {
    version: 0,
    modulus: new BN(n),
    publicExponent: new BN(e),
    privateExponent: new BN(d),
    // switch p and q
    prime1: new BN(q),
    prime2: new BN(p),
    // switch dp and dq
    exponent1: dq,
    exponent2: dp,
    coefficient: new BN(u)
  };
  let key;
  if (typeof nodeCrypto$2.createPrivateKey !== 'undefined') {
    const der = RSAPrivateKey.encode(keyObject, 'der');
    key = { key: der, format: 'der' , type: 'pkcs1', padding: nodeCrypto$2.constants.RSA_PKCS1_PADDING };
  } else {
    const pem = RSAPrivateKey.encode(keyObject, 'pem', {
      label: 'RSA PRIVATE KEY'
    });
    key = { key: pem, padding: nodeCrypto$2.constants.RSA_PKCS1_PADDING };
  }
  try {
    return new Uint8Array(nodeCrypto$2.privateDecrypt(key, data));
  } catch (err) {
    if (randomPayload) {
      return randomPayload;
    }
    throw new Error('Decryption error 2'+err);
  }
}

[larabr]

I think this means there is a problem with the way the message was encrypted -- perhaps not encoded correctly. It's hard to debug this without message/key unfortunately.
PGP tools might be more lenient to decode data than Node; looking quickly at their code, it seems they do not check that there are at least 8 non-zero bytes following the PKCS1 header: https://github.com/keybase/kbpgp/blob/master/src/pad.iced#L106-L120 .

What library were the messages encrypted with?

[Xing1P]

Decryption is working for me, what version of Node are you using?

I did try to run manual test decrypt it working.

node ./testdecrypt.js

but when I test call this function from my running project it got error (DATA_LEN_NOT_EQUAL_TO_MOD_LEN) (Note: Some file).
My Project: Electron v23
Do you have any ideas to check this problem?

[Xing1P]

electron-quick-start.zip

[larabr]

No clue, Electron might cause issues, @twiss do you have ideas / remember if we had trouble supporting Electron?

[twiss]

We've had issues before, yeah. @Xing1P could you try using the browser build rather than the Node.js build of OpenPGP.js, to see if that works better? Since this error comes from the Node.js crypto API, using the Web Crypto API instead might fix this.

[Xing1P]

Yes, now using browser build is working.

[Xing1P]

One more, I need your help. I have a problem with chunk size.
Encrypt From: https://pgpainless.readthedocs.io/en/latest/

1. Decrypt file: 20MB file send from pgpainless(compression Zip)

• pgpainless: 10Sec
• OpenPGPJs: 3Min (chunk 2000+ times)

2. Decrypt file: 20MB file send from OpenPGPJs(compression Zip)

• pgpainless: 10Sec
• OpenPGPJs: 10Sec (chunk 60 times)

   async function decrypt(pk){
    const plainData2 = fs.readFileSync("C:\\Users\\Xing\\Desktop\\ttt\\video_20221202_150102.mp4");
    const blob = new Blob([plainData2], { type: "" })
    const stream = blob.stream();
    console.log("stream",stream)
    const privateKeyObj = await openpgp.readPrivateKey({ armoredKey: pk });
    const message = await openpgp.readMessage({ binaryMessage: stream });
    console.log("message-en",message)
    const { data: decrypted } = await openpgp.decrypt({
        message: message,
        decryptionKeys: privateKeyObj,
        format: 'binary',
        config: { allowUnauthenticatedStream: true, preferredCompressionAlgorithm: openpgp.enums.compression.zlib }
    });
    const wstream= createWritableStream("C:\\Users\\Xing\\Desktop\\ttt\\1111111.mp4")
    await decrypted.pipeTo(wstream)
}
function createWritableStream(destinationPath){
    const sink = {
        // this method is called when the stream is created
        start(controller) {
            // create a writable stream for writing data to test.txt
            this.stream = fs.createWriteStream(destinationPath);
            // handle errors on the stream
            this.stream.on("error", err => {
            // if an error occurs, abort the stream
            controller.error(err);
            this.stream.destroy();
            });
        },
        // this method is called when a chunk of data is ready to be written
        write(chunk) {
            return new Promise((resolve, reject) => {
            // write the chunk to the stream
            console.log("chunk",chunk.length)
            const ok = this.stream.write(chunk);
            if (ok) {
                // if the write succeeds, resolve the promise
                resolve();
            } else {
                // if the write fails, wait for drain event and then resolve
                this.stream.once("drain", resolve);
            }
            });
        },
        // this method is called when no more data will be written
        close() {
            return new Promise((resolve, reject) => {
            // end the stream and resolve when it finishes
            this.stream.end(resolve);
            });
        },
        // this method is called when the stream is aborted
        abort(err) {
            // destroy the stream with an error
            this.stream.destroy(err);
        }
        };
    // create a queuing strategy object with highWaterMark of 1
    const queuingStrategy = new CountQueuingStrategy({highWaterMark: 1});
    
    // create a WritableStream with sink and queuingStrategy objects as arguments
    const writableStream = new WritableStream(sink, queuingStrategy);
    return writableStream
}

[Xing1P]

video_20221202_150102.zip

[larabr]

Hey @Xing1P , please open a different discussion, so that other people can more easily reference solution to past problems, thanks!