Kopierschutz

[OldGrumpy]

Ich kenne das mit Themida zum Schutz der Bösewichte aus eigener Erfahrung. Von einer Software die ich betreue kursiert die letzte Version ohne Wasserzeichen (eben der IDA-Ansatz wie von Assarbad angesprochen) auch als gecrackte Version mit Themida drum rum. Hat mich etwa zwei Stunden gekostet, den laufenden Prozess soweit "aufzumachen" dass ich die geschützte Exe rausziehen konnte um zu schauen was die Jungs alles gepatcht hatten. Rein interessehalber, um zu sehen wieviel Aufwand sie sich gemacht hatten. Und das Resultat war auch zu erwarten: Weg des geringsten Widerstands. Offenbar war die Software sogar gut genug dass in Fernost eine manipulierte Version im Bundle mit Hardware verkauft wurde. Da wurden alle Logos usw. vom Original rausgeschmissen und ein eigenes Logo reingefummelt und das ganze dann als eigene Software verkauft. Im VersionInfo-Block stand sogar noch "unsere" Versionsnummer drin... Seitdem das Wasserzeichen drin ist und die Versionen personalisiert zum Download bereit gestellt werden, ist das Thema gegessen. Ab und zu schaue ich noch bei den üblichen Verdächtigen herum aber bis jetzt hat sich noch keiner getraut. Ich mach mir da keine Illusionen über die Dauerhaftigkeit dieses Zustands, aber ich finde es schon interessant. Die gesamte Integration hat allerdings mehr als 149 Euro gekostet, das stimmt

[IBExpert]

Zitat von Assarbad:

Zitat von IBExpert:

[...] mit denen sich binär veränderte Dateien erkennen lassen könnten.

Gibt es aber bei windoofs nicht, jedenfalls nichts relevantes.

Aha? Noch nicht geguckt, oder nicht tief genug geguckt?

Thema digitale Signaturen kenn ich durchaus, unsere Software ist digital signiert, aber was hindert den Hacker daran, die Routinen, in denen wir die Gültigkeit der Signatur prüfen, lahm zu legen? Eine Windows API Call wie WinVerifyTrust in einer Exe zu finden und die Strukturen des Codes drumherum zu analaysieren stelle ich mich als das einfachste vor!

Zitat von Assarbad:

Zitat von IBExpert:

Wenn sich nun ein System wie Themida im Markt etabliert, dann ist die Notwendigkeit für Antivirenprogramme kaum noch gegeben. Was liegt also näher als so eine Software zu verteufeln?

Den müßtest du aber nochmal erklären. Interessiert mich insbesondere weil Themida ja scheinbar meinen Job gefährdet

Ob dein Job im Antivirumfeld durch Themida gefährdet ist wage ich auch zu beweifeln, aber wenn insbesondere Microsoft oder vielleicht sogar Hardwarehersteller wie Intel/AMD sich auf Standards einigen würden, die sich nicht mal eben durch simples bytepatching umgehen lassen, zum Beispiel Signaturprüfung auf Hardwarebasis, dann wäre es für Softwarehersteller einfacher, gewisse Verfahren zu etablieren, die das cracken sicherlich auch nicht unmöglich machen, aber doch deutlich erschweren. Ist aber vielleicht auch zu theoretisch, was ich mir da vorstelle, da bist du sicherlich wesentlich tiefer drin. Ich für meinen Teil möchte mich aber mit deinem Spezialwissen gar nicht messen, sondern habe halt in themida eine für uns ganz brauchbare Lösung gefunden, die scheinbar nicht jeder mit vertretbarem Aufwand umgehen kann und das reicht mir als Anforderung.

Zitat von Assarbad:

Ansonsten ist es doch i.O. wenn ihr damit zufrieden seid und mit den "Nebenwirkungen" leben könnt.

passender hätte ich das auch nicht zusammenfassen können

[Assarbad]

Zitat von IBExpert:

Thema digitale Signaturen kenn ich durchaus, unsere Software ist digital signiert, aber was hindert den Hacker daran, die Routinen, in denen wir die Gültigkeit der Signatur prüfen, lahm zu legen? Eine Windows API Call wie WinVerifyTrust in einer Exe zu finden und die Strukturen des Codes drumherum zu analaysieren stelle ich mich als das einfachste vor!

Kann man auch "verstecken" den Aufruf. Aber wenn ich es umgehen müßte, würde ich es ohnehin nicht in der EXE selber machen sondern über einen Loader oder ähnliches.

Ansonsten:
Hacker != Cracker


Ein gesundes und frohes Jahr 2011 wünsche ich.

[Peter666]

Ich finde die angetretene Diskussion ja schon nett, aber persönlich sind mir die getesteten Sicherheitstools ein Graus. Halt Kommerz für die breite Masse und somit anfällig für Hacks. Sprich einmal eine Anwendung die so ein Paket nutzt gehackt und schon sind dutzende andere kompromitiert. In den letzten Tagen habe ich mir mal etliche Ansätze im Internet angeguckt und dabei ist mir eines aufgefallen: Es wird an allen Ecken nur mit ganz lauwarmen Wasser gekocht. Sprich: fast jeder Ansatz ist ein feister Clone, eines schon bestehendem.

Ein netter Trick ist zum Beispiel den Programmstart ab $40000 zu überschreiben und somit einem Procdump zu erschweren.

[Aphton]

Zitat von Phoenix:

Das Problem mit dem Exepacker ist, dass ich den in nicht ganz 10 Minuten ausgehebelt habe - das brauchst Du also schon gar nicht zu probieren (sich selbst in Memory entpacken lassen und dann den Prozess-Memory dumpen (da ist das komplette entpackte Programm drin), den richtigen Einsprungspunkt suchen und that's it). Exepacker haben nur einen einzigen Zweck: Speicherplatz auf der Platte oder beim Übertragen durchs Internet zu sparen auf Kosten des RAM bei der Ausführung. Security ist da njiente.

@Verschlüsselung: Nicht ganz falscher Ansatz, das Problem ist, dass man bei der Ausführung solcher Blöcke diese auch während der Ausführung im entschlüsselten Zustand wegdumpen und dann in das binary-Image wieder einfügen kann. Zudem: Ist das Passwort bekannt hat es sich auch ausverschlüsselt.

Holger (von IBExpert) hat auch *lange* sowas versucht und ist jedes mal recht schnell umgangen worden.
Er setzt nun auf Kommerzielle Tools die tatsächlich (bis jetzt) das halten, was sie versprechen.

Man könnte doch einen Filecrypter basierend auf den RC4-Algorithmus bauen, der ne Keyabfrage hat. Das einzige Problem hierbei wäre eben, dass man jedesmal beim Ausführen der Executable das Passwort eingeben muss, damit es im RAM/bei der Codeausführung richtig entschlüsselt (und evt. entpackt) wird.
Natürlich sollte man da keine Exceptionbehandlung einabeun. Dies würde es umso schwerer machen, da man dann wirklich das Passwort kennen muss.
Übrigens - vielleicht geht das nicht direkt aus dem obrigen Text hervor, aber die Keyabfrage wird in die Executable "reingepflanzt" (Section erstellen, Code einfügen, Einsprungspunkt umbiegen)

Edit: Vor einem Memory dump nach einem erfolgreichen Entschlüsseln hilft das natürlich auch nicht weiter. Aber dem Kunden sollte man glaube ich vertrauen können - in der Annahme, dass sich Cracker nicht die Mühe machen, das Produkt zu kaufen um es dann der breiteren Masse verfügbar machen zu können.

MfG

[Assarbad]

Zitat von Aphton:

Aber dem Kunden sollte man glaube ich vertrauen können - in der Annahme, dass sich Cracker nicht die Mühe machen, das Produkt zu kaufen um es dann der breiteren Masse verfügbar machen zu können.

Das ist leider eine Fehleinschätzung. Oftmals werden gestohlene Kreditkarten eingesetzt um ein Produkt zu kaufen und es wird danach geleakt. So bspw. schon geschehen bei IDA. Dagegen kann man sich wohl nur schützen indem man nur andere Zahlungsmethoden erlaubt.

[rollstuhlfahrer]

Nun ja, oder man führt eine Aktiverung ein. Leider sieht man schön anhand der am weitesten verbreitesten kostenpflichtigen Software von Microsoft (nämlich das OS Windows), wie man diese Aktivierung wie im Lehrbuch beschrieben umgehen kann. Es fehlt nur noch, dass man eine Anleitung findet, in der steht, dass man in der HOSTS-Datei eine Domain auf 127.0.0.1 umlegt und dann seinen eigenen Windows-Aktivierungsserver startet.

Bernhard

[Aphton]

Zitat von Assarbad:

Zitat von Aphton:

Aber dem Kunden sollte man glaube ich vertrauen können - in der Annahme, dass sich Cracker nicht die Mühe machen, das Produkt zu kaufen um es dann der breiteren Masse verfügbar machen zu können.

Das ist leider eine Fehleinschätzung. Oftmals werden gestohlene Kreditkarten eingesetzt um ein Produkt zu kaufen und es wird danach geleakt. So bspw. schon geschehen bei IDA. Dagegen kann man sich wohl nur schützen indem man nur andere Zahlungsmethoden erlaubt.

Uff, das hab ich gar nicht bedacht. Außerdem hielt ich das nur für ein Gerücht und weiters dachte ich mir, dass es, falls es ernsthaft gemacht wird, nur von den aller professionelsten gemacht werden kann. Aber trotzdem, ty for the hint.
In Addendum: Ich kann da echt keinen professionellen Tipp geben außer den 08/15 Kram. Letzendlich ist es immer so, dass alles absolut deterministisch ist, ansonsten müsste es nicht existent sein. Von dem her dürfte kein Sicherheitssystem zu 100% sicher sein (0815), und wie schon gesagt wurde, kann man es nur erschweren (again 0815). Ob es sich lohnt, muss man selber einschätzen.
Und meistens ists viel besser, direkt Experten ran zu lassen, weil die sich Tag täglich damit beschäftigen und bestimmt etwas mehr wissen, als man selbst (otto advanced programmer).

MfG

[Peter666]

Ich habe mich vorhin mal hingesetzt und angefangen einen alten Assemblersource für einen Junk Code Generator zu erstellen. Herausgekommen ist folgendes..

Code:

unit UJunkit;
interface
const
  ETG_MOVRR = $00000001;
  ETG_MOVRC = $00000002;
  ETG_MOVSXZX = $00000004;
  ETG_XCHG = $00000008;
  ETG_LEA = $00000010;
  ETG_TTTRR = $00000020;
  ETG_TTTRC = $00000040;
  ETG_INCDEC = $00000080;
  ETG_NOTNEG = $00000100;
  ETG_TESTRR = $00000200;
  ETG_TESTRC = $00000400;
  ETG_IMUL = $00000800;
  ETG_SHIFT = $00001000;
  ETG_SHxD = $00002000;
  ETG_BSWAP = $00004000;
  ETG_XADD = $00008000;
  ETG_BSx = $00010000;
  ETG_BTx = $00020000;
  ETG_JMPS = $00040000;
  ETG_SEG = $00080000;
  ETG_REP = $00100000;
  ETG_ALL = $001FFFFF;
  ETG_DEFAULT = ETG_TTTRC; // used if no cmds specified

  REG_EAX = $00000001;
  REG_ECX = $00000002;
  REG_EDX = $00000004;
  REG_EBX = $00000008;
  REG_ESP = $00000010;
  REG_EBP = $00000020;
  REG_ESI = $00000040;
  REG_EDI = $00000080;
  REG_ALL = (not REG_ESP) and $FF;
  REG_DEFAULT = REG_EAX; // used if no regs specified

procedure Junk(user_param, cmd_avail, regsrcavail,
  regdstavail: DWORD; out osizeptr: DWORD; ncmds, bufsize: DWORD;
  buf: Pointer);

implementation

type
  TRandomFunc = function(userdata, range: DWORD): DWORD; cdecl;

  TETG_Engine = procedure(
    user_param: DWORD; // user-parameter
    cmd_avail: DWORD; // set of ETG_xxx
    regsrcavail: DWORD; // set of REG_xxx
    regdstavail: DWORD; // set of REG_xxx
    out osizeptr: DWORD; // ptr to generated bufsize
    ncmds: DWORD; // max number of commands
    bufsize: DWORD; // max size of buffer
    buf: Pointer; // ptr to output buffer
    Random: TRandomFunc
    ); cdecl;

const
  ETG_bin: array[0..1139] of byte = (
    $C8, $50, $00, $00, $60, $8B, $7D, $24,
    $FC, $81, $65, $10, $EF, $00, $00, $00,
    $75, $07, $C7, $45, $10, $01, $00, $00,
    $00, $81, $65, $14, $EF, $00, $00, $00,
    $75, $07, $C7, $45, $14, $01, $00, $00,
    $00, $81, $65, $0C, $FF, $FF, $1F, $00,
    $75, $07, $C7, $45, $0C, $40, $00, $00,
    $00, $8B, $C7, $2B, $45, $24, $8B, $4D,
    $18, $89, $01, $83, $C0, $10, $3B, $45,
    $20, $73, $0C, $FF, $4D, $1C, $7C, $07,
    $E8, $05, $00, $00, $00, $EB, $E2, $61,
    $C9, $C3, $C7, $45, $FC, $01, $00, $00,
    $00, $C7, $45, $F8, $08, $00, $00, $00,
    $E8, $E4, $03, $00, $00, $89, $45, $C8,
    $C1, $E0, $03, $89, $45, $C4, $E8, $D1,
    $03, $00, $00, $89, $45, $C0, $C1, $E0,
    $03, $89, $45, $BC, $8B, $45, $14, $23,
    $45, $10, $A9, $0F, $00, $00, $00, $74,
    $13, $B8, $02, $00, $00, $00, $E8, $93,
    $03, $00, $00, $89, $45, $FC, $C1, $E0,
    $03, $89, $45, $F8, $B8, $02, $00, $00,
    $00, $E8, $80, $03, $00, $00, $89, $45,
    $DC, $D1, $E0, $89, $45, $D8, $C1, $E0,
    $02, $89, $45, $D4, $B8, $04, $00, $00,
    $00, $E8, $68, $03, $00, $00, $C1, $E0,
    $03, $89, $45, $D0, $E8, $70, $03, $00,
    $00, $C1, $E0, $03, $89, $45, $CC, $E8,
    $70, $03, $00, $00, $89, $45, $F4, $C1,
    $E0, $03, $89, $45, $E4, $E8, $62, $03,
    $00, $00, $89, $45, $EC, $E8, $5F, $03,
    $00, $00, $89, $45, $F0, $C1, $E0, $03,
    $89, $45, $E0, $E8, $51, $03, $00, $00,
    $89, $45, $E8, $E8, $4E, $03, $00, $00,
    $89, $45, $B8, $C1, $E0, $03, $89, $45,
    $B4, $E8, $40, $03, $00, $00, $89, $45,
    $B0, $B8, $1F, $00, $00, $00, $E8, $0B,
    $03, $00, $00, $96, $46, $8B, $55, $0C,
    $8B, $45, $FC, $D1, $EA, $73, $0E, $4E,
    $0F, $84, $27, $01, $00, $00, $4E, $0F,
    $84, $2D, $01, $00, $00, $D1, $EA, $73,
    $0E, $4E, $0F, $84, $2F, $01, $00, $00,
    $4E, $0F, $84, $36, $01, $00, $00, $D1,
    $EA, $73, $07, $4E, $0F, $84, $32, $01,
    $00, $00, $D1, $EA, $73, $07, $4E, $0F,
    $84, $47, $01, $00, $00, $D1, $EA, $73,
    $07, $4E, $0F, $84, $41, $01, $00, $00,
    $D1, $EA, $73, $0E, $4E, $0F, $84, $44,
    $01, $00, $00, $4E, $0F, $84, $45, $01,
    $00, $00, $D1, $EA, $73, $0E, $4E, $0F,
    $84, $42, $01, $00, $00, $4E, $0F, $84,
    $4C, $01, $00, $00, $D1, $EA, $73, $0E,
    $4E, $0F, $84, $59, $01, $00, $00, $4E,
    $0F, $84, $5F, $01, $00, $00, $D1, $EA,
    $73, $07, $4E, $0F, $84, $5E, $01, $00,
    $00, $D1, $EA, $73, $07, $4E, $0F, $84,
    $60, $01, $00, $00, $D1, $EA, $73, $07,
    $4E, $0F, $84, $62, $01, $00, $00, $D1,
    $EA, $73, $0E, $4E, $0F, $84, $65, $01,
    $00, $00, $4E, $0F, $84, $6E, $01, $00,
    $00, $D1, $EA, $73, $0E, $4E, $0F, $84,
    $70, $01, $00, $00, $4E, $0F, $84, $79,
    $01, $00, $00, $D1, $EA, $73, $0E, $4E,
    $0F, $84, $7F, $01, $00, $00, $4E, $0F,
    $84, $97, $01, $00, $00, $D1, $EA, $73,
    $07, $4E, $0F, $84, $A4, $01, $00, $00,
    $D1, $EA, $73, $07, $4E, $0F, $84, $A0,
    $01, $00, $00, $D1, $EA, $73, $07, $4E,
    $0F, $84, $A3, $01, $00, $00, $D1, $EA,
    $73, $0E, $4E, $0F, $84, $A6, $01, $00,
    $00, $4E, $0F, $84, $B0, $01, $00, $00,
    $D1, $EA, $73, $07, $4E, $0F, $84, $B0,
    $01, $00, $00, $D1, $EA, $73, $0E, $4E,
    $0F, $84, $B7, $01, $00, $00, $4E, $0F,
    $84, $B7, $01, $00, $00, $D1, $EA, $73,
    $07, $4E, $0F, $84, $B3, $01, $00, $00,
    $E9, $BC, $FE, $FF, $FF, $0C, $88, $AA,
    $B0, $C0, $0B, $45, $E4, $0B, $45, $F0,
    $AA, $C3, $0C, $8A, $AA, $B0, $C0, $0B,
    $45, $E0, $0B, $45, $F4, $AA, $C3, $B0,
    $B0, $0B, $45, $F8, $0B, $45, $F0, $AA,
    $E9, $8D, $01, $00, $00, $0C, $C6, $AA,
    $B0, $C0, $EB, $F0, $B0, $0F, $AA, $B0,
    $B6, $0B, $45, $FC, $0B, $45, $D4, $AA,
    $B0, $C0, $0B, $45, $C4, $EB, $D3, $0C,
    $86, $AA, $B0, $C0, $0B, $45, $E0, $0B,
    $45, $E8, $AA, $C3, $0C, $86, $AA, $EB,
    $F1, $B0, $8D, $AA, $B0, $05, $0B, $45,
    $C4, $AA, $E9, $59, $01, $00, $00, $0C,
    $00, $0B, $45, $CC, $AA, $EB, $99, $0C,
    $02, $0B, $45, $CC, $AA, $EB, $9E, $0C,
    $80, $AA, $B0, $C0, $0B, $45, $CC, $0B,
    $45, $F0, $AA, $E9, $32, $01, $00, $00,
    $F7, $45, $14, $01, $00, $00, $00, $0F,
    $84, $2C, $FE, $FF, $FF, $0C, $04, $0B,
    $45, $CC, $AA, $E9, $1A, $01, $00, $00,
    $0C, $FE, $AA, $B0, $C0, $0B, $45, $D4,
    $E9, $60, $FF, $FF, $FF, $B0, $40, $0B,
    $45, $D4, $0B, $45, $C8, $AA, $C3, $0C,
    $F6, $AA, $B0, $D0, $0B, $45, $D4, $E9,
    $49, $FF, $FF, $FF, $0C, $84, $AA, $B0,
    $C0, $0B, $45, $B4, $0B, $45, $B0, $AA,
    $C3, $0C, $F6, $AA, $B0, $C0, $0B, $45,
    $B8, $AA, $E9, $DB, $00, $00, $00, $B0,
    $0F, $AA, $B0, $AF, $AA, $B0, $C0, $0B,
    $45, $C4, $0B, $45, $C0, $AA, $C3, $B0,
    $69, $AA, $E8, $EE, $FF, $FF, $FF, $E9,
    $C4, $00, $00, $00, $0C, $D0, $0B, $45,
    $D8, $AA, $B0, $C0, $0B, $45, $CC, $0B,
    $45, $F0, $AA, $C3, $0C, $C0, $AA, $B0,
    $C0, $0B, $45, $CC, $0B, $45, $F0, $AA,
    $E9, $AD, $00, $00, $00, $B0, $0F, $AA,
    $B0, $A4, $0B, $45, $D4, $AA, $B0, $C0,
    $E8, $05, $00, $00, $00, $E9, $98, $00,
    $00, $00, $B0, $C0, $0B, $45, $BC, $0B,
    $45, $C8, $AA, $C3, $F7, $45, $10, $02,
    $00, $00, $00, $0F, $84, $78, $FD, $FF,
    $FF, $B0, $0F, $AA, $B0, $A5, $0B, $45,
    $D4, $AA, $EB, $DE, $B0, $0F, $AA, $B0,
    $C8, $EB, $DC, $B0, $0F, $AA, $B0, $C0,
    $0B, $45, $FC, $AA, $E9, $E1, $FE, $FF,
    $FF, $B0, $0F, $AA, $B0, $BC, $0B, $45,
    $DC, $AA, $E9, $6E, $FF, $FF, $FF, $B0,
    $0F, $AA, $B0, $BA, $AA, $B0, $E0, $0B,
    $45, $D0, $0B, $45, $C8, $AA, $EB, $42,
    $B0, $0F, $AA, $B0, $A3, $0B, $45, $D0,
    $AA, $EB, $9F, $66, $B8, $EB, $01, $66,
    $AB, $B8, $00, $01, $00, $00, $E8, $33,
    $00, $00, $00, $AA, $C3, $B0, $26, $0B,
    $45, $D0, $AA, $C3, $B0, $64, $0B, $45,
    $DC, $AA, $C3, $B0, $F2, $0B, $45, $DC,
    $AA, $C3, $83, $7D, $FC, $00, $74, $0A,
    $E8, $00, $00, $00, $00, $E8, $00, $00,
    $00, $00, $B8, $00, $01, $00, $00, $E8,
    $02, $00, $00, $00, $AA, $C3, $60, $50,
    $FF, $75, $08, $FF, $55, $28, $83, $C4,
    $08, $89, $44, $24, $1C, $61, $0B, $C0,
    $C3, $B8, $08, $00, $00, $00, $E8, $E3,
    $FF, $FF, $FF, $C3, $8B, $55, $10, $EB,
    $0D, $8B, $55, $14, $EB, $08, $8B, $55,
    $10, $0B, $55, $14, $EB, $00, $E8, $DE,
    $FF, $FF, $FF, $8B, $C8, $83, $7D, $FC,
    $00, $75, $03, $83, $E1, $03, $0F, $A3,
    $CA, $73, $EB, $C3);

var randseed: DWORD;

function MyRandom(userdata, range: DWORD): DWORD; cdecl;
begin
  if range = 0 then result := 0 else
  begin
    randseed := randseed * 214013 + 2531011;
    result := randseed mod range;
  end;
end;

procedure Junk(user_param, cmd_avail, regsrcavail,
  regdstavail: DWORD; out osizeptr: DWORD; ncmds, bufsize: DWORD;
  buf: Pointer);
begin
  randseed := GetTickCount;
  TETG_Engine(@ETG_bin)(user_param, cmd_avail, regsrcavail, regdstavail,
    osizeptr, ncmds, bufsize, buf, MyRandom);
  PAnsiChar(buf)[osizeptr] := #$C3; {ret} inc(osizeptr);
end;

Ich war ehrlich gesagt etwas Faul und habe nicht den Assemblercode (Quelle: ETG 2.00 engine) übersetzt, sondern nur das beiliegende C Beispiel umgesetzt.
Soweit erstellt die Anwendung recht praktischen Datenmüll, wenn ich das wie folgt aufrufe
var
buf: Array[0..2000] of byte;

Junk(
0,
ETG_ALL,
REG_ALL,
REG_EAX or REG_EBX,
bufsize,
1000,
sizeof(buf),
@buf);

Damit man den Code via call auch aufrufen kann, sollte am Ende des Puffers, also bei buf[bufsize] noch ein $C3 (ret) gepackt werden.
Mein Problem ist jedoch folgendes: Wenn ich innerhalb meiner Anwendung etwas wie folgt mache:

db $90,$90...$90

und mit meinem Patchtool in der Exe die Nops durch den Junkcode ersetze, müsste ich doch die Register vorher und hinterher manuell wiederherstellen, oder? Ein einfaches Pusha, popa reicht jedoch in dem Fall nicht. Hat da jemand eventuell eine Idee?

Peter

[Assarbad]

Zitat von Peter666:

Damit man den Code via call auch aufrufen kann, sollte am Ende des Puffers, also bei buf[bufsize] noch ein $C3 (ret) gepackt werden.
Mein Problem ist jedoch folgendes: Wenn ich innerhalb meiner Anwendung etwas wie folgt mache:

db $90,$90...$90

und mit meinem Patchtool in der Exe die Nops durch den Junkcode ersetze, müsste ich doch die Register vorher und hinterher manuell wiederherstellen, oder? Ein einfaches Pusha, popa reicht jedoch in dem Fall nicht. Hat da jemand eventuell eine Idee?

Was soll das bringen? Das ist doch dann sehr leicht durchschaubar. Da kann man direkt ein Python oder IDC-Skript für IDA schreiben und es filtern. Selbst ohne Filtern kann ich mir den Stackpointer ja anzeigen lassen.

PUSHA und POPA werden übrigens in "echtem Code" (also von Compilern) eher selten eingesetzt, würden also geradezu herausstehen.