Ich, der Assembler

Was tut man mit einem Stück Closed-Source Software, was den einen Vorteil hat genau das zu tun was man will (und nicht mehr), aber leider den Nachteil regelmäßig abzustürzen?
Und was tut man, wenn dieses Stück der KernelMode-Treiber einer Paketfilter-Firewall ist und „abstürzen“ bedeutet dass man einen Bluescreen bekommt?

Richtig, man holt WinDbg und IDA raus und fängt an den Fehler zu suchen 😉 Continue reading „Ich, der Assembler“

Trust in Me!

Nehmen wir mal an, ein (Delphi-)object, welches eine Liste gleicher Objekte verwalten soll. Man könnte das einen Baum nennen.

  TValueList = array of TValue;
  TValue = object
    FList: TValueList;
    SomeOtherStuff: integer;
  end;

(Für später geborene: das ist die alte Syntax für „record mit Methoden“.)

Leider nimmt uns der Compiler das so nicht ab. Warum? Weil TValue natürlich vorher noch nicht bekannt ist. Und im Gegensatz zu Klassen kann man Records nicht vorwärtsdeklarieren. Wie also könnten wir dieses Problem lösen? Man könnte Pointer verwenden, und bei Verwendung entsprechend erzeugen. Aber freigeben? Es gibt ja keinen Destructor, also keine Option. Man könnte das gesamte Objekt in eine Klassen-Instanz verwandeln, die von IUnknown die Referenzzählung erbt. Das ist aber wesentlich mehr Aufwand als das bisherige „Deklarieren und Verwenden“.

Die Lösung hier zeigt sich in einem fiesen, aber einfachen Hack:

TValueListAlias = array of boolean;
TValue = object
  FList: TValueListAlias;
  SomeOtherStuff: integer;
end;
TValueList = array of TValue;

Dabei spielt es keine Rolle, welchen Basistypen man für das Alias verwendet. Es muss sich nur um ein dynamisches Array handeln. Jetzt kann man in jedem Zugriff auf das eigentliche TValueList casten und alles funktioniert. Dabei kann man die Hässlichkeiten wunderbar in Zugriffsmethoden verbergen.

SetLength(TValueList(FList), 42);

Das funktioniert auch, aber wenn TValue nun Felder die finialisiert werden müssen enthält, wird sich FastMM beschweren, dass eben diese nie freigegeben werden. Es stellt sich heraus, dass SetLength zwar den BaseType richtig speichert und auch in @DynArrayClear exakt diesen wieder beräumt, aber Felder im Gegensatz zu Variablen nicht damit, sondern mit FinalizeArray freigegeben werden. Und dieses richtet sich nach der Deklaration, nicht nach dem was wirklich passiert.

Hier kommt dann der eigentliche Grund für diesen Beitrag: wir sagen der RTL einfach: „Vertrau mir, das ist ein anderer Datentyp!“. Mit anderen Worten: wir patchen die Feld-Tabelle der betroffenen Klasse so, dass FinalizeArray dort ein TValueList (BaseType also TValue, nicht unser Dummy von weiter oben) sieht und dieses korrekt finalisiert.

Das ist zunächst einfacher als gedacht:

TI:= TypeInfo(TValue);
FT := Pointer(Integer(TI) + Byte(TI.Name[0]));
for I := FT.Count-1 downto 0 do begin
  if FT.Fields[I].TypeInfo^ = TypeInfo(TValueListAlias) then
    ppti:= FT.Fields[I].TypeInfo^:= TypeInfo(TValueList);
end;

Nur – das funktioniert so nicht 😉 Runtime Error 216 ist die Folge einer Exception beim Schreiben der neuen TypeInfo. Da hat nämlich mal jemand mitgedacht und die dazugehörige Seite als PAGE_EXECUTE_READ markiert. Was man zum Glück in seinem eigenen Prozess beliebig ändern kann, und so ergibt sich (mit allen Deklarationen) folgendes Meisterwerk:

procedure FixFieldTable(TheRecord, Find, Replace: PTypeInfo);
type
  TFieldInfo = packed record
    TypeInfo: PPTypeInfo;
    Offset: Cardinal;
  end;
 
  PFieldTable = ^TFieldTable;
  TFieldTable = packed record
    X: Word;
    Size: Cardinal;
    Count: Cardinal;
    Fields: array [0..0] of TFieldInfo;
  end;
var
  FT: PFieldTable;
  ppti: PPTypeInfo;
  I, old, dummy: cardinal;
begin
  FT := Pointer(Integer(TheRecord) + Byte(TheRecord.Name[0]));
  for I := FT.Count-1 downto 0 do begin
    if FT.Fields[I].TypeInfo^ = Find then begin
      ppti:= FT.Fields[I].TypeInfo;
      VirtualProtect(ppti,SizeOf(ppti), PAGE_READWRITE, old);
      try
        ppti^:= Replace;
      finally
        VirtualProtect(ppti, sizeof(ppti), old, dummy);
      end;
    end;
  end;
end;
{...}
 
  FixFieldTable(TypeInfo(TValue), TypeInfo(TValueListAlias), TypeInfo(TValueList));

Wer sich die Datenstruktur ansieht, wird feststellen dass TFieldTable ein Feld namens „Size“ enthält. Sollten wir das nicht anpassen? Die einfache Antwort ist: nein! In TValue selbst wird vom dynamischen Array nur ein Pointer auf den Anfang gespeichert, und der ist unabhängig vom genauen Aussehen des Arrays immer gleich groß: nämlich 32bit oder 4 Byte. Es ändert sich also nichts.
Außerdem praktisch: da SetLength den Array-Typ anlegt, den man ihm übergibt (und wir ja auf TValueList casten), werden auch untergeordnete Arrays als das freigegeben was in ihnen steckt.

Das funktioniert so bis mindestens BDS2006, ich kann mir aber vorstellen dass die neuen RTTI-Strukturen in XE hier einige Änderungen notwendig machen. Das müssen dann aber andere testen 😉

Oh, übrigens, wer es nicht erkannt hat: der Titel ist natürlich eine Referenz auf Disney’s Dschungelbuch.

Punkteverteilung

Manchmal, nur ganz selten, verhält sich ein Code anders als man denkt, weil man was anderes programmiert hat als man denkt.

Man nehme z.B. eine KI mit Negamax+AlphaBeta, die immer irgendwelche völlig behämmerten Züge ausführt. Irgendwann ist mir dann mal gedämmert, dass man sich ja mal die Score-Werte ausgeben lassen könnte.

next move
  h1 to g1 score: 9
  h1 to g2 score: 9
  h1 to i2 score: 9
  h1 to h2 score: 9
  h1 to f1 score: 9
  h1 to f3 score: 9
  h1 to h3 score: 9
  i1 to h2 score: 9
  i1 to i2 score: 9
  i1 to g1 score: 9
  i1 to g3 score: 9
  i1 to i3 score: 9
  a9 to b8 score: 9
  a9 to b9 score: 9
  a9 to a8 score: 9
  a9 to c7 score: 9
  a9 to c9 score: 9
  a9 to a7 score: 9

Huch! Alles das gleiche. Wie kann das sein?

    function Score(ABoard: TBoard; Perspective: TField): TScore;
{...}
          if Board[c,r]=Perspective then
{...}

M( M( M( M( M( M( M(

Board ist ein Member von TGame, und damit an dieser Stelle durchaus ein gültiger Bezeichner. Nur leider nicht der den ich will, denn damit habe ich immer das Brett vom Startpunkt bewertet, niemals das nach einem Zug. Sehr schön, es sollte mal einer intelligente Compiler entwickeln, die mir sowas direkt sagen…

Stand back – I know CMD!

Ich merke das schon, Psychologie läuft nicht so gut wie Programmierung und Politik…

gnuplot hält sich für ein sehr gutes Diagramm-Plot-Programm – und das stimmt meistens auch. Wenn es darum geht, Daten aus Dateien einzulesen wird das Skript zwar sehr schnell sehr hässlich, aber es funktioniert. Zumindest, wenn man die Daten vorkocht, denn filtern kann man sie in gnuplot selbst nicht mehr vernünftig. Das ist aber grade dann von Nöten, wenn man lange Messreihen hat, aber zum Beispiel nur an den letzten N Messwerten interessiert ist. Eigentlich doch ein nicht grade seltenes Problem, aber fertige Lösungen jenseits von `tail -n` sind nicht wirklich auffindbar.
Continue reading „Stand back – I know CMD!“

Kleine Hacks erhalten die Freundschaft

Heute mal wieder was aus der Bastelkiste:

Unser Institut für Mechanik hat für Belege und Praktika ein schickes kleines Delphi-Programm, welches die Aufgabenblätter generieren kann. Das ganze hat den Zweck, dass die Aufgaben sich mit der Matrikelnummer personalisieren lassen (RandSeed) und man seine berechneten Werte mittels dieses Programms direkt auf Korrektheit prüfen lassen kann.

Nun sind die Aufgaben nicht immer so ganz ohne, und manchmal hilft es ungemein, nicht nur Eingabefelder zu haben, die einem sagen ob man richtig oder falsch lag, sondern auch mal spicken zu können, wo denn der Fehler liegt.

Aber erstmal eine kleine Anekdote.
Man sitzt also in einer Vorlesung, und macht nebenbei mit einem Kommilitonen ein solches Übungsbelegblatt. Die Gleichungen sehen auch erstmal alle ganz schön aus. Nun hat man ja einen Laptop dabei, kann also die Ergebnisse kontrollieren. Und siehe da: nix passt.
Was tut man also? Man versucht herauszubekommen, was das Programm denn als Zahlenwert erwartet. Irgendwie dachte ich mir (warum, weiß ich auch nicht; vielleicht wars ja Schicksal 😛 ) dass mir ein Hex-Editor weiterhelfen könnte. Konnte er natürlich nicht, hat aber soweit geholfen, als dass ich festgestllt habe, dass es zu jedem Aufgabenblatt 2 Definitionen gibt. Eine generiert die Aufgabenstellung, und eine generiert… Moment. Was ist das? Ein Lösungsweg!
Es gibt also nicht nur 2 Programmversionen (wie schon das _student im Dateinamen vermuten lässt), sondern zu allem Überfluss enthält die selbe Echse offenbar beide Teile. Irgendwo muss also umgeschaltet werden, was gemacht werden soll.

Nachdem man seinen IDA Pro wiedergefunden und gestartet hat, wird also mal das Programm hineingeworfen. Etwas warten, und die Programmstelle wieder finden. Das macht sich recht einfach, immerhin ist der Titel des Belegs ein sehr eindeutiges Merkmal (im Code-Segment jedenfalls). Nun muss man nur noch die XRefs zurückverfolgen, um rauszubekommen wo der wichtige Aufruf erfolgt. Der ist nämlich da, wo basierend auf einem Vergleich der eine oder andere Zweig (=Ausgabeanweisungen) aufgerufen wird. It always boils down to a simple comparision.
Der letzte Schritt (wo allerdings leider die Vorlesung zuende war; der Teil mit dem „IDA wiederfinden“ hatte etwas lange gedauert) ist es nun nur noch, die Zuweisung an die überprüfte Variable zu finden. Auch hier hilft wieder die XRefs-Funktion. Es gibt nämlich nur eine, und die schreibt eine $00, also den Ordinalwert für false. Man könnte also sagen, die betreffende Variable ist sowas wie IsTutorenVersion.
Kurzer Patch in der Exe der (wir wissen ja: es ist Delphi) eine $01 (für true) stattdessen schreibt, und fertig.

Wer das liest und ein berechtigtes Interesse hat, der hat auch Wege mich nach dem Teil zu fragen. Das ist nun grade ein Hack, bei dem ich garantiert kein Responsible Disclosure machen werde. Das wäre nämlich sehr verantwortungslos. Mir selbst gegenüber 😀

Das wars erstmal von meiner Seite,
Martok

How to not be evil [Update]

Wer kennt sie nicht, die beliebte Funktion eval()? Chrome zum Beispiel 😀

Das heißt auch, dass die bisher im Edgemonkey verwendete Kombination von eval/uneval zur (de)serialisierung von Einstellung und Speicherung dieser so in Chrome nie funktionieren wird (selbst wenn später einmal eine GM_setValue-Alternative zur Verfügung steht – stay tuned). Es muss also jedes Vorkommen davon durch die eigentlich viel schöneren und moderneren JSON.parse und JSON.stringify ersetzt werden. Was aber nicht so einfach ist, da die Migration bisheriger Daten natürlich funktionieren muss.
Was gar nicht so einfach ist – uneval erzeugt kein JSON, sondern nur etwas was so ähnlich aussieht!

Man muss also etwas tun, um die Daten in valides JSON zu konvertieren. Was nicht einfach geht, ohne uneval. Bleibt also nur, den String als solchen zu bearbeiten. And here’s how:
Continue reading „How to not be evil [Update]“

Hackfox – Foxhacks

Viele von denen, die hier lesen dürften mein Projekt EdgeMonkey kennen. Für die paar, die es nicht tun: es handelt sich um ein Userscript für Greasemonkey, welches die Entwickler-Ecke verschönert.
Jedenfalls: viele der dort eingesetzten Techniken waren schon immer Bleeding Edge, was Userscripts angeht. Deswegen wirds da auch schnell mal blutig, wenn sich irgendwo etwas ändert.

So ist das bereits mehrmals passiert – die neue Sandbox der Greasemonkey 0.8-Reihe war wohl das offensichtlichste. Aber das war ja noch einfach zu umgehen. Richtig spaßig ist das aber erst viel später auf Firefox 4 geworden, welcher mich auch dazu gebracht hat die hier besprochene Thematik mal genauer zu analysieren.
Continue reading „Hackfox – Foxhacks“

Aus dem Maschinenraum

Heute mal wieder so ein paar schöne WTF-Momente gehabt. Das ist zwar bei WordPress nix neues, weswegen ich heute auch mit Serendipity experimentiert hab. Das ist zwar toll, aber die Permalinkstruktur gefällt mir nicht wirklich, und der Import hat auch nicht geklappt (konsquent falscher Zeichensatz). Ist aber hier nicht das Thema 😉

Was mich heute zum wiederholten Mal verwundert hat, sind spontan nicht mehr funktionierende PHP-Skripte.
PHPExec meinte doch eben völlig unmotiviert („I didn’t touch anything! *looks away*“), mir einen Fehler zu melden, eine Variable wäre nicht initialisiert. Das war sie zwar wirklich nicht, aber das Skript lief ohne Unterschied literally seit Jahren. Fehlerfrei. Ich hab eine glaubhafte Versicherung meines Hosters, dass er auch nix gemacht hat…

Sowas hatte ich schonmal: ein Datenbank-Wrapper, der schon Wochenlang genutzt wurde, meinte auf einmal, Bind-Variablen nicht mehr richtig übergeben zu wollen. Und Überraschung: laut Manual hätte es nie funktionieren können.

Hatte schonmal jemand ähnliche Effekte? Plötzlich veränderliches Verhalten ist etwas, was ich mir so gar nicht erklären kann.

Optimierung mal anders

Aus der Kategorie, „Spaß am Gerät, den man lieber nicht hätte“: Amoklaufende Optimierung im GCC.

Man lese folgenden Code, der alternierend ein LCD mit Zahlen, Buchstaben und „nichts“ füllt:

while (1) {
	for (unsigned char k=0;k<4;k++)  {
		LCD_setCursorPos(k,0);
		LCD_write("1234567890123456");
	}
	delay(250);
	LCD_clear();
	delay(250);
	for (unsigned char k=0;k<4;k++)  {
		LCD_setCursorPos(k,0);
		LCD_write("abcdefghijklmnop");
	}
	delay(250);
}

What could possibly go wrong ❓

Gut, wir kennen ja Murphy: Alles, was schief gehen kann, geht schief. Und wenn schon der Code kaum Fehlerpotential hat, muss zwangsläufig der Compiler seinen Beitrag dazu leisten ❗

Genau das hat er dann auch getan… erstmal äußerte sich das ganze dann darin, dass wider erwarten nur Zahlen, leere Seite und wieder Zahlen kamen. Und dabei die Seite mit den Zahlen irgendwie „zu lang“ zu sehen war.
Was war also los?
Wie in Blick in das praktischerweise im Makefile angeforderte Extended Listing verrät, ist avr-gcc der Meinung, die beiden Schleifen würden das Gleiche machen, und kombiniert die in eine Schleife. Durch Ausprobieren anderer Optimierungsstufen zwischen -Os und -O1 kann man dann gcc immerhin überreden, nicht mehr beides in einer Schleife zu erledigen, sondern die zweite komplett zu ignorieren (toll!)… auch nicht ganz das Wahre. -O0 erzeugt Warnungen in <util/delay.h>, fällt also leider aus.

Die einzige mir bekannte Lösung ist das verlegen der beiden Schleifen in separate Methoden:

void test1(void)
{
	for (unsigned char k=0;k<4;k++)  {
		LCD_setCursorPos(k,0);
		LCD_write("1234567890123456");
	}
	delay(250);
}
 
void test2(void)
{
	for (unsigned char k=0;k<4;k++)  {
		LCD_setCursorPos(k,0);
		LCD_write("abcdefghijklmnop");
	}
	delay(250);
}
while (1) {
	test1();
	LCD_clear();
	delay(250);
	test2();
}

Gut, man muss eingestehen, der gcc hier ist schon etwas (avr-gcc (WinAVR 20080610) 4.3.0) älter. Das ist in einigen Kompatibilitätsproblemen mit anderen Projekten geschuldet, die sich auf ein bestimmtes Verhalten verlassen (hey, ich hab das nicht erfunden, ok?)
Kann also sein, dass das mittlerweile nicht mehr so ist. Aber trotzdem toll, dass so ein Bug es tatsächlich in eine Produktiv-Version schafft. Ist das kein Testcase? Naja, gcc halt…

Too much standard compliance

Hi!

Ich hab mich hier und anderswo ja schon öfter drüber beschwert, dass sich gewisse Browser nicht an Standards halten. ‚Gewisse‘ war dabei meist der IE 😉

Nun, offenbar tritt auch mal das Gegenteil auf… aber zum Anfang.

Ein Uber-1337-Web2.0-Projekt benutzt unter anderem DOM-Manipulation, dabei werden auch <style>-Nodes injected. Und zwar unterhalb des <body>s. Das funktioniert prima im Firefox(3) und in Opera, aber NICHT in IE und Safari/Webkit/KHTML/whatever. Woran liegt das? Nun, laut Standard darf ein <style>-Node nur unterhalb von <head> stehen. Meines Wissens sind Firefox und Opera die einzigen, die das ignorieren und die Dinger auch anderswo parsen. Schade eigentlich, denn meine so einfache Lösung wird jetzt durch Sonderbehandlung für die, die sich an Standards halten wieder komplizierter.

Was mich zum Fazit bringt: auch das W3C hat die Weisheit nicht gepachtet, für mich ist dieser Standard inkonsequent: die an sich ähnlich auszulegenden <script>s darf man schließlich auch überall verwenden.

Wer aber ne gute Idee hat, wie man das so hinkriegt, dass die Styles auch da geparst werden, oder wer mir sagen kann wie ich in IE/Webkit DOM-Änderungen Hooken kann (brauch ich fürs aufräumen, wenn ich doch in den <head> injecten muss), der kriegt ein Bienchen und eine About-Erwähnung 😉

cu,
Martok