Egalware/egwcorelib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'release/AddSublicGen01'

Browse Source
This commit is contained in:
Samuele Locatelli
2024-09-25 11:43:03 +02:00
parent 094bce95a1 321a7091c6
commit e57e429115
8 changed files with 755 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgwCoreLib.BlazorTest/Data/TestData.cs
+2 -1
View File
@@ -17,7 +17,8 @@ namespace EgwCoreLib.BlazorTest.Data
{"TestSvgDraw", "Test SVG draw"},
{"TestGauges", "Test Gauges"},
{"TestChart", "Test Chart.js"},
{"TestRadzenSched", "Test Radzen Scheduler" }
{"TestRadzenSched", "Test Radzen Scheduler" },
{"TestHwInfo", "Test HW Info" }
};
}
}
EgwCoreLib.BlazorTest/EgwCoreLib.BlazorTest.csproj
+3
View File
@@ -20,6 +20,9 @@
</ItemGroup>
<ItemGroup>
<PackageReference Include="DeviceId" Version="6.7.0" />
<PackageReference Include="DeviceId.Windows" Version="6.6.0" />
<PackageReference Include="DeviceId.Windows.Wmi" Version="6.6.0" />
<PackageReference Include="Radzen.Blazor" Version="5.1.8" />
</ItemGroup>
EgwCoreLib.BlazorTest/Pages/TestHwInfo.razor
+119
View File
@@ -0,0 +1,119 @@
@page "/TestHwInfo"
@using DeviceId
@using EgwCoreLib.Utils
<div class="row small">
<div class="col-6">
<ul class="list-group">
<li class="list-group-item active">
Device ID
</li>
@if (ListDevId != null && ListDevId.Count > 0)
{
@foreach (var item in ListDevId)
{
<li class="list-group-item d-flex justify-content-between">
<div class="px-1">@item.Key</div>
<div class="px-1">@item.Value</div>
</li>
}
}
</ul>
<hr />
<ul class="list-group">
<li class="list-group-item active">
Sublicense
</li>
<li class="list-group-item d-flex justify-content-between">
<div class="px-1">CodImpiego</div>
<div class="px-1">@codImpiego</div>
</li>
<li class="list-group-item d-flex justify-content-between">
<div class="px-1">AppKey</div>
<div class="px-1">@appKey</div>
</li>
<li>
<button class="btn btn-primary" @onclick="Regenerate">ReGen</button>
</li>
</ul>
</div>
<div class="col-6">
<ul class="list-group">
<li class="list-group-item active">
Machine Info
</li>
@if (ListMachineInfo != null && ListMachineInfo.Count > 0)
{
@foreach (var item in ListMachineInfo)
{
<li class="list-group-item d-flex justify-content-between">
<div class="px-1">@item.Key</div>
<div class="px-1">@item.Value</div>
</li>
}
}
</ul>
</div>
</div>
@code {
protected Dictionary<string, string> ListDevId { get; set; } = new Dictionary<string, string>();
protected Dictionary<string, string> ListMachineInfo { get; set; } = new Dictionary<string, string>();
protected MachineDataValidator MDValidator { get; set; } = new MachineDataValidator();
protected SubLicManager SubLicManager { get; set; } = new SubLicManager();
protected string codImpiego = "";
protected string appKey = "";
protected override void OnInitialized()
{
string deviceId = "";
deviceId = new DeviceIdBuilder()
.OnWindows(windows => windows.AddWindowsDeviceId())
.ToString();
ListDevId.Add("DevId_01", deviceId);
deviceId = new DeviceIdBuilder()
.AddMachineName()
.AddOsVersion()
// .AddFileToken("machine.uid")
.ToString();
ListDevId.Add("DevId_02", deviceId);
deviceId = new DeviceIdBuilder()
.AddMachineName()
.AddUserName()
.AddOsVersion()
.OnWindows(windows => windows
.AddMacAddressFromWmi(excludeWireless: true, excludeNonPhysical: true)
.AddProcessorId()
.AddMotherboardSerialNumber()
.AddSystemDriveSerialNumber())
.ToString();
ListDevId.Add("DevId_03", deviceId);
ListMachineInfo = MachineDataValidator.userInfo;
foreach (var item in MachineDataValidator.netInfo)
{
if (!ListMachineInfo.ContainsKey(item.Key))
{
ListMachineInfo.Add(item.Key, item.Value);
}
}
Regenerate();
}
protected void Regenerate()
{
codImpiego = SubLicManager.CodImpiego();
appKey = SubLicManager.GenKey(passphrase);
}
private string passphrase = "SaltPass";
}
EgwCoreLib.Razor/EgwCoreLib.Razor.csproj
+2 -2
View File
@@ -5,8 +5,8 @@
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<PackageId>EgwCoreLib.Razor</PackageId>
<version>0.9.0.0</version>
<Authors>S.E. Locatelli, Z.Majid</Authors>
<version>1.5.0.0</version>
<Authors>S.E. Locatelli</Authors>
<Company>EgalWare</Company>
<Description>Libreria componenti Razor/Blazor</Description>
<requireLicenseAcceptance>false</requireLicenseAcceptance>
EgwCoreLib.Utils/EgwCoreLib.Utils.csproj
+6 -1
View File
@@ -5,7 +5,7 @@
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<PackageId>EgwCoreLib.Utils</PackageId>
<version>0.9.0.0</version>
<version>1.5.0.0</version>
<Authors>S.E. Locatelli</Authors>
<Company>EgalWare</Company>
<Description>Libreria Utility base dotnet core</Description>
@@ -16,7 +16,12 @@
</PropertyGroup>
<ItemGroup>
<PackageReference Include="DeviceId" Version="6.7.0" />
<PackageReference Include="DeviceId.Windows" Version="6.6.0" />
<PackageReference Include="DeviceId.Windows.Wmi" Version="6.6.0" />
<PackageReference Include="NLog" Version="5.3.4" />
<PackageReference Include="System.Drawing.Common" Version="7.0.0" />
<PackageReference Include="System.Management" Version="8.0.0" />
<PackageReference Include="ZXing.Net" Version="0.16.9" />
<PackageReference Include="ZXing.Net.Bindings.Windows.Compatibility" Version="0.16.12" />
</ItemGroup>
EgwCoreLib.Utils/MachineDataValidator.cs
+219
View File
@@ -0,0 +1,219 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace EgwCoreLib.Utils
{
/// <summary>
/// Classe validazione valori
/// </summary>
public class MachineDataValidator
{
#region Public Fields
public static Dictionary<string, string> biosInfo = new Dictionary<string, string>();
public static Dictionary<string, string> cpuInfo = new Dictionary<string, string>();
public static Dictionary<string, string> netInfo = new Dictionary<string, string>();
public static Dictionary<string, string> osInfo = new Dictionary<string, string>();
public static Dictionary<string, string> ramInfo = new Dictionary<string, string>();
public static Dictionary<string, string> userInfo = new Dictionary<string, string>();
public static Dictionary<string, string> volInfo = new Dictionary<string, string>();
#endregion Public Fields
#region Public Constructors
/// <summary>
/// Init classe validatore
/// </summary>
/// <param name="currMachineData"></param>
public MachineDataValidator()
{
// inizializzo info di base
if (machTestData == null || machTestData.Count == 0)
{
machTestData = setupData();
}
}
#endregion Public Constructors
#region Public Properties
/// <summary>
/// Restituisce HASH del codice impiego = payload utente
/// </summary>
/// <returns></returns>
public string macHash
{
get => calcMachineHash();
}
#endregion Public Properties
#if false
/// <summary>
/// Verifica validità info correnti
/// </summary>
/// <returns></returns>
public async Task<bool> testCurrInfo()
{
return await testInfo();
}
#endif
#region Public Methods
/// <summary>
/// Verifica validità info correnti
/// </summary>
/// <returns></returns>
public static async Task<bool> testCurrInfo()
{
var cDV = new MachineDataValidator();
return await cDV.testInfo();
}
#endregion Public Methods
#region Private Fields
/// <summary>
/// Dati rispetto cui fare i calcoli di validazione
/// </summary>
private static Dictionary<string, string> machTestData = new Dictionary<string, string>();
#endregion Private Fields
#region Private Methods
/// <summary>
/// Calcola HASH del codice impiego = payload utente
/// </summary>
/// <returns></returns>
private string calcMachineHash()
{
string hash = "";
string buffData = currBaseBuffer();
if (!string.IsNullOrEmpty(buffData))
{
// hashing!
using (var hAlgo = SHA512.Create())
//using (var hAlgo = MD5.Create())
{
byte[] InputBytes = Encoding.UTF8.GetBytes(buffData);
var byteHash = hAlgo.ComputeHash(InputBytes);
hash = BitConverter.ToString(byteHash).Replace("-", "").Replace("/", "").Replace("\\", "").ToLowerInvariant();
}
}
return hash;
}
/// <summary>
/// Calcola hash key da info PC
/// </summary>
/// <returns></returns>
private string currBaseBuffer()
{
string answ = "????????????????????????????????????????????";
StringBuilder sb = new StringBuilder();
try
{
// calcolo hashKey da alcuni valori solamente
sb.Append($"{machTestData["SystemName"]}|");
sb.Append($"{machTestData["ProcessorId"]}|");
sb.Append($"{machTestData["PartNumber"]}|");
sb.Append($"{machTestData["MACAddress"]}|");
sb.Append($"{machTestData["SerialNumber"]}|");
sb.Append($"{machTestData["OSArchitecture"]}|");
sb.Append($"{machTestData["SoftwareElementID"]}|");
sb.Append($"{machTestData["SystemBiosMajorVersion"]}|");
sb.Append($"{machTestData["SystemBiosMinorVersion"]}|");
sb.Append($"{machTestData["CpuVersion"]}|");
sb.Append($"{machTestData["BiosVersion"]}|");
if (sb.Length > 0)
{
answ = sb.ToString();
// lo uso 2 volte dritto e reverse...
answ += ReverseString(sb.ToString());
}
}
catch
{ }
return answ;
}
/// <summary>
/// Legge la hash key dal file licenza salvato
/// </summary>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
private async Task<string> getSavedHash()
{
string answ = "############################################################";
string filePath = "Conf/lic.file";
if (File.Exists(filePath))
{
answ = await File.ReadAllTextAsync(filePath);
}
return answ;
}
/// <summary>
/// Esegue reverse delal stringa
/// </summary>
/// <param name="myStr"></param>
/// <returns></returns>
private string ReverseString(string myStr)
{
char[] myArr = myStr.ToCharArray();
Array.Reverse(myArr);
return new string(myArr);
}
/// <summary>
/// Predispone elenco dati di test
/// </summary>
/// <returns></returns>
private Dictionary<string, string> setupData()
{
// creo un unico array di info
Dictionary<string, string> testData = new Dictionary<string, string>();
biosInfo = MachineInfo.GetInfo("BIOS");
cpuInfo = MachineInfo.GetInfo("CPU");
netInfo = MachineInfo.GetInfo("NET");
osInfo = MachineInfo.GetInfo("OS");
ramInfo = MachineInfo.GetInfo("RAM");
userInfo = MachineInfo.GetInfo("USER");
volInfo = MachineInfo.GetInfo("VOL");
testData = biosInfo.Concat(cpuInfo).Concat(netInfo).Concat(osInfo).Concat(ramInfo).GroupBy(ele => ele.Key).ToDictionary(ele => ele.Key, ele => ele.First().Value);
return testData;
}
/// <summary>
/// Effettua verifica putuale tra hash Key fornita ed hash key calcolata da info PC
/// </summary>
/// <returns></returns>
private async Task<bool> testInfo()
{
// recupero hash key da conf applicativo (licenza)
string fileHash = await getSavedHash();
/// recupero hash calcolata
string calcHash = calcMachineHash();
// confronto con hashKey calcolata da info PC + dati...
return fileHash.Equals(calcHash);
}
#endregion Private Methods
}
}
EgwCoreLib.Utils/MachineInfo.cs
+335
View File
@@ -0,0 +1,335 @@
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Management;
using System.Text;
using System.Threading.Tasks;
namespace EgwCoreLib.Utils
{
/// <summary>
/// Gestione info macchina
/// ATTENZIONE! per ora solo windows...
/// </summary>
public class MachineInfo
{
#region Public Methods
/// <summary>
/// Restitusice info richieste
/// </summary>
/// <param name="infoType"></param>
/// <returns></returns>
public static Dictionary<string, string> GetInfo(string infoType)
{
var outInfo = new Dictionary<string, string>();
switch (infoType)
{
case "BIOS":
outInfo = GetBiosInfo();
break;
case "CPU":
outInfo = GetCpuInfo();
break;
case "NET":
outInfo = GetNetInfo();
break;
case "OS":
outInfo = GetOsInfo();
break;
case "RAM":
outInfo = GetRamInfo();
break;
case "USER":
outInfo = GetUserInfo();
break;
case "VOL":
outInfo = GetVolumeInfo();
break;
default:
break;
}
return outInfo;
}
#endregion Public Methods
#region Private Fields
private static Logger Log = LogManager.GetCurrentClassLogger();
#endregion Private Fields
#region Private Methods
/// <summary>
/// Info BIOS
/// </summary>
/// <returns></returns>
private static Dictionary<string, string> GetBiosInfo()
{
ManagementObjectCollection moc;
Dictionary<string, string> DictParam = new Dictionary<string, string>();
try
{
moc = new ManagementObjectSearcher("select * from Win32_BIOS").Get();
}
catch
{
Log.Error("Error: WMI API Not loaded.");
return DictParam;
}
foreach (ManagementObject obj in moc)
{
searchWmiParam(DictParam, obj, "Manufacturer", "Manufacturer");
searchWmiParam(DictParam, obj, "ReleaseDate", "ReleaseDate");
searchWmiParam(DictParam, obj, "SMBIOSBIOSVersion", "SMBIOSBIOSVersion");
searchWmiParam(DictParam, obj, "SMBIOSMajorVersion", "SMBIOSMajorVersion");
searchWmiParam(DictParam, obj, "SMBIOSMinorVersion", "SMBIOSMinorVersion");
searchWmiParam(DictParam, obj, "SoftwareElementID", "SoftwareElementID");
searchWmiParam(DictParam, obj, "SoftwareElementState", "SoftwareElementState");
searchWmiParam(DictParam, obj, "SystemBiosMajorVersion", "SystemBiosMajorVersion");
searchWmiParam(DictParam, obj, "SystemBiosMajorVersion", "SystemBiosMajorVersion");
searchWmiParam(DictParam, obj, "SystemBiosMinorVersion", "SystemBiosMinorVersion");
searchWmiParam(DictParam, obj, "BiosVersion", "Version");
}
return DictParam;
}
/// <summary>
/// Info processore
/// </summary>
/// <returns></returns>
private static Dictionary<string, string> GetCpuInfo()
{
ManagementObjectCollection moc;
Dictionary<string, string> DictParam = new Dictionary<string, string>();
try
{
moc = new ManagementObjectSearcher("select * from Win32_Processor").Get();
}
catch
{
Log.Error("Error: WMI API Not loaded.");
return DictParam;
}
foreach (ManagementObject obj in moc)
{
searchWmiParam(DictParam, obj, "AddressWidth", "AddressWidth");
searchWmiParam(DictParam, obj, "Architecture", "Architecture");
searchWmiParam(DictParam, obj, "CurrentClockSpeed", "CurrentClockSpeed");
searchWmiParam(DictParam, obj, "CurrentVoltage", "CurrentVoltage");
searchWmiParam(DictParam, obj, "DataWidth", "DataWidth");
searchWmiParam(DictParam, obj, "Description", "Description");
searchWmiParam(DictParam, obj, "ExtClock", "ExtClock");
searchWmiParam(DictParam, obj, "Family", "Family");
searchWmiParam(DictParam, obj, "L2CacheSize", "L2CacheSize");
searchWmiParam(DictParam, obj, "L3CacheSize", "L3CacheSize");
searchWmiParam(DictParam, obj, "Level", "Level");
searchWmiParam(DictParam, obj, "LoadPercentage", "LoadPercentage");
searchWmiParam(DictParam, obj, "Manufacturer", "Manufacturer");
searchWmiParam(DictParam, obj, "NumberOfCores", "NumberOfCores");
searchWmiParam(DictParam, obj, "NumberOfLogicalProcessors", "NumberOfLogicalProcessors");
searchWmiParam(DictParam, obj, "ProcessorId", "ProcessorId");
searchWmiParam(DictParam, obj, "ProcessorType", "ProcessorType");
searchWmiParam(DictParam, obj, "Revision", "Revision");
searchWmiParam(DictParam, obj, "Role", "Role");
searchWmiParam(DictParam, obj, "SocketDesignation", "SocketDesignation");
searchWmiParam(DictParam, obj, "SystemName", "SystemName");
searchWmiParam(DictParam, obj, "CpuVersion", "Version");
}
return DictParam;
}
/// <summary>
/// Info Networking
/// </summary>
/// <returns></returns>
private static Dictionary<string, string> GetNetInfo()
{
ManagementObjectCollection moc;
Dictionary<string, string> DictParam = new Dictionary<string, string>();
try
{
moc = new ManagementObjectSearcher("select * from Win32_NetworkAdapter WHERE NetEnabled = 'true'").Get();
}
catch
{
Log.Error("Error: WMI API Not loaded.");
return DictParam;
}
foreach (ManagementObject obj in moc)
{
searchWmiParam(DictParam, obj, "AdapterType", "AdapterType");
searchWmiParam(DictParam, obj, "Description", "Description");
searchWmiParam(DictParam, obj, "GUID", "GUID");
searchWmiParam(DictParam, obj, "MACAddress", "MACAddress");
searchWmiParam(DictParam, obj, "Manufacturer", "Manufacturer");
searchWmiParam(DictParam, obj, "Name", "Name");
searchWmiParam(DictParam, obj, "SystemName", "SystemName");
searchWmiParam(DictParam, obj, "PhysicalAdapter", "PhysicalAdapter");
searchWmiParam(DictParam, obj, "ProductName", "ProductName");
searchWmiParam(DictParam, obj, "ServiceName", "ServiceName");
}
return DictParam;
}
/// <summary>
/// Info OS
/// </summary>
/// <returns></returns>
private static Dictionary<string, string> GetOsInfo()
{
ManagementObjectCollection moc;
Dictionary<string, string> DictParam = new Dictionary<string, string>();
try
{
moc = new ManagementObjectSearcher("select * from Win32_OperatingSystem").Get();
}
catch
{
Log.Error("Error: WMI API Not loaded.");
return DictParam;
}
foreach (ManagementObject obj in moc)
{
searchWmiParam(DictParam, obj, "Caption", "Caption");
searchWmiParam(DictParam, obj, "Version", "Version");
searchWmiParam(DictParam, obj, "MaxNumberOfProcesses", "MaxNumberOfProcesses");
searchWmiParam(DictParam, obj, "MaxProcessMemorySize", "MaxProcessMemorySize");
searchWmiParam(DictParam, obj, "OSArchitecture", "OSArchitecture");
searchWmiParam(DictParam, obj, "SerialNumber", "SerialNumber");
searchWmiParam(DictParam, obj, "BuildNumber", "BuildNumber");
searchWmiParam(DictParam, obj, "RegisteredUser", "RegisteredUser");
}
return DictParam;
}
/// <summary>
/// Info RAM
/// </summary>
/// <returns></returns>
private static Dictionary<string, string> GetRamInfo()
{
ManagementObjectCollection moc;
Dictionary<string, string> DictParam = new Dictionary<string, string>();
try
{
moc = new ManagementObjectSearcher("select * from Win32_PhysicalMemory").Get();
}
catch
{
Log.Error("Error: WMI API Not loaded.");
return DictParam;
}
foreach (ManagementObject obj in moc)
{
searchWmiParam(DictParam, obj, "DeviceLocator", "DeviceLocator");
searchWmiParam(DictParam, obj, "DataWidth", "DataWidth");
searchWmiParam(DictParam, obj, "ConfiguredVoltage", "ConfiguredVoltage");
searchWmiParam(DictParam, obj, "FormFactor", "FormFactor");
searchWmiParam(DictParam, obj, "ConfiguredClockSpeed", "ConfiguredClockSpeed");
searchWmiParam(DictParam, obj, "MaxVoltage", "MaxVoltage");
searchWmiParam(DictParam, obj, "MinVoltage", "MinVoltage");
searchWmiParam(DictParam, obj, "Speed", "Speed");
searchWmiParam(DictParam, obj, "SMBIOSMemoryType", "SMBIOSMemoryType");
searchWmiParam(DictParam, obj, "PartNumber", "PartNumber");
}
return DictParam;
}
/// <summary>
/// Info User (macchina, dominio, username)
/// </summary>
/// <returns></returns>
private static Dictionary<string, string> GetUserInfo()
{
ManagementObjectCollection moc;
Dictionary<string, string> DictParam = new Dictionary<string, string>();
try
{
DictParam.Add("MachineName", Environment.MachineName);
DictParam.Add("UserDomainName", Environment.UserDomainName);
DictParam.Add("UserName", Environment.UserName);
}
catch(Exception exc)
{
Log.Error($"Error in GetUserInfo{Environment.NewLine}{exc}");
}
return DictParam;
}
/// <summary>
/// Info Volumes (HDD/SSD)
/// </summary>
/// <returns></returns>
private static Dictionary<string, string> GetVolumeInfo()
{
ManagementObjectCollection moc;
Dictionary<string, string> DictParam = new Dictionary<string, string>();
try
{
moc = new ManagementObjectSearcher("select DriveLetter, DeviceID from Win32_Volume").Get();
}
catch
{
Log.Error("Error: WMI API Not loaded.");
return DictParam;
}
foreach (ManagementObject obj in moc)
{
// mi limito al disco "C:"
string sDrive = "DriveLetter";
var objVal = $"{obj[sDrive]}";
if (objVal == "C:")
{
searchWmiParam(DictParam, obj, "DeviceID", "DeviceID");
searchWmiParam(DictParam, obj, "DriveLetter", "DriveLetter");
}
}
return DictParam;
}
/// <summary>
/// Effettua estrazione parametri WMI da elenco recuperato
/// </summary>
/// <param name="Processor"></param>
/// <param name="obj"></param>
/// <param name="pName"></param>
/// <param name="pKey"></param>
private static void searchWmiParam(Dictionary<string, string> Processor, ManagementObject obj, string pName, string pKey)
{
try
{
var objVal = $"{obj[pKey]}";
string strVal = objVal != null ? objVal : "";
Processor.Add(pName, strVal);
}
catch
{ }
}
#endregion Private Methods
}
}
EgwCoreLib.Utils/SubLicManager.cs
+69
View File
@@ -0,0 +1,69 @@
using DeviceId;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace EgwCoreLib.Utils
{
/// <summary>
/// Classe gestione SubLicenze (attivazioni)
/// </summary>
public class SubLicManager
{
private MachineDataValidator MachineDataValidator { get; set; } = null!;
private MachineInfo MachineInfo { get; set; } = null!;
public SubLicManager()
{
MachineDataValidator = new MachineDataValidator();
MachineInfo = new MachineInfo();
}
public string CodImpiego()
{
Guid tempKey = Guid.NewGuid();
string codice = $"{tempKey}";
// impiego libreria nuget
codice = new DeviceIdBuilder()
.AddMachineName()
.AddUserName()
.AddOsVersion()
.OnWindows(windows => windows
.AddMacAddressFromWmi(excludeWireless: true, excludeNonPhysical: true)
.AddProcessorId()
.AddMotherboardSerialNumber()
.AddSystemDriveSerialNumber())
.ToString();
return codice;
}
/// <summary>
/// Genera KEY macchina in modalità encrypt
/// </summary>
/// <param name="passphrase"></param>
/// <returns></returns>
public string GenKey(string passphrase)
{
Guid tempKey = Guid.NewGuid();
string message = $"{tempKey}";
var UserData = MachineInfo.GetInfo("USER");
string payload = $"{DateTime.Now:yyMMdd}-{DateTime.Now:HHmmss}";
if (UserData.ContainsKey("MachineName"))
{
payload += $"|{UserData["MachineName"]}";
}
if (UserData.ContainsKey("UserDomainName"))
{
payload += $"|{UserData["UserDomainName"]}";
}
if (UserData.ContainsKey("UserName"))
{
payload += $"|{UserData["UserName"]}";
}
return SteamCrypto.EncryptString(message, passphrase);
}
}
}