Program.cs

using System;
using System.Web.Configuration;
using System.Web.Security;
using System.Configuration;
using System.Collections.Generic;

namespace FormsTicketCrypt
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                PrintUsage();
                return;
            }

            string mode = args[0].ToLower();

            try
            {
                switch (mode)
                {
                    case "decrypt":
                        DecryptMode(args);
                        break;
                    case "encrypt":
                        EncryptMode(args);
                        break;
                    default:
                        Console.WriteLine($"Unknown mode: {mode}");
                        PrintUsage();
                        break;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }

            Console.ReadLine();
        }

        static void ConfigureMachineKey(string validationKey, string decryptionKey, string validation = "HMACSHA256", string decryption = "AES")
        {
            MachineKeySection machineKey = new MachineKeySection();

            machineKey.ValidationKey = validationKey;
            machineKey.DecryptionKey = decryptionKey;

            // Parse validation algorithm (ENUM)
            machineKey.Validation =
                (MachineKeyValidation)Enum.Parse(typeof(MachineKeyValidation), validation, ignoreCase: true);

            // Decryption algorithm is a STRING
            machineKey.Decryption = decryption;

            // Replace internal cached machineKey config
            typeof(MachineKeySection)
                .GetField("s_config", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)
                ?.SetValue(null, machineKey);
        }



        static void ParseMachineKeyArgs(string[] args, ref int startIndex, out string validationKey, out string decryptionKey, out string validation, out string decryption)
        {
            validationKey = null;
            decryptionKey = null;
            validation = "HMACSHA256";
            decryption = "AES";

            // Track the earliest non-machine-key argument index
            int firstNonMachineKey = -1;

            for (int i = startIndex; i < args.Length; i++)
            {
                string arg = args[i].ToLower();

                bool isMachineKeyArg = true;

                switch (arg)
                {
                    case "-validationkey":
                        if (i + 1 < args.Length) validationKey = args[++i];
                        break;

                    case "-decryptionkey":
                        if (i + 1 < args.Length) decryptionKey = args[++i];
                        break;

                    case "-validation":
                        if (i + 1 < args.Length) validation = args[++i];
                        break;

                    case "-decryption":
                        if (i + 1 < args.Length) decryption = args[++i];
                        break;

                    default:
                        // Not a machine-key option
                        isMachineKeyArg = false;
                        break;
                }

                if (!isMachineKeyArg)
                {
                    if (firstNonMachineKey == -1)
                        firstNonMachineKey = i;
                }
            }

            // If there were non-machine-key flags, modifications start there
            if (firstNonMachineKey != -1)
                startIndex = firstNonMachineKey;
            else
                startIndex = args.Length;
        }



        static void DecryptMode(string[] args)
        {
            if (args.Length < 2)
            {
                Console.WriteLine("Please supply encrypted forms ticket for decryption");
                Console.WriteLine("Usage: FormsTicketCrypt decrypt <encrypted_ticket> [machinekey_options]");
                Console.WriteLine("MachineKey Options:");
                PrintMachineKeyUsage();
                return;
            }

            string encryptedTicket = args[1];

            int startIndex = 2;
            ParseMachineKeyArgs(args, ref startIndex, out string validationKey, out string decryptionKey, out string validation, out string decryption);

            if (string.IsNullOrEmpty(validationKey) || string.IsNullOrEmpty(decryptionKey))
            {
                Console.WriteLine("Error: Both -validationkey and -decryptionkey are required");
                return;
            }

            // Configure machine key
            ConfigureMachineKey(validationKey, decryptionKey, validation, decryption);

            FormsAuthenticationTicket unencryptedTicket = FormsAuthentication.Decrypt(encryptedTicket);

            Console.WriteLine("=== DECRYPTED TICKET ===");
            Console.WriteLine($"Version: {unencryptedTicket.Version}");
            Console.WriteLine($"Name: {unencryptedTicket.Name}");
            Console.WriteLine($"IssueDate: {unencryptedTicket.IssueDate}");
            Console.WriteLine($"Expiration: {unencryptedTicket.Expiration}");
            Console.WriteLine($"IsPersistent: {unencryptedTicket.IsPersistent}");
            Console.WriteLine($"UserData: {unencryptedTicket.UserData}");
            Console.WriteLine($"CookiePath: {unencryptedTicket.CookiePath}");
        }

        static void EncryptMode(string[] args)
        {
            if (args.Length < 2)
            {
                Console.WriteLine("Please supply base encrypted ticket for modification");
                Console.WriteLine("Usage: FormsTicketCrypt encrypt <base_ticket> [machinekey_options] [modification_options]");
                Console.WriteLine("MachineKey Options:");
                PrintMachineKeyUsage();
                Console.WriteLine("Modification Options:");
                PrintModificationUsage();
                return;
            }

            string baseEncryptedTicket = args[1];

            // Parse machine key arguments first
            int startIndex = 2;
            ParseMachineKeyArgs(args, ref startIndex, out string validationKey, out string decryptionKey, out string validation, out string decryption);

            if (string.IsNullOrEmpty(validationKey) || string.IsNullOrEmpty(decryptionKey))
            {
                Console.WriteLine("Error: Both -validationkey and -decryptionkey are required");
                return;
            }

            // Configure machine key
            ConfigureMachineKey(validationKey, decryptionKey, validation, decryption);

            // Decrypt the base ticket
            FormsAuthenticationTicket baseTicket = FormsAuthentication.Decrypt(baseEncryptedTicket);

            // Parse modification arguments
            string newName = baseTicket.Name;
            string newUserData = baseTicket.UserData;
            DateTime newExpiration = baseTicket.Expiration;
            bool newIsPersistent = baseTicket.IsPersistent;
            string newCookiePath = baseTicket.CookiePath;

            for (int i = startIndex; i < args.Length; i++)
            {
                switch (args[i].ToLower())
                {
                    case "-name":
                        if (i + 1 < args.Length) newName = args[++i];
                        break;
                    case "-userdata":
                        if (i + 1 < args.Length) newUserData = args[++i];
                        break;
                    case "-expiry":
                        if (i + 1 < args.Length && int.TryParse(args[++i], out int minutes))
                            newExpiration = DateTime.Now.AddMinutes(minutes);
                        break;
                    case "-persistent":
                        if (i + 1 < args.Length)
                            newIsPersistent = bool.Parse(args[++i]);
                        break;
                    case "-path":
                        if (i + 1 < args.Length) newCookiePath = args[++i];
                        break;
                }
            }

            // Create modified ticket
            FormsAuthenticationTicket modifiedTicket = new FormsAuthenticationTicket(
                version: baseTicket.Version,
                name: newName,
                issueDate: DateTime.Now,
                expiration: newExpiration,
                isPersistent: newIsPersistent,
                userData: newUserData,
                cookiePath: newCookiePath
            );

            string encryptedModifiedTicket = FormsAuthentication.Encrypt(modifiedTicket);

            Console.WriteLine("=== ORIGINAL TICKET ===");
            PrintTicketInfo(baseTicket);
            Console.WriteLine("\n=== MODIFIED TICKET ===");
            PrintTicketInfo(modifiedTicket);
            Console.WriteLine($"\n=== ENCRYPTED MODIFIED TICKET ===");
            Console.WriteLine(encryptedModifiedTicket);
        }

        static void PrintTicketInfo(FormsAuthenticationTicket ticket)
        {
            Console.WriteLine($"Version: {ticket.Version}");
            Console.WriteLine($"Name: {ticket.Name}");
            Console.WriteLine($"IssueDate: {ticket.IssueDate}");
            Console.WriteLine($"Expiration: {ticket.Expiration}");
            Console.WriteLine($"IsPersistent: {ticket.IsPersistent}");
            Console.WriteLine($"UserData: {ticket.UserData}");
            Console.WriteLine($"CookiePath: {ticket.CookiePath}");
        }

        static void PrintMachineKeyUsage()
        {
            Console.WriteLine("  -validationkey <key>   Validation key (required)");
            Console.WriteLine("  -decryptionkey <key>   Decryption key (required)");
            Console.WriteLine("  -validation <alg>      Validation algorithm (default: HMACSHA256)");
            Console.WriteLine("  -decryption <alg>      Decryption algorithm (default: AES)");
        }

        static void PrintModificationUsage()
        {
            Console.WriteLine("  -name <username>       Change username");
            Console.WriteLine("  -userdata <data>       Change user data");
            Console.WriteLine("  -expiry <minutes>      Set expiry in minutes from now");
            Console.WriteLine("  -persistent <true/false> Set persistent flag");
            Console.WriteLine("  -path <path>           Set cookie path");
        }

        static void PrintUsage()
        {
            Console.WriteLine("Forms Authentication Ticket Cryptography Tool");
            Console.WriteLine("=============================================");
            Console.WriteLine("Usage:");
            Console.WriteLine("  FormsTicketCrypt decrypt <encrypted_ticket> -validationkey <key> -decryptionkey <key>");
            Console.WriteLine("  FormsTicketCrypt encrypt <base_ticket> -validationkey <key> -decryptionkey <key> [modification_options]");
            Console.WriteLine("");
            Console.WriteLine("MachineKey Options (required for both modes):");
            PrintMachineKeyUsage();
            Console.WriteLine("");
            Console.WriteLine("Modification Options (for encrypt mode only):");
            PrintModificationUsage();
            Console.WriteLine("");
            Console.WriteLine("Examples:");
            Console.WriteLine("  FormsTicketCrypt decrypt \"7EC2DAFAB915269B...\" -validationkey \"EBF9076B4E...\" -decryptionkey \"B26C371EA0A...\"");
            Console.WriteLine("  FormsTicketCrypt encrypt \"7EC2DAFAB915269B...\" -validationkey \"EBF9076B4E...\" -decryptionkey \"B26C371EA0A...\" -name \"admin\" -expiry 120");
            Console.WriteLine("  FormsTicketCrypt encrypt \"7EC2DAFAB915269B...\" -validationkey \"EBF9076B4E...\" -decryptionkey \"B26C371EA0A...\" -userdata \"role=admin\" -persistent true");
        }
    }
}