Considering the aforementioned components and their structure, it is necessary to have a function whose responsibility is to prepare the entire initial state of the algorithm:

• Have defined within its body the constant, key, nonce, and counter.
• Fill both matrices (block and stream) with 0.
• Set the key position to 64 (invalid position).
• Copy the constant to positions [0, 16) bytes of the block matrix.
• Copy the key to positions [16, 48) bytes of the block matrix.
• Copy the counter to positions [48, 56) bytes of the block matrix.
• Copy the nonce to positions [56, 64) bytes of the block matrix.

From the block matrix, it is necessary to generate the keystream, which is stored in the stream matrix. To do this, an endomorphic function \(f: \mathbb{Z}^{4\times4} \mapsto \mathbb{Z}^{4\times4}\) is considered, which takes the block matrix as input and repeatedly and deterministically applies a binary diffusion operation.

Initially, in \(f\), we copy the content of the block matrix to the stream matrix. Next, we repeatedly apply the same binary diffusion operation. This operation takes four elements from the matrix as input and also returns four elements, overwriting the ones that were taken as input from the matrix. The same 8 sets of 4 elements are chosen for each repetition of the application. These 8 sets consist of: each column of the matrix, from left to right, and each diagonal in the same direction as the main diagonal, including the main diagonal itself, from left to right, wrapping around when necessary.

• Columns:

• Diagonals:

At this point, we have the stream matrix as a copy of the block matrix operated with binary diffusion. To finalize the generation of the stream matrix, we simply add the block matrix to it. Binary overflow due to this addition is possible, but it can be ignored since the decimal representation is not relevant, and therefore, arithmetic concerns are not taken into account.

Finally, as a purely illustrative simplification, the generation of the keystream is given by:

Previously, we mentioned the existence of a binary diffusion function that operates on 4 elements of the stream matrix, and we need to define it. However, before that, we need to learn about two more bitwise operations, \texttt{leftRotate} and \texttt{rightRotate}, which are binary rotations. Their definitions extend the binary shift operation present in the C language, with the difference that instead of adding leading zeros to the beginning or end of the bits, the bits rotate, with the first bit becoming the last, or vice versa for the other operation.

We call the binary diffusion function \texttt{qRoundF}, and it takes 4 in-out arguments:

Essa função é uma variação do procedimento original, em que \texttt{<<<=} represeta \texttt{leftRotation}:

This function is a variation of the original procedure that is not used, where \texttt{<<<=} represents \texttt{leftRotation}:

a += b; d ^= a; d <<<= 16;
c += d; b ^= c; b <<<= 12;
a += b; d ^= a; d <<<= 8;
c += d; b ^= c; b <<<= 7;

Viewing the stream matrix as a sequential list in the usual order, and with \texttt{xi} representing the i-th element within this list, the following sequence is applied repeatedly, updating the same input elements with the output of the function:

qRoundF(x0, x4,  x8, x12)
qRoundF(x1, x5,  x9, x13)
qRoundF(x2, x6, x10, x14)
qRoundF(x3, x7, x11, x15)
qRoundF(x0, x5, x10, x15)
qRoundF(x1, x6, x11, x12)
qRoundF(x2, x7,  x8, x13)
qRoundF(x3, x4,  x9, x14)

The number of times this sequence is applied is typically referred to as ``rounds''.

For the use of what has been described so far, it is only necessary to apply the stream matrix to any message and generate a new stream matrix from the block matrix.

For the application of the stream matrix to the message, it is first considered that the matrix can be interpreted as an array of 64 bytes (4 columns, 4 rows, 4 bytes per element). With this in mind, two cursors are implemented, one on top of the message and another on top of the stream matrix, both initialized at zero. In this way, the first byte is operated with the first byte of the stream matrix, and so on, incrementing both cursors by 1.

If the message cursor reaches the end, the operation is complete, but the stream matrix cursor will be stored for the next use, considering that the message may not arrive in its entirety. If the message has been completely received, it is the responsibility of the user of this algorithm to reset it to its initial state.

In the other case, when the key matrix cursor reaches the end but the message cursor does not, it is only necessary to regenerate a new stream matrix. However, it is necessary to modify the block matrix since generating the new stream matrix would result in the same matrix. Ideally, the keystream (obtained from the key matrix) should be a pseudo-random sequence and not periodic.

Therefore, whenever all the bytes of the stream matrix are used up, a new one should be generated from the current state of the block matrix, and after it is generated, update the block matrix, increasing its entropy. The chosen method increments, byte by byte, the values contained in the counter segment. The responsible for the increment is called the ``mixer'', which has an initial value of 1 and is 16 bits in size. We add the first byte of the counter to the mixer and overwrite the first byte of the counter with the last 8 bits of the result. Note that we deliberately do not use the 8 most significant bits of the mixer because our next step is to apply an 8-bit right shift to the mixer, transforming the most significant bits into the least significant bits. From there, we move on to the next byte of the counter, with the mixer not necessarily equaling 1, and repeat the same process. If you observe this behavior carefully, you will notice that the first byte of the counter will show a counter of how many times the key matrix was generated (considering the subtraction of the initial value), and from the second byte onwards, a more explosive count, quickly reaching the limit of the representation of a single byte and increasing the overall entropy of the block matrix as a whole.

To minimize the difficulty, the existence of functions encapsulating basic file handling functionalities should also be considered.

The first functionality should concern itself with indicating, at the moment when a file is opened for reading, whether it is known to be encrypted or not. This can be easily done by attempting to read the first 4 bytes at the beginning of the file, and if those 4 bytes match the format defined for it (commonly referred to as ``MAGIC''), the file is considered encrypted, and these first bytes read should be discarded. For reading, with the file open, you can read as many bytes as desired, and if it is indicated that the file in context is encrypted, you simply apply the procedure previously elucidated using the stream matrix, resulting in decrypted bytes. Finally, for file closure, just position the cursor at the end of the stream matrix (forcing it to generate a new one for a future file), remove the indication that the file in context is encrypted, and close the file normally, as usual.