(转)使用Vernam(维尔南/弗纳姆)算法实现文件加密解密[C#]

原文：使用Vernam(维尔南/弗纳姆)算法实现文件加密解密[C#]

本文介绍如何通过Gilbert Sandford Vernam的算法实现一个简洁而又稳定的文件加密解密类。通过此类加密的数据是绝对无法在没有密钥的情况下被破解的。它的基本原理是，需要有一个需要加密的明文和一个随机生成的解密钥匙文件。然后使用这两个文件组合起来生成密文：(明文) 组合 (密钥) = 加密后的密文。
使用Vernam加密算法，经其处理的密钥可以拥有与待加密文件大小相同的密钥长度，而且输出文件的大小相比待加密文件无任何改变（精确到字节）。换言之，密钥文件越大，加密强度越高！举个例子，如果想加密一个5M的文件，那么密钥长度将高达40,000,000位，输出文件大小则仍为5M。前面的数字意味着即使是梦幻配置的个人电脑，想要在“有生之年”靠穷取法破解出密码，也是不可能完成的任务！待加密文件类型不限，密钥文件也可以是任何数据：应用程序、交换文件，或者音乐文件，甚至是您宠物的靓照，等等...

Vernam密码算法:
1、 现代密码体制的萌芽是Vernam加密方法。
2、Vernam密码是美国电话电报公司的Gilbert Vernam在1917年为电报通信设计的一种非常方便的密码，它在近代计算机和通信系统设计中得到了广泛应用。
3、Vernam密码的明文、密钥和密文均用二元数字序列表示。这是一种使用异或方法进行加密解密的方法。
4、要编制Vernam密码，只需先把明文和密钥表示成二元序列，再把它们按位模2相加，就可得到密文。
5、而解密只需把密文和密钥的二元序列按位模2相加便可得到明文。
6、开始时使用一个定长的密钥序列，这样产生的密文能形成有规律的反复，易被破译；后来采用的密钥与明文同长，且密钥序列只用一次，称为“一次一密体制”。

Vernam类：

using System;
using System.IO;

public class Vernam
{
/// <summary>
/// Encrypts a file by the Vernam-algorithm
/// </summary>
/// <param name="originalFile">
/// Name of the file to be encrypted. Data is read from this file.
/// </param>
/// <param name="encryptedFile">
/// Name of the encrypted file. The encrypted data gets written to that file.
/// </param>
/// <param name="keyFile">
/// Name of the key file. The one time key gets written to that file.
/// </param>
public void EncryptFile(string originalFile, string encryptedFile, string keyFile)
{
// Read in the bytes from the original file:
byte[] originalBytes;
using (FileStream fs = new FileStream(originalFile, FileMode.Open))
{
originalBytes = new byte[fs.Length];
fs.Read(originalBytes, 0, originalBytes.Length);
}

// Create the one time key for encryption. This is done
// by generating random bytes that are of the same lenght
// as the original bytes:
byte[] keyBytes = new byte[originalBytes.Length];
Random random = new Random();
random.NextBytes(keyBytes);

// Write the key to the file:
using (FileStream fs = new FileStream(keyFile, FileMode.Create))
{
fs.Write(keyBytes, 0, keyBytes.Length);
}

// Encrypt the data with the Vernam-algorithm:
byte[] encryptedBytes = new byte[originalBytes.Length];
DoVernam(originalBytes, keyBytes, ref encryptedBytes);

// Write the encrypted file:
using (FileStream fs = new FileStream(encryptedFile, FileMode.Create))
{
fs.Write(encryptedBytes, 0, encryptedBytes.Length);
}
}
//---------------------------------------------------------------------
/// <summary>
/// Decrypts a file by Vernam-algorithm
/// </summary>
/// <param name="encryptedFile">
/// Name of the encrypted file
/// </param>
/// <param name="keyFile">
/// Name of the key file. The content of this file has to be the same
/// as the content generated while encrypting
/// </param>
/// <param name="decryptedFile">
/// Name of the decrypted file. The decrypted data gets written to this
/// file
/// </param>
public void DecryptFile(string encryptedFile, string keyFile, string decryptedFile)
{
// Read in the encrypted bytes:
byte[] encryptedBytes;
using (FileStream fs = new FileStream(encryptedFile, FileMode.Open))
{
encryptedBytes = new byte[fs.Length];
fs.Read(encryptedBytes, 0, encryptedBytes.Length);
}

// Read in the key:
byte[] keyBytes;
using (FileStream fs = new FileStream(keyFile, FileMode.Open))
{
keyBytes = new byte[fs.Length];
fs.Read(keyBytes, 0, keyBytes.Length);
}

// Decrypt the data with the Vernam-algorithm:
byte[] decryptedBytes = new byte[encryptedBytes.Length];
DoVernam(encryptedBytes, keyBytes, ref decryptedBytes);

// Write the decrypted file:
using (FileStream fs = new FileStream(decryptedFile, FileMode.Create))
{
fs.Write(decryptedBytes, 0, decryptedBytes.Length);
}
}
//---------------------------------------------------------------------
/// <summary>
/// Computes the Vernam-encryption/decryption
/// </summary>
/// <param name="inBytes"></param>
/// <param name="keyBytes"></param>
/// <param name="outBytes"></param>
private void DoVernam(byte[] inBytes, byte[] keyBytes, ref byte[] outBytes)
{
// Check arguments:
if ((inBytes.Length != keyBytes.Length) ||
(keyBytes.Length != outBytes.Length))
throw new ArgumentException("Byte-array are not of same length");

// Encrypt/decrypt by XOR:
for (int i = 0; i < inBytes.Length; i++)
outBytes[i] = (byte)(inBytes[i] ^ keyBytes[i]);
}
}

使用范例：

class Program
{
static void Main(string[] args)
{
Vernam vernam = new Vernam();

// Test with an image:
vernam.EncryptFile("Image.gif", "Image_encrypted.gif", "Key01.dat");
vernam.DecryptFile("Image_encrypted.gif", "Key01.dat", "Image_decrypted.gif");

// Test with text file:
vernam.EncryptFile("Text.txt", "Text_encrypted.txt", "Key02.dat");
vernam.DecryptFile("Text_encrypted.txt", "Key02.dat", "Text_decrypted.txt");

// Test with pdf file:
vernam.EncryptFile("Text.pdf", "Text_encrypted.pdf", "Key03.dat");
vernam.DecryptFile("Text_encrypted.pdf", "Key03.dat", "Text_decrypted.pdf");
}
}