Program.cs

using iTextSharp.text;
using iTextSharp.text.pdf;
using Microsoft.Win32;
using System;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Printing;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using ZXing;
using Version = System.Version;

namespace Relock
{
    static class Program
    {
        // Import AttachConsole and FreeConsole from Kernel32.dll
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool AttachConsole(int dwProcessId);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool FreeConsole();

        // Import WriteConsoleInput to simulate input
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool WriteConsoleInput(IntPtr hConsoleInput, [In] INPUT_RECORD[] lpBuffer, uint nLength, out uint lpNumberOfEventsWritten);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern IntPtr GetStdHandle(int nStdHandle);

        const int STD_INPUT_HANDLE = -10;
        const int ATTACH_PARENT_PROCESS = -1;

        // Define INPUT_RECORD struct for input events
        struct INPUT_RECORD
        {
            public ushort EventType;
            public KEY_EVENT_RECORD KeyEvent;
        }

        // Define KEY_EVENT_RECORD struct
        struct KEY_EVENT_RECORD
        {
            public bool bKeyDown;
            public ushort wRepeatCount;
            public ushort wVirtualKeyCode;
            public ushort wVirtualScanCode;
            public char uChar;
            public uint dwControlKeyState;
        }

        [STAThread]
        private static void Main(string[] args)
        {
            if (args.Length > 0)
            {
                string drive = args[0].ToLower();
                switch (drive)
                {
                    case "/register":
                        RegisterInRegistry();
                        break;
                    case "/unregister":
                        UnregisterFromRegistry();
                        break;
                    default:
                        Application.EnableVisualStyles();
                        Application.SetCompatibleTextRenderingDefault(false);
                        getRecoveryKey(drive);
                        lockDrive(drive);
                        break;
                }
            }
            else
            {
                // Versioning information for display
                Version version = Assembly.GetExecutingAssembly().GetName().Version;
                string relockVersion = $"{version.Major}.{version.Minor}.{version.Build}";

                // Attach to parent console (e.g., command line if launched from there)
                AttachConsole(ATTACH_PARENT_PROCESS);

                // Display version and usage information in the console
                Console.WriteLine("\n\n" +
                    String.Format(Properties.Resources.Relock0ReLockABitlockerEnabledDrive2024ManfredMueller, relockVersion) + "\n\n" +
                    Properties.Resources.UsageRelockRegisterUnregister + "\n" +
                    "/register\t" + Properties.Resources.RegisterInTheExplorerContextMenu + "\n" +
                    "/unregister\t" + Properties.Resources.UnregisterFromTheExplorerContextMenu
                );

                // Emulate Enter key press to simulate user pressing "Enter"
                SimulateEnterKeyPress();

                // Ensure the console is released immediately after writing
                FreeConsole();

                // Exit the application cleanly
                Environment.Exit(0); // Exit code 0 means success
            }
        }

        // Method to simulate Enter key press
        private static void SimulateEnterKeyPress()
        {
            IntPtr stdInputHandle = GetStdHandle(STD_INPUT_HANDLE);

            INPUT_RECORD[] records = new INPUT_RECORD[2];
            records[0].EventType = 0x0001; // KEY_EVENT
            records[0].KeyEvent.bKeyDown = true;
            records[0].KeyEvent.wVirtualKeyCode = 0x0D; // Virtual code for "Enter"
            records[0].KeyEvent.wVirtualScanCode = 0x1C;
            records[0].KeyEvent.uChar = '\r';

            records[1].EventType = 0x0001; // KEY_EVENT
            records[1].KeyEvent.bKeyDown = false;
            records[1].KeyEvent.wVirtualKeyCode = 0x0D; // Virtual code for "Enter"
            records[1].KeyEvent.wVirtualScanCode = 0x1C;
            records[1].KeyEvent.uChar = '\r';

            WriteConsoleInput(stdInputHandle, records, (uint)records.Length, out _);
        }

        public static void RegisterInRegistry()
        {
            string keyName = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Classes\\Drive\\shell\\relock-bde";
            string shellParent = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Classes\\Drive\\shell";
            string _vDefault = Properties.Resources.RelockThisDrive;
            const string _vAppliesTo = "System.Volume.BitLockerProtection:=System.Volume.BitLockerProtection#On OR System.Volume.BitLockerProtection:=System.Volume.BitLockerProtection#Encrypting OR System.Volume.BitLockerProtection:=System.Volume.BitLockerProtection#Suspended";
            const string _vMultiSelectModel = "Single";
            string appPath = Assembly.GetExecutingAssembly().Location;
            string appIcon = appPath + ",0";  // Assuming the icon is the first resource in the executable

            try
            {
                Registry.SetValue(keyName, "", _vDefault);
                Registry.SetValue(keyName, "AppliesTo", _vAppliesTo);
                Registry.SetValue(keyName, "MultiSelectModel", _vMultiSelectModel);
                Registry.SetValue(keyName, "Icon", appIcon);

                string commandKeyName = keyName + "\\command";
                string _vCommandValue = appPath + " %1";

                Registry.SetValue(commandKeyName, "", _vCommandValue);

                Registry.SetValue(shellParent, "", "relock-bde");  // make this verb the default (bold)

                MessageBox.Show(Properties.Resources.ProgramSuccessfullyRegisteredInTheRegistry, "Relock", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                MessageBox.Show(Properties.Resources.ErrorWhileUpdatingRegistry + ex.Message, "Relock", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        public static void UnregisterFromRegistry()
        {
            try
            {
                RegistryKey key = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Drive\\shell", true);
                if (key != null)
                {
                    key.DeleteSubKeyTree("relock-bde", false);
                    key.Close();

                    MessageBox.Show(Properties.Resources.ProgramSuccessfullyUnregisteredFromTheRegistry, "Relock", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                else
                {
                    MessageBox.Show(Properties.Resources.RegistryKeyNotFound, "Relock", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Properties.Resources.ErrorWhileUpdatingRegistry + ex.Message, "Relock", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        public static void getRecoveryKey(string driveLetter)
        {
            try
            {
                driveLetter = driveLetter.Replace("\\", "");

                var psi = new ProcessStartInfo("manage-bde", string.Format("-protectors -get {0} -Type recoverypassword", driveLetter))
                {
                    RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    WindowStyle = ProcessWindowStyle.Hidden
                };

                StringBuilder outputBuilder = new StringBuilder();

                using (Process process = new Process())
                {
                    process.StartInfo = psi;
                    process.OutputDataReceived += (sender, e) =>
                    {
                        if (!string.IsNullOrEmpty(e.Data))
                        {
                            outputBuilder.AppendLine(e.Data);
                        }
                    };

                    process.ErrorDataReceived += (sender, e) =>
                    {
                        if (!string.IsNullOrEmpty(e.Data))
                        {
                            outputBuilder.AppendLine(Properties.Resources.OutputError + e.Data);
                        }
                    };

                    process.Start();
                    process.BeginOutputReadLine();
                    process.BeginErrorReadLine();
                    process.WaitForExit();
                }

                string output = outputBuilder.ToString();

                // Filter lines that end with a number and do not contain "ersion"
                string[] lines = output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string line in lines)
                {
                    if (System.Text.RegularExpressions.Regex.IsMatch(line, @"[0-9]$") && !line.Contains("ersion"))
                    {
                        // Remove spaces and get the result
                        string result = line.Replace(" ", string.Empty);

                        // Keep original recovery key for copy/unmask
                        string originalRecoveryKey = result;
                        bool isMasked = true;

                        // Generate QR code image
                        string qrData = $"{result}";
                        var qrWriter = new BarcodeWriter
                        {
                            Format = BarcodeFormat.QR_CODE,
                            Options = new ZXing.Common.EncodingOptions
                            {
                                Width = 400,
                                Height = 400,
                                Margin = 1
                            }
                        };

                        using (var qrImage = qrWriter.Write(qrData))
                        {
                            // Convert the icon to a bitmap
                            using (var iconBitmap = Properties.Resources.relock.ToBitmap())
                            {
                                using (Graphics graphics = Graphics.FromImage(qrImage))
                                {
                                    // Draw the icon on the QR code, centered on the white square
                                    int iconX = (qrImage.Width - iconBitmap.Width) / 2;
                                    int iconY = (qrImage.Height - iconBitmap.Height) / 2;
                                    graphics.DrawImage(iconBitmap, new Point(iconX, iconY));
                                }

                                // Create the PictureBox to display the combined image
                                using (var pictureBox = new PictureBox())
                                {
                                    pictureBox.Image = qrImage;
                                    pictureBox.SizeMode = PictureBoxSizeMode.AutoSize;
                                    pictureBox.Refresh(); // Force refresh to ensure the image is displayed

                                    // Create the label for the recovery key
                                    Label recoveryKeyLabel = new Label
                                    {
                                        AutoSize = false,
                                        Width = pictureBox.Width,
                                        TextAlign = ContentAlignment.MiddleCenter,
                                        MaximumSize = new Size(pictureBox.Width, 0), // Ensure the label does not exceed the width of the PictureBox
                                        Height = 50, // Ensure enough height to fit the text
                                        Text = result
                                    };

                                    // Adjust font size to fit the label width
                                    System.Drawing.Font font = AdjustFontToFitLabel(recoveryKeyLabel, result);
                                    recoveryKeyLabel.Font = font;

                                    recoveryKeyLabel.Text = MaskKey(originalRecoveryKey);

                                    // Create the label for the drive letter
                                    Label driveLabel = new Label
                                    {
                                        AutoSize = false,
                                        Width = pictureBox.Width,
                                        TextAlign = ContentAlignment.MiddleCenter,
                                        MaximumSize = new Size(pictureBox.Width, 0),
                                        Height = 30, // Height of the label above the QR code
                                        Text = string.Format(Properties.Resources.RecoveryCodeForDrive0, driveLetter.ToUpper())
                                    };

                                    // Adjust font size to fit the label width
                                    System.Drawing.Font driveFont = AdjustFontToFitLabel(driveLabel, driveLabel.Text);
                                    driveLabel.Font = driveFont;

                                    // Local helper to mask key
                                    string MaskKey(string key)
                                    {
                                        if (string.IsNullOrEmpty(key)) return key;
                                        if (key.Length <= 4) return new string('\u2022', key.Length);
                                        return new string('\u2022', key.Length - 4) + key.Substring(key.Length - 4);
                                    }

                                    // Create the form
                                    Form form = new Form
                                    {
                                        Icon = Properties.Resources.relock,
                                        Text = Properties.Resources.RecoveryKey,
                                        AutoSize = true,
                                        AutoSizeMode = AutoSizeMode.GrowAndShrink,
                                        StartPosition = FormStartPosition.CenterScreen
                                    };

                                    // Add controls to the form in the correct order
                                    form.Controls.Add(driveLabel);
                                    form.Controls.Add(pictureBox);
                                    form.Controls.Add(recoveryKeyLabel);

                                    // Create and configure the PrintButton
                                    Button printButton = new Button
                                    {
                                        Text = Properties.Resources.Print,
                                        AutoSize = true
                                    };

                                    printButton.Click += (sender, e) =>
                                    {
                                        var confirm = MessageBox.Show(Properties.Resources.DoYouWantToPrintTheRecoveryKey, "Relock", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                                        if (confirm != DialogResult.Yes) return;

                                        using (PrintDocument printDocument = new PrintDocument())
                                        {
                                            printDocument.PrintPage += (s, ev) =>
                                            {
                                                float margin = 10;
                                                float xCenter = (ev.PageBounds.Width - pictureBox.Width) / 2;
                                                float y = margin;

                                                ev.Graphics.DrawString(driveLabel.Text, driveLabel.Font, Brushes.Black, xCenter, y);
                                                y += driveLabel.Height + margin;
                                                ev.Graphics.DrawImage(pictureBox.Image, xCenter, y);
                                                y += pictureBox.Height + margin;
                                                ev.Graphics.DrawString(recoveryKeyLabel.Text, recoveryKeyLabel.Font, Brushes.Black, xCenter, y);
                                            };

                                            using (PrintDialog printDialog = new PrintDialog())
                                            {
                                                printDialog.Document = printDocument;
                                                if (printDialog.ShowDialog() == DialogResult.OK)
                                                {
                                                    printDocument.Print();
                                                }
                                            }
                                        }
                                    };

                                    // Create and configure the SaveButton
                                    Button saveButton = new Button
                                    {
                                        Text = Properties.Resources.Save,
                                        AutoSize = true
                                    };

                                    saveButton.Click += (sender, e) =>
                                    {
                                        SaveFileDialog saveFileDialog = new SaveFileDialog
                                        {
                                            CreatePrompt = true,
                                            OverwritePrompt = true,
                                            Filter = Properties.Resources.PDFFilesPdfPNGImagePngJPEGImageJpg,
                                            DefaultExt = "pdf",
                                            FileName = "RecoveryKey.pdf"
                                        };

                                        if (saveFileDialog.ShowDialog() == DialogResult.OK)
                                        {
                                            string ext = Path.GetExtension(saveFileDialog.FileName).ToLowerInvariant();

                                            if (ext == ".pdf")
                                            {
                                                // Create the PDF document
                                                using (var pdfDocument = new Document())
                                                {
                                                    PdfWriter.GetInstance(pdfDocument, new FileStream(saveFileDialog.FileName, FileMode.Create));
                                                    pdfDocument.Open();

                                                    // Add the drive label text
                                                    var driveLabelParagraph = new Paragraph(driveLabel.Text, FontFactory.GetFont("Arial", driveLabel.Font.Size, iTextSharp.text.Font.BOLD))
                                                    {
                                                        Alignment = Element.ALIGN_CENTER,
                                                        SpacingAfter = 20f
                                                    };
                                                    pdfDocument.Add(driveLabelParagraph);

                                                    // Add the QR code image
                                                    using (var qrStream = new MemoryStream())
                                                    {
                                                        qrImage.Save(qrStream, System.Drawing.Imaging.ImageFormat.Png);
                                                        var qrPdfImage = iTextSharp.text.Image.GetInstance(qrStream.ToArray());
                                                        qrPdfImage.Alignment = Element.ALIGN_CENTER;
                                                        pdfDocument.Add(qrPdfImage);
                                                    }

                                                    // Add the recovery key text
                                                    var recoveryKeyParagraph = new Paragraph(recoveryKeyLabel.Text, FontFactory.GetFont("Arial", recoveryKeyLabel.Font.Size, iTextSharp.text.Font.BOLD))
                                                    {
                                                        Alignment = Element.ALIGN_CENTER,
                                                        SpacingBefore = 20f
                                                    };
                                                    pdfDocument.Add(recoveryKeyParagraph);

                                                    pdfDocument.Close();
                                                }
                                            }
                                            else if (ext == ".png" || ext == ".jpg" || ext == ".jpeg")
                                            {
                                                // Render combined image and save
                                                int margin = 10;
                                                int width = Math.Max(pictureBox.Width, 400) + margin * 2;
                                                int height = driveLabel.Height + pictureBox.Height + recoveryKeyLabel.Height + margin * 5;

                                                using (Bitmap bmp = new Bitmap(width, height))
                                                {
                                                    using (Graphics g = Graphics.FromImage(bmp))
                                                    {
                                                        g.Clear(Color.White);

                                                        int x = margin + (width - margin * 2 - pictureBox.Width) / 2;
                                                        int y = margin;

                                                        // Draw drive label
                                                        using (Brush b = new SolidBrush(Color.Black))
                                                        {
                                                            g.DrawString(driveLabel.Text, driveLabel.Font, b, x, y);
                                                        }

                                                        y += driveLabel.Height + margin;

                                                        // Draw QR
                                                        g.DrawImage(qrImage, x, y);
                                                        y += pictureBox.Height + margin;

                                                        // Draw recovery key
                                                        using (Brush b = new SolidBrush(Color.Black))
                                                        {
                                                            g.DrawString(recoveryKeyLabel.Text, recoveryKeyLabel.Font, b, x, y);
                                                        }
                                                    }

                                                    if (ext == ".png")
                                                    {
                                                        bmp.Save(saveFileDialog.FileName, System.Drawing.Imaging.ImageFormat.Png);
                                                    }
                                                    else
                                                    {
                                                        bmp.Save(saveFileDialog.FileName, System.Drawing.Imaging.ImageFormat.Jpeg);
                                                    }
                                                }
                                            }
                                        }
                                    };

                                    // Create and configure the CopyButton
                                    Button copyButton = new Button
                                    {
                                        Text = Properties.Resources.Copy,
                                        AutoSize = true
                                    };

                                    copyButton.Click += (sender, e) =>
                                    {
                                        // Robust clipboard copy with retries because clipboard can be busy
                                        const int maxRetries = 5;
                                        const int retryDelayMs = 200;
                                        bool success = false;
                                        for (int i = 0; i < maxRetries; i++)
                                        {
                                            try
                                            {
                                                Clipboard.SetText(originalRecoveryKey);
                                                success = true;
                                                break;
                                            }
                                            catch (Exception)
                                            {
                                                Thread.Sleep(retryDelayMs);
                                            }
                                        }

                                        if (success)
                                        {
                                            MessageBox.Show(Properties.Resources.RecoveryKeyCopiedToClipboard, "Relock", MessageBoxButtons.OK, MessageBoxIcon.Information);
                                        }
                                        else
                                        {
                                            MessageBox.Show(Properties.Resources.FailedToCopyToClipboardPleaseTryAgain, "Relock", MessageBoxButtons.OK, MessageBoxIcon.Error);
                                        }
                                    };

                                    // Create and configure the Mask/Unmask Button
                                    Button maskButton = new Button
                                    {
                                        Text = Properties.Resources.Unmask,
                                        AutoSize = true
                                    };

                                    maskButton.Click += (sender, e) =>
                                    {
                                        isMasked = !isMasked;
                                        if (isMasked)
                                        {
                                            recoveryKeyLabel.Text = MaskKey(originalRecoveryKey);
                                            maskButton.Text = Properties.Resources.Unmask;
                                        }
                                        else
                                        {
                                            recoveryKeyLabel.Text = originalRecoveryKey;
                                            maskButton.Text = Properties.Resources.Mask;
                                        }
                                    };

                                    // Create a FlowLayoutPanel to hold the buttons and center them
                                    FlowLayoutPanel buttonsPanel = new FlowLayoutPanel
                                    {
                                        AutoSize = true,
                                        AutoSizeMode = AutoSizeMode.GrowAndShrink,
                                        FlowDirection = FlowDirection.LeftToRight,
                                        WrapContents = false
                                    };

                                    buttonsPanel.Controls.Add(copyButton);
                                    buttonsPanel.Controls.Add(maskButton);
                                    buttonsPanel.Controls.Add(saveButton);
                                    buttonsPanel.Controls.Add(printButton);

                                    form.Controls.Add(buttonsPanel);

                                    // Adjust layout
                                    driveLabel.Location = new Point(0, 10);
                                    pictureBox.Location = new Point(0, driveLabel.Bottom + 10);
                                    recoveryKeyLabel.Location = new Point(0, pictureBox.Bottom + 10);

                                    // Place the buttons panel centered under the recovery key when form is shown
                                    form.Shown += (s, ev) =>
                                    {
                                        buttonsPanel.Location = new Point((form.ClientSize.Width - buttonsPanel.Width) / 2, recoveryKeyLabel.Bottom + 10);
                                    };

                                    form.ShowDialog();
                                }
                            }
                        }

                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                string errorMessage = string.Format(Properties.Resources.ErrorRetrievingKey, ex.Message);
                MessageBox.Show(errorMessage, Properties.Resources.Error, MessageBoxButtons.OK, MessageBoxIcon.Error);

                // Copy the error message to the clipboard
                try
                {
                    Clipboard.SetText(errorMessage);
                }
                catch { }
            }
        }

        private static System.Drawing.Font AdjustFontToFitLabel(Label label, string text)
        {
            // Define the maximum font size to try
            float fontSize = 20; // Initial font size
            System.Drawing.Font font = new System.Drawing.Font("Arial", fontSize, FontStyle.Bold);
            SizeF textSize;

            // Measure text size and adjust font size
            using (Graphics g = label.CreateGraphics())
            {
                do
                {
                    fontSize--;
                    font = new System.Drawing.Font("Arial", fontSize, FontStyle.Bold);
                    textSize = g.MeasureString(text, font);
                }
                while (textSize.Width > label.Width && fontSize > 1);
            }

            return font;
        }
        public static void lockDrive(string driveLetter)
        {
            try
            {
                driveLetter = driveLetter.Replace("\\", "");

                var psi = new ProcessStartInfo("manage-bde", string.Format("-lock {0} -ForceDismount", driveLetter))
                { CreateNoWindow = true, WindowStyle = ProcessWindowStyle.Hidden };
                Process.Start(psi);
            }
            catch (Exception exc)
            {
                MessageBox.Show(string.Format( Properties.Resources.FailedToLockDriveRN0, exc.Message), "Relock",
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}