using HalconDotNet;
|
using Microsoft.Win32;
|
using LB_SmartVision;
|
using SharpCompress.Common;
|
using System.Collections.Concurrent;
|
using System.Configuration;
|
using System.Diagnostics;
|
using System.Drawing.Imaging;
|
using System.Runtime.InteropServices;
|
using System.Security;
|
using System.Security.Cryptography;
|
using System.Text;
|
using System.Text.RegularExpressions;
|
using System.Threading.Tasks;
|
|
namespace LB_SmartVision.Tool
|
{
|
public sealed class Tool : IDisposable
|
{
|
// 静态构造函数启动消费者任务
|
static Tool()
|
{
|
// 启动消费者任务
|
_logConsumerTask = Task.Factory.StartNew(
|
() => ProcessLogQueue(_logCts.Token),
|
_logCts.Token,
|
TaskCreationOptions.LongRunning,
|
TaskScheduler.Default);
|
|
// FIFO 行为，超出容量时阻塞
|
_RealImageQueue = new BlockingCollection<ImageSaveTask>(capacity);
|
_RealImageCts = new CancellationTokenSource();
|
StartRealImageConsumer();
|
}
|
|
public void Dispose()
|
{
|
try
|
{
|
// 停止接受新日志
|
_logQueue.CompleteAdding();
|
// 取消正在进行的操作
|
_logCts.Cancel();
|
// 等待消费者完成
|
if (!_logConsumerTask.Wait(TimeSpan.FromSeconds(5)))
|
{
|
Debug.WriteLine("日志消费者线程关闭超时");
|
}
|
|
_RealImageCts.Cancel();
|
_RealImageQueue.CompleteAdding();
|
while (_RealImageQueue.TryTake(out var task))
|
{
|
if (task.Image is Bitmap bitmap)
|
{
|
bitmap.Dispose();
|
}
|
else if (task.Image is HObject hobject)
|
{
|
hobject.Dispose();
|
}
|
}
|
_RealImageCts.Dispose();
|
_RealImageQueue.Dispose();
|
_RealImageConsumerTask?.Dispose();
|
}
|
catch { }
|
finally
|
{
|
_logCts.Dispose();
|
_logQueue.Dispose();
|
}
|
}
|
|
#region 日志功能
|
|
|
public static string _logFilePath = Path.Combine(GlobalVar.strPathLog, $"{GlobalVar.strStartTime}.log");
|
public static string _logFilePathBackup = Path.Combine(GlobalVar.strPathLog, $"{GlobalVar.strStartTime}(副本).log");
|
|
private static readonly BlockingCollection<string> _logQueue = new BlockingCollection<string>(1024);
|
private static readonly CancellationTokenSource _logCts = new CancellationTokenSource();
|
private static Task _logConsumerTask;
|
private static readonly object _fileLock = new object();
|
|
// 添加日志到队列
|
public static bool AddLog(string message)
|
{
|
if (!_logQueue.IsAddingCompleted)
|
{
|
try
|
{
|
_logQueue.Add(message, _logCts.Token);
|
return true;
|
}
|
catch (InvalidOperationException)
|
{
|
// 队列已关闭
|
return false;
|
}
|
}
|
return false;
|
}
|
|
// 消费者任务处理队列
|
private static void ProcessLogQueue(CancellationToken ct)
|
{
|
try
|
{
|
foreach (var logEntry in _logQueue.GetConsumingEnumerable(ct))
|
{
|
lock (_fileLock)
|
{
|
try
|
{
|
File.AppendAllText(_logFilePath, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} {logEntry}{Environment.NewLine}");
|
}
|
catch
|
{
|
try
|
{
|
// 日志写入失败二次尝试
|
File.AppendAllText(_logFilePath, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} {logEntry}{Environment.NewLine}");
|
}
|
catch
|
{
|
try
|
{
|
// 日志写入失败处理（可添加到备用队列或控制台输出）
|
File.AppendAllText(_logFilePathBackup, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} {logEntry}{Environment.NewLine}");
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"日志写入失败: {ex.Message}");
|
}
|
}
|
}
|
}
|
|
}
|
}
|
catch (OperationCanceledException)
|
{
|
// 正常取消
|
}
|
}
|
|
// 尝试写入文件的辅助方法
|
private static bool TryWriteToFile(string path, byte[] data)
|
{
|
try
|
{
|
using (var stream = new FileStream(
|
path,
|
FileMode.Append,
|
FileAccess.Write,
|
FileShare.ReadWrite,
|
bufferSize: 4096,
|
useAsync: true))
|
{
|
stream.Write(data, 0, data.Length);
|
return true;
|
}
|
}
|
catch
|
{
|
return false;
|
}
|
}
|
#endregion
|
|
#region 存原图功能
|
/// <summary>
|
/// 超出容量时阻塞
|
/// </summary>
|
private static readonly BlockingCollection<ImageSaveTask> _RealImageQueue;
|
private static readonly CancellationTokenSource _RealImageCts;
|
private static Task _RealImageConsumerTask;
|
private static int _restartCount;
|
private const int MaxRestarts = 5;
|
private static int capacity = 10; // 队列容量
|
|
// 获取指定图像格式的编码器信息
|
private static ImageCodecInfo GetEncoder(ImageFormat format)
|
{
|
// 获取所有已安装的图像编码器
|
ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
|
|
// 查找匹配指定格式的编码器
|
return codecs.FirstOrDefault(codec => codec.FormatID == format.Guid);
|
}
|
|
public static long _imageQuality = 100L;
|
static ImageCodecInfo jpegEncoder = null;
|
static EncoderParameters encoderParams = null;
|
static char[] invalidChars = Path.GetInvalidFileNameChars();
|
|
// 图片保存任务结构
|
public struct ImageSaveTask
|
{
|
public object Image { get; set; }
|
public string FullPath { get; set; }
|
|
public string ImageType { get; set; }
|
|
public long Quality { get; set; }
|
|
public ImageSaveTask(object image, string fullPath, string imageType = "jpg", long quality = 50L)
|
{
|
Image = image;
|
FullPath = fullPath;
|
ImageType = imageType.ToLower();
|
Quality = quality;
|
}
|
}
|
|
private static void StartRealImageConsumer()
|
{
|
_RealImageConsumerTask = Task.Run(async () =>
|
{
|
try
|
{
|
await RealImageProcessQueue();
|
}
|
catch when (_RealImageCts.IsCancellationRequested)
|
{
|
// 正常关闭
|
}
|
catch (Exception ex)
|
{
|
if (++_restartCount <= MaxRestarts)
|
{
|
StartRealImageConsumer(); // 自动重启
|
}
|
AddLog($"保存图片StartRealImageConsumer出现异常:{ex.Message}");
|
}
|
}, _RealImageCts.Token);
|
}
|
|
private static async Task RealImageProcessQueue()
|
{
|
foreach (var task in _RealImageQueue.GetConsumingEnumerable(_RealImageCts.Token))
|
{
|
try
|
{
|
await SaveImageAsync(task);
|
}
|
catch (Exception ex)
|
{
|
AddLog($"保存图片RealImageProcessQueue出现异常:{ex.Message}");
|
}
|
finally
|
{
|
if (task.Image != null)
|
{
|
if (task.Image is Bitmap bitmap)
|
{
|
bitmap.Dispose();
|
}
|
if (task.Image is HObject hobject)
|
{
|
hobject.Dispose();
|
}
|
}
|
}
|
}
|
}
|
|
public static void AddRealImage(object image, string filePath, string fileName, string imageType = "jpg", long quality = 50L)
|
{
|
if (_RealImageCts.IsCancellationRequested)
|
throw new InvalidOperationException("Processor is shutting down");
|
|
if (IsSave(filePath))
|
{
|
string fullPath = Path.Combine(filePath, $"{fileName}.{imageType.ToLower()}");
|
|
// FIFO 行为，超出容量时阻塞
|
//// 缓存图片大于容量说明磁盘存储不过来了,取出所有元素直到队列为空
|
//if (_RealImageQueue.Count >= capacity + 1)
|
//{
|
// AddLog("缓存图片超过10张,清空已经缓存的旧图片");
|
// while (_RealImageQueue.TryTake(out _)) { }
|
//}
|
|
if (image is HObject hObject)
|
{
|
_RealImageQueue.Add(new ImageSaveTask
|
{
|
Image = hObject.Clone(),
|
FullPath = fullPath,
|
ImageType = imageType.ToLower(),
|
Quality = quality
|
}, _RealImageCts.Token);
|
}
|
else if (image is Bitmap bitmap)
|
{
|
_RealImageQueue.Add(new ImageSaveTask
|
{
|
Image = bitmap.Clone(),
|
FullPath = fullPath,
|
ImageType = imageType.ToLower(),
|
Quality = quality
|
}, _RealImageCts.Token);
|
}
|
}
|
}
|
|
// 程序启动时初始化编码器缓存
|
private static readonly Dictionary<Guid, ImageCodecInfo> _encoderCache =
|
ImageCodecInfo.GetImageEncoders()
|
.ToDictionary(codec => codec.FormatID);
|
|
// 通过ImageFormat获取编码器
|
private static ImageCodecInfo GetEncoderByFormat(ImageFormat format)
|
{
|
_encoderCache.TryGetValue(format.Guid, out var encoder);
|
return encoder;
|
}
|
|
// 通过字符串类型获取编码器
|
private static ImageCodecInfo GetEncoderByType(string imageType)
|
{
|
var format = GetImageFormat(imageType);
|
return GetEncoderByFormat(format);
|
}
|
|
// 获取ImageFormat的辅助方法
|
private static ImageFormat GetImageFormat(string imageType)
|
{
|
switch (imageType.ToLowerInvariant())
|
{
|
case "jpg":
|
case "jpeg": return ImageFormat.Jpeg;
|
case "png": return ImageFormat.Png;
|
case "bmp": return ImageFormat.Bmp;
|
case "gif": return ImageFormat.Gif;
|
case "tif":
|
case "tiff": return ImageFormat.Tiff;
|
default: throw new NotSupportedException($"不支持的图片格式: {imageType}");
|
}
|
}
|
|
private static async Task SaveImageAsync(ImageSaveTask task)
|
{
|
try
|
{
|
// 参数校验
|
if (task.Image == null) throw new ArgumentNullException(nameof(task.Image));
|
if (string.IsNullOrWhiteSpace(task.FullPath))
|
throw new ArgumentException("Invalid file path");
|
|
var dir = Path.GetDirectoryName(task.FullPath);
|
if (!Directory.Exists(dir))
|
{
|
Directory.CreateDirectory(dir);
|
}
|
|
if (task.Image is HObject hObject && hObject.IsInitialized())
|
{
|
try
|
{
|
//Halcon存图需要用斜杠
|
task.FullPath.Replace("\\", "/");
|
HOperatorSet.WriteImage(hObject, task.ImageType, 0, task.FullPath);
|
}
|
catch { AddLog("保存图片时HOperatorSet.WriteImage发生异常"); }
|
}
|
else if (task.Image is Bitmap bitmap)
|
{
|
// 获取对应格式的编码器
|
ImageCodecInfo encoder = GetEncoderByType(task.ImageType);
|
|
// 配置编码参数
|
var encoderParams = new EncoderParameters(1);
|
encoderParams.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, task.Quality);
|
|
// 使用内存流中转避免文件锁冲突
|
using (var memoryStream = new MemoryStream())
|
{
|
// 同步编码转异步操作（线程池优化）
|
await Task.Run(() =>
|
{
|
bitmap.Save(memoryStream, encoder, encoderParams);
|
memoryStream.Position = 0; // 重置流位置
|
}).ConfigureAwait(false);
|
|
// 原子性写入（临时文件+替换）
|
var tempPath = $"{task.FullPath}.{Guid.NewGuid()}.tmp";
|
|
// 异步文件写入（带缓冲区优化）
|
using (var fileStream = new FileStream(
|
tempPath,
|
FileMode.Create,
|
FileAccess.Write,
|
FileShare.None,
|
bufferSize: 81920, // 80KB缓冲区
|
useAsync: true))
|
{
|
await memoryStream.CopyToAsync(fileStream)
|
.ConfigureAwait(false);
|
}
|
|
// 原子替换文件（跨平台兼容）
|
File.Move(tempPath, task.FullPath);
|
}
|
}
|
}
|
catch (Exception ex) when (IsRetryableException(ex))
|
{
|
AddLog($"保存图片IsRetryableException出现异常:{ex.Message}");
|
}
|
catch (Exception ex)
|
{
|
AddLog($"保存图片SaveImageAsync出现异常:{ex.Message}");
|
}
|
}
|
|
// 判断是否可重试的异常
|
private static bool IsRetryableException(Exception ex)
|
{
|
return ex is IOException
|
or UnauthorizedAccessException
|
or TimeoutException;
|
}
|
#endregion
|
|
#region 磁盘回收功能
|
public static double MinSpace = 10;
|
/// <summary>
|
/// 获取磁盘剩余空间
|
/// </summary>
|
/// <param name="strPath"></param>
|
/// <returns></returns>
|
public static double GetHardDiskFreeSpace(string strPath)
|
{
|
//磁盘名称
|
string strHardDiskName = strPath.Substring(0, 1);
|
|
//获取C盘的剩余空间
|
DriveInfo cDrive = new DriveInfo(strHardDiskName);
|
// 检查驱动器是否是有效的
|
if (cDrive.IsReady)
|
{
|
// 获取剩余空间
|
long freeSpace = cDrive.AvailableFreeSpace;
|
|
// 将字节数转换为GB单位
|
return (double)freeSpace / (1024 * 1024 * 1024);
|
}
|
else
|
{
|
return 0;
|
}
|
}
|
|
/// <summary>
|
/// 判断是否允许保存
|
/// </summary>
|
/// <param name="fullPath">保存文件的完整路径</param>
|
/// <returns></returns>
|
public static bool IsSave(string fullPath)
|
{
|
// 获取上一级目录（父目录）
|
string parentDirectory = Path.GetDirectoryName(fullPath);
|
if (GetHardDiskFreeSpace(parentDirectory) >= MinSpace)
|
return true;
|
else
|
{
|
if (DeletOutTimeFiles(parentDirectory))
|
{
|
// 删除超期文件后再次判断容量能否存储
|
if (GetHardDiskFreeSpace(parentDirectory) >= MinSpace)
|
return true;
|
|
return false;
|
}
|
else
|
return false;
|
}
|
}
|
|
/// <summary>
|
///删除超出时间的文件夹路径
|
/// </summary>
|
/// <param name="directoryPath"></param>
|
/// <returns></returns>
|
public static bool DeletOutTimeFiles(string directoryPath, int days = 30)
|
{
|
try
|
{
|
// 保存时间不超过30天
|
DateTime NowTime = DateTime.Now; // 当前日期作为截止日期
|
DirectoryInfo directoryInfo = new DirectoryInfo(directoryPath);
|
DirectoryInfo[] directories = directoryInfo.GetDirectories();
|
|
for (int i = 0; i < directories.Length; i++)
|
{
|
if (directories[i].CreationTime.AddDays(days) < NowTime)
|
{
|
try
|
{
|
Directory.Delete(directories[i].FullName, recursive: true);
|
Debug.WriteLine($"Deleted {directories[i].FullName}");
|
}
|
catch (Exception ex)
|
{
|
// 可以选择在这里记录日志继续处理下一个文件
|
Debug.WriteLine($"Error deleting {directories[i].FullName}: {ex.Message}");
|
}
|
}
|
}
|
|
AddLog($"磁盘空间不足,已删除路径[{directoryPath}]超过{days}天的文件,累计{directories.Length}个!");
|
return true;
|
}
|
catch { return false; }
|
}
|
|
#endregion
|
|
public static bool ContainsChinese(string text)
|
{
|
if (string.IsNullOrEmpty(text))
|
{
|
return false;
|
}
|
|
return Regex.IsMatch(text, @"[\u4e00-\u9fa5]");
|
}
|
|
/// <summary>
|
/// 保存CSV到本地
|
/// </summary>
|
/// <param name="fileDirectoryAndName"></param>
|
/// <param name="obj"></param>
|
public static void WriteDataToFile(string fileDirectoryAndName, object[] obj)
|
{
|
try
|
{
|
string text = "";
|
// 写入CSV文件
|
using (var streamWriter = new StreamWriter(fileDirectoryAndName, true, Encoding.UTF8))
|
{
|
for (int i = 0; i < obj.Length; i++)
|
{
|
text += (obj[i].ToString().Replace(",", "，"));
|
if (i < obj.Length - 1)
|
{
|
text += ",";
|
}
|
}
|
streamWriter.Write(text);
|
streamWriter.WriteLine(); // 写入换行符
|
}
|
}
|
catch { }
|
}
|
|
/// <summary>
|
/// 保存数据到本地
|
/// </summary>
|
/// <param name="strCCDName"></param>
|
/// <param name="timeCode"></param>
|
/// <param name="productCode"></param>
|
/// <param name="result"></param>
|
/// <param name="resultData"></param>
|
public static void SaveData(string filePath, List<string> DataTitle, Dictionary<string, object> resultData)
|
{
|
try
|
{
|
if (resultData.Count <= 0 || resultData == null)
|
{
|
return;
|
}
|
|
var dir = Path.GetDirectoryName(filePath);
|
if (!Directory.Exists(dir))
|
{
|
Directory.CreateDirectory(dir);
|
}
|
|
if (!File.Exists(filePath))
|
{
|
WriteDataToFile(filePath, DataTitle.ToArray());
|
}
|
|
List<string> SaveData = new List<string>();
|
|
foreach (var item in DataTitle)
|
{
|
if (resultData.ContainsKey(item))
|
{
|
double dData = 0;
|
if (double.TryParse(resultData[item].ToString(), out dData))
|
{
|
SaveData.Add(dData.ToString("F2"));
|
}
|
else
|
{
|
SaveData.Add((resultData[item]?.ToString()).Replace(",", "，").ToString());
|
}
|
}
|
else
|
SaveData.Add("NULL");
|
}
|
try
|
{
|
WriteDataToFile(filePath, SaveData.ToArray());
|
}
|
catch (Exception ex)
|
{
|
//文件被占用保存到副本中
|
try
|
{
|
//再次尝试写入
|
WriteDataToFile(filePath, SaveData.ToArray());
|
}
|
catch
|
{
|
//写入失败写到副本中
|
filePath = AddCopySuffix(filePath, "(副本)");
|
if (!File.Exists(filePath))
|
{
|
WriteDataToFile(filePath, DataTitle.ToArray());
|
}
|
|
WriteDataToFile(filePath, SaveData.ToArray());
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
AddLog("生产数据保存失败,原因是:" + ex.ToString());
|
}
|
}
|
|
public static string AddCopySuffix(string filePath, string suffix = "(副本)")
|
{
|
if (string.IsNullOrEmpty(filePath))
|
{
|
return filePath;
|
}
|
|
string directory = Path.GetDirectoryName(filePath);
|
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
|
string extension = Path.GetExtension(filePath);
|
|
return Path.Combine(directory, $"{fileNameWithoutExtension}({suffix}){extension}");
|
}
|
|
/// <summary>
|
/// 加密文件
|
/// </summary>
|
/// <param name="inputFilePath"></param>
|
/// <param name="outputFilePath"></param>
|
/// <param name="key"></param>
|
/// <param name="iv"></param>
|
public static void EncryptFile(string inputFilePath, string outputFilePath, string key = "", string iv = "")
|
{
|
using (Aes aes = Aes.Create())
|
{
|
if (key != "")
|
{
|
aes.Key = Convert.FromBase64String(key);
|
aes.IV = Convert.FromBase64String(iv);
|
}
|
else
|
{
|
aes.Key = new byte[32];
|
aes.IV = new byte[16];
|
}
|
|
using (FileStream outputFileStream = new FileStream(outputFilePath, FileMode.Create))
|
using (ICryptoTransform encryptor = aes.CreateEncryptor())
|
using (CryptoStream cryptoStream = new CryptoStream(outputFileStream, encryptor, CryptoStreamMode.Write))
|
using (FileStream inputFileStream = new FileStream(inputFilePath, FileMode.Open))
|
{
|
inputFileStream.CopyTo(cryptoStream);
|
}
|
}
|
}
|
|
/// <summary>
|
/// 解密文件
|
/// </summary>
|
/// <param name="inputFilePath"></param>
|
/// <param name="outputFilePath"></param>
|
/// <param name="key"></param>
|
/// <param name="iv"></param>
|
public static void DecryptFile(string inputFilePath, string outputFilePath, string key = "", string iv = "")
|
{
|
using (Aes aes = Aes.Create())
|
{
|
if (key != "")
|
{
|
aes.Key = Convert.FromBase64String(key);
|
aes.IV = Convert.FromBase64String(iv);
|
}
|
else
|
{
|
aes.Key = new byte[32];
|
aes.IV = new byte[16];
|
}
|
|
using (FileStream inputFileStream = new FileStream(inputFilePath, FileMode.Open))
|
using (ICryptoTransform decryptor = aes.CreateDecryptor())
|
using (CryptoStream cryptoStream = new CryptoStream(inputFileStream, decryptor, CryptoStreamMode.Read))
|
using (FileStream outputFileStream = new FileStream(outputFilePath, FileMode.Create))
|
{
|
cryptoStream.CopyTo(outputFileStream);
|
}
|
}
|
}
|
|
#region 加密狗
|
private const string DOG_AES_SALT = "MYAPP_KEY_SALT";
|
private const string DOG_AES_KEY = "MYAPP_AES_KEY";
|
private const string DOG_AES_IV = "MYAPP_AES_IV";
|
private const string REGISTRY_PATH = @"SOFTWARE\MyApp\SoftDog";
|
|
private static bool SetRegistryValue(RegistryKey baseKey, string valueName, string value)
|
{
|
try
|
{
|
using (RegistryKey key = baseKey.CreateSubKey(REGISTRY_PATH, RegistryKeyPermissionCheck.ReadWriteSubTree))
|
{
|
if (key != null)
|
{
|
key.SetValue(valueName, value, RegistryValueKind.String);
|
return true;
|
}
|
}
|
}
|
catch (SecurityException)
|
{
|
// 权限不足，正常情况
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"设置注册表值失败: {ex.Message}");
|
}
|
|
return false;
|
}
|
|
private static string GetRegistryValue(string valueName)
|
{
|
// 先尝试HKLM
|
string value = GetRegistryValue(Registry.LocalMachine, valueName);
|
if (!string.IsNullOrEmpty(value))
|
{
|
return value;
|
}
|
|
// 再尝试HKCU
|
return GetRegistryValue(Registry.CurrentUser, valueName);
|
}
|
|
private static string GetRegistryValue(RegistryKey baseKey, string valueName)
|
{
|
try
|
{
|
using (RegistryKey key = baseKey.OpenSubKey(REGISTRY_PATH, false))
|
{
|
return key?.GetValue(valueName) as string;
|
}
|
}
|
catch
|
{
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// 获取AES加密参数
|
/// </summary>
|
public static (byte[] Key, byte[] IV) GetAesParameters()
|
{
|
try
|
{
|
string keyBase64 = GetRegistryValue(DOG_AES_KEY);
|
string ivBase64 = GetRegistryValue(DOG_AES_IV);
|
|
// 如果系统级没有，尝试用户级
|
|
if (!string.IsNullOrEmpty(keyBase64) && !string.IsNullOrEmpty(ivBase64))
|
{
|
byte[] key = Convert.FromBase64String(keyBase64);
|
byte[] iv = Convert.FromBase64String(ivBase64);
|
|
return (key, iv);
|
}
|
|
return (null, null);
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"获取AES参数失败: {ex.Message}");
|
return (null, null);
|
}
|
}
|
|
/// <summary>
|
/// 验证加密狗
|
/// </summary>
|
public static bool ValidateAesDog()
|
{
|
var (key, iv) = GetAppBoundKey("VisionUltra");
|
|
if (key == null || iv == null)
|
return false;
|
|
// 验证密钥和IV的格式和长度
|
return key.Length == 32 && iv.Length == 16; // AES-256: 32字节密钥, 16字节IV
|
}
|
|
/// <summary>
|
/// 生成与应用绑定的AES加密狗
|
/// </summary>
|
public static bool GenerateAppBoundDog(string appIdentifier)
|
{
|
try
|
{
|
using (Aes aes = Aes.Create())
|
{
|
aes.GenerateKey();
|
aes.GenerateIV();
|
|
// 使用应用标识符作为盐值
|
byte[] salt = Encoding.UTF8.GetBytes(appIdentifier);
|
|
// 加密密钥本身（可选的安全增强）
|
byte[] encryptedKey = EncryptKeyWithSalt(aes.Key, salt, aes.IV);
|
|
// 存储加密后的密钥和盐值
|
string encryptedKeyBase64 = Convert.ToBase64String(encryptedKey);
|
string saltBase64 = Convert.ToBase64String(salt);
|
string ivBase64 = Convert.ToBase64String(aes.IV);
|
|
bool success = SetRegistryValue(Registry.CurrentUser, DOG_AES_KEY, encryptedKeyBase64);
|
success &= SetRegistryValue(Registry.CurrentUser, DOG_AES_SALT, saltBase64);
|
success &= SetRegistryValue(Registry.CurrentUser, DOG_AES_IV, ivBase64);
|
|
return success;
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"生成应用绑定加密狗失败: {ex.Message}");
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 验证并获取应用绑定密钥
|
/// </summary>
|
public static (byte[] Key, byte[] IV) GetAppBoundKey(string expectedAppIdentifier)
|
{
|
try
|
{
|
string encryptedKeyBase64 = GetRegistryValue(DOG_AES_KEY);
|
string saltBase64 = GetRegistryValue(DOG_AES_SALT);
|
string ivBase64 = GetRegistryValue(DOG_AES_IV);
|
|
if (string.IsNullOrEmpty(encryptedKeyBase64) || string.IsNullOrEmpty(saltBase64) || string.IsNullOrEmpty(ivBase64))
|
{
|
return (null, null);
|
}
|
|
byte[] encryptedKey = Convert.FromBase64String(encryptedKeyBase64);
|
byte[] salt = Convert.FromBase64String(saltBase64);
|
byte[] iv = Convert.FromBase64String(ivBase64);
|
|
// 验证应用标识符
|
string storedAppIdentifier = Encoding.UTF8.GetString(salt);
|
if (storedAppIdentifier != expectedAppIdentifier)
|
{
|
return (null, null);
|
}
|
|
// 解密密钥
|
byte[] key = DecryptKeyWithSalt(encryptedKey, salt, iv);
|
|
return (key, iv);
|
}
|
catch (Exception ex)
|
{
|
Debug.WriteLine($"获取应用绑定密钥失败: {ex.Message}");
|
return (null, null);
|
}
|
}
|
|
private static byte[] EncryptKeyWithSalt(byte[] key, byte[] salt, byte[] iv)
|
{
|
using (var deriveBytes = new Rfc2898DeriveBytes(key, salt, 10000, HashAlgorithmName.SHA256))
|
{
|
byte[] derivedKey = deriveBytes.GetBytes(32); // AES-256
|
// 这里可以添加额外的加密逻辑
|
return derivedKey;
|
}
|
}
|
|
private static byte[] DecryptKeyWithSalt(byte[] encryptedKey, byte[] salt, byte[] iv)
|
{
|
// 反向解密过程
|
using (var deriveBytes = new Rfc2898DeriveBytes(encryptedKey, salt, 10000, HashAlgorithmName.SHA256))
|
{
|
return deriveBytes.GetBytes(32);
|
}
|
}
|
|
/// <summary>
|
/// 使用加密狗中的密钥加密数据
|
/// </summary>
|
public static string EncryptWithDog(string plainText)
|
{
|
var (key, iv) = GetAesParameters();
|
|
if (key == null || iv == null)
|
throw new InvalidOperationException("未找到有效的加密狗");
|
|
using (Aes aes = Aes.Create())
|
{
|
aes.Key = key;
|
aes.IV = iv;
|
|
ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
|
|
using (var ms = new MemoryStream())
|
using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
|
{
|
using (var sw = new StreamWriter(cs))
|
{
|
sw.Write(plainText);
|
}
|
return Convert.ToBase64String(ms.ToArray());
|
}
|
}
|
}
|
|
/// <summary>
|
/// 使用加密狗中的密钥解密数据
|
/// </summary>
|
public static string DecryptWithDog(string cipherText)
|
{
|
var (key, iv) = GetAesParameters();
|
|
if (key == null || iv == null)
|
throw new InvalidOperationException("未找到有效的加密狗");
|
|
using (Aes aes = Aes.Create())
|
{
|
aes.Key = key;
|
aes.IV = iv;
|
|
ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
|
|
byte[] cipherBytes = Convert.FromBase64String(cipherText);
|
|
using (var ms = new MemoryStream(cipherBytes))
|
using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
|
using (var sr = new StreamReader(cs))
|
{
|
return sr.ReadToEnd();
|
}
|
}
|
}
|
|
/// <summary>
|
/// 注册加密狗
|
/// </summary>
|
public static bool RegistrationDog()
|
{
|
Debug.WriteLine("正在生成AES加密狗...");
|
|
if (GenerateAppBoundDog("VisionUltra"))
|
{
|
Debug.WriteLine("AES加密狗生成成功！");
|
|
// 建议用户备份这些值
|
Debug.WriteLine("\n请妥善保存以上密钥信息！");
|
return true;
|
}
|
else
|
{
|
Debug.WriteLine("加密狗生成失败，请以管理员身份运行");
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 检查软加密狗
|
/// </summary>
|
/// <returns></returns>
|
public static bool CheckDog()
|
{
|
if (!ValidateAesDog())
|
{
|
Debug.WriteLine("未找到有效的AES加密狗");
|
|
return false;
|
}
|
|
Debug.WriteLine("AES加密狗验证成功");
|
return true;
|
}
|
|
|
|
#endregion
|
|
/// <summary>
|
/// 复制文件夹及其内容
|
/// </summary>
|
/// <param name="sourceDir"></param>
|
/// <param name="destDir"></param>
|
/// <returns></returns>
|
public static bool CopyDirectory(string sourceDir, string destDir)
|
{
|
try
|
{
|
// 检查目标文件夹是否存在，如果不存在，则创建它
|
if (!Directory.Exists(destDir))
|
{
|
Directory.CreateDirectory(destDir);
|
}
|
|
// 复制所有文件到目标文件夹
|
foreach (string file in Directory.GetFiles(sourceDir))
|
{
|
string destFile = Path.Combine(destDir, Path.GetFileName(file));
|
File.Copy(file, destFile, true); // 第三个参数为 true，表示如果文件已存在，则覆盖它
|
}
|
|
// 递归复制所有子文件夹
|
foreach (string subDir in Directory.GetDirectories(sourceDir))
|
{
|
string destSubDir = Path.Combine(destDir, Path.GetFileName(subDir));
|
CopyDirectory(subDir, destSubDir); // 递归调用复制子文件夹
|
}
|
return true;
|
}
|
catch { return false; }
|
}
|
|
/// <summary>
|
/// 重命名文件夹
|
/// </summary>
|
/// <param name="oldDir"></param>
|
/// <param name="newDir"></param>
|
/// <returns></returns>
|
public static bool RenameDirectory(string oldDir, string newDir)
|
{
|
try
|
{
|
// 重命名文件夹
|
if (Directory.Exists(oldDir))
|
{
|
Directory.Move(oldDir, newDir);
|
return true;
|
}
|
Debug.WriteLine($"文件不存在: {oldDir}");
|
return false;
|
}
|
catch { return false; }
|
}
|
|
/// <summary>
|
/// 重命名文件
|
/// </summary>
|
/// <param name="oldFile"></param>
|
/// <param name="newFile"></param>
|
/// <returns></returns>
|
public static bool RenameFile(string oldFile, string newFile)
|
{
|
try
|
{
|
if (!File.Exists(newFile))
|
{
|
// 重命名文件
|
File.Move(oldFile, newFile);
|
Debug.WriteLine($"文件已重命名: {oldFile} -> {newFile}");
|
return true;
|
}
|
|
Debug.WriteLine($"文件不存在: {oldFile}");
|
return false;
|
}
|
catch { return false; }
|
}
|
|
#region 读写到exe.Config文件
|
public static void WriteConfig(string node, string value)
|
{
|
System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
|
if (config.AppSettings.Settings[node] == null)
|
{
|
config.AppSettings.Settings.Add(node, value);
|
}
|
else
|
{
|
config.AppSettings.Settings[node].Value = value;
|
}
|
config.Save(ConfigurationSaveMode.Modified);
|
ConfigurationManager.RefreshSection("appSettings");//重新加载新的配置文件
|
}
|
public static bool ReadStringConfig(string node, out string result)
|
{
|
result = "";
|
try
|
{
|
if (ConfigurationManager.AppSettings != null && ConfigurationManager.AppSettings.Count > 0 && ConfigurationManager.AppSettings.AllKeys.Contains(node))
|
{
|
result = ConfigurationManager.AppSettings[node].ToString();
|
if (result == null)
|
{
|
WriteConfig(node, "");
|
result = "";
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
else
|
{
|
return false;
|
}
|
}
|
catch
|
{
|
WriteConfig(node, "");
|
result = "";
|
return false;
|
}
|
}
|
|
public static bool ReadBoolenConfig(string node, out bool result)
|
{
|
result = false;
|
try
|
{
|
result = Convert.ToBoolean(ConfigurationManager.AppSettings[node]);
|
if (result == null)
|
{
|
WriteConfig(node, (false).ToString());
|
result = false;
|
return false;
|
|
}
|
else
|
{
|
return true;
|
}
|
}
|
catch
|
{
|
WriteConfig(node, (false).ToString());
|
result = false;
|
return false;
|
}
|
}
|
#endregion
|
}
|
}
|
