文件加密传输，进度条，断点

客户端：
using System;
using System.Collections;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.Reflection;
using System.Threading;
using Newtonsoft.Json;
using System.IO;
using System.Windows.Forms;

namespace Client
{
public class SslTcpClient
{
private string caCertificate, serverName; //定义字符串
private int port;
private Client.UpdateMenuHandle updateMenuCallback; //声明委托方法
private Client.UpdateUI connectSuccessCallback, logCallback, disconnectCallback, downloadSuccessCallback;//声明委托方法
private Client.ExceptionHandle exceptionCallback;//声明委托方法
private Client.UpdateProcessBarHandle updateProcessBarHandle;//声明委托方法
private Thread clientThread; //声明多线程
private Mutex socketMutex; //声明线程锁
private bool is_downloading; //布尔类型

private Semaphore semaphoreWaitFile; //限制线程数量
private class DownloadCommand
{
public string filename;
public int filestart;
public bool is_download;
}
private DownloadCommand downloadCommand;
private string savaPath;
public SslTcpClient(string caCertificate,
string serverName, int port,
Client.UpdateMenuHandle updateMenuCallback,
Client.UpdateUI connectSuccessCallback,
Client.UpdateUI disconnectCallback,
Client.UpdateUI logCallback,
Client.UpdateUI downloadSuccessCallback,
Client.UpdateProcessBarHandle updateProcessBarHandle,
Client.ExceptionHandle exceptionCallback)
{
this.caCertificate = caCertificate;
this.serverName = serverName;
this.port = port;
this.updateMenuCallback = updateMenuCallback;
this.connectSuccessCallback = connectSuccessCallback;
this.disconnectCallback = disconnectCallback;
this.logCallback = logCallback;
this.downloadSuccessCallback = downloadSuccessCallback;
this.updateProcessBarHandle = updateProcessBarHandle;
this.exceptionCallback = exceptionCallback; //赋值
this.clientThread = new Thread(new ThreadStart(RunClientFun)); //新开一个线程

semaphoreWaitFile = new Semaphore(0, 1); //限制只能一个线程 最大并发数为1
}
private bool ValidateServerCertificate( //验证证书的函数
object sender, //证书的调用
X509Certificate certificate, //证书数据
X509Chain chain, //证书链
SslPolicyErrors sslPolicyErrors) //验证套接字
{
if (sslPolicyErrors == SslPolicyErrors.None)//没有套接字错误
return true;

Console.WriteLine("Certificate error: {0}", sslPolicyErrors);
return false;
}
private X509Certificate LocalCertificateSelection(//加载证书的函数
object sender, //证书的调用者
string targetHost, //目标主机
X509CertificateCollection localCertificates, //加载证书数据
X509Certificate remoteCertificate, //远程证书数据
string[] acceptableIssuers)
{
return X509Certificate.CreateFromCertFile(caCertificate);//从文件加载证书数据
}
private void RunClientFun()//新的线程运行的函数
{
TcpClient client; //TCP连接

try
{
client = new TcpClient(serverName, port);//配置连接的属性
connectSuccessCallback?.Invoke();//判断是否连接成功
Console.WriteLine("Client connected.");
SslStream sslStream = new SslStream(//证书流
client.GetStream(),
false,
new RemoteCertificateValidationCallback(ValidateServerCertificate),//验证证书
new LocalCertificateSelectionCallback(LocalCertificateSelection)//调用证书
);
try
{
sslStream.AuthenticateAsClient("localhost");//验证本地服务
}
catch (AuthenticationException e)//捕获错误信息的 网络连接出错的话 说明验证失败
{
Console.WriteLine("Exception: {0}", e.Message);
if (e.InnerException != null)
{
Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
}
Console.WriteLine("Authentication failed - closing the connection.");

client.Close();//关闭连接
return;
}
string serverMessage = ReadMessage(sslStream);//从服务读取数据
string[] fileList = JsonConvert.DeserializeObject<string[]>(serverMessage);//反序列化字符串json
updateMenuCallback?.Invoke(fileList);//把fileList的数据传过去处理
semaphoreWaitFile.WaitOne();//阻塞线程，等上面的执行完
string jsonstr = JsonConvert.SerializeObject(downloadCommand);//序列化数据成json数据
byte[] message = Encoding.UTF8.GetBytes(jsonstr);//把数据转成utf-8 的byte数组
sslStream.Write(message);//写入数据
sslStream.Flush();//结束写入
if (downloadCommand.is_download == true) {//判断开始下载文件
byte[] fileLengthArray = new byte[8];//申请内存
sslStream.Read(fileLengthArray, 0, 8);//把数据读出来，读取8 个byte长度的数据
long fileLength = System.BitConverter.ToInt64(fileLengthArray, 0);//获取文件数据的长度
updateProcessBarHandle?.Invoke((int)Math.Round(100.0 * downloadCommand.filestart / fileLength));//把数据传到进度条显示
FileStream fs;//文件流
if (!File.Exists(this.savaPath))//判断文件不存在
{
fs = File.Create(this.savaPath);//创建文件
}
else
{
fs = File.OpenWrite(this.savaPath);//打开文件写入数据
fs.Seek(downloadCommand.filestart, SeekOrigin.Begin);//获取开始读取的长度
}
socketMutex = new Mutex();//这里添加一个线程锁
is_downloading = true;
byte[] buffer = new byte[1024]; //申请1024长度的缓存
long receivedLength = downloadCommand.filestart;
while (receivedLength < fileLength)//循环读取，每次读取1024
{
socketMutex.WaitOne();//锁起来
int block = sslStream.Read(buffer, 0, 1024);//开始读数据
socketMutex.ReleaseMutex();//解锁
if (block > 0)//如果数据满足1024
{
fs.Write(buffer, 0, block);//把数据写进去
updateProcessBarHandle?.Invoke((int)Math.Round(100.0 * receivedLength / fileLength));//更新进度条
receivedLength += block;//数据递增
}
}
updateProcessBarHandle?.Invoke(100);//下载完毕更新进度条的显示到100%
fs.Flush();//关闭文件流
fs.Close();//关闭文件
socketMutex.Close();//取消线程锁
downloadSuccessCallback?.Invoke();//返回已经下载完成的信息
MessageBox.Show("文件下载完成", "提示");
}
else//上传文件
{
string downloadCommand1Json = ReadMessage(sslStream);//从服务里读数据
DownloadCommand downloadCommand1 = JsonConvert.DeserializeObject<DownloadCommand>(downloadCommand1Json);//反序列化字符串json
FileStream fs = File.OpenRead(Path.Combine(this.savaPath, downloadCommand1.filename));//打开文件读取内容
byte[] sizeArray = System.BitConverter.GetBytes(fs.Length);//获取文件长度
sslStream.Write(sizeArray);//开始写入长度信息
sslStream.Flush();//关闭流
fs.Seek(downloadCommand1.filestart, SeekOrigin.Begin);//开始读取文件数据
updateProcessBarHandle?.Invoke(0);//更新进度条为0
socketMutex = new Mutex();//申请线程锁
is_downloading = true;
int length;
byte[] buffer = new byte[1024];//申请1024长度的缓存
do
{
socketMutex.WaitOne();//锁起来
length = fs.Read(buffer, 0, 1024);//开始读数据 1024长度
socketMutex.ReleaseMutex();//解锁
sslStream.Write(buffer, 0, length);//把数据写到服务流去
updateProcessBarHandle?.Invoke((int)Math.Round(100.0 * fs.Seek(0,SeekOrigin.Current) / fs.Length));//更新进度条
} while (length > 0);
sslStream.Flush();//关闭服务流
fs.Close();//关闭文件
socketMutex.Close();//取消锁
downloadSuccessCallback?.Invoke();//返回已经上传完毕
MessageBox.Show("文件上传完成", "提示");//提示出来
}
sslStream.Close();//关闭服务
client.Close();//关闭连接
}
catch (Exception e)
{
exceptionCallback?.Invoke(e);//出错信息返回
}
}
public void Upload(string path)//上传文件函数
{
downloadCommand = new DownloadCommand();
downloadCommand.filename = Path.GetFileName(path);//获取文件名
downloadCommand.filestart = 0;//从文件头开始读
downloadCommand.is_download = false;
this.savaPath = Path.GetDirectoryName(path);//获取文件路径
semaphoreWaitFile.Release();//线程启动 最多只能一个线程
}
public void Download(string name, string savaPath, int start=0)//下载文件
{
downloadCommand = new DownloadCommand();
downloadCommand.filename = name;
downloadCommand.filestart = start;
downloadCommand.is_download = true;

this.savaPath = savaPath;
semaphoreWaitFile.Release();//线程启动 最多只能一个线程
}
public void Pause()//暂停
{
if (socketMutex != null)//先判断线程锁是否存在
{
if (is_downloading)//如果正在下载
{
socketMutex.WaitOne();//加锁
is_downloading = false;
MessageBox.Show("传输已暂停", "提示");//弹出提示
}
else
{
socketMutex.ReleaseMutex();//解锁
is_downloading = true;
MessageBox.Show("传输已恢复", "提示");
}
}
}
public void RunClient()//服务启动函数
{
clientThread.Start();//启动线程
}
public void DisconnectClient()//断开连接
{
clientThread.Abort();//停止线程
}
private static string ReadMessage(SslStream sslStream)//从服务流里读取数据
{
byte[] buffer = new byte[2048];//每次读取2048
StringBuilder messageData = new StringBuilder();//可以自动控制大小
int bytes;
do
{
bytes = sslStream.Read(buffer, 0, buffer.Length);//开始读取数据
Decoder decoder = Encoding.UTF8.GetDecoder();//转成utf-8
char[] chars = new char[decoder.GetCharCount(buffer, 0, bytes)];//开始读取数据
decoder.GetChars(buffer, 0, bytes, chars, 0);//转成char 数据
messageData.Append(chars);//拼接数据
if (messageData.ToString().IndexOf("") != -1)//判断是不是已经写入数据了
{
break;
}
}
while (bytes != 0);
return messageData.ToString();//返回string数据
}
}

服务器端：
using System;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Text;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Reflection;
using System.Collections.Generic;
using System.IO;
using Newtonsoft.Json;
using System.Reflection.Emit;

namespace Server
{
public sealed class SslTcpServer
{
private X509Certificate serverCertificate = null; //声明证书数据
private TcpListener listener; //声明网络监听服务
private Thread process_thread; //声明一个线程
private Server.UpdateUI startCallback, stopCallback;//声明委托方法
private Server.ExceptionHandle exceptionCallback;//声明委托方法
private Server.LogHandle logCallback;//声明委托方法
private string[] fileLists; //字符串数组
private string prefixPath;

private class DownloadCommand
{
public string filename;
public int filestart;
public bool is_download;
}
private DownloadCommand receivedCommand;

public SslTcpServer(string certificate, int port,
string prefixPath,
string[] fileLists,
Server.UpdateUI startCallback,
Server.UpdateUI stopCallback,
Server.ExceptionHandle exceptionCallback,
Server.LogHandle logCallback)
{
serverCertificate = X509Certificate.CreateFromCertFile(certificate);
listener = new TcpListener(IPAddress.Any, port);
this.prefixPath = prefixPath;
this.fileLists = fileLists;
this.startCallback = startCallback;
this.stopCallback = stopCallback;
this.exceptionCallback = exceptionCallback;
this.logCallback = logCallback;
}

private void ProcessFun()//启动服务线程
{
try
{
logCallback?.Invoke("服务器已启动，等待客户端连接...");
while (true)//一直循环监听
{
if (listener.Pending())
{
TcpClient client = listener.AcceptTcpClient();
ProcessClient(client);
}
else
{
Thread.Sleep(200);
}
}
}
catch(Exception e)
{
exceptionCallback?.Invoke(e);
}
}

public void ServerStart()//开始启动服务
{
try
{
listener.Start();
process_thread = new Thread(new ThreadStart(ProcessFun));//开辟线程
process_thread.Start();
startCallback?.Invoke();//返回已经启动服务的信息
}
catch(Exception e)
{
exceptionCallback?.Invoke(e);
}
}
public void ServerAbort()//关闭服务
{
process_thread.Abort();//关闭线程
listener.Stop();//停止监听
stopCallback?.Invoke();//返回停止监听的信息
logCallback?.Invoke("服务器已关闭");
}
void ProcessClient(TcpClient client)//处理连接的信息
{
logCallback?.Invoke("一个客户端已连接");
SslStream sslStream = new SslStream(client.GetStream(), false);//从服务流里面读数据
try
{
sslStream.AuthenticateAsServer(serverCertificate,
false, SslProtocols.Tls12, false);//调用证书 解析

//sslStream.ReadTimeout = 5000;
//sslStream.WriteTimeout = 5000;
logCallback?.Invoke("构建共享目录文件列表...");
string fileListsJson = JsonConvert.SerializeObject(fileLists);//序列化数据成json数据
logCallback?.Invoke(fileListsJson);
byte[] message = Encoding.UTF8.GetBytes(fileListsJson);//把数据转成utf-8 的byte数组
logCallback?.Invoke("正在发送文件列表...");
sslStream.Write(message);//写入数据
sslStream.Flush();//结束写入
logCallback?.Invoke("文件列表发送完成，等待进一步指令...");
string command = ReadMessage(sslStream);
receivedCommand = JsonConvert.DeserializeObject<DownloadCommand>(command);
logCallback?.Invoke("收到指令： " + command);
string wholePath = Path.Combine(prefixPath, receivedCommand.filename);//获取文件名
if (receivedCommand.is_download == true)//判断开始下载文件
{
if (File.Exists(wholePath))//判断文件存在
{
logCallback?.Invoke("文件开始传输：" + wholePath);
FileStream fs = File.OpenRead(wholePath);//文件流
byte[] sizeArray = System.BitConverter.GetBytes(fs.Length);//获取文件长度
fs.Seek(receivedCommand.filestart, SeekOrigin.Begin);//开始读取文件数据
sslStream.Write(sizeArray);//开始写入长度信息
sslStream.Flush();//关闭流
int length;
byte[] buffer = new byte[1024];//申请1024长度的缓存
do
{
length = fs.Read(buffer, 0, 1024);//开始读数据 1024长度
sslStream.Write(buffer, 0, length);//把数据写到服务流去
} while (length > 0);
fs.Close();//关闭文件
sslStream.Flush();//关闭服务流
logCallback?.Invoke("文件传输完毕：");
}
else
{
logCallback?.Invoke("请求的文件不存在：" + wholePath);
}
}
else//上传文件
{
FileStream fs;
DownloadCommand command1 = new DownloadCommand();
command1.filename = receivedCommand.filename;//获取文件名
command1.is_download = false;
if (File.Exists(wholePath))//判断文件存在
{
fs = File.OpenWrite(wholePath);//打开文件
fs.Seek(0, SeekOrigin.End);//读取文件长度
command1.filestart = (int)fs.Length;//写入长度
}
else//不存在则创建文件夹
{
command1.filestart = 0;
fs = File.Create(wholePath);
}
string command1Json = JsonConvert.SerializeObject(command1);//序列化字符串json
message = Encoding.UTF8.GetBytes(command1Json);//把数据转成utf-8 的byte数组
sslStream.Write(message);//写入数据
sslStream.Flush();//结束写入
logCallback?.Invoke("已发送回应：指定从文件的第" + command1.filestart.ToString() + "字节开始下载");

byte[] sizeArray = new byte[8];//申请内存
sslStream.Read(sizeArray, 0, 8);//把数据读出来，读取8 个byte长度的数据
long fileLength = System.BitConverter.ToInt64(sizeArray, 0);//文件总大小
logCallback?.Invoke("文件总大小：" + fileLength.ToString() + "字节");
logCallback?.Invoke("文件开始接收：" + wholePath);
byte[] buffer = new byte[1024]; //申请1024长度的缓存
long receivedLength = command1.filestart;
while (receivedLength < fileLength)//循环读取，每次读取1024
{
int block = sslStream.Read(buffer, 0, 1024);
if (block > 0)
{
fs.Write(buffer, 0, block);//把数据写进去
receivedLength += block;//数据递增
}
}
logCallback?.Invoke("文件传输完成：" + wholePath);
fs.Flush();//关闭文件流
fs.Close();//关闭文件
}
}
catch (AuthenticationException e){//用来捕获错误信息
logCallback?.Invoke("Exception: " + e.Message);
if (e.InnerException != null)
{
logCallback?.Invoke("Inner exception: " + e.InnerException.Message);
}
logCallback?.Invoke("身份认证失败 - 正在关闭连接...");
sslStream.Close();//关闭服务流
client.Close();//关闭连接
return;
}
finally
{
sslStream.Close();
client.Close();
}
sslStream.Close();
client.Close();
}
string ReadMessage(SslStream sslStream)//从服务流里读取数据
{
byte[] buffer = new byte[2048];//每次读取2048
StringBuilder messageData = new StringBuilder();//可以自动控制大小
Decoder decoder = Encoding.UTF8.GetDecoder();//转成utf-8
int bytes;
do
{
bytes = sslStream.Read(buffer, 0, buffer.Length);//开始读取数据
char[] chars = new char[decoder.GetCharCount(buffer, 0, bytes)];//转成char 数据
decoder.GetChars(buffer, 0, bytes, chars, 0);
messageData.Append(chars);//拼接数据
if (messageData.ToString().IndexOf("") != -1)//判断是否已经写入数据
{
break;
}
}
while (bytes != 0);

return messageData.ToString();//返回string数据
}
}

文件加密传输，进度条，断点