Question

我正在执行此应用程序，它取决于存储在xml文件中的设置。此文件应加密，其中的值由负责创建应用程序设置的人员提供，用于根据用户安装的版本确定可用的功能选项。

我需要一种方法来在我的软件中存储硬编码的密码，以便能够在运行时解密该文件并读取其中的值以查看用户可以访问的应用程序的哪些功能。

请记住，不应编辑此文件，并将其作为软件的一部分提供。

我没有提供任何代码，因为它更多的是设计问题，而不是编码问题。

我知道对密码进行硬编码是愚蠢的，但我没有选择。

Answer 1

如果您将应用程序提供给不值得信任的用户（即这是一个桌面应用程序，而不是用户无法直接访问的[ASP]服务器上运行的代码）那么您无能为力。

如果您要将代码提供给将解密配置文件的用户，则在某些时候，他们将能够自己访问该文件。如果你投入时间/精力/金钱，你可能会变得更难，甚至可能更难，但你不能让它变得不可能。以下是他们可以做的一些事情：

反编译您的程序并查找password = "12345"代码行。
监控程序的内存;看看它何时加载XML文件，并尝试在内存中找到它的解密版本。
找到您阅读解密的XML文件的代码部分，并相应地执行一些操作并更改代码，以便它始终执行任何他们想要的操作，而不管文件中的内容是什么（实际上只是注释掉if检查）。

为了使上述步骤更难（但并非不可能），您可以做的一些事情包括：

模糊代码。
签署您的代码。
做任意无意义的东西以试图混淆是代码嗅探器（例如通过拥有3个文件来播放shell游戏，全部读取它们，然后解密它们，然后实际使用它们中的2个。
将配置文件发送到您的Web服务进行解密，而不是在本地解密。（可以通过嗅探网络获取解密结果来解决这个问题。）
拥有一个您查询的Web服务，以查看用户是否有权执行您想要的操作（再次，这可以通过嗅探/欺骗网络连接来解决）。

现在，实际上可能会阻止用户做“某事”，具体取决于“某事物”是什么，而不是首先给他们提供代码。这些（可能;如果编码正确）是牢不可破的：

在服务器上完成工作
1. 拥有执行某些敏感工作的网络服务。桌面应用程序仅管理UI或其他非敏感任务。如果你这样做，用户只能破坏你给他们的代码。
2. 使整个应用程序成为一个网站，或其他基于服务器的应用程序（即想到MMORPGS），如果没有服务器，它根本不起作用;它几乎完成了所有敏感（和非敏感）工作。

请注意，唯一的 true 解决方案需要在使用应用程序时为所有用户提供互联网连接;他们无法离线。

Answer 2

internal const string XmlPassword = "This is more like security through "+
+"obfuscation than real security.  If it fits your purposes, cool, but you "+
+"might want to consider using real encryption, like public key encryption";

Answer 3

一种方法是始终根据文件的某些散列加密设置文件。然后，您的软件可以使用与密钥相同的哈希来解密文件。

所以你基本上会做以下事情：

获取文件名（和/或文件的某些其他属性 - 大小，或许）
计算文件名的哈希值
使用该哈希来解密文件

不是说这是一种很好的方法，也不是我个人在任何类型的制作软件中使用的方法，但至少你不依赖于代码中的明文或带有字符串的字符串，它可以让你灵活地改变设置文件名并依赖于加密约定。

同样，这可能只是“存储源中的密钥”解决方案的一步。

Answer 4

如果我正在阅读问题 - OP需要使用某种类型的第三方软件包解密提供的文件（已加密），并且他已从软件的原始发布者处获得了解密密码（密钥）

我会做类似于它的建议，只是代替加密文件，加密提供的密码，将加密的密码存储在配置文件中，然后在运行时读取和解密密码，并用它来解密文件

这样，您就不会在源代码中硬编码明文密码，以便轻松嗅出。通过将其保存在配置文件中，您可以在将来根据需要轻松更改它。

回答评论：

我使用AES256。

我将此类用于AES256加密/解密：

#region Preprocessor Directives

# if __FRAMEWORK_V35 || __FRAMEWORK_V4
#define __DotNet35Plus
#endif

#if !__DotNet35Plus
#warning AES implementation used by this compile of the library is not NIST certified as FIPS 140-2 compliant
#endif

#endregion

#region Namespaces
using System;
using System.Security.Cryptography;
using System.IO;
using System.Text;
using System.Threading;
using System.Runtime.Serialization.Formatters.Binary;
#endregion

namespace Simple
{
    public static class AES256Encryption
    {
        private static readonly object _lock = new object();
        private const Int32 KeySize = 256;
#if __DotNet35Plus
        private static AesCryptoServiceProvider thisCSP = new AesCryptoServiceProvider();
#else
        private static RijndaelManaged thisCSP = new RijndaelManaged();
#endif
        private static MemoryStream msEncrypt = new MemoryStream();
        private static CryptoStream csEncrypt;
        private static MemoryStream msDecrypt = new MemoryStream();
        private static CryptoStream csDecrypt;

        public enum stringIOType
        {
            base64EncodedString = 0,
            HexEncodedString = 1
        }

        public static bool NISTCertified()
        {
#if __DotNet35Plus
            return true;
#else
            return false;
#endif
        }

        #region Encryption Methods
        public static byte[] encryptBytes(byte[] Value, string PassPhrase, Encoding PassPhraseEncoding)
        {
            try
            {
                Monitor.Enter(_lock);
                return encryptBytes(Value, getKeyFromPassPhrase(PassPhrase, PassPhraseEncoding), getIVFromPassPhrase(PassPhrase, PassPhraseEncoding));
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static byte[] encryptBytes(byte[] Value, byte[] Key, byte[] IV)
        {
            try
            {
                Monitor.Enter(_lock);
#if __DotNet35Plus
                thisCSP = new AesCryptoServiceProvider();
#else
                thisCSP = new RijndaelManaged();
#endif
                thisCSP.KeySize = KeySize;
                Int32 bitLength = Key.Length * 8;
                if (bitLength != thisCSP.KeySize)
                {
                    throw new ArgumentException("The supplied key's length [" + bitLength.ToString() + " bits] is not a valid key size for the AES-256 algorithm.", "Key");
                }
                bitLength = IV.Length * 8;
                if (bitLength != thisCSP.BlockSize)
                {
                    throw new ArgumentException("The supplied IV's length [" + bitLength.ToString() + " bits] is not a valid IV size for the AES-256 algorithm.", "IV");
                }
                ICryptoTransform Encryptor = thisCSP.CreateEncryptor(Key, IV);
                msEncrypt = new MemoryStream();
                csEncrypt = new CryptoStream(msEncrypt, Encryptor, CryptoStreamMode.Write);
                csEncrypt.Write(Value, 0, Value.Length);
                csEncrypt.FlushFinalBlock();
                Encryptor.Dispose();
                Encryptor = null;
                msEncrypt.Close();
                return msEncrypt.ToArray();
            }
            finally
            {
                thisCSP = null;
                Monitor.Exit(_lock);
            }
        }

        public static string encryptString(string Value, string PassPhrase, Encoding PassPhraseEncoding, Encoding inputEncoding, stringIOType outputType)
        {
            try
            {
                Monitor.Enter(_lock);
                return encryptString(Value, getKeyFromPassPhrase(PassPhrase, PassPhraseEncoding), getIVFromPassPhrase(PassPhrase, PassPhraseEncoding), inputEncoding, outputType);
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static string encryptString(string Value, byte[] Key, byte[] IV, Encoding inputEncoding, stringIOType outputType)
        {
            try
            {
                Monitor.Enter(_lock);
                byte[] baseValue = (byte[])Array.CreateInstance(typeof(byte), inputEncoding.GetByteCount(Value));
                baseValue = inputEncoding.GetBytes(Value);
                switch(outputType)
                {
                    case stringIOType.base64EncodedString:
                        return Convert.ToBase64String(encryptBytes(baseValue, Key, IV));
                    case stringIOType.HexEncodedString:
                        return ByteArrayToHexString(encryptBytes(baseValue, Key, IV));
                    default:
                        return Convert.ToBase64String(encryptBytes(baseValue, Key, IV));
                }
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }
        #endregion

        #region Decryption Methods
        public static byte[] decryptBytes(byte[] Value, string PassPhrase, Encoding PassPhraseEncoding)
        {
            try
            {
                Monitor.Enter(_lock);
                return decryptBytes(Value, getKeyFromPassPhrase(PassPhrase, PassPhraseEncoding), getIVFromPassPhrase(PassPhrase, PassPhraseEncoding));
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static byte[] decryptBytes(byte[] Value, byte[] Key, byte[] IV)
        {
            try
            {
                Monitor.Enter(_lock);
#if __DotNet35Plus
                thisCSP = new AesCryptoServiceProvider();
#else
                thisCSP = new RijndaelManaged();
#endif
                thisCSP.KeySize = KeySize;
                Int32 bitLength = Key.Length * 8;
                if (bitLength != thisCSP.KeySize)
                {
                    throw new ArgumentException("The supplied key's length [" + bitLength.ToString() + " bits] is not a valid key size for the AES-256 algorithm.", "Key");
                }
                bitLength = IV.Length * 8;
                if (bitLength != thisCSP.BlockSize)
                {
                    throw new ArgumentException("The supplied IV's length [" + bitLength.ToString() + " bits] is not a valid IV size for the AES-256 algorithm.", "IV");
                }
                try
                {
                    byte[] Decrypted;
                    ICryptoTransform Decryptor = thisCSP.CreateDecryptor(Key, IV);
                    msDecrypt = new MemoryStream(Value);
                    csDecrypt = new CryptoStream(msDecrypt, Decryptor, CryptoStreamMode.Read);
                    Decrypted = (byte[])Array.CreateInstance(typeof(byte), msDecrypt.Length);
                    csDecrypt.Read(Decrypted, 0, Decrypted.Length);
                    Decryptor.Dispose();
                    Decryptor = null;
                    msDecrypt.Close();
                    Int32 trimCount = 0;
                    // Remove any block padding left over from encryption algorithm before returning
                    for (Int32 i = Decrypted.Length - 1; i >= 0; i--)
                    {
                        if (Decrypted[i] == 0) { trimCount++; } else { break; }
                    }
                    if (trimCount > 0)
                    {
                        byte[] buffer = (byte[])Array.CreateInstance(typeof(byte), Decrypted.Length - trimCount);
                        Array.ConstrainedCopy(Decrypted, 0, buffer, 0, buffer.Length);
                        Array.Clear(Decrypted, 0, Decrypted.Length);
                        Array.Resize<byte>(ref Decrypted, buffer.Length);
                        Array.Copy(buffer, Decrypted, buffer.Length);
                        buffer = null;
                    }
                    return Decrypted;
                }
                finally
                {
                    thisCSP = null;
                }
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static string decryptString(string Value, string PassPhrase, Encoding PassPhraseEncoding, stringIOType inputType, Encoding outputEncoding)
        {
            try
            {
                Monitor.Enter(_lock);
                return decryptString(Value, getKeyFromPassPhrase(PassPhrase, PassPhraseEncoding), getIVFromPassPhrase(PassPhrase, PassPhraseEncoding), inputType, outputEncoding);
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static string decryptString(string Value, byte[] Key, byte[] IV, stringIOType inputType, Encoding outputEncoding)
        {
            try
            {
                Monitor.Enter(_lock);
                byte[] baseValue;
                switch (inputType)
                {
                    case stringIOType.base64EncodedString:
                        baseValue = Convert.FromBase64String(Value);
                        break;
                    case stringIOType.HexEncodedString:
                        baseValue = HexStringToByteArray(Value);
                        break;
                    default:
                        baseValue = Convert.FromBase64String(Value);
                        break;
                }
                return outputEncoding.GetString(decryptBytes(baseValue, Key, IV));
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }
        #endregion

        #region Key/Digest Generation Methods
        public static byte[] getKeyFromPassPhrase(string PassPhrase, Encoding encoder)
        {
            Monitor.Enter(_lock);
            try
            {
                return getDigest(PassPhrase, encoder, 32);
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static byte[] getIVFromPassPhrase(string PassPhrase, Encoding encoder)
        {
            Monitor.Enter(_lock);
            try
            {
                byte[] buffer = (byte[])Array.CreateInstance(typeof(byte), encoder.GetByteCount(PassPhrase));
                byte[] reverseBuffer = (byte[])Array.CreateInstance(typeof(byte), encoder.GetByteCount(PassPhrase));
                buffer = encoder.GetBytes(PassPhrase);
                for (Int32 i = 0; i <= buffer.Length - 1; i++)
                {
                    reverseBuffer[i] = buffer[buffer.Length - i - 1];
                }
                return getDigest(reverseBuffer, 16);
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static byte[] getDigest(string value, Encoding encoder, Int32 digestLength)
        {
            Monitor.Enter(_lock);
            try
            {
                return getDigest(encoder.GetBytes(value), digestLength);
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static byte[] getDigest(object value, Int32 digestLength)
        {
            Monitor.Enter(_lock);
            try
            {
                BinaryFormatter bf = new BinaryFormatter();
                MemoryStream ms = new MemoryStream();
                bf.Serialize(ms, value);
                return getDigest(ms.ToArray(), digestLength);
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static byte[] getDigest(byte[] value, Int32 digestLength)
        {
            Monitor.Enter(_lock);
            try
            {
                Int32 iterations = 0;
                // Find first non-zero byte value to use to calculate iterations
                for (Int32 i = 0; i < value.Length; i++)
                {
                    if (value[i] != 0) { iterations = (Int32)(value[i] * 10); break; }
                }
                // There were no non-zero byte values use the max for iterations
                if (iterations == 0) { iterations = (Int32)(byte.MaxValue * 10); }
                Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(value, new SHA256Managed().ComputeHash(value), iterations);
                return deriveBytes.GetBytes(digestLength);
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }
        #endregion

        #region HexArray/String String/HexArray Converters
        public static string ByteArrayToHexString(byte[] ba)
        {
            try
            {
                Monitor.Enter(_lock);
                StringBuilder hex = new StringBuilder(ba.Length * 2);
                foreach (byte b in ba)
                    hex.AppendFormat("{0:x2}", b);
                return hex.ToString();
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }

        public static byte[] HexStringToByteArray(String hex)
        {
            try
            {
                Monitor.Enter(_lock);
                int NumberChars = hex.Length;
                byte[] bytes = new byte[NumberChars / 2];
                for (int i = 0; i < NumberChars; i += 2)
                    bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
                return bytes;
            }
            finally
            {
                Monitor.Exit(_lock);
            }
        }
        #endregion
    }
}

如果您使用的是.Net Framework 3.5或4.0，则将__FRAMEWORK_V35或__FRAMEWORK_V40定义为预处理器的值。使用的类不适用于小于3.5的框架版本。如果您使用的是早期的框架版本，则不要定义预处理器值，并且将使用较早的类。

首先获取文件的名称。

然后使用以下内容加密OEM密码（我建议编写一个小工具来执行此操作）：

string fileName = "Whatever The Filename is";
string password = "Whatever the OEM supplied password is";
string encryptedValue = Simple.AES256Encryption.encryptString(password, fileName, new UTF8Encoding(), new UTF8Encoding(), stringIOType.base64EncodedString);

将生成的base64编码字符串从encryptString保存到配置文件中。

要恢复OEM密码：

string encryptedPassword = "This is the base64 encoded string you read from your config file";
string decrytptedPassword = Simple.AES256Encryption.decryptString(encryptedPassword, fileName, new UTF8Encoding(), stringIOType.base64EncodedString, new UTF8Encoding());

需要硬编码密码

4 个答案: