using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using NewLife;
using NewLife.Log;
namespace NewLife.XCoder.Services;
/// <summary>本地凭据存储:把连接串密码、密钥等敏感值加密后存到配置目录</summary>
/// <remarks>
/// Windows 优先用系统 DPAPI(当前用户绑定,密钥由系统保管),DPAPI 不可用时回退 AES-256-CBC;
/// 其它平台统一用 AES-256-CBC,密钥由「机器名 + 用户名 + 固定盐」派生。
/// 文件里带算法前缀(<c>dpapi:</c> / <c>aes:</c>),旧版无前缀数据仍按 AES 读取。
/// 两者都是**本机绑定**加密,换机器或换用户后无法解密,符合「凭据不出本机」的预期。
/// </remarks>
public class CredentialStore
{
private const String _PrefixDpapi = "dpapi:";
private const String _PrefixAes = "aes:";
private static readonly String _DefaultFile = Path.Combine(AppPaths.ConfigDirectory, "credentials.dat");
private readonly Dictionary<String, String> _items = new(StringComparer.Ordinal);
private readonly Object _lock = new();
/// <summary>全局实例</summary>
public static CredentialStore Instance { get; } = new();
/// <summary>存储文件路径(测试可注入临时路径)</summary>
public String FilePath { get; }
/// <summary>实例化,使用默认存储文件</summary>
public CredentialStore() : this(_DefaultFile) { }
/// <summary>实例化</summary>
/// <param name="filePath">存储文件路径</param>
public CredentialStore(String filePath)
{
FilePath = filePath;
Load();
}
/// <summary>读取一个凭据</summary>
/// <param name="key">凭据键</param>
/// <returns>明文;不存在或解密失败返回 null</returns>
public String? Get(String key)
{
if (key.IsNullOrEmpty()) return null;
lock (_lock) return _items.TryGetValue(key!, out var value) ? value : null;
}
/// <summary>写入/更新一个凭据</summary>
/// <param name="key">凭据键</param>
/// <param name="secret">明文</param>
public void Set(String key, String secret)
{
if (key.IsNullOrEmpty()) throw new ArgumentException("凭据键不能为空", nameof(key));
lock (_lock)
{
if (secret.IsNullOrEmpty()) _items.Remove(key!);
else _items[key!] = secret!;
Save();
}
}
/// <summary>删除一个凭据</summary>
/// <param name="key">凭据键</param>
/// <returns>是否存在并删除</returns>
public Boolean Remove(String key)
{
if (key.IsNullOrEmpty()) return false;
lock (_lock)
{
if (!_items.Remove(key!)) return false;
Save();
return true;
}
}
/// <summary>全部凭据键(不含值)</summary>
public IReadOnlyList<String> Keys
{
get
{
lock (_lock) return [.. _items.Keys];
}
}
/// <summary>清空全部凭据</summary>
public void Clear()
{
lock (_lock)
{
_items.Clear();
Save();
}
}
private void Load()
{
try
{
if (!File.Exists(FilePath)) return;
foreach (var raw in File.ReadAllLines(FilePath))
{
var line = raw.Trim();
if (line.Length == 0 || line.StartsWith("#", StringComparison.Ordinal)) continue;
var index = line.IndexOf('\t');
if (index <= 0) continue;
var key = line[..index];
var cipher = line[(index + 1)..];
var plain = Decrypt(cipher);
if (plain != null) _items[key] = plain;
}
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
}
private void Save()
{
try
{
var lines = new List<String>(_items.Count + 1) { "# 码神工具本地凭据(AES-256 本机绑定加密,勿手工编辑)" };
foreach (var item in _items)
{
lines.Add(item.Key + "\t" + Encrypt(item.Value));
}
Directory.CreateDirectory(Path.GetDirectoryName(FilePath) ?? AppPaths.ConfigDirectory);
File.WriteAllLines(FilePath, lines, new UTF8Encoding(false));
TryRestrictPermissions(FilePath);
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
}
private static void TryRestrictPermissions(String path)
{
// POSIX 上收紧到 600,避免同机其它用户读到密文
if (OperatingSystem.IsWindows()) return;
try
{
File.SetUnixFileMode(path, UnixFileMode.UserRead | UnixFileMode.UserWrite);
}
catch
{
// 文件系统不支持时忽略
}
}
/// <summary>派生本机密钥(机器名 + 用户名 + 固定盐)</summary>
/// <returns>32 字节密钥</returns>
public static Byte[] DeriveKey()
{
var seed = "NewLife.XCoder.Credential|" + Environment.MachineName + "|" + Environment.UserName + "|v1";
return SHA256.HashData(Encoding.UTF8.GetBytes(seed));
}
/// <summary>加密明文,返回带算法前缀的密文(dpapi: / aes:,均为 Base64)</summary>
/// <param name="plain">明文</param>
/// <returns>密文文本</returns>
public static String Encrypt(String plain)
{
if (plain == null) return "";
var raw = Encoding.UTF8.GetBytes(plain);
// Windows 优先交给系统 DPAPI;失败(极少数策略禁用场景)回退 AES
if (DpapiProtector.IsSupported)
{
var protectedData = DpapiProtector.Protect(raw);
if (protectedData != null && protectedData.Length > 0) return _PrefixDpapi + Convert.ToBase64String(protectedData);
}
return _PrefixAes + EncryptAes(raw);
}
/// <summary>解密带前缀的密文,也兼容旧版无前缀(纯 AES)数据</summary>
/// <param name="cipher">密文文本</param>
/// <returns>明文;格式或密钥不匹配返回 null</returns>
public static String? Decrypt(String? cipher)
{
if (cipher.IsNullOrEmpty()) return null;
var text = cipher!;
if (text.StartsWith(_PrefixDpapi, StringComparison.Ordinal))
{
if (!DpapiProtector.IsSupported) return null;
try
{
var data = DpapiProtector.Unprotect(Convert.FromBase64String(text[_PrefixDpapi.Length..]));
return data == null ? null : Encoding.UTF8.GetString(data);
}
catch (FormatException)
{
return null;
}
}
if (text.StartsWith(_PrefixAes, StringComparison.Ordinal)) text = text[_PrefixAes.Length..];
return DecryptAes(text);
}
/// <summary>纯 AES 加密(供旧数据与测试对比使用)</summary>
/// <param name="data">明文字节</param>
/// <returns>Base64(iv + 密文)</returns>
public static String EncryptAes(Byte[] data)
{
using var aes = Aes.Create();
aes.Key = DeriveKey();
aes.GenerateIV();
using var encryptor = aes.CreateEncryptor();
var cipher = encryptor.TransformFinalBlock(data, 0, data.Length);
var buffer = new Byte[aes.IV.Length + cipher.Length];
aes.IV.CopyTo(buffer, 0);
cipher.CopyTo(buffer, aes.IV.Length);
return Convert.ToBase64String(buffer);
}
/// <summary>解密 Base64(iv + 密文)</summary>
/// <param name="cipher">Base64 文本</param>
/// <returns>明文;格式或密钥不匹配返回 null</returns>
public static String? DecryptAes(String? cipher)
{
if (cipher.IsNullOrEmpty()) return null;
try
{
var buffer = Convert.FromBase64String(cipher!);
if (buffer.Length <= 16) return null;
using var aes = Aes.Create();
aes.Key = DeriveKey();
aes.IV = buffer[..16];
using var decryptor = aes.CreateDecryptor();
var plain = decryptor.TransformFinalBlock(buffer, 16, buffer.Length - 16);
return Encoding.UTF8.GetString(plain);
}
catch
{
return null;
}
}
}
|