Hemligt meddelande 🤫

🧠 Syfte

Kom igen, vem har inte drömt om att skicka hemliga meddelanden? Det här kodexemplet visar hur du kan “gömma” en text i en bild – en riktig spiongrej! Vi ska använda lite enkel C-Sharp-magi för att både gömma och avslöja budskapet. Det är perfekt för att öva på grundläggande C-Sharp-koncept som arrayer och loopar. Låter kul, va?

💻 Koden

using System;
using System.Drawing;
using System.Drawing.Imaging;

public class SecretMessage
{
    public static void HideMessage(string message, string imagePath, string outputPath)
    {
        // Läs in bilden
        Bitmap image = new Bitmap(imagePath);
        int width = image.Width;
        int height = image.Height;

        // Konvertera meddelandet till en byte-array
        byte[] messageBytes = System.Text.Encoding.UTF8.GetBytes(message);
        int messageLength = messageBytes.Length;

        // Kontrollera om bilden är tillräckligt stor för att gömma meddelandet
        if (width * height * 3 < messageLength * 8) {
            Console.WriteLine("Bilden är för liten för det här meddelandet!");
            return;
        }

        // Göm meddelandet i bildens pixeldata
        int index = 0;
        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                Color pixel = image.GetPixel(x, y);
                if (index < messageLength * 8)
                {
                    // Ändra minst signifikanta biten i varje färgknalle
                    int newR = pixel.R - (pixel.R % 2) + ((messageBytes[index / 8] >> (index % 8)) & 1);
                    int newG = pixel.G - (pixel.G % 2) + (((messageBytes[index / 8] >> (index % 8)) & 1));
                    int newB = pixel.B - (pixel.B % 2) + (((messageBytes[index / 8] >> (index % 8)) & 1));
                    image.SetPixel(x, y, Color.FromArgb(newR, newG, newB));
                    index++;
                }
            }
        }

        // Spara den modifierade bilden
        image.Save(outputPath, ImageFormat.Bmp);
        Console.WriteLine("Meddelandet är gömt!");
    }


    public static string RevealMessage(string imagePath)
    {
        // Läs in bilden
        Bitmap image = new Bitmap(imagePath);
        int width = image.Width;
        int height = image.Height;
        string message = "";

        // Extrahera meddelandet från bildens pixeldata
        for (int y = 0; y < height; y++)
        {
            for (int x = 0; x < width; x++)
            {
                Color pixel = image.GetPixel(x, y);
                message += ((pixel.R % 2) * 128 + (pixel.G % 2) * 64 + (pixel.B % 2) * 32).ToString();
            }
        }

        // Konvertera binärsträngen till en textsträng
        string binaryString = message;
        byte[] decodedBytes = new byte[binaryString.Length / 8];
        for (int i = 0; i < decodedBytes.Length; i++)
        {
            decodedBytes[i] = Convert.ToByte(binaryString.Substring(i * 8, 8), 2);
        }
        return System.Text.Encoding.UTF8.GetString(decodedBytes);
    }

    public static void Main(string[] args)
    {
        // Exempel på hur man använder funktionerna
        HideMessage("Detta är ett hemligt meddelande!", "input.bmp", "output.bmp"); //Input och output bild krävs
        string revealedMessage = RevealMessage("output.bmp");
        Console.WriteLine($"Avslöjat meddelande: {revealedMessage}");
    }
}

📋 Förklaring

Tänk dig bilden som en massa små lådor (pixlar). I varje låda finns tre färger (röd, grön, blå). Vi ändrar den allra minsta detaljen i färgen (den lägsta biten) för att gömma en bit av vårt meddelande. Det är som att skriva med osynligt bläck!

HideMessage-funktionen gör just det: den tar ditt meddelande, konverterar det till binärkod (nollor och ettor), och sen gömmer den dessa nollor och ettor i bildens pixlar. Det är en bit i taget.

RevealMessage gör precis tvärtom. Den läser bilden, plockar ut de gömda bitarna, och sätter ihop dem igen till ditt hemliga meddelande. Magi!

Viktigt: Du behöver en input.bmp-bild för att koden ska fungera. Skapa en enkel bildfil med det namnet i samma katalog som din .cs fil.

graph TD A[Meddelande] --> B(Konvertera till binär); B --> C{Göm i bildens pixlar}; C --> D[Modifierad bild]; E[Modifierad bild] --> F(Extrahera binär från pixlar); F --> G(Konvertera till text); G --> H[Avslöjat meddelande];

Den här bilden visar arbetsflödet. Först gömmer vi meddelandet i bilden, sen extraherar vi det.

Enkelt, eller hur? Men kom ihåg – ju större meddelande, desto större bild behöver du!

⚠️ Vanliga misstag

Felaktig bildformat: Koden fungerar bäst med BMP-bilder. Andra format kan ge problem.
För litet bild: Om bilden är för liten jämfört med meddelandet, kommer meddelandet inte att kunna gömmas helt. Koden skriver ut ett felmeddelande i detta fall.
Glömma att spara: Se till att spara den modifierade bilden efter att du gömt meddelandet.

📚 Sammanfattning

Vi har lärt oss att gömma och avslöja hemliga meddelanden i bilder med hjälp av C-Sharp! Det var lite knepigt, men superhäftigt!

😄 Obligatoriskt pappaskämt

Vad kallar man en programmerare som inte kan sova? En bug hunter!

Du klarar det här! Koda vilt!