#region Server
/// <summary>
/// 用于保存非对称加密(数字证书)的公钥
/// </summary>
private string publicKey = string.Empty;
/// <summary>
/// 用于保存非对称加密(数字证书)的私钥
/// </summary>
private string pfxKey = string.Empty;
///===========================
///服务端代码
///===========================
/// <summary>
/// 用于跟客户端通信的Socket
/// </summary>
private Socket serverCommunicateSocket;
/// <summary>
/// 定义接收缓存块的大小
/// </summary>
private static int serverBufferSize = 1024;
/// <summary>
/// 缓存块
/// </summary>
byte[] bytesReceivedFromClient = new byte[serverBufferSize];
/// <summary>
/// 密钥K
/// </summary>
private string key = string.Empty;
StringBuilder messageFromClient = new StringBuilder();
/// <summary>
/// 开启服务器
/// </summary>
private void btnStartServer_Click(object sender, EventArgs e)
{
//先生成数字证书(模拟，及非对称密钥对)
RSAKeyInit();
//负责侦听
StartListen();
}
void RSAKeyInit()
{
RSAProcessor.CreateRSAKey(ref publicKey, ref pfxKey);
//本例中，先指定一对公钥、私钥
publicKey = "<RSAKeyValue><Modulus>httkQLJ52ODWcIoDont7izs0Kn8OIr3IJ+Q5DC3RgzojjphvHN/5N4miVN+U0fz405o53CRP0PUghyq0rbHZNj7ZW1M1Vh/ne4lDvP/q44QerhYewTUwT92tHj8GyYxvegkp98vT95YkjFJRByQCXrhKBW64ziqnDL2n9LeUPBM=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
pfxKey = "<RSAKeyValue><Modulus>httkQLJ52ODWcIoDont7izs0Kn8OIr3IJ+Q5DC3RgzojjphvHN/5N4miVN+U0fz405o53CRP0PUghyq0rbHZNj7ZW1M1Vh/ne4lDvP/q44QerhYewTUwT92tHj8GyYxvegkp98vT95YkjFJRByQCXrhKBW64ziqnDL2n9LeUPBM=</Modulus><Exponent>AQAB</Exponent><P>vZPGLPJBxtjhoSSt7OXvAqalRU8IXmPbojk7/j9f1DW1DRCLwof6MjJqt4uAY9D/L/GPJh9zIddeVM3lkr9s6Q==</P><Q>tht1LlLi7XQJHsVfgJ1ewBjjOOzQSfmO+RTClWXKquuup4pblF51jSDK+5VlyibD5chzeO1mxjvzkEfcJNgTmw==</Q><DP>kZXfdfrhKqy5sX+ylaAKydViTHSiL6KuM8mSWfEfTZ+lF5BiVBUKvevb6nKWOZFxt8bhMNysFQwI5EVujSC2qQ==</DP><DQ>hEsqM77vMEWNopcMLCkm/jKWT3JqVnM/lF+qhFHwi36v4PK4WO7OQvpBu8bqrZK/2ZxnlsAQW46OAJDTsshuZQ==</DQ><InverseQ>BfZy74k5EqN6l7faYHSYvqWuRMSWwp4dCXF43uT8wcf3kciYxIkbaNNY56ulJbCAN2SyDQkD3PF+Sp3qtJZ/Vg==</InverseQ><D>ADbI6fFekCGLNZKCfveDMq1dX9PjydpTPvz1ujc4ZeTpuYg0ZO9WDeiCAXB5Y/vqySstfFPybHp3Gr/OmZf2qEbKQlK6Ztms3R30rnqk/2/XHtAm5AeVLhf03q/+76mtvgtUTspgth55JpIKGYNKcQTJBbgepbyVT26YjMwrMoE=</D></RSAKeyValue>";
}
void StartListen()
{
IPEndPoint iep = new IPEndPoint(IPAddress.Parse("192.168.1.103"), 8009);
//负责侦听的socket
Socket listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(iep);
listenSocket.Listen(50);
listenSocket.BeginAccept(new AsyncCallback(this.Accepted), listenSocket);
ListBoxShow("开始侦听...");
btnStartServer.Enabled = false;
}
/// <summary>
/// 负责客户端的连接，并开始将自己置于接收状态
/// </summary>
void Accepted(IAsyncResult result)
{
Socket listenSocket = result.AsyncState as Socket;
//初始化和客户端进行通信的socket
serverCommunicateSocket = listenSocket.EndAccept(result);
ListBoxShow("有客户端连接到...");
serverCommunicateSocket.BeginReceive(bytesReceivedFromClient, 0, serverBufferSize, SocketFlags.None,
new AsyncCallback(this.ReceivedFromClient), null);
}
/// <summary>
/// 负责处理接收自客户端的数据
/// </summary>
void ReceivedFromClient(IAsyncResult result)
{
int read = serverCommunicateSocket.EndReceive(result);
if (read > 0)
{
messageFromClient.Append(UTF32Encoding.Default.GetString(bytesReceivedFromClient, 0, read));
//处理并显示数据
ProcessAndShowInServer();
serverCommunicateSocket.BeginReceive(bytesReceivedFromClient, 0, serverBufferSize, 0,
new AsyncCallback(ReceivedFromClient), null);
}
}
private void ProcessAndShowInServer()
{
string msg = messageFromClient.ToString();
//如果接收到<EOF>表示完成一次，否则继续将自己置于接收状态
if (msg.IndexOf("<EOF>") > -1)
{
//如果客户端发送Key,则负责初始化Key
if (msg.IndexOf("<KEY>") > -1)
{
//用私钥解密发送过来的Key信息
key = RSAProcessor.RSADecrypt(pfxKey, msg.Substring(0, msg.Length - 10));
ListBoxShow(string.Format("接收到客户端密钥：{0}", key));
}
else
{
//解密SSL通道中发送过来的密文并显示
ListBoxShow(string.Format("接收到客户端消息：{0}", RijndaelProcessor.DecryptString(msg.Substring(0, msg.Length - 5), key)));
}
}
messageFromClient.Clear();
}
/// <summary>
/// 负责向客户端发送数据
/// </summary>
private void btnStartSendToClient_Click(object sender, EventArgs e)
{
//加密消息体
string msg = string.Format("{0}{1}", RijndaelProcessor.EncryptString(DateTime.Now.ToString(), key), "<EOF>");
RijndaelProcessor.DecryptString(msg.Substring(0, msg.Length - 5), key);
byte[] msgBytes = UTF32Encoding.Default.GetBytes(msg);
serverCommunicateSocket.BeginSend(msgBytes, 0, msgBytes.Length, SocketFlags.None, null, null);
ListBoxShow(string.Format("发送:{0}", msg));
}
/// <summary>
/// 界面显示
/// </summary>
private void ListBoxShow(string argMsg)
{
listBoxServer.BeginInvoke(new Action(() =>
{
listBoxServer.Items.Add(argMsg);
}));
}
#endregion
#region Client
/// <summary>
/// 用于保存非对称加密(数字证书)的公钥
/// </summary>
private string publicKey = "<RSAKeyValue><Modulus>httkQLJ52ODWcIoDont7izs0Kn8OIr3IJ+Q5DC3RgzojjphvHN/5N4miVN+U0fz405o53CRP0PUghyq0rbHZNj7ZW1M1Vh/ne4lDvP/q44QerhYewTUwT92tHj8GyYxvegkp98vT95YkjFJRByQCXrhKBW64ziqnDL2n9LeUPBM=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
///==============================
/// 客户端代码
///==============================
///用于跟踪服务器通信的socket
private Socket clientCommunicateSocket;
/// <summary>
/// 用于暂存接收到的字符串
/// </summary>
StringBuilder messageFromServer = new StringBuilder();
/// <summary>
/// 定义接收存储块的大小
/// </summary>
private static int clientBufferSize = 1024;
/// <summary>
/// 缓存块
/// </summary>
byte[] bytesReceivedFromServer = new byte[clientBufferSize];
/// <summary>
/// 随机生产的key,在这里硬编码为"key123"
/// </summary>
private string keyCreateRandom = "key123";
//Guid.NewGuid().ToString().ToUpper().Replace("-", "") +Guid.NewGuid().ToString().ToUpper().Replace("-", "");
private void btnConnectToServer_Click(object sender, EventArgs e)
{
IPEndPoint iep = new IPEndPoint(IPAddress.Parse("192.168.1.103"), 8009);
Socket connectSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
connectSocket.BeginConnect(iep, new AsyncCallback(this.Connected), connectSocket);
btnConnectToServer.Enabled = false;
}
void Connected(IAsyncResult result)
{
clientCommunicateSocket = result.AsyncState as Socket;
clientCommunicateSocket.EndConnect(result);
clientCommunicateSocket.BeginReceive(bytesReceivedFromServer, 0, clientBufferSize, SocketFlags.None,
new AsyncCallback(this.ReceivedFromServer), null);
ListBoxClientShow("客户端连接上服务器...");
//连接成功便发送密钥K给服务器
SendKey();
}
void ReceivedFromServer(IAsyncResult result)
{
int read = clientCommunicateSocket.EndReceive(result);
if (read > 0)
{
messageFromServer.Append(UTF32Encoding.Default.GetString(bytesReceivedFromServer, 0, read));
//处理并显示客户端数据
ProcessAndShowInClient();
clientCommunicateSocket.BeginReceive(bytesReceivedFromServer, 0, clientBufferSize, 0,
new AsyncCallback(ReceivedFromServer), null);
}
}
void ProcessAndShowInClient()
{
//如果接收到<EOF>表示完成一次接收，否则继续将自己置于接收状态
if (messageFromServer.ToString().IndexOf("<EOF>") > -1)
{
//解密消息体并呈现出来
ListBoxClientShow(string.Format("接收到服务器消息：{0}",
RijndaelProcessor.DecryptString(
messageFromServer.ToString().Substring(0, messageFromServer.ToString().Length - 5)
, keyCreateRandom)));
messageFromServer.Clear();
}
}
private void btnStartSendToServer_Click(object sender, EventArgs e)
{
//加密消息体
string msg = string.Format("{0}{1}",
RijndaelProcessor.EncryptString(DateTime.Now.ToString(), keyCreateRandom), "<EOF>");
byte[] msgBytes = UTF32Encoding.Default.GetBytes(msg);
clientCommunicateSocket.BeginSend(msgBytes, 0, msgBytes.Length, SocketFlags.None, null, null);
ListBoxClientShow(string.Format("发送:{0}", msg));
}
void SendKey()
{
string msg = RSAProcessor.RSAEncrypt(publicKey, keyCreateRandom) + "<KEY><EOF>";
byte[] msgBytes = UTF32Encoding.Default.GetBytes(msg);
clientCommunicateSocket.BeginSend(msgBytes, 0, msgBytes.Length, SocketFlags.None, null, null);
ListBoxClientShow(string.Format("发送：{0}", keyCreateRandom));
}
void ListBoxClientShow(string argMsg)
{
listBoxClient.BeginInvoke(new Action(() =>
{
listBoxClient.Items.Add(argMsg);
}));
}
#endregion
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
namespace LibAlgorithm
{
/// <summary>
/// Rijndael对称加密算法
/// </summary>
public class RijndaelProcessor
{
/// <summary>
/// 缓冲区大小
/// </summary>
private static int bufferSize = 128 * 1024;
/// <summary>
/// 密钥salt
/// </summary>
private static byte[] salt = { 134, 216, 7, 36, 88, 164, 91, 227, 174, 76, 191, 197, 192, 154, 200, 248 };
//salt用来防止穷举暴力破解(salt是在密钥导出之前在密码末尾引入的随机字节，它使得这类攻击变得非常困难)
/// <summary>
/// 初始化向量
/// </summary>
private static byte[] iv = { 134, 216, 7, 36, 88, 164, 91, 227, 174, 76, 191, 197, 192, 154, 200, 248 };
//初始化向量iv起到的也是增强破解难度的作用
/// <summary>
/// 初始化 并返回对称加密算法
/// </summary>
/// <param name="argKey"></param>
/// <param name="argSalt"></param>
/// <returns></returns>
private static SymmetricAlgorithm CreateRijindael(string argKey, byte[] argSalt)
{
PasswordDeriveBytes pdb = new PasswordDeriveBytes(argKey, argSalt, "SHA256", 1000);
SymmetricAlgorithm sma = Rijndael.Create();
sma.KeySize = 256;
sma.Key = pdb.GetBytes(32);
sma.Padding = PaddingMode.PKCS7;
return sma;
}
public static string EncryptString(string argInput, string argKey)
{
using (MemoryStream memoryStream = new MemoryStream())
using (SymmetricAlgorithm algorithm = CreateRijindael(argKey, salt))
{
algorithm.IV = iv;
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, algorithm.CreateEncryptor(),
CryptoStreamMode.Write))
{
byte[] bytes = UTF32Encoding.Default.GetBytes(argInput);
cryptoStream.Write(bytes, 0, bytes.Length);
cryptoStream.Flush();
}
return Convert.ToBase64String(memoryStream.ToArray());
}
}
public static string DecryptString(string argInput, string argKey)
{
using (MemoryStream inputMemoryStream = new MemoryStream(Convert.FromBase64String(argInput)))
using (SymmetricAlgorithm algorithm = CreateRijindael(argKey, salt))
{
algorithm.IV = iv;
using (CryptoStream cryptoStream = new CryptoStream(inputMemoryStream, algorithm.CreateDecryptor(),
CryptoStreamMode.Read))
{
StreamReader sr = new StreamReader(cryptoStream);
return sr.ReadToEnd();
}
}
}
}
}
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
namespace LibAlgorithm
{
/// <summary>
/// RSA非对称加密
/// </summary>
public class RSAProcessor
{
public static void CreateRSAKey(ref string publicKey, ref string pfxKey)
{
RSACryptoServiceProvider provider = new RSACryptoServiceProvider();
pfxKey = provider.ToXmlString(true);
publicKey = provider.ToXmlString(false);
}
public static string RSAEncrypt(string argXmlPublicKey, string argEncryptString)
{
byte[] btEncryptedSecret = Encoding.UTF8.GetBytes(argEncryptString);
btEncryptedSecret = CRSAWrap.EncryptBuffer(argXmlPublicKey, btEncryptedSecret);
return Convert.ToBase64String(btEncryptedSecret);
}
public static string RSADecrypt(string xmlPrivateKey, string argDecryptString)
{
byte[] btDecryptedSecred = Convert.FromBase64String(argDecryptString);
btDecryptedSecred = CRSAWrap.DecryptBuffer(xmlPrivateKey,btDecryptedSecred);
return Encoding.UTF8.GetString(btDecryptedSecred);
}
}
class CRSAWrap
{
public static byte[] EncryptBuffer(string rsaKeyString, byte[] btSecret)
{
int keySize = 0;
int blockSize = 0;
int counter = 0;
int iterations = 0;
int index = 0;
byte[] btPlaintextToken;
byte[] btEncryptedToken;
byte[] btEncryptedSecret;
RSACryptoServiceProvider rsaSender = new RSACryptoServiceProvider();
rsaSender.FromXmlString(rsaKeyString);
keySize = rsaSender.KeySize / 8;
blockSize = keySize - 11;
if ((btSecret.Length % blockSize) != 0)
{
iterations = btSecret.Length / blockSize + 1;
}
else
{
iterations = btSecret.Length / blockSize;
}
btPlaintextToken = new byte[blockSize];
btEncryptedSecret = new byte[iterations * keySize];
for (index = 0, counter = 0; counter < iterations; counter++,index += blockSize)
{
if (counter == (iterations - 1))
{
int lastblockSize = btSecret.Length % blockSize;
btPlaintextToken = new byte[lastblockSize];
Array.Copy(btSecret, index, btPlaintextToken, 0, lastblockSize);
}
else
{
Array.Copy(btSecret, index, btPlaintextToken, 0, blockSize);
}
btEncryptedToken = rsaSender.Encrypt(btPlaintextToken, false);
Array.Copy(btEncryptedToken, 0, btEncryptedSecret, counter * keySize, keySize);
}
return btEncryptedSecret;
}
public static byte[] DecryptBuffer(string argRsaKeyString, byte[] btEncryptedSecret)
{
int keySize = 0;
int blockSize = 0;
int counter = 0;
int iterations = 0;
int index = 0;
int byteCount = 0;
byte[] btPlaintextToken;
byte[] btEncryptedToken;
byte[] btDecryptedSecret;
RSACryptoServiceProvider rsaReceiver=new RSACryptoServiceProvider();
rsaReceiver.FromXmlString(argRsaKeyString);
keySize = rsaReceiver.KeySize/8;
blockSize = keySize - 11;
if ((btEncryptedSecret.Length%keySize) != 0)
{
return null;
}
iterations = btEncryptedSecret.Length/keySize;
btEncryptedToken=new byte[keySize];
Queue<byte[]> tokenQueue=new Queue<byte[]>();
for (index = 0,counter = 0; counter < iterations; index += blockSize,counter++)
{
Array.Copy(btEncryptedSecret,counter*keySize,btEncryptedToken,0,keySize);
btPlaintextToken = rsaReceiver.Decrypt(btEncryptedToken, false);
tokenQueue.Enqueue(btPlaintextToken);
}
byteCount = 0;
foreach (var plainTextToken in tokenQueue)
{
byteCount += plainTextToken.Length;
}
counter = 0;
btDecryptedSecret=new byte[byteCount];
foreach (var plainTextToken in tokenQueue)
{
if (counter==(iterations-1))
{
Array.Copy(plainTextToken,0,btDecryptedSecret,btDecryptedSecret.Length-plainTextToken.Length,plainTextToken.Length);
}
else
{
Array.Copy(plainTextToken,0,btDecryptedSecret,counter*blockSize,blockSize);
}
counter++;
}
return btDecryptedSecret;
}
}
}
源码下载地址：Test117_使用SSL确保通信中的数据安全.rar