Das erste Snippet hat mich schmunzeln lassen. Aber gut, ich hatte solche Lösungen aber nicht ausgeschlossen^^
👍, Du bist dran...

Was mir grade noch auffällt: Da is nicht der Syncblock (der is ein IntPtr davor, sic), sondern die Typenangabe, aber das ist in diesem Falle egal^^

Ich hab mir mal ne Aufgabe ausgedacht. Sie ist auf jeden Fall lösbar und das mit einer überschaubaren Zahl an Codezeilen. Ziel ist es, eigenen Code einzufügen, sodass Gelöst auf der Console ausgegeben wird.

using System;
using System.Runtime.InteropServices;

class Program
{
    static void Main(string[] args)
    {
        string ShouldBe = "This String";
        string IsAtStart= "R4nd0om data or somthing nobody cares about....";
        IntPtr buffer = Marshal.StringToHGlobalUni(IsAtStart);
        int hash = ShouldBe.GetHashCode();//Doppelte Prüfung hält besser

        WriteToBuffer(buffer, ShouldBe);

        string newString = Marshal.PtrToStringUni(buffer);
        Marshal.FreeHGlobal(buffer);

        if (newString == ShouldBe && newString.GetHashCode() == hash)
            Console.WriteLine("Gelöst");
        else
            Console.WriteLine("Nicht gelöst, in \"buffer\" steht: "+newString);
        Console.ReadLine();
    }

    //Hinter dem Ende dieses Kommentars darf der Code geändert werden.
    //Der nachfolgende vorgegebene Code ist als Hinweis gedacht und darf gelöscht/bearbeitet werden.
    //Folgende Ausdrücke dürfen dabei NICHT verwendet werden:
    //unsafe, Marshal, DllImport, extern, Reflection, GetType, typeof, Type, Program, Console, Main

    [StructLayout(LayoutKind.Explicit)]
    struct SomeStruct
    {
        //TODO
    }

        //TODO

    private static void WriteToBuffer(IntPtr buffer, string ShouldBe)
    {
        //TODO
    }
}

Es steht sogar in der Beschreibung von meinem Progrämmchen, was man für ein Handle braucht... Lies doch einfach.

Beschreibung:

Schade, dass ich diese Methode erst heute entdeckt habe:
Der Windows-Kernel hat einen Objektmanager, welcher diverse Objekte und deren Handles verwaltet. Prozesse sind solche Objekte.
Ein Prozess hat standardmäßig ein Handle auf sich selbst, welches das Recht WRITE_DAC hat. Dieses kann man nutzen, um die Zugriffsrechte auf das Prozess-Objekt zu ändern. Man kann z.B. hinzufügen, dass für alle Nutzer bestimmte Rechte gesperrt werden. Wenn jetzt ein NEUES Handle mit diesen Rechten angefordert wird, dann wird der Zugriff gesperrt. (Vorher erstellte Handles sind aber afaik weiterhin gültig).

Jedenfalls lassen sich so die Funktionen TerminateProcess (welches der Taskmanager verwendet) und CreateRemoteThread (aka dll injection) und WriteProcessMemory und einiger anderer Kram blockieren.

Es funktioniert nur, wenn der Benutzer nicht zuviele (Admin-)Rechte hat.
Die Idee hat ansonsten noch 3 Schwächen:
1.) Es können Handles erstellt werden, bevor der Code ausgeführt wird. Dies lässt sich eventuell umgehen, indem man einen weiteren Prozess startet und diesen sofort schützt, noch bevor er die Ausführung beginnt.
2.) Mit dem Debug Privilege (welches Existiert, um als Admin Systemservice zu debuggen) lassen sich trotzdem Handles erstellen.
3.) Ich bin mir nicht ganz sicher, aber ich glaube, mit SetWindowsHookEx lässt es sich ebenfalls umgehen.

Die Idee ist nicht von mir, aber ich bin wohl der erste, der das in C# umsetzt.

Man könnte es noch erweitern, dass man auch die Threadobjekte schützt, das wird aber etwas komplizierter.

Du musst irgendwie mitbekommen wenn jemand das versucht oder es von Windows sperren lassen:
-Die Benutzerrechte/Zugriffsrechte auf deinen Prozess setzten, sodass windows sperrt, aber das ist wahrscheinlich schwer möglich, da dein Programm wahrscheinlich als Standardnutzer laufen soll...
[EDIT] Ich hab mal was gebastelt in der Richtung: Prozess schützen (Nur dokumentierte Apis, keine Hooks)

Daneben gibt es noch Hooking, das ist aber unsauber. Es gibt verschidene Alternativen, wo man das machen könnte:
-Im eigenen Prozess Loadlibrary Hooken, Nicht allzu sicher, aber relativ einfach und sogar aus c# heraus machbar
-Zentral als Kernelmode Treiber, geht aber nur in x86 und man kann sehr viel falsch machen
-Zentral im Systemservice csrss (Kann mit etwas Trixerei umgangen werden, man muss ich aber sehr auskennen um damit was zu machen)
-In jedem einzelnen Prozess (die umständlichste und dämlichste Methode)

Dann gibt es unter Windows noch geschützte Prozesse für DRM. Man muss sie aber mit einem (gekauften) Zeitifikat signieren.

Never trust the Client: Es gibt Leute (z.B. mich), die auf Streamingseiten meißt eh die Url kopieren und im lokalen Player anschauen.
Egal wie du es anstellst, wenn das nicht auf der Serverseite blockiert wird, dann ist es grundsätzlich nicht sicher. (Sieht man ja daran, wie sicher DRM ist, lol)
Du brauchst also einen Server, der das unterstützt oder ein einfacheres Bezahlmodell (z.B. Pauschalpreis für den ganzen Film.)

wie ich Rechte setze das weiß ich schon, das Problem ist die UAC.
Und ich brauche zentral eine Stelle an der ich Daten schreiben kann, unabhängig vom Benutzer.

Hä!?

Ich habe grade mal einen ordner mit gesetzten Rechten in "C:\Program files" erstellt.
Es geht! Ich habe keine probleme mit UAC! Einfach eine Berechtigung hinzufügen, dass "Jeder" (ohne die Anführungsstiche natürlich) auf den Ordner zugreifen kann UND dass diese Berechtigung für alle Unterelemente übernommen werden soll. Klappt wunderbar.

Ich kann mich zommi nur anschließen: Mono.Cecil
Noch ein Blogeintrag zum Thema.

Gibt es irgendwelche Tricks/Tips um die CPU-Last beim Zeichnen zu reduzieren?

Winforms is halt viel Softwarerendering, nimm WPF für die GPU oder reduziere deine Gui soweit wie möglich...

Außerdem solltest du vermeiden, auf ein Bitmap zu zeichnen. Pictureboxen sind nicht zum Zeichnen!!

Es gibt die Möglichkeit, die Zugriffsrechte von Dateien und Verzeichnissen so zu setzten, dass alle Benutzer Schreibrechte haben. Das ist allerdings potentiell gefährlich, je nach Inhalt.
Eines meiner Spiele macht es so.
Das Framework bietet dafür Apis.

hinten kommen weitere Variablen dazu

Irgendwie kommt mir das fast zu einfach vor:
Nimm immer das gleiche Struct mit allen Feldern, lies nur soviel ein, wie da is in der Datei und schreib den Rest des structs mit Nullen voll....

Evtl gibts es hier auch noch viel bessere Möglichkeiten eine generelle abstrakte Suche zu implementieren?

Du kannst code zur Laufzeit Compilieren.
Das geht mit gängigen .net Sprachen wie c#. Das ist schon im Framework eingebaut!

Ansonsten geht mir Reflection so ziemlich alles, und man kann auch Typenprüfunegn einbauen. Wenn einem das dann noch zu langsam ist: DynamicMethods

Für mich übersetzt: Die Methode gibt die höchste in beiden Zahlen enthaltene Zweierpotenz zurück.

Plus alle anderen auch...

Gibt dieses Statement :

C#-Code:
operand + 1 & operand

tatsächlich
die höchste enthaltene Zweierpotenz zurück?

Probier doch mal aus:

operand=7 =>
7+1 & 7
=8 & 7
=8 & (1+2+4)
=0

Irgendwie nicht so ganz...

true oder false zurück gibt, solange in zahl alle Zweierpozenzen enthalten sind, die auch in operand enthalten sind.

return (operand & zahl) == operand

Wenn du die höchste Zweierpotenz haben willst:

if(zahl==0)return 0;
int ergebnis=1;
while((zahl>>=1)!=0)ergebnis<<=1;
return ergebnis;

ASLR stört da nicht weiter... Du schreibst ja einen Trainer und keinen Shellcode.

Wenn man nicht aufpasst, dann doch: Denn die Basisaddressen der dlls und stacks werden zufällig gewählt. Das heißt, dass man sich ne Liste der Module und Thread-stacks holen muss (dafür gibt es apis) und dann prüfen muss, ob eine Variable innerhalb eines Moduls liegt.

ich bezweifle auch, dass es so einfach ist, einen stabilen Zugriffspfad zu finden. Dafür brauchst du Erfahrung. Trainer werden von Leuten geschrieben, die sich mit sowas schon auskennen.

Jap!

Yield gibt das resultat "nacheinander zurück" somit vorteilhaft (schneller) wenn das Resultat per Binding an das UI gebunden wird ?

Japp, yield baut eine state maschine. Z.B. in Yield, and the C# state machine hat jemand das mal genauer angeschaut.
In manchen Situationen sicherlich schneller, aber im Speziellem Falle muss das nicht unbedingt so sein.

Die Länge ist bei yield return nicht bekant, bevor der gesamte Enumerator durchlaufen wurde. Deshalb muss eventuell sowieso ne Liste erstellt werden oder der Enumerator wird mehrfach durchlaufen. Außerdem handelst du dir mit yield leichter Threading-Probleme ein.

Also, wenn ich den letzten pointer gefunden habe( und wie ich das verstanden habe, bleibt bei dem die adresse immer gleich) kann ich mit c# einfach in die adresse von diesem pointer schreiben?

Ja, WENN

Und ich bezweifle dass es so einfach gehen wird.

Überleg dir mal, was du in c# machst. Du schreibst Klassen. Diese Klassen haben mehrere Felder=Variablen. Wenn du eine Instanz mit new erstellst, wird sie an zufälliger stelle allokiert. Wenn du ein Member der Klasse verändern möchtest, brauchst du eine Referenz=Zeiger dees Objekts. Der Zeiger liegt dann entweder in einem Static oder auf dem Stack oder in einem anderen Objekt. Außerdem zeigt der Zeiger auf das erste Feld der Klasse (Im Falle von c# ist das erste Feld immer der Objekttyp) und NICHT DIREKT AUF DEN WERT DEN DU HABEN WILLST, SONDERN MEHR ODER WENIGER KURZ DAVOR. Mal abgesehen davon dass der Zeiger selber an belibiger position gespeichert sein kann (z.B. in nem anderen Objekt)

Außerdem kommt aslr immer mehr in Mode (Sicherheitsmaßnahme, zufällige Speicheraddressen für Dlls und co) Das lässt sich aber umgehen, wenn man Informationen über den Zielprozess auslesen kann. Ist aber etwas komplizierter...

Habe ich das richtig verstanden, dass du versuchst, aus einem 2d-standbild, das mit einer normalen Kamera gemacht wurde automatisch ein stereoskopisches machen willst?

Automatisch geht sowas überhaupt nicht, höchstens, wenn man manuell angibt, was wie weit vorne liegt oder wenn bewegungen zu sehen sind, sodass anhand der geschwindigkeitsunterschiede was angeschätzt werden kann. Und selbst dann muss man noch irgendwie die verborgenen ränder der Objekte füllen... sowas geht kaum bis garnicht, esseiedenn du erstellst ein 3d-modell von hand. (z.b. in blender)

(Hmm ich habe ein interessantes Programm in die richtung gefunden kein c#, sondern c++ http://make3d.stanford.edu/faq.html)

Die Stichwörter dazu sind Reflection und Mono.Cecil, frag mal Floste 😉 Jade.NET (C# - Decompiler) 😁 hehe

-Man sollte sich mit il-code auskennen
-Generell in c# fitt sein
-Sich Gedanken über Algorithemn machen und am besten etwas Lektüre
-Eine gute Repräsentation im Ram ist wichtig, mit der man arbeiten kann und die hat es in diesem falle ziemlich in sich. (Eine If-Anweisung hat z.b. einen oder zwei Blöcke an untergeordneten Anweisungen und dazu noch Parameter, die ihrerseits Anweisungen mit Parametern sind)

Es ist ziemlich viel Arbeit, sowas selber zu schreiben, das is mit 15 doch ein sehr ambitioniertes Ziel.

Ist es denn möglich den Rückgabewert wieder in ein IEnumerable<string> herein zu schreiben? Oder muss ich das dann über .Add() realisieren?

new string[1]{wert}

Frage die sich mir stellt, wie konvertiere ich ihm das nun richtig?

Wie wärs mit garnicht?

Entweder fu willst ein einzelnes Element, dann ist das vom Typ string,
oder du willst ne liste aller Elemente, dann lass einfach das .Single weg und du hast IEnumerable<string> als Ergebnis...

public Invoker(string[] args)
      {
          Object objekt = args[0];

Folglich wäre object doch immer vom Typ string -> nicht sehr sinnvoll

Und jetzt in Run würde ich gerne objekt.methode(current_value);

@object.GetType().InvokeMember(...

Erklär doch bitte mal, wozu du das eigendlich genau brauchst.

😁 Erstaunlich, dass ihr beiden jeweils um 0:24 bzw 25 antwortet, und beide richtig^^
Und Zommis Frage:

Warum ist das GC.KeepAlive nötig? Würde er sonst nicht internalisieren? wurde auchnoch beantwortet, bevor sie gestellt wurde 👍

Habt ihr euch wirklich nicht abgesproochen?

Ich hab mich wenigstens gut amüsiert heute moren, aber genug der String-Theorie, der nächste ist dran!

Im Anhang ist eine .net exe. Es soll eine Eingabe gefunden werden, die zu folgender Ausgabe führt: richtig

Wie letztes mal:
1.) Es ist nicht ganz so offensichtlich, wie es den Anschein hat.
2.) Es gibt eine Lösung!!!!

Wie man unschwer erkennen kann, ist es diesesmal sehr wenig Code, also auch weniger Platz um etwas zu verstecken. Wissen um die Eigenheiten der Clr und Msil sollte zur Lösung sehr nützlich sein.

Also: Fröhliches "wtf?!"

(Wenn jemand sich wundert, kann er gerne seinen Kommentar abgeben 😄)

Hier mein Vorschlag:

using System;
using System.Collections.Generic;

class AchtDamen
{
    const int brettGröße = 8;
    const int feldzahl = brettGröße * brettGröße;

    static void Main(string[] args)
    {
        int[] angriffszahlen = new int[brettGröße * brettGröße];
        int aktuellesFeld = 0;

        Stack<int> schritte = new Stack<int>();
        while (true)
        {
            if (aktuellesFeld < feldzahl)
            {
                if (angriffszahlen[aktuellesFeld] == 0)
                {
                    FürAlleErreichbarenFelder(aktuellesFeld % brettGröße, aktuellesFeld / brettGröße,
                        (x, y) =>
                        {
                            angriffszahlen[x + y * brettGröße]++;
                        });
                    schritte.Push(aktuellesFeld);
                    if (schritte.Count == 8)
                        break;

                    aktuellesFeld = 0;
                }
                else
                    aktuellesFeld++;
                continue;
            }
            if (schritte.Count > 0)
            {
                aktuellesFeld = schritte.Pop();
                FürAlleErreichbarenFelder(aktuellesFeld % brettGröße, aktuellesFeld / brettGröße,
                    (x, y) =>
                    {
                        angriffszahlen[x + y * brettGröße]--;
                    });
                aktuellesFeld++;
                continue;
            }
            Console.WriteLine("Keine Lösung gefunden!");
            Console.ReadLine();
            return;
        }
        char[] ausgabe = new char[feldzahl];
        for (int i = 0; i < ausgabe.Length; i++)
            ausgabe[i] = (((i + i / brettGröße) & 1) == 0) ? ' ' : 'ˆ';
        foreach (int schritt in schritte)
        {
            ausgabe[schritt] = 'Q';
        }

        Console.WriteLine("##########");
        for (int y = 0; y < brettGröße; y++)
        {
            Console.Write("#");
            for (int x = 0; x < brettGröße; x++)
                Console.Write(ausgabe[x + y * brettGröße]);
            Console.WriteLine("#");
        }
        Console.WriteLine("##########");
        Console.ReadLine();
    }

    private static void FürAlleErreichbarenFelder(int xStart, int yStart, Action<int, int> aktion)
    {
        aktion(xStart, yStart);
        int x, y;

        for (x = 0; x < brettGröße; x++)//quer
        {
            if (x != xStart)
                aktion(x, yStart);
        }

        for (y = 0; y < brettGröße; y++)//senkrecht
        {
            if (y != yStart)
                aktion(xStart, y);
        }

        x = xStart; y = yStart;//links oben
        while (x > 0 && y > 0)
            aktion(--x, --y);

        x = xStart; y = yStart;//rechts unten
        while (x < brettGröße - 1 && y < brettGröße - 1)
            aktion(++x, ++y);

        x = xStart; y = yStart;//links unten
        while (x > 0 && y < brettGröße - 1)
            aktion(--x, ++y);

        x = xStart; y = yStart;//rechts oben
        while (x < brettGröße - 1 && y > 0)
            aktion(++x, --y);
    }
}

Ich hab auch schon eine aufgabe der Kategorie

Kopf -> Tisch!

(Obwohl: Diesesmal ist es nur halb so lang^^)

Das hat garantiert jemand mit Absicht gemacht. Unerfahrene kommen z.B. in der Regel nicht auf die Idee, statics als readonly zu deklarieren.

((Zwei)Zeiger).EigenschaftAusZwei = 10; // so geht's

Sowas nennt sich auch casting.

Sleep

Polling sollte man vermeiden -> WaitOne &co

Du solltest dir wirklich den Link von michlG angucken!!

Ich komme ursprünglich aus dem C++ Bereich

In c++ gibt es eine andere Möglichkeit, die in c# umzusetzen ist allerdings eher problematisch. Man kann aber einfach eine c dll in c# einbinden. Die Idee ist alle Maus und Tastatureingaben für die Zielanwendung zu ignorieren/abzufangen

//Installieren:
{
HMODULE currentModule;
GetModuleHandleEx(
    GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
    (LPCTSTR)&GetMsgProc,//sic!
    &currentModule);

HHook myHook = SetWindowsHookEx(
    WH_GETMESSAGE,
    &GetMsgProc,
    currentModule,
    GetWindowThreadProcessId(targetwindow,NULL));

thread darf nicht beendet werden, sondern muss nachrichtenschleife haben (application.Run in c#, while(getmessage) in c++)


Am Ende:
UnhookWindowsHookEx(myHook);
}

//--------------------------------------------------------------

LRESULT CALLBACK GetMsgProc(
  __in  int code,
  __in  WPARAM wParam,
  __in  LPARAM lParam
)
{
    MSG* msg=(MSG*)lParam;
    UINT msgCode=msg->message;
    if(doBlock &&
        (
          (msgCode >= WM_KEYFIRST && msgCode <=WM_KEYLAST)
        ||(msgCode >= WM_MOUSEFIRST  && msgCode <=WM_MOUSELAST)
        )
    )
    {
        msg->message=WM_NULL;
        msg->lParam=NULL;
        msg->wParam=NULL;
        return 0;
    } 
    return CallNextHookEx(hhk,nCode,wParam, lParam);
);
}

weshalb ich einen switch irgendwie als unnötig empfinde er würde ja sowieso so aussehen:

Warum nicht so:

switch(i)
{
case 1:
case 2:
case 4000:
case 1337:
case 100:
    foo();
    break;
}

Allerdings ist der Vorschlag von ujr für sehr viele Werte deutlich schneller, sofern das HashSet wiederverwendet wird.

Und wiederverwendet heißt meißt statische Variable!

😁 Das Problem hatte ich auch schon^^ Textfeld mit Formatierung und klickbarem Text

Lösung: window.external in Javascript
WebBrowser.ObjectForScripting

-> Bitte die Suchfunktion benutzen.

Hier ein paar Ergebnisse:
Prozess schützen
Prozess abschiessen unterbinden

[EDIT]
Dort wird das zwar nur am Rande besprochen, aber ich halte es für keine gute Idee, den Prozess wirklich zu verstecken. Man muss ihn nicht verstecken, um das Beenden über Taskmanager zuz verhindern.

Update 5 (1.0.0.5):
-Abbruchbedingung wird jetzt in den Schleifenkopf geschrieben, falls moeglich, statt des if(..)break;
-Arrayinitialisierungen aus Blobs
-Magic Numbers werden jetzt durch die entsprechenden Konstanten und im Falle von Enums auch Flags ersetzt.
-Constructoren von Delegaten werden jetzt besser angezeigt, falls moeglich. (Arbeite grade daran, dass es auch für generische Delegaten geht)
-Wenn möglich wird der Fragezeichen-Operator (cond?a:b) benutzt.
-Diverse Bugs behoben, sodass es keine Abstürtze mehr gibt beim komplettem Decompilieren von diversen Assemblies. (u.a. der Konkurrenz)

Ich hab mal ne Kommadozeilenversion erstellt, die komplette Assemblies auf die Platte dumpt. (Ich finde 1200 Methoden/sec für mscorlib kann sich sehen lassen.) Dieses Feature werde ich wahrscheinlich in die offizielle Gui-Version einbauen, in der nächsten Version.

Eigendlich ist es besser, die asynchronen funktionen mit callbacks zu nutzen. Das ist dann allerdings ne nummer schwerer. In C#5 wird das einfacher zu benutzen werden.

Wenn du nicht mehr als 1GB RAM brauchst, solltest du bei x86 bleiben - erst bei RAM-intensiven Anwendungen muss man sich mit den Problemen herumschlagen, die x64 mit sich bringen kann.

Naja, der x64 modus ist etwas schneller:

1. Größere Register bringen ein paar wenige Prozent.
2. Der Jit optimiert in x64 deutlich aggressiver: Tailcall optimization ohne Tail-prefix, Casts werden anders optimiert, ...
   Von daher kann es sein, dass es sich performancemäßig trotzdem Lohnt. Ich habe aber nicht wirklich Ahnung, wieviel das in der Praxis bringt.

Generell: Wenn du nichts einbaust, das x86 erfordert, dann musst du dich da auch nicht drum kümmern und AnyCpu ist die beste Wahl: Bessere Performance auf x64 und läuft trotzdem auf x86.

Selbst wenn du unmanaged Code einbaust, kannst du ihn meißt so schreiben dass er auf beiden Architekturen läuft. Zur Not if(IntPtr.Size==8)...

Selbiges gilt für P/Invoke: Wenn es System-dlls sind, muss man sie lediglich richtig einbinden und wenn es eigene sind, kann man 2 Versionen bauen und dann das Arbeitsverzeichnis entsprechend setzen.

Mit COM kenne ich mich nicht so aus.

Streams gibt es viele. Benutzt du einen MemoryStream?

(:::

DisplayClass4 statt DisplayClass1!

In der anderen Klasse ist es umgekehrt, das sind die IL Instruktionen von denen Floste gesprochen hat.

Richtig 😁 👍

Wenn jetzt die "falsche" Methode aufgerufen wird ist wird die variable pws abgerufen ohne das sie initalisiert wurde übrig bleibt der Typ, der ist eben System.String[] der wird magischerweise fund zugewiesen, die eigentlich System-String ist (Aber warum? Das habe ich nicht ganz kapiert)

Mit magie hat das ganze nichts zutun.
Hehe, also übrigbleiben tut bei einer nicht initialisierten variable erstmal ein null.
Eigendlich wurde es ja initialisiert, nur sind im speicher die felder einer klasse keineswegs alphabetisch sortiert, sondern (mit bestimmten ausnahmen) in der reihenfolge, in der sie definiert wurden. Und in DisplayClass1 und DisplayClass4 sind die felder fund und pws im speicher vertauscht. Daher ist pws in fund zu finden und umgekehrt, wenn man einen reinterpret cast durchführt.
Da ein string[] aber dadurch immernoch kein string ist, ist ToString nötig, sonst gibts abstürtze, und um das unauffällig zu machen eben das Concat.

Markus war zwar schneller, aber irgendwie gefällt mir deine Antwort besser, Scavanger.
Gelöst ist es in jedem Fall. -> Der Nächste kann ne Aufgabe stellen

Eigendlich sollte es in der richtigen reihenfolge anzeigen, tut es allerdings in desem falle nicht 😦. es fehlt ein goto, das aus bestimmten gründen nicht angezeigt wird. Ich werd mich zur nächsten version ans beheben machen. Wenigstens kann ich mich trösten, dass reflector auch mist baut.

Denn laut Code müssten eigentlich alle Einträge des Arrays (je Methode) passen.

Jap, das ist 100% richtig!
Nur habe ich 2 msil-instruktionen vertauscht

Also überseh ich definitiv den springenden Punkt warum sie es nicht tun.

Der springende punkt ist ein typensprung.

Ich hab mir schon gedacht, dass das bezweifelt werden wird:

(Wenn jemand zweifeln sollte: es ist lösbar!)

JA, es ist möglich! Das ist ja grade das witzige^^

EDIT: Hab mir das ganze im reflector angeguckt. Das return false ist ziemlich falsch übersetzt! Es steht so nicht im code:

        return ergebnis;

Ich bleibe dabei: Es gibt eine lösung!

Ich gebe die Aufgabe ab, 24h sind mir zu kurz....

Das heißt dann wohl, ich darf eine stellen, wenn ich möchte?

Ich hab mal ein .net-programm geschrieben, das macht ne passwortabfrage. Es ist auf den ersten blick mit 65 zeilen ziemlich einfach und überschaubar, aber... guckt einfach selbst rein... 😁 :evil:

Ich habe auf ziemlich viele gemeinheiten verzichtet und es kommen keine hashes/kryptozeugs vor, kein dateizugriff und kein netzwerkzugriff, es wird kein code nachgeladen, es ist alles managed code und lässt sich mit reflector anzeigen.

Bin mal gespannt, wer als erster ne idee hat (oder auch nicht).
(Wenn jemand zweifeln sollte: es ist lösbar!)

Genaue aufgabenstellung: Finde eine eingabe, die das angehängte programm dazu bringt, "korrekt" auszugeben.

(Irgendwie denke ich, dass es niemand schaffen wird.)

Wow tolles Tool!

Danke^^

So, ich hab mal ein neues update (über den updater, einfach ein altes jade.exe starten) rausgehauen:

Update V 3:

• Bedingte verknüpfungen (&& , ||)
• Einfache logische Operationen werden gleich ausgeführt: (00) ->true, !(ab) -> a!=b, etc
  -Derartig sinnvole konstrukte wie if(false) werden wegoptimiert (mit diesem trick bringen viele obfuscatoren den .net Reflector aus dem tritt)
  -Viele kleine verbesserungen/bugfixes

[Edit 21.3.2011]
Update V 4:

• Variablen werden automatisch benannt (besser als vorher)
• Mehr unnötige Variablen werden entfernt -> der Code sieht teilweise deutlich klarer aus
• Einen off-by-one beseitigt, der in try/catch/finally seltsame effekte erzielt hatte
• Schleifenfindung leicht überarbeitet: Jetzt ist der Schleifenanfang deutlich öfter auch am Anfang, so ganz zufrieden bin ich noch nicht.
  -Setzen von Gotos leicht überarbeitet
  -this wird jetzt in blau statt schwarz angezeigt (wers braucht)^^

Mein Jade.NET kann das auch so, der generierte code ist aber etwas seltsam^^ Guter test iwie

Fehlermeldung:
Fehler 1 Methodenname erwartet. C:********\test\Program.cs 8 13 test
t

Alternativ: 😁

Exakt das gleiche hatte ich auch probiert, aber die property vom string hat vorrang -> geht nicht!

Vielleicht solltest du deinen code mal compilieren^^

Also ich finde es viel schöner einfach garnichts zu ändern an program.cs und stattdessen eine alternative main einzustellen:

using System.Linq;
using System.Reflection;

public static class ABoringClass
{
    static void Main(string[] args)
    {
        if (args.FirstOrDefault() == "Ihr Name") args[0] = "";
        typeof(Program).InvokeMember("Main", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Static, null, null, new object[1] { args });
    }
}

Ich behaupte mal, dass es auch ohne ein Wort in Program.cs zu ändern geht, wenn man was in den Projekteigenschaften umstellt.

Btw: Gilt

+"Floste"

als ein Wort?

mhmm, ist der code aus dem link dann als Unsinn zu werten ?
mhmm.

Also irgendwie schon: Der code aus dem link funktioniert wie folgt:

Das programm generiert einen delegaten auf die funktion. Dadurch wird diese compiliert.
Den delegaten wandelt es in einen zeiger um. Um es besser erklären zu können, mal als beispiel 0xBF513ED0 diese zahl ist nur für diesen einen prozess gültig. Wenn man den prozess neustartet oder ein weiteres mal startet ist sie ebenfalls ungültig.

Dann wird ein neuer prozess gestartet, und dem wird die 0xBF513ED0 als befehlszeilenargument übergeben.

Dadurch weiß der neu gestartete prozess, wo die zeilfunktion im originalprozess genau ligt, denn er originalprozess hat es ihm aktiv mitgeteilt. Ansonsten wüsste der neue prozess ja nicht, ob es nun 0xBF513ED0 oder 0xBF826C3E oder wasauchimmer ist. Diese Parameterübergabe ist also absolut notwendig in dem beispiel.
Im neuen prozess existiert die funktion schlichtweg nicht, da sie nochnicht compiliert wurde! Wenn der neue prozess also die 0xBF513ED0 für sichselbst aufrufen würde, würde er abstürtzen!

Er ruft sie aber nicht für sichselbst, sondern mit createremotethread für den originalprozess auf, wo die addresse ja auch herkommt.

Das funktioniert zwar, aber was ist, wenn der zielprozess nicht so kooperativ ist und deinen code freiwillig lädt und dir auchnoch die addresse von diesem aktiv mitteilt!?
Dann geht dieser ansatz schlichtweg nicht.

Das beispiel funktioniert also im spezialfall, dass der andere prozess aktiv mithilft, ansonsten nicht. Es ist also praktisch nicht einsetzbar.

================================================================================

Mein ansatz ist ein anderer:

Greife auf systembibliotheken zu, die es bereits in jedem prozess an gleicher addresse gibt, um bootstrappercode (in c++) zu laden, welcher dann wiederum die runtime initialisiert und deinen c#code ausführt.

Mal ne etwas detailiertere anleitung, für meinen ansatz:

Mein snippet ist nur für x86.
1.) lad dir die loaderdll runter
2.) erstelle eine c# dll mit dateinamen "inject.dll" mit zielframework 2 oder 3/3.5
Code der dll:

using System;

public class Hook
{
    [STAThread]
    public static int Init(string empty)
    {
        return 0;
    }

    [STAThread]
    public static int GetHookProc(string empty)
    {
        return 0;
    }

    [STAThread]
    public static int Run(string empty)
    {
        System.Windows.Forms.MessageBox.Show("Hallo aus"+Process.GetCurrentProcess().Process.ProcessName);
        return 0;
    }
}

3.)Erstelle eine anwendung mit dem injectcore-code aus dem snippet und compiliere diese als x86, nicht anycpu. Sorge vor dem Ausführen dafür, dass die loaderdll.dll und inject.dll im gleichen verzeichnis wie die exe sind.
Starte die exe** ohne debugging!** und wähle eine x86 anwendung als ziel (z.b. firefox, alles was im taskmanager ein sternchen hat)

Ich habe letzere der von herbivore genannten möglichkeiten verwendet.
Ich zeichne mir jetzt einfach nen rahmen, gibt wenigstens keine solchen probleme.

Mit CreateRemoteThread, könnte man da nicht gleich eine c# function in den fremden Prozeß stecken, also aus meinem "injezierenden" Prozeß heraus ?
Dann würde man sich das laden der dll's etc. sparen.

Mir ist allerdings unklar, ob der ZielProzeß dabei zumindest auch CLR based sein müßte.

Das problem dabei ist der jit-compiler

Der erzeugt den code einer funktion erst beim ersten aufruf und sucht sich dafür einen "zufälligen" (wos halt grade passt) platz.

Wenn man also createremotethread auf soeine funktion benutzt, dann existiert diese im anderen prozess entweder noch garnicht oder an völlig anderer stelle. Das resultat ist also im bestenfall garkeins, normalerweise aber ein crash des andren prozesses.

Es geht also nicht direkt mit createremotethread auf eine c#-funktion.

Wenn du ein festes ziel c# hast, dann empfielt sich dieses einfach in den eigenen prozess zu laden (Assembly.Load), lokal alle hooks oder wasauchimmer zu setzen und dann den entrypoint aufzurufen.