using System;
 
namespace RC5Alg
{
    public class RC5
    {
        const int W = 64;                            // половина длины блока в битах. 
                                                     // Возможные значения 16, 32 и 64. 
                                                     // Для эффективной реализации величину W 
                                                     // рекомендуют брать равным машинному слову. 
                                                     // Например, для 64-битных платформ оптимальным будет
                                                     // выбор W=64, что соответствует размеру блока в 128 бит.
 
        const int R = 16;                            // число раундов. Возможные значения 0…255. 
                                                     // Увеличение числа раундов обеспечивает увеличение 
                                                     // уровня безопасности шифра. Так, если R = 0, 
                                                     // то информация шифроваться не будет.
 
        const UInt64 PW = 0xB7E151628AED2A6B;        // 64-битная константа
        const UInt64 QW = 0x9E3779B97F4A7C15;        // 64-битная константа
 
        UInt64 L;                                  // массив слов для секретного ключа пользователя
        UInt64 S;                                  // таблица расширенных ключей
        int t;                                       // размер таблицы
        int b;                                       // длина ключа в байтах. Возможные значения 0…255.
        int u;                                       // кол-во байтов в одном машинном слове
        int c;                                       // размер массива слов L
 
        public RC5
        {
            /* 
             *  Перед непосредственно шифрованием или расшифровкой данных выполняется процедура расширения ключа.
             *  Процедура генерации ключа состоит из четырех этапов:
             *      1. Генерация констант
             *      2. Разбиение ключа на слова
             *      3. Построение таблицы расширенных ключей
             *      4. Перемешивание
             */
 
            // основные переменные
            UInt64 x, y;
            int i, j, n;
 
            /* 
             * Этап 1. Генерация констант
             * Для заданного параметра W генерируются две псевдослучайные величины,
             * используя две математические константы: e и f.
             * Qw = Odd * 2^W;
             * Pw = Odd * 2^W;
             * где Odd - это округление до ближайшего нечетного целого.
             * 
             * Для оптимизации алгоритмы эти 2 величины определены заранее.
             */
 
            /*
             * Этап 2. Разбиение ключа на слова
             * На этом этапе происходит копирование ключа K..K в массив слов L..L, где
             * c = b/u, а u = W/8. Если b не кратен W/8, то L дополняется нулевыми битами до ближайшего 
             * большего размера c, при котором длина ключа b будет кратна W/8.
             */
 
            u = W >> 3;
            b = key.Length;
            c = b % u > 0 ? b / u + 1 : b / u;
            L = new UInt64;
 
            for 
            {
                L = ROL + key;
            }
 
            /* Этап 3. Построение таблицы расширенных ключей
             * На этом этапе происходит построение таблицы расширенных ключей S..S, 
             * которая выполняется следующим образом:
             */
 
            t = 2 * ;
            S = new UInt64;
            S = PW;
            for 
            {
                S = S + QW;
            }
 
            /* Этап 4. Перемешивание
             * Циклически выполняются следующие действия:
             */
 
            x = y = 0;
            i = j = 0;
            n = 3 * Math.Max;
 
            for 
            {
                x = S = ROL, 3);
                y = L = ROL, );
                i =  % t;
                j =  % c;
            }
        }
 
        /// <summary>
        /// Циклический сдвиг битов слова влево
        /// </summary>
        /// <param name="a">машинное слово: 64 бита</param>
        /// <param name="offset">смещение</param>
        /// <returns>машинное слово: 64 бита</returns>
        private UInt64 ROL
        {
            UInt64 r1, r2;
            r1 = a << offset;
            r2 = a >> ;
            return ;
 
        }
 
        /// <summary>
        /// Циклический сдвиг битов слова вправо
        /// </summary>
        /// <param name="a">машинное слово: 64 бита</param>
        /// <param name="offset">смещение</param>
        /// <returns>машинное слово: 64 бита</returns>
        private UInt64 ROR
        {
            UInt64 r1, r2;
            r1 = a >> offset;
            r2 = a << ;
            return ;
 
        }
 
        /// <summary>
        /// Свертка слова по 8-ми байтам
        /// </summary>
        /// <param name="b">массив байтов</param>
        /// <param name="p">позиция</param>
        /// <returns></returns>
        private static UInt64 BytesToUInt64
        {
            UInt64 r = 0;
            for 
            {
                r |= b;
                r <<= 8;
            }
            r |= b;
            return r;
        }
 
        /// <summary>
        /// Развертка слова по 8-ми байтам
        /// </summary>
        /// <param name="a">64-битное слово</param>
        /// <param name="b">массив байтов</param>
        /// <param name="p">позиция</param>
        private static void UInt64ToBytes
        {
            for 
            {
                b = ;
                a >>= 8;
            }
            b = ;
        }
 
        /// <summary>
        /// Операция шифрования
        /// </summary>
        /// <param name="inBuf">входной буфер для шифруемых данных</param>
        /// <param name="outBuf">выходной буфер</param>
        public void Cipher
        {
            UInt64 a = BytesToUInt64;
            UInt64 b = BytesToUInt64;
 
            a = a + S;
            b = b + S;
 
            for 
            {
                a = ROL, b) + S;
                b = ROL, a) + S;
            }
 
            UInt64ToBytes;
            UInt64ToBytes;
        }
 
        /// <summary>
        /// Операция расшифрования
        /// </summary>
        /// <param name="inBuf">входной буфер для шифруемых данных</param>
        /// <param name="outBuf">выходной буфер</param>
        public void Decipher
        {
            UInt64 a = BytesToUInt64;
            UInt64 b = BytesToUInt64;
 
            for 
            {
                b = ROR, a) ^ a;
                a = ROR, b) ^ b;
            }
 
            b = b - S;
            a = a - S;
 
            UInt64ToBytes;
            UInt64ToBytes;
        }
    }
}