Danke für deinen Tipp. Ich werde mich dann mal näher mit "Obfuscator" beschäftigen. Mich wundert es nur, dass die Softwarehersteller bisher wohl noch nichts Schlaues entwickelt haben, um ihren Quellcode z.B. zu verschlüsseln. Wenn ich das richtig verstehe, kann man unter mehr oder weniger hohem Aufwand den Quellcode wieder lesbar machen, oder?

Das ursprüngliche Problem habe ich jetzt auch lösen können. Der Grund, warum mir keine Konsole angezeigt wurde, war der Eintrag CompilerOptions = "/t:winexe" bei CompilerParameters. Den Eintrag habe ich mal auskommentiert und es wurde alles angezeigt. Die Begründung hierfür fehlt mir zwar noch, da laut msdn "/t:winexe" dazu dient, ein Windows Programm zu erstellen, aber ich nehme es jetzt mal so hin.

Gruß

Ich habe mir das so vorgestellt:

Ich habe mein zu schützendes .Net-Programm als Exe vorliegen. Das lese ich ganz normal in ein Byte-Array ein und verschlüssel es mit dem RC4-Algorithmus oder dem RSA-Algorithmus (zu langsam?). Das Array gebe ich der neuen Anwendung als Ressource mit. Diese fragt in der Konsole nach einem Passwort. Dann wird das verschlüsselte Byte-Array aus den Ressourcen geladen, entschlüsselt und im Arbeitsspeicher ausgeführt. Das Ganze soll etwas an die Eingabe einer Seriennummer bei gekaufter Software erinnern, nur, dass bei mir damit das eigentliche Programm entschlüsselt wird.

Mir ist bewusst, dass ich damit keine Profis abhalten kann, aber wenigstens etwas erschweren möchte ich es ihnen bzw. Leuten, die nicht so viel Ahnung davon haben.

Wie gesagt, es funktioniert eigentlich auch alles, nur es wird kein Konsolenfenster beim Ausführen des zu schützenden Programms angezeigt.

Nur so aus Interesse: Weiß jemand, wie Softwarehersteller ihren Quellcode schützen?

Du redest von sog. Disassemblern, oder? Ja, das weiß ich. Aber erschwere ich das nicht alles, da mein zu schützendes Programm nur als Ressource vorliegt und diese nach Möglichkeit noch gepackt oder verschlüsselt?

Hallo herbivore,

ja, für dieses "Matroschka-Spiel" gibt es Gründe. Ich versuche dadurch mein eigentliches Programm vor Reverse Engineering zu schützen. Ich weiß, dass man ein Speicherabbild erstellen kann, wenn das Programm im Speicher liegt, aber mit der Methode will ich es wenigstens etwas erschweren.

Gruß

Hallo,

momentan versuche ich mich an dem CodeDom Compiler und Assembly.Load(), leider habe ich damit etwas Probleme.

Zu meinem Vorhaben:

Ich habe ein Konsolenprogramm geschrieben, das den Quelltext einer weiteren Konsolenanwendung aus den Ressourcen einliest. Diese zweite Konsolenanwendung bekommt Ressourcen in Form eines .Net Programms (byte[]) zugewiesen.
Die Aufgabe der zweiten Konsolenanwendung ist es, das .Net-Programm in den Speicher zu laden und dort auszuführen.
Damit es verständlicher wird, poste ich mal den Quellcode des Hauptprogramms, das die zweite Konsolenanwendung erzeugt:

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            string source = Properties.Resource.Source;
            ResourceWriter rw = new ResourceWriter("res.resources");
            CompilerParameters para = new CompilerParameters() 
            { 
                GenerateExecutable = true,
                CompilerOptions = "/t:winexe",
            };
            para.OutputAssembly = "AssemblyBsp.exe";
            para.ReferencedAssemblies.Add("System.dll");
            //auszuführendes .Net-Programm
            byte[] file = File.ReadAllBytes("Pfad zur Test.exe");
            rw.AddResource("file", file);
            rw.Close();


            para.EmbeddedResources.Add("res.resources");
            CompilerResults res = new CSharpCodeProvider().CompileAssemblyFromSource(para, source);
            File.Delete("res.resources");

        }
    }
}

Jetzt die Source.txt, die den Quellcode dieser zweiten Anwendung enthält:

class Program
{
	static void Main()
    {		
		try
        {							
			ResourceManager MANAGER = new ResourceManager("res", Assembly.GetExecutingAssembly());
            byte[] file = (byte[])MANAGER.GetObject("file");
            Assembly a = Assembly.Load(file);
            MethodInfo m = a.EntryPoint;
            m.Invoke(null, new object[]{new string[0]});
			
        }
        catch(Exception ex) 
		{}
	}   
}

Das Programm, das jetzt durch Ausführen der zweiten Konsolenanwendung startet, ist wiederum eine Konsolenanwendung (oben Test.exe genannt). Diese Test.exe schreibt ein paar Zeilen in die Konsole, legt einen Ordner auf dem Desktop an und schließt sich nach 100 Sekunden wieder.
Das führt mich zu meinem Problem:

Wenn ich die Exe ausführe, wird der Ordner erstellt, aber es wird keine Konsole geöffnet. Wenn ich alles ohne das Kompilieren mache, wird die Test.exe ganz normal in den Speicher geladen und vollständig ausgeführt/angezeigt. Woran liegt das?

Ich hoffe, dass ich mein Anliegen halbwegs verständlich rüberbringen konnte. Wenn es noch Fragen gibt, bitte stellen.

Gruß