randombytes | random bytes from browserify stand | Cryptography library

GridFS is a specification for storing and retrieving files that exceed the BSON document size limit of 16 MB. GridFS is a convention implemented by all MongoDB drivers that stores binary data across many smaller documents. The binaries are split into the chunks and then the chunks are stored in collections created by GridFS.

Having said that, given the presented use cases i would highly recommend using media server for storage as given the application landscape, that makes a more economical, viable and scalable solution.

Having said that, I would generally, avoid putting BLOBs in the database if there are other storage options that cost less as using a database as BLOB store is generally not a cost optimised solution. Sure, there are valid reasons for storing blobs in the database, but given the application’s use case (it being media intensive), use the media server for file storage, and databases for data structures.

In such cases, It is often easy to get "cost unoptimized" with time. Plus the database size would grow exponentially with time, bringing it's own challenges with RAM (WiredTiger Cache) management.

All in all - if it was me - I would use media storage for BLOB intensive applications than relying on databases.

User.findOne will return a Promise. So you need to add await keyword.

I also faced similar issues. The resolution for me was with mongoose version. The issue arises in the version 6.0.5 but is working in the version 5.13.7

JavaScript numbers are always stored as double precision floating point numbers, following the international IEEE 754 standard.

This format stores numbers in 64 bits (where the number (the fraction) is stored in bits 0 to 51, the exponent in bits 52 to 62, and the sign in bit 63).

Math.random() returns only positive numbers, therefore the sign bit is irrelevant. That means that Math.random() can not produce more that 2 ** 63 different values, in fact it is less than that, as Math.random() returns only values between 0 and 1 (which means that depending on the implementation none or not all of the 11 exponent bits are used). When your range is larger than that, Math.random() will not be able to generate every number within that range. Within the limit, your approach should work.

You set up cookieSession in your bootstrap, but your bootstrap has nothing to do with you tests. You need to call the same app.use() in your test setup that you would in your bootstrap to have middleware parity, or move the middleware to a Nest Middleware so you don't have to worry about this in the future.

The specs for the Fernet format can be found on https://github.com/fernet/spec/blob/master/Spec.md

There they specify both a generating and a veryfying steps, here is the generating which should give enough information for your implementation:

• Record the current time for the timestamp field.
• Choose a unique IV.
• Construct the ciphertext:
  • Pad the message to a multiple of 16 bytes (128 bits) per RFC 5652, section 6.3. This is the same padding technique used in PKCS #7 v1.5 and all versions of SSL/TLS (cf. RFC 5246, section 6.2.3.2 for TLS 1.2).
  • Encrypt the padded message using AES 128 in CBC mode with the chosen IV and user-supplied encryption-key.
• Compute the HMAC field as described above using the user-supplied signing-key.
• Concatenate all fields together in the format above.
• base64url encode the entire token.

From this we can see that the signing key (first half of full key) is used in HMAC, while the second half is used in the AES128-CBC, so just dividing the key into two separate elements (with proper conversion from hex string to bytes) should be enough for using Node.js crypto module (https://nodejs.org/en/knowledge/cryptography/how-to-use-crypto-module/) to construct your own implementation.

The reason is this breaking change:

DeflateStream, GZipStream, and CryptoStream diverged from typical Stream.Read and Stream.ReadAsync behavior in two ways:

They didn't complete the read operation until either the buffer passed to the read operation was completely filled or the end of the stream was reached.

And the new behaviour is:

Starting in .NET 6, when Stream.Read or Stream.ReadAsync is called on one of the affected stream types with a buffer of length N, the operation completes when:

At least one byte has been read from the stream, or The underlying stream they wrap returns 0 from a call to its read, indicating no more data is available.

In your case you are affected because of this code in Decrypt method:

You can achieve this using stream Transform(). Create a new stream Transform(), get the processed chunk length in it, then simply calculate progress with chunk length and file size, then add this new transform to your existing pipe.

Like this:-

You can do the port to NodeJS more or less 1:1: