feat: implement secure config and machine id key generator

src/StevanFreeborn.Extensions.Configuration.Secure/Configuration/SecureConfig.cs

@@ -1,3 +1,5 @@
+using System.Text.Json;
+
 using StevanFreeborn.Extensions.Configuration.Secure.Cryptography;
 using StevanFreeborn.Extensions.Configuration.Secure.Storage;
 
@@ -5,7 +7,7 @@ namespace StevanFreeborn.Extensions.Configuration.Secure.Configuration;
 
 internal interface ISecureConfig
 {
-  Task DeleteAsync<t>(string key, CancellationToken ct = default);
+  Task<bool> DeleteAsync(string key, CancellationToken ct = default);
   Task<T?> GetAsync<T>(string key, CancellationToken ct = default);
   Task SetAsync<T>(string key, T value, CancellationToken ct = default);
 }
@@ -23,16 +25,42 @@ internal sealed class SecureConfig(
 
   public async Task SetAsync<T>(string key, T value, CancellationToken ct = default)
   {
-    throw new NotImplementedException();
+    if (string.IsNullOrWhiteSpace(key))
+    {
+      throw new ArgumentNullException(nameof(key));
+    }
+
+    if (value is null)
+    {
+      throw new ArgumentNullException(nameof(value));
+    }
+
+    var json = JsonSerializer.Serialize(value);
+    var encryptedValue = _cryptoProvider.Encrypt(json);
+
+    await _storageProvider.WriteAsync(key, encryptedValue, ct).ConfigureAwait(false);
   }
 
   public async Task<T?> GetAsync<T>(string key, CancellationToken ct = default)
   {
-    throw new NotImplementedException();
+    if (string.IsNullOrEmpty(key))
+    {
+      throw new ArgumentNullException(nameof(key));
+    }
+
+    var encryptedData = await _storageProvider.ReadAsync(key, ct).ConfigureAwait(false);
+
+    if (string.IsNullOrWhiteSpace(encryptedData))
+    {
+      return default;
+    }
+
+    var data = _cryptoProvider.Decrypt(encryptedData);
+    return JsonSerializer.Deserialize<T>(data);
   }
 
-  public async Task DeleteAsync<t>(string key, CancellationToken ct = default)
+  public Task<bool> DeleteAsync(string key, CancellationToken ct = default)
   {
-    throw new NotImplementedException();
+    return _storageProvider.DeleteAsync(key, ct);
   }
 }

src/StevanFreeborn.Extensions.Configuration.Secure/Cryptography/MachineIdKeyGenerator.cs

@@ -0,0 +1,114 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+using Microsoft.Extensions.Logging;
+
+namespace StevanFreeborn.Extensions.Configuration.Secure.Cryptography;
+
+internal interface IMachineIdKeyGenerator
+{
+  string GetId();
+}
+
+internal sealed class MachineIdKeyGenerator : IMachineIdKeyGenerator
+{
+  private const string IOPlatformUUID = nameof(IOPlatformUUID);
+  private const string MachineGuid = nameof(MachineGuid);
+  private const string WinRegistryPath = @"SOFTWARE\Microsoft\Cryptography";
+  private readonly ILogger<MachineIdKeyGenerator> _logger;
+  private readonly Lazy<string> _machineId;
+
+  public MachineIdKeyGenerator(ILogger<MachineIdKeyGenerator> logger)
+  {
+    _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    _machineId = new(GenerateMachineId);
+  }
+
+  public string GetId()
+  {
+    return _machineId.Value;
+  }
+
+  private string GenerateMachineId()
+  {
+    try
+    {
+      if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+      {
+        using var key = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(WinRegistryPath);
+        var guid = key?.GetValue(MachineGuid)?.ToString();
+
+        if (string.IsNullOrWhiteSpace(guid) is false)
+        {
+          return guid;
+        }
+      }
+
+      if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+      {
+        const string machineIdPath = "/etc/machine-id";
+        if (File.Exists(machineIdPath))
+        {
+          return File.ReadAllText(machineIdPath).Trim();
+        }
+      }
+
+      if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+      {
+        var startInfo = new ProcessStartInfo
+        {
+          FileName = "ioreg",
+          Arguments = "-rd1 -c IOPlatformExpertDevice",
+          RedirectStandardOutput = true,
+          UseShellExecute = false,
+          CreateNoWindow = true
+        };
+
+        using var process = Process.Start(startInfo);
+        using var reader = process?.StandardOutput;
+        var output = reader?.ReadToEnd();
+
+        if (output != null && output.Contains(IOPlatformUUID, StringComparison.OrdinalIgnoreCase))
+        {
+          var parts = output.Split([IOPlatformUUID], StringSplitOptions.None);
+
+          if (parts.Length > 1)
+          {
+            var idPart = parts[1].Split('\"');
+
+            if (idPart.Length > 3)
+            {
+              return idPart[3];
+            }
+          }
+        }
+      }
+    }
+#pragma warning disable CA1031
+    catch (Exception ex)
+#pragma warning restore CA1031
+    {
+      _logger.LogFailedRetrievingMachineId(ex);
+    }
+
+    _logger.LogUsingFallbackStrategy();
+    return $"{Environment.MachineName}_{Environment.UserName}";
+  }
+}
+
+internal static partial class LogMessages
+{
+  [LoggerMessage(
+      EventId = 1,
+      Level = LogLevel.Warning,
+      Message = "Failed to retrieve hardware-specific machine ID. Falling back to environment variables."
+  )]
+  public static partial void LogFailedRetrievingMachineId(this ILogger logger, Exception ex);
+
+  [LoggerMessage(
+      EventId = 2,
+      Level = LogLevel.Information,
+      Message = "Using fallback strategy for Machine ID generation."
+  )]
+  public static partial void LogUsingFallbackStrategy(this ILogger logger);
+}

src/StevanFreeborn.Extensions.Configuration.Secure/Cryptography/MachineIdKeyProvider.cs

@@ -0,0 +1,5 @@
+namespace StevanFreeborn.Extensions.Configuration.Secure.Cryptography;
+
+internal sealed class MachineIdKeyProvider
+{
+}

src/StevanFreeborn.Extensions.Configuration.Secure/StevanFreeborn.Extensions.Configuration.Secure.csproj

@@ -16,6 +16,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <InternalsVisibleTo Include="$(AssemblyName).Tests" />
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="10.0.5" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
     <PackageReference Include="System.Text.Json" Version="10.0.5" />
   </ItemGroup>