用VB.NET实现ASP.NET中的AES

关于使用AES加密URL链接以使用VB.NET 2005在ASP.NET中将用户名传递到另一个网站的好链接或文章是什么？ 仅供参考：接收网站将有权访问私钥进行解密。

指出Rijndael使用AES加密算法。由于托管实现随.net framework一起提供（并且至少从1.1开始提供），因此使用它应该满足OP

我们有一个非常简单的例子，使用Rijndael作为加密和解密流

如果你有办法将共享秘密（例如私钥）传送到另一个网站，那么你可能可以使用普通的老式对称加密（没有公钥，双方都知道IV和私钥）。如果您的大脑是共享密钥的“不安全通道”（例如，您管理两个网站），则情况尤其如此：）

看一看。AES实现 不随.NET framework一起提供 但它链接到一个自定义 实现（AES.exe）

:

---

下面您将找到一个类，该类提供AES加密/解密方法，该方法显式提供URL友好字符串，以便在像您这样的应用程序中使用。它还有处理字节数组的方法

注意：您应该在键数组和向量数组中使用不同的值！你不会希望有人通过假设你按原样使用这段代码来找出你的密钥！你所要做的就是改变一些数字（必须是第一个） 不要这样做！编写自己的密码系统很容易导致出错。最好使用现有的系统，如果没有，请找懂密码的人来做。如果必须自己做，请阅读

请记住：“我们已经有了足够快、不安全的系统。”（Bruce Schneier）——做正确的事情，以后再担心性能

也就是说，如果你坚持使用AES来实现自己的目标，这里有一些建议

初始化向量 AES是一种分组密码。给定一个密钥和一块明文，它会将其转换为特定的密文。问题是，相同的数据块每次都会生成具有相同密钥的相同密文。因此，假设您发送的数据如下：

用户=加密（用户名）&角色=加密（用户角色）

它们是两个独立的块，UserRoles加密每次都有相同的密文，不管名称如何。我所需要的只是管理员的密文，我可以将它与我的密码用户名一起输入。哎呀

就是这样。主要的想法是你将一个块的密文，并将其XOR到下一个块的密文中。这样我们将进行加密（UserRoles，Username），Username密文受UserRoles的影响

问题是，第一个块仍然容易受到攻击-仅通过查看某人的密文，我可能知道他们的角色。输入。IV“启动”密码并确保其具有随机数据来加密流的其余部分。因此，现在UserRoles ciphertext具有随机IV XOR的密文。问题已解决

因此，请确保为每条消息生成一个随机IV。IV不敏感，可以用密文以明文发送。请使用足够大的IV——在许多情况下，块的大小应该合适

诚实正直 AES不提供完整性功能。任何人都可以修改您的密文，解密仍然有效。一般来说，它不太可能是有效数据，但可能很难知道有效数据是什么。例如，如果您传输的是加密的GUID，则很容易修改某些位并生成完全不同的位。这可能会导致d到应用程序错误等

修复方法是在明文上运行散列算法（使用SHA256或SHA512），并将其包含在您传输的数据中。因此，如果我的消息是（用户名，角色），您将发送（用户名，角色，散列（用户名，角色））.现在，如果有人通过翻转一点来篡改密文，哈希将不再计算，您可以拒绝该消息

导出密钥 如果需要从密码生成密钥，请使用内置类：。这提供了salt和迭代，可以提高派生密钥的强度，并减少在密钥受损时发现密码的机会

计时/重播 编辑：很抱歉之前没有提到这一点：p.你还需要确保你有一个反重播系统。如果你只是对消息进行加密并传递，任何收到消息的人都可以重新发送它。为了避免这种情况，你应该在消息中添加一个时间戳。如果时间戳与某个阈值不同，则拒绝该消息。你可以ay还希望包含一个一次性ID（这可能是IV），并拒绝来自使用相同ID的其他IP的时间有效消息

确保在包含计时信息时进行哈希验证是很重要的。否则，如果您没有检测到这种暴力尝试，可能会有人篡改一点密文并生成有效的时间戳

示例代码 由于显然正确使用IV对一些人来说是有争议的，这里有一些代码可以生成随机IV并将它们添加到您的输出中。它还将执行身份验证步骤，确保加密的数据没有被修改

using System;
using System.Security.Cryptography;
using System.Text;

class AesDemo {

    const int HASH_SIZE = 32; //SHA256

    /// <summary>Performs encryption with random IV (prepended to output), and includes hash of plaintext for verification.</summary>
    public static byte[] Encrypt(string password, byte[] passwordSalt, byte[] plainText) {
        // Construct message with hash
        var msg = new byte[HASH_SIZE + plainText.Length];
        var hash = computeHash(plainText, 0, plainText.Length);
        Buffer.BlockCopy(hash, 0, msg, 0, HASH_SIZE);
        Buffer.BlockCopy(plainText, 0, msg, HASH_SIZE, plainText.Length);

        // Encrypt
        using (var aes = createAes(password, passwordSalt)) {
            aes.GenerateIV();
            using (var enc = aes.CreateEncryptor()) {

                var encBytes = enc.TransformFinalBlock(msg, 0, msg.Length);
                // Prepend IV to result
                var res = new byte[aes.IV.Length + encBytes.Length];
                Buffer.BlockCopy(aes.IV, 0, res, 0, aes.IV.Length);
                Buffer.BlockCopy(encBytes, 0, res, aes.IV.Length, encBytes.Length);
                return res;
            }
        }
    }

    public static byte[] Decrypt(string password, byte[] passwordSalt, byte[] cipherText) {
        using (var aes = createAes(password, passwordSalt)) {
            var iv = new byte[aes.IV.Length];
            Buffer.BlockCopy(cipherText, 0, iv, 0, iv.Length);
            aes.IV = iv; // Probably could copy right to the byte array, but that's not guaranteed

            using (var dec = aes.CreateDecryptor()) {
                var decBytes = dec.TransformFinalBlock(cipherText, iv.Length, cipherText.Length - iv.Length);

                // Verify hash
                var hash = computeHash(decBytes, HASH_SIZE, decBytes.Length - HASH_SIZE);
                var existingHash = new byte[HASH_SIZE];
                Buffer.BlockCopy(decBytes, 0, existingHash, 0, HASH_SIZE);
                if (!compareBytes(existingHash, hash)){
                    throw new CryptographicException("Message hash incorrect.");
                }

                // Hash is valid, we're done
                var res = new byte[decBytes.Length - HASH_SIZE];
                Buffer.BlockCopy(decBytes, HASH_SIZE, res, 0, res.Length);
                return res;
            }
        }
    }

    static bool compareBytes(byte[] a1, byte[] a2) {
        if (a1.Length != a2.Length) return false;
        for (int i = 0; i < a1.Length; i++) {
            if (a1[i] != a2[i]) return false;
        }
        return true;
    }

    static Aes createAes(string password, byte[] salt) {
        // Salt may not be needed if password is safe
        if (password.Length < 8) throw new ArgumentException("Password must be at least 8 characters.", "password");
        if (salt.Length < 8) throw new ArgumentException("Salt must be at least 8 bytes.", "salt");
        var pdb = new PasswordDeriveBytes(password, salt, "SHA512", 129);
        var key = pdb.GetBytes(16);

        var aes = Aes.Create();
        aes.Mode = CipherMode.CBC;
        aes.Key = pdb.GetBytes(aes.KeySize / 8);
        return aes;
    }

    static byte[] computeHash(byte[] data, int offset, int count) {
        using (var sha = SHA256.Create()) {
            return sha.ComputeHash(data, offset, count);
        }
    }

    public static void Main() {
        var password = "1234567890!";
        var salt = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
        var ct1 = Encrypt(password, salt, Encoding.UTF8.GetBytes("Alice; Bob; Eve;: PerformAct1"));
        Console.WriteLine(Convert.ToBase64String(ct1));
        var ct2 = Encrypt(password, salt, Encoding.UTF8.GetBytes("Alice; Bob; Eve;: PerformAct2"));
        Console.WriteLine(Convert.ToBase64String(ct2));

        var pt1 = Decrypt(password, salt, ct1);
        Console.WriteLine(Encoding.UTF8.GetString(pt1));
        var pt2 = Decrypt(password, salt, ct2);
        Console.WriteLine(Encoding.UTF8.GetString(pt2));

        // Now check tampering
        try {
            ct1[30]++;
            Decrypt(password, salt, ct1);
            Console.WriteLine("Error: tamper detection failed.");
        } catch (Exception ex) {
            Console.WriteLine("Success: tampering detected.");
            Console.WriteLine(ex.ToString());
        }
    }
}

使用系统；
使用System.Security.Cryptography；
使用系统文本；
类AesDemo{
const int HASH_SIZE=32；//SHA256
///使用random IV（在输出之前）执行加密，并包括用于验证的明文散列。
公共静态字节[]加密（字符串密码、字节[]密码、字节[]明文）{
//用散列构造消息
var msg=新字节[HASH_SIZE+明文.Length]；
var hash=computeHash（明文，0，明文.Length）；
块拷贝（散列，0，消息，0，散列大小）；
Buffer.BlockCopy（纯文本、0、消息、散列）
using System;
using System.Security.Cryptography;
using System.Text;

class AesDemo {

    const int HASH_SIZE = 32; //SHA256

    /// <summary>Performs encryption with random IV (prepended to output), and includes hash of plaintext for verification.</summary>
    public static byte[] Encrypt(string password, byte[] passwordSalt, byte[] plainText) {
        // Construct message with hash
        var msg = new byte[HASH_SIZE + plainText.Length];
        var hash = computeHash(plainText, 0, plainText.Length);
        Buffer.BlockCopy(hash, 0, msg, 0, HASH_SIZE);
        Buffer.BlockCopy(plainText, 0, msg, HASH_SIZE, plainText.Length);

        // Encrypt
        using (var aes = createAes(password, passwordSalt)) {
            aes.GenerateIV();
            using (var enc = aes.CreateEncryptor()) {

                var encBytes = enc.TransformFinalBlock(msg, 0, msg.Length);
                // Prepend IV to result
                var res = new byte[aes.IV.Length + encBytes.Length];
                Buffer.BlockCopy(aes.IV, 0, res, 0, aes.IV.Length);
                Buffer.BlockCopy(encBytes, 0, res, aes.IV.Length, encBytes.Length);
                return res;
            }
        }
    }

    public static byte[] Decrypt(string password, byte[] passwordSalt, byte[] cipherText) {
        using (var aes = createAes(password, passwordSalt)) {
            var iv = new byte[aes.IV.Length];
            Buffer.BlockCopy(cipherText, 0, iv, 0, iv.Length);
            aes.IV = iv; // Probably could copy right to the byte array, but that's not guaranteed

            using (var dec = aes.CreateDecryptor()) {
                var decBytes = dec.TransformFinalBlock(cipherText, iv.Length, cipherText.Length - iv.Length);

                // Verify hash
                var hash = computeHash(decBytes, HASH_SIZE, decBytes.Length - HASH_SIZE);
                var existingHash = new byte[HASH_SIZE];
                Buffer.BlockCopy(decBytes, 0, existingHash, 0, HASH_SIZE);
                if (!compareBytes(existingHash, hash)){
                    throw new CryptographicException("Message hash incorrect.");
                }

                // Hash is valid, we're done
                var res = new byte[decBytes.Length - HASH_SIZE];
                Buffer.BlockCopy(decBytes, HASH_SIZE, res, 0, res.Length);
                return res;
            }
        }
    }

    static bool compareBytes(byte[] a1, byte[] a2) {
        if (a1.Length != a2.Length) return false;
        for (int i = 0; i < a1.Length; i++) {
            if (a1[i] != a2[i]) return false;
        }
        return true;
    }

    static Aes createAes(string password, byte[] salt) {
        // Salt may not be needed if password is safe
        if (password.Length < 8) throw new ArgumentException("Password must be at least 8 characters.", "password");
        if (salt.Length < 8) throw new ArgumentException("Salt must be at least 8 bytes.", "salt");
        var pdb = new PasswordDeriveBytes(password, salt, "SHA512", 129);
        var key = pdb.GetBytes(16);

        var aes = Aes.Create();
        aes.Mode = CipherMode.CBC;
        aes.Key = pdb.GetBytes(aes.KeySize / 8);
        return aes;
    }

    static byte[] computeHash(byte[] data, int offset, int count) {
        using (var sha = SHA256.Create()) {
            return sha.ComputeHash(data, offset, count);
        }
    }

    public static void Main() {
        var password = "1234567890!";
        var salt = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
        var ct1 = Encrypt(password, salt, Encoding.UTF8.GetBytes("Alice; Bob; Eve;: PerformAct1"));
        Console.WriteLine(Convert.ToBase64String(ct1));
        var ct2 = Encrypt(password, salt, Encoding.UTF8.GetBytes("Alice; Bob; Eve;: PerformAct2"));
        Console.WriteLine(Convert.ToBase64String(ct2));

        var pt1 = Decrypt(password, salt, ct1);
        Console.WriteLine(Encoding.UTF8.GetString(pt1));
        var pt2 = Decrypt(password, salt, ct2);
        Console.WriteLine(Encoding.UTF8.GetString(pt2));

        // Now check tampering
        try {
            ct1[30]++;
            Decrypt(password, salt, ct1);
            Console.WriteLine("Error: tamper detection failed.");
        } catch (Exception ex) {
            Console.WriteLine("Success: tampering detected.");
            Console.WriteLine(ex.ToString());
        }
    }
}

public static void Main() {
    var buff = new byte[8];
    new Random().NextBytes(buff);
    var v = BitConverter.ToUInt64(buff, 0);
    Console.WriteLine("Value: " + v.ToString());
    Console.WriteLine("Value (bytes): " + BitConverter.ToString(BitConverter.GetBytes(v)));
    var aes = Aes.Create();
    aes.GenerateIV();
    aes.GenerateKey();
    var encBytes = aes.CreateEncryptor().TransformFinalBlock(BitConverter.GetBytes(v), 0, 8);
    Console.WriteLine("Encrypted: " + BitConverter.ToString(encBytes));
    var dec = aes.CreateDecryptor();
    Console.WriteLine("Decrypted: " + BitConverter.ToUInt64(dec.TransformFinalBlock(encBytes, 0, encBytes.Length), 0));
    for (int i = 0; i < 8; i++) {
        for (int x = 0; x < 250; x++) {
            encBytes[i]++;
            try {
                Console.WriteLine("Attacked: " + BitConverter.ToUInt64(dec.TransformFinalBlock(encBytes, 0, encBytes.Length), 0));
                return;
            } catch { }
        }
    }
}