三重 DES：指定的密钥是“TripleDES”的已知弱密钥，无法使用

StackOverflow https://stackoverflow.com/questions/744530

题

我正在使用 .NET 3.0 类 System.Security.Cryptography.MACTripleDES 类来生成 MAC 值。不幸的是，我正在使用使用“1111111111111111“（十六进制）作为单长度 DES 密钥。这 System.Security.Cryptography 库会对密钥进行一些健全性检查，如果您尝试使用加密弱密钥，则会返回异常。

例如：

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 MACTripleDES(key))
{
  computedMac = mac.ComputeHash(data);
}

抛出异常

System.Security.Cryptography.CryptographicException : Specified key is a known weak key for 'TripleDES' and cannot be used.

我知道这不是安全密钥。在生产过程中，该设备将闪烁新的安全密钥。同时，有什么办法可以抑制这个异常的抛出吗？也许是一个 app.config 或者注册表设置？

编辑：密钥实际上是 101010...由于算法强制奇校验。我不确定这对于 DES 算法是否通用，或者只是我所做的支付处理工作中的一个要求。

编辑2：下面 Daniel 的回答提供了一些有关黑客 .NET 的非常好的信息。不幸的是，我无法使用这种技术解决我的问题，但仍然有一些有趣的阅读内容。

有帮助吗？

解决方案

而不是使用反复假单DES CBC-MAC的DES密钥MACTripleDES的，你可以只实现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 代码 反射器 和插件 反射IL

编辑：

抱歉，我花了一段时间才将所有内容加载到我的虚拟机（运行 Ubuntu）中，并且不想弄乱 Mono。

  • 安装 ReflexIL 插件：查看 -> 加载项 -> 添加
  • 打开 ReflexIL：工具 -> ReflexIL v0.9
  • 找到 IsWeakKey() 函数。（您可以使用搜索：F3)
  • 将出现两个函数，双击 System.Security.Cryptography.TripleDES 中的函数
  • ReflexIL 也应该出现。在“说明”选项卡中，一直向下滚动到第 29 行（偏移 63）。
  • 将 ldc.i4.1 更改为 ldc.i4.0，这意味着该函数将始终返回 false。

在程序集窗格（左侧）中，您现在可以向上滚动并单击“公共语言运行时库”，ReflexIL 窗格将为您提供保存它的选项。

重要笔记：

  • 首先备份您的原始程序集！（mscorlib.dll）
  • mscorlib.dll 是一个已签名的程序集，您将需要 ReflexIL 的 .NET SDK（sn.exe 工具）来使其跳过验证。我刚刚自己检查过，您应该已经安装了 Visual C#。只需在要求时单击“注册它以跳过验证（在此计算机上）”即可。
  • 我认为我不必告诉您只在您的开发机器上使用它:)

祝你好运！如果您需要其他说明，请随时使用评论框。

编辑2：

我很困惑！

我从 mscorlib 程序集中的 set_Key 函数中完全删除了 IsWeakKey 检查。我绝对确定我修改了正确的函数，并且我做得正确。Reflector 的反汇编程序不再显示该检查。然而有趣的是，Visual C# 仍然抛出相同的异常。

这让我相信 mscorlib 一定仍然以某种方式缓存在某个地方。但是，将 mscorlib.dll 重命名为 mscorlib.dll_ 会导致 MSVC# 崩溃，因此它仍然必须依赖于原始 dll。

这是非常有趣的事情，但我想我已经到了我不知道发生了什么的地步，它根本没有任何意义！请参阅附图。:(

编辑3：

我注意到 Olly 与 mscoree、mscorsec 和 mscorwks 等程序集不同；mscorlib.dll 实际上并不位于：c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\

但相反，在一个看似不存在的位置：C：\ WINDOWS \ assembly \ NativeImages_v2.0.50727_32 \ mscorlib \ 6d667f19d687361886990f3ca0f49816 \ mscorlib.ni.dll

我想我在这里遗漏了一些东西:)将对此进行更多调查。

编辑4：

即使在修补了 IsWeakKey 中的所有内容并尝试删除和生成新的本机映像（x.你.dll）的 mscorlib.dll 使用“ngen.exe”，我得到了相同的异常。我必须指出，即使卸载本机 mscorlib 映像后，它仍在使用 mscorlib.ni.dll ...嗯。

我放弃。我希望有人能够回答到底发生了什么，因为我确实不知道。:)

我发现你需要做什么。幸运的是，有一种方法可以创建不检查弱密钥的 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 论坛中

我不是安全专家，但将您的密钥与另一个值进行异或不足以满足健全性检查吗？您可以为您的调试版本执行此操作（使用适当的 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上的代码后）

静态 bool TripleDES.IsWeakKey(Byte[] rgbKey)

由于它是静态的 - 很容易根据它测试您的密钥

  1. 大小必须是16或24个字节（???）为什么他们不能将其放在文档中
  2. 代码检查几个简单重复只需创建随机enuogh值

请参阅代码： https://github.com/mono/mono/blob/master/mcs/class/corlib/System.Security.Cryptography/TripleDES.cs

德克尔

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top