In die EXE des eigenen Programms während Laufzeit schreiben?

Hallo,

ich arbeite im moment an einem Programm das Integritätstests auf Datein durchfürt. Jetzt habe ich mal eine Frage. Ich wollte die Vergleichsschlüssel(checksummen) nicht in einer seperaten Datei speichern sondern etwas verstecken.

Mein Professor hat mir den Vorschlag gemacht die Schlüssel in die eigene EXE zu schreiben. Ich habe sowas schon in C++ implementiert aber da wird der Schlüssel in die zu testenden Dateien ans Ende geschrieben.

Das funktioniert auch ganz gut und in C# wäre das sicher auch kein problem. Aber gibt es ihrgend eine Möglichkeit das auch in die eigene EXE des Programs zu schreiben?

Ich habe das schonmal probiert und die Exception bekommen das die Datei schon von einem anderen Prozess benutzt wird.

Hat da jemand vielleicht vorschläge wie man an die Sache rangehen könnte?

mfg Taki

Hallo,

ich mach sowas auch :

Eigene Exe umbennen, dann neue Exe reinkopieren, ändern, Programm automatisch neu starten.

Die eigene Exe (umbenannt) kann man sicher lesen und dann ne neue Datei anlegen.

Voilà !

Grüße Bernd

PS.: Klappt auch bei Diensten !

Hallo Taki Haki,

Vielleicht ist AppDomain auch etwas für dich. Such einfach mal hier im Forum, das Thema wurde schon öfter angeschnitten. Ich glaube talla hat da auch einiges Interessantes dazu geschrieben, dann kannst du die Suche einschränken.

Gruß,
Thomas

@progger: Du meinst sicherlich Shadowcopy via Appdomain? 😉

Hallo dr4g0n76,

Ja, genau das mein ich! Man kann sich ja nie alle Begriffe merken 😉

Gruß,
Thomas

PS: Wenn du was findest, Taki Haki (oder auch jeder andere), wäre es schön, wenn du deine Ergebnisse hier berichtest =).

Hallo,

erstmal toll das so schnell Antworten gekommen sind 🙂

@BerndFfm umbenennen und neustarten geht glaube ich nicht 😠 ich will ja im Grunde das Programm "nicht" neustarten. Aus Sicherheitsgründen soll das Programm selber ja auch die Vergleichsschlüssel enthalten.

Jetzt zu dem AppDomain und ShadowCopy, ich habe gestern Abend mal ein wenig im Forum danach gesucht und ehm ich muss dazu sagen das ich mit sowas bis jetzt noch nie arbeiten mußte X(

Aber ich versuche mal das was ich darüber weiß kurz zu erklären und dann könnte mir ja jemand sagen ob ich das so richtig verstanden habe 😁

Also ich würde mein Funktionalität also Klassen die mit den Schlüsseln arbeiten usw. in eine DLL packen. Diese würde ich dann in meinem Programm laden das per AddDomain und Schadowcopy arbeitet. Die DLL würde dann temporär in einem anderen Verzeichnis gespeichern und mit dieser Kopie wird dann gearbeitet?

Ich könnte dann auf die echte DLL im Code zugreifen und in diese Bytes schreiben und auch lesen ohne das diese von einem Prozess blockiert wird?

Stimmt das so in etwa? X(

mfg Taki

Ich denke ich habe die Lösung, anhand eines Beispiels!!!

Das Programm "Reflector" ist in .NET geschrieben und kann sich somit selbst disassembleren.

Das Programm prüft immer beim start, ob ein Update gemacht werden soll! Da das Programm nur aus 1-er ExE besteht, ist es doch das was ihr sucht!!

Wenn ihr es habt könnt ihr es ja mal posten.

Original von Taki Haki
Stimmt das so in etwa? X(

So in etwa stimmt das, nur ich versteh nicht so richtig, wo der Unterschied zu einer stinknormalen neu erstellten Datei ist.

Ja mit einer DLL ist das im Grunde das gleich wie eine seperate Datei in der die Schlüssel stehen 🙁

Am besten wäre eine Datei (exe) in der dann auch die Schlüssel versteckt werden.

@Trivalik das klingt eigendlich danach was ich suche 😁 aber ich finde nicht den Code zu dem Programm 🙁

Es gibt auch noch eine Möglichkeit, die DLL in der der Schlüssel steht, wird als Plugin realisiert. Dort wird ein string definiert.

z.B. string skey = "0000000000000000000000000000000000000000000000000000000"

die Länge des Strings, der initialisiert werden muss(!), gibt die höchstmögliche Länge des Schlüssels an.

Bei einem neuschreiben des Keys, wird zuerst das Plugin (und damit die zugehörige DLL) entladen, dann der Key geschrieben und danach die DLL wieder geladen.

Wie du siehst sage ich "entladen", denn soweit ich weiss, kann der Prozess der Läuft nicht seine eigene ausführbare dtaie von der er gestartet wurde verändern.

Ich lasse mich aber auch gern eines besseren belehren.

Vielleicht gibt es bestimmte PE-Header-Sections die zur Laufzeit ausgetauscht werden dürfen. Mir sind bisher aber keine bekannt.

Generell ist es eigentlich eh nicht zu empfehlen in die eigene lauffähige Datei zu schreiben. Da schlägt dann hoffentlich auch der Virenkiller alarm.

hmm ok

also geht das wohl doch nicht so leicht umzusetzen. Ich werde mich nochmal erkundigen ob ich das nicht auch anders lösen kann. Die Schlüssel direkt in die zu prüfenden Dateien schreiben würde ja auch gehen.

Trotzdem danke erstmal für die vielen Antworten 🙂

Hallo!

Sollte es sich dabei um ein "normales" Programm handeln, welches im Programm-Verzeichnis installiert wird, sollte man dabei immer beachten, dass beim ändern der eigenen Exe-Datei ein Schreibversuch erstmal nur mit Adminstratorrechten funktioniert (ausser, bei der Installation werden die Verzeichnisrechte angepasst).

Anderer Vorschlag:
Du gibst deinem Program einen StrongName und benutzt den ebenfalls hier im Forum kuerzlich angesprochenen IsolatedStorage.. Damit duerfte eigentlich (..) niemand sonst an die von dir abgelegten Schluessel kommen.

Ok DarKlajid ich versuch mich gerade darüber schlau zu machen 🙂

Könnte dann nur meine Anwendung auf die Dateien in denen die Schlüssel sind zugreifen?

Hallo Taki Haki,

ohne eine Eingabe eines nur dem Benutzer bekannten Passworts gibt es keine wirkliche Sicherheit. Siehe die ähnliche Diskussion um [FAQ] DB-Passwort/Connection-String sicher speichern.

Aber besser als die Daten in der EXE-Datei selbst zu speichern (schauder), ist es alle mal.

herbivore

Hallo,

also ich habe das gerade einmal ausprobiert 😁

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.IO;
using System.IO.IsolatedStorage;

namespace Isolated_Storage
{
    class Program
    {
        static void Main(string[] args)
        {
            
            IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForDomain();
            IsolatedStorageFileStream stream = new IsolatedStorageFileStream("data.txt", FileMode.Create, store);
            StreamWriter sw = new StreamWriter(stream);
            sw.Write("Test");

            sw.Close();
            stream.Close();
            store.Close();

            store = IsolatedStorageFile.GetUserStoreForDomain();
            stream = new IsolatedStorageFileStream("data.txt", FileMode.Open, store);
            StreamReader sr = new StreamReader(stream);
            Console.WriteLine(sr.ReadToEnd());
            Console.Read();
        }
    }
}

Danach habe ich nachgeschaut ob ich die Datei data.txt finde aber den Pfad den ich mir im debugStop angeschaut habe finde ich nicht und ich habe mir schon versteckte dateien anzeigen lassen.

Gibt es da überhaupt eine Möglichkeit von außen dranzukommen außer über meine Anwendung?

und dann noch eine 2 kleine Frage 😁

Es gibt ja 3 Möglichkeiten sich den IsolatedStorage zu erstellen/abzufragen

.GetUserStoreForApplication();
.GetUserStoreForAssembly();
.GetUserStoreForDomain();

Im Grunde geben mir die 3 Methoden doch alle einen Speicherort zurück oder nicht? Da ich nicht für einzelnen Assemblys einen Speicherplatz brauchen sonden insgesamt nur einen reicht mir ja die .GetUserStoreForApplication(); oder sehe ich das falsch ? 😁

brauchte ich zwingend einen "StringName" für meinen Anwendung?

mfg Taki

Ich fuerchte bei Detailfragen muss ich passen: Ich habe das selbst erst kuerzlich ueber dieses Forum gefunden und noch nicht benutzt. Ich finde es allerdings sehr nett..
Grundidee ist ja dabei, dass du eine sichere (im Sinne von: Nicht direkt mit dem Filesystem verbunden.. Sandbox fuer unsicheren Code z.B.) Methode hast, Daten abzulegen. Ich wuerde es als "Cookies fuer Webapplikationen auf Speed" bezeichnen.
Wo genau der Store ist siehst du in dem Artikel der hier referenziert wurde (http://www.dotnetdevs.com/articles/IsolatedStorage.aspx) und darauf kann man natuerlich auch von extern zugreifen. Irgendwie..

ahh mit dem Tool storeadm.exe findet man die Sachen wieder 🙂 nett

wenn ich

store = IsolatedStorageFile.GetUserStoreForApplication();

versuche bekomme ich immer eine exception "Die Anwendungsidentität des Aufrufers kann nicht bestimmt werden" ???

Muss ich meine Anwendung noch eine art Identität geben? X(

mfg Taki

ps. sn.exe und http://www.developer.com/net/vb/article.php/3292231
damit werde ich das wohl hinbekommen 🙂

Original von Taki Haki
Mein Professor hat mir den Vorschlag gemacht die Schlüssel in die eigene EXE zu schreiben.

Um mit Herbis Worten zu sprechen: Doppel-Schauder

Und sowas von einem Professor. Der Kerl sollte sich schämen, seinen Studis sowas zu empfehlen. Um sicherzustellen, dass einem kein manipulierterCode untergeschoben wird, hat .NET wahrhaft besseres zu bieten (z.B. signierte Assemblies).

Daten in die EXE zu schreiben, ist wohl die schlechteste aller denkbaren Lösungen und scheitert vermutlich schon an den Nutzerrechten...

Wenn du Sicherheit willst:

Zuerst mit System.Security.Cryptography.SHA512Managed.ComputeHash das Passwort hashen, dann mittels System.Security.Cryptographie.ProtectedData.Protect den Hash verschlüsseln und anschließend per IsolatedStorage speichern.