code up

Author: sPROFFEs

code/KeyGenerator/KeyGenerator.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <UseWindowsForms>true</UseWindowsForms>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

code/KeyGenerator/MainForm.Designer.cs

@@ -0,0 +1,102 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using System.Windows.Forms;
+
+namespace KeyGenerator
+{
+    public partial class MainForm : Form
+    {
+        public MainForm()
+        {
+            InitializeComponent();
+            this.generateButton.Click += new System.EventHandler(this.generateButton_Click);
+            this.copyPublicKeyButton.Click += new System.EventHandler(this.copyPublicKeyButton_Click);
+
+            try
+            {
+                // Display the public key for the admin to copy into the main application
+                this.publicKeyTextBox.Text = LicenseGenerator.GetPublicKey();
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show($"A critical error occurred during key generation: {ex.Message}\n\nThe application will now close.", "Fatal Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                // Close the form immediately if key generation fails.
+                // Using Load event to close because constructor is too early.
+                this.Load += (s, e) => this.Close();
+            }
+        }
+
+        private void generateButton_Click(object? sender, EventArgs e)
+        {
+            string encryptedMachineId = this.machineIdTextBox.Text.Trim();
+            if (string.IsNullOrWhiteSpace(encryptedMachineId))
+            {
+                MessageBox.Show("Please enter the user's Encrypted Machine ID.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                return;
+            }
+
+            try
+            {
+                this.licenseKeyTextBox.Text = LicenseGenerator.GenerateLicenseKey(encryptedMachineId);
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show($"An error occurred: {ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+            }
+        }
+
+        private void copyPublicKeyButton_Click(object? sender, EventArgs e)
+        {
+            Clipboard.SetText(this.publicKeyTextBox.Text);
+            MessageBox.Show("Public key copied to clipboard.", "Copied", MessageBoxButtons.OK, MessageBoxIcon.Information);
+        }
+    }
+
+    public static class LicenseGenerator
+    {
+        private const string PrivateKeyFileName = "private_key.b64";
+        private static readonly RSA _privateKey;
+
+        static LicenseGenerator()
+        {
+            // This static constructor is called once when the class is first accessed.
+            if (File.Exists(PrivateKeyFileName))
+            {
+                // If a key file exists, load it.
+                string privateKeyBase64 = File.ReadAllText(PrivateKeyFileName);
+                _privateKey = RSA.Create();
+                _privateKey.ImportRSAPrivateKey(Convert.FromBase64String(privateKeyBase64), out _);
+            }
+            else
+            {
+                // If no key file exists, generate a new one and save it.
+                _privateKey = RSA.Create(2048); // Generate a new 2048-bit RSA key.
+                byte[] privateKeyBytes = _privateKey.ExportRSAPrivateKey();
+                string privateKeyBase64 = Convert.ToBase64String(privateKeyBytes);
+                File.WriteAllText(PrivateKeyFileName, privateKeyBase64);
+            }
+        }
+
+        public static string GetPublicKey()
+        {
+            // Export the public part of the key in Base64 format.
+            byte[] publicKeyBytes = _privateKey.ExportRSAPublicKey();
+            return Convert.ToBase64String(publicKeyBytes);
+        }
+
+        public static string GenerateLicenseKey(string encryptedMachineId)
+        {
+            // Decrypt the user's machine ID.
+            byte[] encryptedBytes = Convert.FromBase64String(encryptedMachineId);
+            byte[] decryptedBytes = _privateKey.Decrypt(encryptedBytes, RSAEncryptionPadding.OaepSHA256);
+            string machineId = Encoding.UTF8.GetString(decryptedBytes);
+
+            // Sign the decrypted machine ID to create the license key.
+            byte[] machineIdBytes = Encoding.UTF8.GetBytes(machineId);
+            byte[] signature = _privateKey.SignData(machineIdBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
+            return Convert.ToBase64String(signature);
+        }
+    }
+}

code/KeyGenerator/MainForm.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Windows.Forms;
+
+namespace KeyGenerator
+{
+    internal static class Program
+    {
+        /// <summary>
+        ///  The main entry point for the application.
+        /// </summary>
+        [STAThread]
+        static void Main()
+        {
+            Application.SetHighDpiMode(HighDpiMode.SystemAware);
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            Application.Run(new MainForm());
+        }
+    }
+}

code/KeyGenerator/Program.cs

@@ -0,0 +1,91 @@
+import logging
+from telegram import Update, BotCommand
+from telegram.ext import Application, CommandHandler, ContextTypes
+
+from license_generator import generate_license_key, get_public_key_base64
+
+# --- Configuration ---
+TELEGRAM_API_KEY = "apikey"
+
+# Enable logging
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    welcome_text = (
+        "Welcome to the License Key Generator Bot!\n\n"
+        "Commands available:\n"
+        "• /generate <EncryptedMachineID> → Generate a license key\n"
+        "• /publickey → Show the Public Key for app compilation\n\n"
+        "Example:\n"
+        "/generate ABCDE12345..."
+    )
+    await update.message.reply_text(welcome_text)
+
+
+async def generate(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    if not context.args:
+        await update.message.reply_text(
+            "Please provide an Encrypted Machine ID after the command.\n"
+            "Example: /generate ABCDE12345..."
+        )
+        return
+
+    encrypted_machine_id = context.args[0]
+    user = update.effective_user
+    logger.info(f"User {user.username} ({user.id}) requested a key for machine ID: {encrypted_machine_id}")
+
+    try:
+        license_key = generate_license_key(encrypted_machine_id)
+        response_text = f"License Key Generated Successfully:\n\n`{license_key}`"
+        await update.message.reply_text(response_text, parse_mode='MarkdownV2')
+        logger.info(f"Successfully generated key for machine ID: {encrypted_machine_id}")
+    except Exception as e:
+        logger.error(f"Failed to generate key for machine ID: {encrypted_machine_id}. Error: {e}")
+        await update.message.reply_text(
+            "An error occurred while generating the license key. "
+            "Please ensure the Encrypted Machine ID is correct and try again."
+        )
+
+
+async def publickey(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Sends the public key in Base64 for app compilation."""
+    try:
+        public_key = get_public_key_base64()
+        response_text = (
+            "Public Key (Base64, ready for C#):\n\n"
+            f"{public_key}"
+        )
+        # Use HTML format to avoid MarkdownV2 escaping issues
+        await update.message.reply_text(response_text)
+        logger.info("Public key sent successfully.")
+    except Exception as e:
+        logger.error(f"Error retrieving public key: {e}", exc_info=True)
+        await update.message.reply_text("An error occurred while retrieving the public key.")
+
+
+async def post_init(application: Application) -> None:
+    commands = [
+        BotCommand("start", "Show welcome message and instructions"),
+        BotCommand("generate", "Generate a new license key from a machine ID"),
+        BotCommand("publickey", "Show the public key for app compilation"),
+    ]
+    await application.bot.set_my_commands(commands)
+
+
+def main() -> None:
+    application = Application.builder().token(TELEGRAM_API_KEY).post_init(post_init).build()
+
+    application.add_handler(CommandHandler("start", start))
+    application.add_handler(CommandHandler("generate", generate))
+    application.add_handler(CommandHandler("publickey", publickey))
+
+    logger.info("Starting bot...")
+    application.run_polling()
+
+
+if __name__ == "__main__":
+    main()