Refactor - c#, android and web

[MihailsKuzmins]

.NET changes (c#):

public class EncryptionService2
{
    private const int
        KeySize = 256,
        BlockSize = 128,
        KeyLength = 32,
        IvLength = 16;

    private static Encoding Encoding => Encoding.UTF8;

    public string Encrypt(string inputText, string encryptionKey, string initVector)
    {
        using var rijndaelAlgorithm = GetRijndaelAlgorithm(encryptionKey, initVector);
        using var encryptor = rijndaelAlgorithm.CreateEncryptor();

        var inputBytes = Encoding.GetBytes(inputText);

        return encryptor
            .TransformFinalBlock(inputBytes, 0, inputBytes.Length)
            .Run(Convert.ToBase64String);
    }

    public string Decrypt(string inputText, string encryptionKey, string initVector)
    {
        using var rijndaelAlgorithm = GetRijndaelAlgorithm(encryptionKey, initVector);
        using var decryptor = rijndaelAlgorithm.CreateDecryptor();

        var inputBytes = Convert.FromBase64String(inputText);

        return decryptor
            .TransformFinalBlock(inputBytes, 0, inputBytes.Length)
            .Run(Encoding.GetString);
    }

    private static RijndaelManaged GetRijndaelAlgorithm(string encryptionKey, string initVector)
    {
        var encryptionKeyBytes = Encoding.GetBytes(encryptionKey);
        var initVectorBytes = Encoding.GetBytes(initVector);

        var encryptionKeyArray = new byte[KeyLength];
        var initialVectorArray = new byte[IvLength];

        CopyBytes(encryptionKeyBytes, encryptionKeyArray);
        CopyBytes(initVectorBytes, initialVectorArray);

        return new RijndaelManaged
        {
            Mode = CipherMode.CBC,
            Padding = PaddingMode.PKCS7,
            KeySize = KeySize,
            BlockSize = BlockSize,
            Key = encryptionKeyArray,
            IV = initialVectorArray
        };
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static void CopyBytes(byte[] source, byte[] destination) =>
        Array.Copy(source, destination, Math.Min(source.Length, destination.Length));
}

Android changes (Kotlin):

class EncryptionService {
    fun encrypt(inputText: String, encryptionKey: String, initVector: String): String =
        getCipher(Cipher.ENCRYPT_MODE, encryptionKey, initVector)
            .doFinal(inputText.toByteArray(charset))
            .run { Base64.encodeToString(this, Base64.DEFAULT) }

    fun decrypt(inputText: String, encryptionKey: String, initVector: String): String {
        val decodedValue = inputText.toByteArray()
            .run { Base64.decode(this, Base64.DEFAULT) }

        return getCipher(Cipher.DECRYPT_MODE, encryptionKey, initVector)
            .doFinal(decodedValue)
            .run<ByteArray, String>(::String)
    }

    companion object {
        private const val keyLength = 32
        private const val ivLength = 16
        private val charset = Charsets.UTF_8

        private fun getCipher(mode: Int, encryptionKey: String, initVector: String): Cipher {
            val encryptionKeyBytes = encryptionKey.toByteArray(charset)
            val initVectorBytes = initVector.toByteArray(charset)

            val secretKeySpec = ByteArray(keyLength)
                .also { copyBytes(encryptionKeyBytes, it) }
                .run { SecretKeySpec(this, "AES") }

            val ivParameterSpec = ByteArray(ivLength)
                .also { copyBytes(initVectorBytes, it) }
                .run(::IvParameterSpec)

            return Cipher.getInstance("AES/CBC/PKCS5Padding")
                .apply { init(mode, secretKeySpec, ivParameterSpec) }
        }

        private fun copyBytes(source: ByteArray, destination: ByteArray) {
            System.arraycopy(source, 0, destination, 0, minOf(source.size, destination.size))
        }
    }
}

Web changes (TypeScript)

export default class EncryptionService {
    private static readonly KeySize = 32
    private static readonly IvSize = 16
    private readonly mAlgorithm = 'AES-256-CBC'

    encrypt(plainText: string, encryptionKey: string, initVector: string) {
        const [encryptionKeyArray, initVectorArray] = EncryptionService.getByteArrays(encryptionKey, initVector)

        const encryptor = Crypto.createCipheriv(this.mAlgorithm, encryptionKeyArray, initVectorArray)
        encryptor.setEncoding('base64')
        encryptor.write(plainText)
        encryptor.end()

        return encryptor.read()
    }

    decrypt(encryptedText: string, encryptionKey: string, initVector: string) {
        const [encryptionKeyArray, initVectorArray] = EncryptionService.getByteArrays(encryptionKey, initVector)

        const decryptor = Crypto.createDecipheriv(this.mAlgorithm, encryptionKeyArray, initVectorArray)

        return decryptor
            .update(encryptedText, 'base64', 'utf8')
            .concat(decryptor.final('utf8'))
    }

    private static getByteArrays(encryptionKey: string, initVector: string) {
        const encryptionKeyArray = new Uint8Array(EncryptionService.KeySize),
            initVectorArray = new Uint8Array(EncryptionService.IvSize)

        const textEncoder = new TextEncoder()
        textEncoder.encodeInto(encryptionKey, encryptionKeyArray)
        textEncoder.encodeInto(initVector, initVectorArray)

        return [encryptionKeyArray, initVectorArray] as const
    }
}