TripleDES: указанный ключ является известным слабым ключом для TripleDES и не может использоваться

Вместо использования MACTripleDES с повторяющимся ключом DES для подделки одного DES CBC-MAC вы можете просто реализовать CBC-MAC самостоятельно поверх DESCryptoServiceProvider.

‹1111111111111111> не является слабым ключом DES.

Это рассчитает DES CBC-MAC:

public static byte[] CalcDesMac(byte[] key, byte[] data){
        DESCryptoServiceProvider des = new DESCryptoServiceProvider();
        des.Key = key;
        des.IV = new byte[8];
        des.Padding = PaddingMode.Zeros;
        MemoryStream ms = new MemoryStream();
        using(CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write)){
          cs.Write(data, 0, data.Length);
        }
        byte[] encryption = ms.ToArray();
        byte[] mac = new byte[8];
        Array.Copy(encryption, encryption.Length-8, mac, 0, 8);
        PrintByteArray(encryption);
        return mac;
    }

Я бы не рекомендовал это, но вы должны иметь возможность модифицировать IL-код, который проверяет слабые ключи, используя Reflector и надстройка ReflexIL

редактировать:

Извините, мне потребовалось некоторое время, чтобы загрузить все это в мою виртуальную машину (под управлением Ubuntu), и я не хотел связываться с Mono.

• Установите надстройку ReflexIL: Вид -> Надстройки -> Добавить
• Откройте ReflexIL: Инструменты -> ReflexIL v0.9
• Найдите функцию IsWeakKey(). (Вы можете использовать поиск: F3)
• Появятся две функции, дважды щелкните ту, что находится в System.Security.Cryptography.TripleDES.
• ReflexIL тоже должен был подойти. На вкладке «Инструкции» прокрутите до строки 29 (смещение 63).
• Измените ldc.i4.1 на ldc.i4.0, это означает, что функция всегда будет возвращать false.

На панели сборок (слева) теперь вы можете прокрутить вверх и щелкнуть Common Language Runtime Library, панель ReflexIL предоставит вам возможность сохранить ее.

Важные заметки:

• Сначала сделайте резервную копию своей оригинальной сборки! (mscorlib.dll)
• mscorlib.dll — это подписанная сборка, и вам понадобится .NET SDK (инструмент sn.exe) для ReflexIL, чтобы пропустить проверку. Я только что проверил это сам, у вас уже должно быть это с установленным Visual C#. Просто нажмите Зарегистрировать для пропуска проверки (на этом компьютере), когда вас попросят.
• Я не думаю, что должен говорить вам, чтобы вы использовали это только на своей машине разработки :)

Удачи! Если вам нужны дополнительные инструкции, пожалуйста, не стесняйтесь использовать поле для комментариев.

редактировать2:

Я смущен!

Я узнал, что тебе нужно сделать. К счастью, есть доступный метод, который создает ICryptoTranforms, который не проверяет наличие слабых ключей. Вам также нужно следить за базовым классом, поскольку он также выполняет проверки работоспособности. С помощью рефлексии просто вызовите метод _NewEncryptor (вам нужно немного больше рефлексии, но идея в этом).

К счастью, MACTripleDES имеет поле типа TripleDES, так что выведите его из MACTripleDES и замените его путем отражения в конструкторах. Я сделал всю работу за вас.

Я не могу убедиться, что сгенерирован правильный MAC-адрес, но исключения не выдаются. Кроме того, вы можете захотеть прокомментировать код и выполнить обработку исключений (ошибки отражения - например, если полей/методов нет) - но это ТАК; так что я не заморачивался.

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

namespace DesHack
{
    class Program
    {
        static void Main(string[] args)
        {
            byte[] key = new byte[24];
            for (int i = 0; i < key.Length; i++)
                key[i] = 0x11;

            byte[] data = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
            byte[] computedMac = null;
            using (MACTripleDES mac = new MACTripleDESHack(key))
            {
                computedMac = mac.ComputeHash(data);
            }
        }
    }

    class MACTripleDESHack : MACTripleDES
    {
        TripleDES _desHack = new DesHack();

        static FieldInfo _cspField = typeof(MACTripleDES).GetField("des", BindingFlags.Instance | BindingFlags.NonPublic);

        public MACTripleDESHack()
            : base()
        {
            RewireDes();
        }

        public MACTripleDESHack(byte[] rgbKey)
            : base(rgbKey)
        {
            RewireDes();
        }

        private void RewireDes()
        {
            _cspField.SetValue(this, _desHack);
        }

    }

    class DesHack : TripleDES
    {
        TripleDESCryptoServiceProvider _backing = new TripleDESCryptoServiceProvider();

        static MethodInfo _newEncryptor;
        static object _encrypt;
        static object _decrypt;

        public override int BlockSize
        {
            get
            {
                return _backing.BlockSize;
            }
            set
            {
                _backing.BlockSize = value;
            }
        }

        public override int FeedbackSize
        {
            get
            {
                return _backing.FeedbackSize;
            }
            set
            {
                _backing.FeedbackSize = value;
            }
        }

        // For these two we ALSO need to avoid
        // the base class - it also checks
        // for weak keys.
        private byte[] _iv;
        public override byte[] IV
        {
            get
            {
                return _iv;
            }
            set
            {
                _iv = value;
            }
        }

        private byte[] _key;
        public override byte[] Key
        {
            get
            {
                return _key;
            }
            set
            {
                _key = value;
            }
        }

        public override int KeySize
        {
            get
            {
                return _backing.KeySize;
            }
            set
            {
                _backing.KeySize = value;
            }
        }

        public override KeySizes[] LegalBlockSizes
        {
            get
            {
                return _backing.LegalBlockSizes;
            }
        }

        public override KeySizes[] LegalKeySizes
        {
            get
            {
                return _backing.LegalKeySizes;
            }
        }

        public override CipherMode Mode
        {
            get
            {
                return _backing.Mode;
            }
            set
            {
                _backing.Mode = value;
            }
        }

        public override PaddingMode Padding
        {
            get
            {
                return _backing.Padding;
            }
            set
            {
                _backing.Padding = value;
            }
        }


        static DesHack()
        {
            _encrypt = typeof(object).Assembly.GetType("System.Security.Cryptography.CryptoAPITransformMode").GetField("Encrypt").GetValue(null);
            _decrypt = typeof(object).Assembly.GetType("System.Security.Cryptography.CryptoAPITransformMode").GetField("Decrypt").GetValue(null);
            _newEncryptor = typeof(TripleDESCryptoServiceProvider).GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
        }

        public DesHack()
        {            
        }

        public override ICryptoTransform CreateDecryptor()
        {
            return CreateDecryptor(_key, _iv);
        }

        public override ICryptoTransform CreateEncryptor()
        {
            return CreateEncryptor(_key, _iv);
        }

        public override ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgbIV)
        {
            // return this._NewEncryptor(rgbKey, base.ModeValue, rgbIV, base.FeedbackSizeValue, CryptoAPITransformMode.Decrypt);
            return (ICryptoTransform) _newEncryptor.Invoke(_backing,
                new object[] { rgbKey, ModeValue, rgbIV, FeedbackSizeValue, _decrypt });
        }

        public override ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgbIV)
        {
            // return this._NewEncryptor(rgbKey, base.ModeValue, rgbIV, base.FeedbackSizeValue, CryptoAPITransformMode.Encrypt);
            return (ICryptoTransform) _newEncryptor.Invoke(_backing,
                new object[] { rgbKey, ModeValue, rgbIV, FeedbackSizeValue, _encrypt });
        }

        public override void GenerateIV()
        {
            _backing.GenerateIV();
        }

        public override void GenerateKey()
        {
            _backing.GenerateKey();
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
                ((IDisposable) _backing).Dispose();
            base.Dispose(disposing);
        }
    }
}

К сожалению, поведение нельзя переопределить.

Есть отличное предложение по использованию отражение на форумах MSDN

Я не эксперт по безопасности, но разве XOR вашего ключа с другим значением не будет достаточным для проверки работоспособности? Вы можете сделать это для своей отладочной версии (с правильным IFDEF), чтобы вы могли правильно проверить и удалить ее для своей версии выпуска или рабочей версии, где ключ будет достаточно сильным.

Решения, основанные на отражении, помогают обойти проблему, но они грязные и злые. Еще никто не упомянул очень полезный метод: TripleDES.IsWeakKey

У меня была эта проблема, и я решил ее с помощью очень простой утилиты, которую я использую непосредственно перед тем, как установить ключ в моем CryptoServiceProvider:

private void MakeSecureKey(byte[] key)
{
    while(TripleDES.IsWeakKey(key))
    {
        var sha = SHA256Managed.Create().ComputeHash(key);
        Array.Copy(sha,key,key.Length);
    }
}

Если вы вызываете его в любое время, когда создаете шифратор или дешифратор, он должен предотвратить сбой и всегда давать вам безопасный ключ.

Довольно просто (после просмотра кода с GitHub)

статическое логическое значение TripleDES.IsWeakKey (Byte [] rgbKey)

Так как он статичен - легко проверить свой ключ на нем.

1. Размер должен быть либо 16, либо 24 байта (???) Почему нельзя указать в документации
2. Проверка кода на несколько простых повторений Просто создайте достаточное количество случайных значений

См. код по адресу: https://github.com/mono/mono/blob/master/mcs/class/corlib/System.Security.Cryptography/TripleDES.cs

Декель