PGCT.cs

// SPDX-FileCopyrightText: 2017-2020 Melbot Studios, S.L.
// SPDX-License-Identifier: LicenseRef-Melbot-Portfolio
//
// Original author: Miguel Angel Exposito (2017-2020)
//
// This source code is the property of Melbot Studios, S.L. and is published
// publicly for portfolio and educational review purposes with the express
// written authorization of Melbot Studios, S.L.
//
// All rights remain with Melbot Studios, S.L. Redistribution, modification,
// commercial use, or derivative works are not permitted without prior
// written consent of the copyright holder. See LICENSE for full terms.
//
// Note: this C# implementation mirrors the AES-CTR helper in the firmware
// (`Main/Project/src/HAL/Crypt.c`, adapted from Nordic Semiconductor's
// DevZone reference). The structure, parameter conventions, and inline
// doxygen comments — including the `NRF_*` retval names that are not
// applicable on this side — are intentionally kept aligned with the
// firmware-side documentation for cross-reference.

using System.Security.Cryptography;
using System;
using System.IO;

namespace Melbot.PodLib
{
    class PGCT
    {
        const uint KeyLen = 16;
        const uint CtrByteLen = 4;
        const uint NonceRandByteLen = 12;

        static bool _isInitialized = false;

        byte[] _ecbDataKey;
        byte[] _ecbClearText;
        readonly byte[] _zeros = new byte[16];
        ICryptoTransform _cTransform;
        Aes _aes;
        /**
         * @brief Initializes the module with the given nonce and key
         * @details The nonce will be copied to an internal buffer so it does not need to
         *          be retained after the function returns. Additionally, a 32-bit counter
         *          will be initialized to zero and placed into the least-significant 4 bytes
         *          of the internal buffer. The nonce value should be generated in a
         *          reasonable manner (e.g. using this module's nonce_generate function).
         *
         * @param[in]    p_nonce    An array of length 16 containing 12 random bytes
         *                          starting at index 4
         * @param[in]    p_ecb_key  An array of length 16 containing the ECB key
         */

        public void CtrInit(byte[] nonce, byte[] key)
        {
            _isInitialized = true;
            _ecbDataKey = key.Clone() as byte[];
            _ecbClearText = new byte[CtrByteLen + NonceRandByteLen];
            Array.Copy(nonce, 0, _ecbClearText, CtrByteLen, NonceRandByteLen);

            // Zero the counter value.
            // No need to do this

            _aes = Aes.Create();
            _aes.Mode = CipherMode.ECB;

            _cTransform = _aes.CreateEncryptor(_ecbDataKey, _zeros);
        }

        public void CtrDeInit()
        {
            _isInitialized = false;
            _ecbDataKey = null;
            _ecbClearText = null;

            _aes?.Clear();
            _aes?.Dispose();
            _aes = null;
        }

        void Cpt(byte[] buf, ref uint ctr)
        {
            if (!_isInitialized) throw new InvalidOperationException();

            // Write the counter to the cleartext
            using (var ms = new MemoryStream(_ecbClearText))
            {
                using (var wr = new BinaryWriter(ms))
                    wr.Write(ctr);
            }

            uint i = 0;

            while (i < buf.Length)
            {
                byte[] resultArray;

                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, _cTransform, CryptoStreamMode.Write))
                    {
                        csEncrypt.Write(_ecbClearText, 0, _ecbClearText.Length);
                        resultArray = msEncrypt.ToArray();
                    }
                }

                for (uint j = 0; i < buf.Length && j < KeyLen; ++i, ++j)
                {
                    buf[i] ^= resultArray[j];
                }

                //uint ctr = 0;
                // Increment the counter.
                using (var ms = new MemoryStream(_ecbClearText))
                {
                    ms.Seek(0, SeekOrigin.Begin);
                    ++ctr;
                    using (var wr = new BinaryWriter(ms))
                        wr.Write(ctr);
                }
            }
        }

        /**
         * @brief Encrypts the given buffer in-situ
         * @details The encryption step is done separately (using the nonce, counter, and
         *          key) and then the result from the encryption is XOR'd with the given
         *          buffer in-situ. The counter will be incremented only if no error occurs.
         *
         * @param[in]    p_clear_text    An array of length 16 containing the clear text
         *
         * @retval    NRF_SUCCESS                         Success
         * @retval    NRF_ERROR_INVALID_STATE             Module has not been initialized
         * @retval    NRF_ERROR_SOFTDEVICE_NOT_ENABLED    SoftDevice is present, but not enabled
         */
        public void Ect(byte[] pCt, ref uint ctr)
        {
            Cpt(pCt, ref ctr);
        }

        /**
         * @brief Decrypts the given buffer in-situ
         * @details The encryption step is done separately (using the nonce, counter, and
         *          key) and then the result from the encryption is XOR'd with the given
         *          buffer in-situ. The counter will be incremented only if no error occurs.
         *
         * @param[in]    p_cipher_text    An array of length 16 containing the cipher text
         *
         * @retval    NRF_SUCCESS                         Succeess
         * @retval    NRF_ERROR_INVALID_STATE             Module has not been initialized
         * @retval    NRF_ERROR_SOFTDEVICE_NOT_ENABLED    SoftDevice is present, but not enabled         * 
         */
        public void Dct(byte[] pCt, ref uint ctr)
        {
            Cpt(pCt, ref ctr);
        }
    }
}