annotations/Azaion.Common/Services/HardwareService.cs

using System.Diagnostics;
using System.Net.NetworkInformation;
using System.Security.Cryptography;
using System.Text;
using Azaion.Common.DTO;

namespace Azaion.Common.Services;

public interface IHardwareService
{
    Task<HardwareInfo> GetHardware();
}

public class HardwareService : IHardwareService
{
    private const string WIN32_GET_HARDWARE_COMMAND =
        "wmic OS get TotalVisibleMemorySize /Value && " +
        "wmic CPU get Name /Value && " +
        "wmic path Win32_VideoController get Name /Value";

    private const string UNIX_GET_HARDWARE_COMMAND =
        "/bin/bash -c \"free -g | grep Mem: | awk '{print $2}' && " +
        "lscpu | grep 'Model name:' | cut -d':' -f2 && " +
        "lspci | grep VGA | cut -d':' -f3\"";

    public async Task<HardwareInfo> GetHardware()
    {
        try
        {
            var output = await RunCommand(Environment.OSVersion.Platform == PlatformID.Win32NT
                ? WIN32_GET_HARDWARE_COMMAND
                : UNIX_GET_HARDWARE_COMMAND);

            var lines = output
                .Replace("TotalVisibleMemorySize=", "")
                .Replace("Name=", "")
                .Replace("  ", " ")
                .Trim()
                .Split(['\n', '\r'], StringSplitOptions.RemoveEmptyEntries);

            var memoryStr = "Unknown RAM";
            if (lines.Length > 0)
            {
                memoryStr = lines[0];
                if (int.TryParse(memoryStr, out var memKb))
                    memoryStr = $"{Math.Round(memKb / 1024.0 / 1024.0)} Gb";
            }

            var hardwareInfo = new HardwareInfo
            {
                Memory = memoryStr,
                CPU = lines.Length > 1 && string.IsNullOrEmpty(lines[1])
                    ? "Unknown RAM"
                    : lines[1],
                GPU = lines.Length > 2 && string.IsNullOrEmpty(lines[2])
                    ? "Unknown GPU"
                    : lines[2]
            };
            hardwareInfo.Hash = ToHash($"Azaion_{MacAddress()}_{hardwareInfo.CPU}_{hardwareInfo.GPU}");
            return hardwareInfo;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            throw;
        }
    }

    private string MacAddress()
    {
        var macAddress = NetworkInterface
            .GetAllNetworkInterfaces()
            .Where(nic => nic.OperationalStatus == OperationalStatus.Up)
            .Select(nic => nic.GetPhysicalAddress().ToString())
            .FirstOrDefault();

        return macAddress ?? string.Empty;
    }

    private async Task<string> RunCommand(string command)
    {
        try
        {
            using var process = new Process();
            process.StartInfo.FileName = Environment.OSVersion.Platform == PlatformID.Unix ? "/bin/bash" : "cmd.exe";
            process.StartInfo.Arguments = Environment.OSVersion.Platform == PlatformID.Unix
                ? $"-c \"{command}\""
                : $"/c {command}";
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.CreateNoWindow = true;

            process.Start();
            var result = await process.StandardOutput.ReadToEndAsync();
            await process.WaitForExitAsync();

            return result.Trim();
        }
        catch
        {
            return string.Empty;
        }
    }

    private static string ToHash(string str) =>
        Convert.ToBase64String(SHA384.HashData(Encoding.UTF8.GetBytes(str)));

}