浅谈.NET中加密和解密的实现方法分享

.net将原来独立的api和sdk合并到一个框架中，这对于程序开发人员非常有利。它将cryptoapi改编进.net的system.security.cryptography名字空间，使密码服务摆脱了sdk平台的神秘性，变成了简单的.net名字空间的使用。由于随着整个框架组件一起共享，密码服务更容易实现了，现在仅仅需要学习 system.security.cryptography名字空间的功能和用于解决特定方案的类。
　　加密和解密的算法

　　system.security.cryptography名字空间包含了实现安全方案的类，例如加密和解密数据、管理密钥、验证数据的完整性并确保数据没有被篡改等等。本文重点讨论加密和解密。

　　加密和解密的算法分为对称（symmetric）算法和不对称（asymmetric）算法。对称算法在加密和解密数据时使用相同的密钥和初始化矢量，典型的有des、 tripledes和rijndael算法，它适用于不需要传递密钥的情况，主要用于本地文档或数据的加密。不对称算法有两个不同的密钥，分别是公共密钥和私有密钥，公共密钥在网络中传递，用于加密数据，而私有密钥用于解密数据。不对称算法主要有rsa、dsa等，主要用于网络数据的加密。

　　加密和解密本地文档

　　下面的例子是加密和解密本地文本，使用的是rijndael对称算法。

　　对称算法在数据流通过时对它进行加密。因此首先需要建立一个正常的流（例如i/o流）。文章使用filestream类将文本文件读入字节数组，也使用该类作为输出机制。

　　接下来定义相应的对象变量。在定义symmetricalgorithm抽象类的对象变量时我们可以指定任何一种对称加密算法提供程序。代码使用的是 rijndael算法，但是很容易改为des或者tripledes算法。.net使用强大的随机密钥设置了提供程序的实例，选择自己的密钥是比较危险的，接受计算机产生的密钥是一个更好的选择，文中的代码使用的是计算机产生的密钥。

　　下一步，算法实例提供了一个对象来执行实际数据传输。每种算法都有createencryptor和createdecryptor两个方法，它们返回实现icryptotransform接口的对象。

　　最后，现在使用binaryreader的readbytes方法读取源文件，它会返回一个字节数组。binaryreader读取源文件的输入流，在作为cryptostream.write方法的参数时调用readbytes方法。指定的cryptostream实例被告知它应该操作的下层流，该对象将执行数据传递，无论流的目的是读或者写。

　　下面是加密和解密一个文本文件的源程序片断：

namespace com.billdawson.crypto
{
class textfilecrypt
{
public static void main(string[] args)
{
string file = args[0];
string tempfile = path.gettempfilename();
//打开指定的文件
filestream fsin = file.open(file,filemode.open,
fileaccess.read);
filestream fsout = file.open(tempfile, filemode.open,
fileaccess.write);
//定义对称算法对象实例和接口
symmetricalgorithm symm = new rijndaelmanaged();
icryptotransform transform = symm.createencryptor();
cryptostream cstream = new cryptostream(fsout,transform,
ryptostreammode.write);

binaryreader br = new binaryreader(fsin);
// 读取源文件到cryptostream
cstream.write(br.readbytes((int)fsin.length),0,(int)fsin.length);
cstream.flushfinalblock();
cstream.close();
fsin.close();
fsout.close();

console.writeline("created encrypted file {0}", tempfile);
console.writeline("will now decrypt and show contents");

// 反向操作--解密刚才加密的临时文件
fsin = file.open(tempfile,filemode.open,fileaccess.read);
transform = symm.createdecryptor();
cstream = new cryptostream(fsin,transform,
cryptostreammode.read);

streamreader sr = new streamreader(cstream);
console.writeline("decrypted file text: " + sr.readtoend());
fsin.close();
}
}
}

加密网络数据

　　如果我有一个只想自己看到的文档，我不会简单的通过e-mail发送给你。我将使用对称算法加密它；如果有人截取了它，他们也不能阅读该文档，因为他们没有用于加密的唯一密钥。但是你也没有密钥。我需要使用某种方式将密钥给你，这样你才能解密文档，但是不能冒密钥和文档被截取的风险。

　　非对称算法就是一种解决方案。这类算法使用的两个密钥有如下关系：使用公共密钥加密的信息只能被相应的私有密钥解密。因此，我首要求你给我发送你的公共密钥。在发送给我的途中可能有人会截取它，但是没有关系，因为他们只能使用该密钥给你的信息加密。我使用你的公共密钥加密文档并发送给你。你使用私有密钥解密该文档，这是唯一可以解密的密钥，并且没有通过网络传递。

　　不对称算法比对称算法计算的花费多、速度慢。因此我们不希望在线对话中使用不对称算法加密所有信息。相反，我们使用对称算法。下面的例子中我们使用不对称加密来加密对称密钥。接着就使用对称算法加密了。实际上安全接口层（ssl）建立服务器和浏览器之间的安全对话使用的就是这种工作方式。
示例是一个tcp程序，分为服务器端和客户端。服务器端的工作流程是：

　　 从客户端接收公共密钥。

　　 使用公共密钥加密未来使用的对称密钥。

　　 将加密了的对称密钥发送给客户端。

　　 给客户端发送使用该对称密钥加密的信息。

　　代码如下：

namespace com.billdawson.crypto
{
public class cryptoserver
{
private const int rsa_key_size_bits = 1024;
private const int rsa_key_size_bytes = 252;
private const int tdes_key_size_bits = 192;

public static void main(string[] args)
{
int port;
string msg;
tcplistener listener;
tcpclient client;
symmetricalgorithm symm;
rsacryptoserviceprovider rsa;
//获取端口
try
{
port = int32.parse(args[0]);
msg = args[1];
}
catch
{
console.writeline(usage);
return;
}
//建立监听
try
{
listener = new tcplistener(port);
listener.start();
console.writeline("listening on port {0}",port);

client = listener.accepttcpclient();
console.writeline("connection.");
}
catch (exception e)
{
console.writeline(e.message);
console.writeline(e.stacktrace);
return;
}

try
{
rsa = new rsacryptoserviceprovider();
rsa.keysize = rsa_key_size_bits;

// 获取客户端公共密钥
rsa.importparameters(getclientpublickey(client));

symm = new tripledescryptoserviceprovider();
symm.keysize = tdes_key_size_bits;

//使用客户端的公共密钥加密对称密钥并发送给客。
encryptandsendsymmetrickey(client, rsa, symm);

//使用对称密钥加密信息并发送
encryptandsendsecretmessage(client, symm, msg);
}
catch (exception e)
{
console.writeline(e.message);
console.writeline(e.stacktrace);
}
finally
{
try
{
client.close();
listener.stop();
}
catch
{
//错误
}
console.writeline("server exiting");
}
}

private static rsaparameters getclientpublickey(tcpclient client)
{
// 从字节流获取串行化的公共密钥，通过串并转换写入类的实例
byte[] buffer = new byte[rsa_key_size_bytes];
networkstream ns = client.getstream();
memorystream ms = new memorystream();
binaryformatter bf = new binaryformatter();
rsaparameters result;

int len = 0;
int totallen = 0;

while(totallen
(len = ns.read(buffer,0,buffer.length))>0)
{
totallen+=len;
ms.write(buffer, 0, len);
}

ms.position=0;

result = (rsaparameters)bf.deserialize(ms);
ms.close();

return result;

}

private static void encryptandsendsymmetrickey(
tcpclient client,
rsacryptoserviceprovider rsa,
symmetricalgorithm symm)
{
// 使用客户端的公共密钥加密对称密钥
byte[] symkeyencrypted;
byte[] symivencrypted;

networkstream ns = client.getstream();

symkeyencrypted = rsa.encrypt(symm.key, false);
symivencrypted = rsa.encrypt(symm.iv, false);

ns.write(symkeyencrypted, 0, symkeyencrypted.length);
ns.write(symivencrypted, 0, symivencrypted.length);

}

private static void encryptandsendsecretmessage(tcpclient client,
symmetricalgorithm symm,
string secretmsg)
{
// 使用对称密钥和初始化矢量加密信息并发送给客户端
byte[] msgasbytes;
networkstream ns = client.getstream();
icryptotransform transform =
symm.createencryptor(symm.key,symm.iv);
cryptostream cstream =
new cryptostream(ns, transform, cryptostreammode.write);

msgasbytes = encoding.ascii.getbytes(secretmsg);

cstream.write(msgasbytes, 0, msgasbytes.length);
cstream.flushfinalblock();
}
}

客户端的工作流程是：

　　 建立和发送公共密钥给服务器。

　　 从服务器接收被加密的对称密钥。

　　 解密该对称密钥并将它作为私有的不对称密钥。

　　 接收并使用不对称密钥解密信息。

　　代码如下：

namespace com.billdawson.crypto
{
public class cryptoclient
{
private const int rsa_key_size_bits = 1024;
private const int rsa_key_size_bytes = 252;
private const int tdes_key_size_bits = 192;
private const int tdes_key_size_bytes = 128;
private const int tdes_iv_size_bytes = 128;
public static void main(string[] args)
{
int port;
string host;
tcpclient client;
symmetricalgorithm symm;
rsacryptoserviceprovider rsa;

if (args.length!=2)
{
console.writeline(usage);
return;
}

try
{
host = args[0];
port = int32.parse(args[1]);
}
catch
{
console.writeline(usage);
return;
}

try //连接
{
client = new tcpclient();
client.connect(host,port);
}
catch(exception e)
{
console.writeline(e.message);
console.write(e.stacktrace);
return;
}

try
{
console.writeline("connected. sending public key.");
rsa = new rsacryptoserviceprovider();
rsa.keysize = rsa_key_size_bits;
sendpublickey(rsa.exportparameters(false),client);
symm = new tripledescryptoserviceprovider();
symm.keysize = tdes_key_size_bits;

memorystream ms = getrestofmessage(client);
extractsymmetrickeyinfo(rsa, symm, ms);
showsecretmessage(symm, ms);
}
catch(exception e)
{
console.writeline(e.message);
console.write(e.stacktrace);
}
finally
{
try
{
client.close();
}
catch { //错误
}
}
}

private static void sendpublickey(
rsaparameters key,
tcpclient client)
{
networkstream ns = client.getstream();
binaryformatter bf = new binaryformatter();
bf.serialize(ns,key);
}

private static memorystream getrestofmessage(tcpclient client)
{
//获取加密的对称密钥、初始化矢量、秘密信息。对称密钥用公共rsa密钥
//加密，秘密信息用对称密钥加密
memorystream ms = new memorystream();
networkstream ns = client.getstream();
byte[] buffer = new byte[1024];

int len=0;

// 将netstream 的数据写入内存流
while((len = ns.read(buffer, 0, buffer.length))>0)
{
ms.write(buffer, 0, len);
}
ms.position = 0;
return ms;
}

private static void extractsymmetrickeyinfo(
rsacryptoserviceprovider rsa,
symmetricalgorithm symm,
memorystream msorig)
{
memorystream ms = new memorystream();

// 获取tdes密钥--它被公共rsa密钥加密，使用私有密钥解密
byte[] buffer = new byte[tdes_key_size_bytes];
msorig.read(buffer,0,buffer.length);
symm.key = rsa.decrypt(buffer,false);

// 获取tdes初始化矢量
buffer = new byte[tdes_iv_size_bytes];
msorig.read(buffer, 0, buffer.length);
symm.iv = rsa.decrypt(buffer,false);
}

private static void showsecretmessage(
symmetricalgorithm symm,
memorystream msorig)
{
//内存流中的所有数据都被加密了
byte[] buffer = new byte[1024];
int len = msorig.read(buffer,0,buffer.length);

memorystream ms = new memorystream();
icryptotransform transform =
symm.createdecryptor(symm.key,symm.iv);
cryptostream cstream =new cryptostream(ms, transform,
cryptostreammode.write);
cstream.write(buffer, 0, len);
cstream.flushfinalblock();

// 内存流现在是解密信息，是字节的形式，将它转换为字符串
ms.position = 0;
len = ms.read(buffer,0,(int) ms.length);
ms.close();

string msg = encoding.ascii.getstring(buffer,0,len);
console.writeline("the host sent me this secret message:");
console.writeline(msg);
}
}
}

使用对称算法加密本地数据时比较适合。在保持代码通用时我们可以选择多种算法，当数据通过特定的cryptostream时算法使用转换对象加密该数据。需要将数据通过网络发送时，首先使用接收的公共不对称密钥加密对称密钥。

本文只涉及到system.security.cryptography名字空间的一部分服务。尽管文章保证只有某个私有密钥可以解密相应公共密钥加密的信息，但是它没有保证是谁发送的公共密钥，发送者也可能是假的。需要使用处理数字证书的类来对付该风险。