借助网络配置,控制Modbus工具的日志显示,避免卡死界面
智能大石头 authored at 2021-12-11 22:09:19
8.31 KiB
XCoder
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;
        }
    }
}