PADS | Packaged version of Python Algorithms

The code is mostly OK, there are just a few minor issues:

1. CryptoJS does not automatically disable the default PKCS7 padding for stream cipher modes like CTR. Therefore, PKCS7 padding must be applied in the Go code.
2. Since the CryptoJS code uses the internal PBKDF, the OpenSSL format is required for decryption (i.e. the ASCII encoding of Salted__ followed by the 8 bytes salt and the actual ciphertext), hex encoded. So the Go code must format and encode the data accordingly.
3. CryptoJS derives key and IV when using the internal PBKDF. Therefore, in the CryptoJS code, the specified IV is ignored during decryption. Hence, in the Go code, any IV can be specified.

The following code corresponds to your code, extended by the PKCS#7 padding and the formatting/encoding of the result (consider the comments in the code). Note that, as in your code, a hard-coded salt is used for simplicity, but in practice a randomly generated salt must be applied for security reasons:

Nice job so far on the project! You were right in using querySelectorAll, but you'll need to loop through the elements to add the onClick to all the pads. First I'd change the pad variable to querySelectorAll like this:

Have I correctly loaded a linear frame buffer, and, if not, how could I do so?

In your code you just assume that the linear frame buffer mode is available. You should inspect the ModeInfoBlock.ModeAttributes bit 7 to know for sure. The bit needs to be ON:

In the snippet, the width of the row is 540px, thus the width of a col-sm-2 is 2 / 12 * 540 = 90px. The corresponding rule :

This code will cause an infinite rerender loop:

You could use Variable Length Arrays as function parameters.

Here is how you would shift them right and left 8 bits.

The C# code uses Rijndael with a block size of 256 bits (see comments), a static IV (see comments) and returns only the ciphertext (i.e. without prepended IV).
The Go code applies AES with by definition a block size of 128 bits, a randomly generated IV (the static IV in the code is ignored) and returns the concatenation of IV and ciphertext.

AES is a subset of Rijndael. Rijndael defines different block sizes and key sizes between 128 and 256 bits in 32 bit steps, see here. For AES only the block size 128 bits is defined and the key sizes 128, 192 and 256 bits. Note that the standard is AES and not Rijndael, so AES should be preferred over Rijndael (many libraries do not even implement Rijndael, but AES instead).

A static IV is insecure. Key/IV pairs must not repeat for security reasons. Therefore, in general, with a fixed key, a random IV is generated for each encryption. The IV is not secret and is passed along with the ciphertext to the decryption side, typically concatenated in the order IV|ciphertext.

Therefore, the current Go code is a secure implementation (even more secure is authenticated encryption e.g. via GCM), while the C# code is not. So it would make more sense to modify the C# code to be functionally equivalent to the Go code.
However, since the C# code seems to be the reference, the following changes are needed in the Go code to make it functionally identical to the C# code:

• Instead of AES, Rijndael must be applied. In the following example, pkg.go.dev/github.com/azihsoyn/rijndael256 is used. To do this, import "github.com/azihsoyn/rijndael256" and formally replace aes with rijndael256. You can of course apply another implementation.
• The static IV is to be applied: bm := cipher.NewCBCEncrypter(block, IV). iv and its filling is to be removed together with associated imports.
• Only the ciphertext is returned in the enecrypt()-method: return ciphertext[rijndael256.BlockSize:].

The following Go code gives the result of the C# code: