{"id":46,"date":"2010-07-09T18:00:54","date_gmt":"2010-07-09T16:00:54","guid":{"rendered":"http:\/\/www.anginf.de\/?p=46"},"modified":"2014-07-10T17:15:46","modified_gmt":"2014-07-10T15:15:46","slug":"signature-programme","status":"publish","type":"post","link":"https:\/\/www.anginf.de\/?p=46","title":{"rendered":"Signature-Programme"},"content":{"rendered":"

Eine Signatur im Usenet soll maximal 4 Zeilen lang und je Zeile maximal 80 Zeichen umfassen. Statt aber nur langweilig seinen Namen\/Anschrift\/Adresse zu nennen, kann man diesen Platz auch dazu nutzen, um mehr oder weniger sinnfreie Programme dort zu hinterlegen.<\/p>\n

Klassischer Weise wurden die meisten Signatur-Programme in der Programmiersprache C geschrieben, da diese f\u00fcr viele der sonst nur (platz)aufwendig beschreibbaren Strukturen auch k\u00fcrzere Varianten m\u00f6glich waren. Wer zudem noch auf die korrekten Reihenfolge der Interpretierung achtet, kann hier enorm viel Quellcode-Speicherplatz sparen.<\/p>\n

Durch das Ausreizen der F\u00e4higkeiten der Programmiersprache werden solche Programme auch h\u00e4ufig recht schwierig zu lesen oder zu verstehen, man bezeichnet solche Programme als Obfuscated.<\/p>\n

Im laufe der Zeit habe ich haupts\u00e4chlich zwei Signature-Programs genutzt, beide sind in C geschrieben und zumindest auf einer Unix\/Linux-Konsole mit einem GNU C-Compiler (gcc) compilierbar und anschliessend ausf\u00fchrbar.<\/p>\n

Einfache verschleierte Ausgabe einer URL<\/p>\n

main(a,b){char*c=\"ji3yijyxwjlfr44?uyymm\";for(;a++<21;)putchar(c[21-a]-5);}<\/pre>\n
Zugegeben, das war nicht unbedingt ein sehr schwieriges Programm, aber es verschleierte zumindest ein wenig seine Herkunft. Sicherlich sieht man sofort, dass dies eindeutig das \u00e4ltere Programm ist. :)
\nVertikaler geschwungener Scroller der Initialien<\/p>\n
main(a,b){int c=0,d=0,e[10]={70,137,145,98,0,255,4,8,4,255};for(;++d;c=0){puts\r\n(\"\\e[2J\");while(c<10){for(b=a=abs((c+++d)%16-8)+1;--a>1\/(10-b)-1\/b;)putchar(32)\r\n;for(a=8;a>0;putchar((e[c-1]>>--a&1)*3+32));puts(\"\");}usleep(34567);}}<\/pre>\n
Wie man sieht konnte ich mich auch mit drei Zeilen begn\u00fcgen. Es gibt auch noch Stellen im Programm, welche weiter optimierbar w\u00e4ren, aber da ich sowieso nicht mehr soviel im Usenet aktiv bin, fehlt mir auch der Reiz.<\/p>\n
Da ich \u00f6fters darauf angesprochen wurde, erkl\u00e4re ich gerne die Funktionsweise en detail. Etwas klarer wird das Programm, wenn man es zun\u00e4chst einmal formatiert darstellt. Ich habe bereits f\u00fcr die einzelnen Bl\u00f6cke ein grobe Erkl\u00e4rung als Kommentar hinzugef\u00fcgt:<\/p>\n
main(a,b)\r\n{\r\n  \/* Declaration of variables and data structure (the Initials) *\/\r\n  int c=0,d=0,e[10]={70,137,145,98,0,255,4,8,4,255};\r\n  \/* Endless for, initializes c to 0 and increases \"d\" everytime *\/\r\n  for(;++d;c=0)\r\n  {\r\n    \/* Clear screen *\/\r\n    puts(\"\\e[2J\");\r\n    \/* Ten lines to show (according to 10 data items in e[] *\/\r\n    while(c<10) {   \/* How many spaces are needed in front of each data item *\/\r\n      for(b=a=abs((c+++d)%16-8)+1;--a>1\/(10-b)-1\/b;)\r\n        putchar(32);\r\n      \/* Print the field according to the data with stars or spaces *\/\r\n      for(a=8;a>0;putchar((e[c-1]>>--a&1)*3+32));\r\n      \/* Newline *\/\r\n      puts(\"\");\r\n    }\r\n  usleep(34567);\r\n  }\r\n}<\/pre>\n
Das besondere liegt offensichtlich in den for()-Schleifen, daher ist es sinnvoll, sich diese noch einmal etwas genauer zu betrachten. Eine for()-Schleife besteht aus drei Teilen, der Initialisierung, der Abbruchbedingung und der Schrittweite. Das besondere ist, dass jeder dieser Teile auch ganz \"regul\u00e4ren\" Code ausf\u00fchren kann. Die Initialisierung wird nur einmalig ausgef\u00fchrt, die Bedingung und die Schrittweite bei jedem Durchlauf. Hier also zun\u00e4chst die erste Schleife:<\/p>\n
\r\nfor(\r\n  b=a=abs((c+++d)%16-8)+1;\r\n  --a>1\/(10-b)-1\/b;\r\n)<\/pre>\n
Initial werden b und a auf das Ergebnis aus<\/p>\n
abs((c+++d)%16-8)+1<\/pre>\n
gesetzt. c gibt dabei die aktuelle Zeile wieder, d ver\u00e4ndert sich erst nach jedem vollst\u00e4ndigen Bild, wird also erst nach dem n\u00e4chsten \"Clear screen\" wieder ver\u00e4ndert. Die Teilanweisung<\/p>\n
c+++d<\/pre>\n
erh\u00f6ht dabei erst das c und f\u00fchrt anschliessend die Addition aus. Die l\u00e4ngere Schreibweise daf\u00fcr w\u00e4re:<\/p>\n
c = c + 1;\r\nc + d;<\/pre>\n
Der R\u00fcckgabewert dieser Funktion wird nun modulo 16 gerechnet, somit erhalten wir einen Wert zwischen 0 und 15. Durch das Abziehen der 8 (ergibt -8 bis 7) und das anschliessende Verwenden der Funktion<\/p>\n
abs()<\/pre>\n
erh\u00e4lt man einen Wert zwischen 0 und 8, das +1 verschiebt das wieder auf den Bereich 1 und 9.<\/p>\n
Durch die Initialisierung haben nun beide Variablen denselben Wert zwischen 1 und 8. Der Bedingungsteil wird leichter verst\u00e4ndlich, wenn man sich die Formel einfach etwas getrennter anschaut:<\/p>\n
--a > 1\/(10-b) - 1\/b<\/pre>\n
Die Pr\u00fcfung lautet also: \"Ist (das zuvor verkleinerte) a noch gr\u00f6sser als die Subtraktion der Br\u00fcche? Wenn ja, dann noch eine Schleife durchlaufen. Da in dem \"Schrittweite\"-Bereich die Variable a immer um eins reduziert wird, ist diese Bedingung irgendwann nicht mehr korrekt. Das ganze dient einfach dazu, die hohen und die kleinen Werte von a ein wenig zu d\u00e4mpfen. Nimmt b die Werte 1 oder 2 an, wird die Schleife immer zweimal durchlaufen, bei b=8 oder b=9 immer achtmal. Auf diese Weise sieht die Animation etwas \"fl\u00fcssiger\" aus, da es mehr an die Sinus-Kurve erinnert, ohne dass ein Sinus gerechnet werden muss.<\/p>\n
Bei jedem Durchlauf dieser Schleife wird ein Leerzeichen ausgegeben.<\/p>\n
Die zweite for()-Schleife hat Ihren besondern Reiz in dem \"Schrittweite\"-Part:<\/p>\n
for(\r\n  a=8;\r\n  a>0;\r\n  putchar((e[c-1]>>--a&1)*3+32)\r\n);<\/pre>\n
Die Schleife soll offensichtlich achtmal durchlaufen werden, normalerweise w\u00fcrde man einfach ein a-- als Schrittweite-Part nehmen. Durch das Voranstellen der Minuszeichen vor dem a wird das dekrementieren bereits vor der Auswertung durchgef\u00fchrt.<\/p>\n
Der Teil<\/p>\n
e[c-1]<\/pre>\n
greift banal auf das Datenfeld zu, welches f\u00fcr die cte Zeile zust\u00e4ndig ist. Das -1 wird gebraucht, weil bei Arrays in c das erste Element mit 0 indexiert wird.<\/p>\n
Der ausgelesene Werte aus dem Array wird nun mittels >> geshiftet. Der Wert in dem Datenfeld ist ein Wert zwischen 0 und 255, l\u00e4sst sich also in 8 Bit darstellen. Der erste Wert \"70\" wird in der Bin\u00e4rschreibweise zu: 01000110. Wir verschieben (\"shiften\") nun diesen Bitvektor um a-1 nach \"rechts\". a durchl\u00e4uft in unserer Schleife die Werte 8 bis 1, also shiften wir zun\u00e4chst um 7:<\/p>\n
Shifting bei a=7 und Bitvektor 01000110:<\/p>\n
01000110 (0)\r\nx0100011 (1)\r\nxx010001 (2)\r\nxxx01000 (3)\r\nxxxx0100 (4)\r\nxxxxx010 (5)\r\nxxxxxx01 (6)\r\nxxxxxxx0 (7)<\/pre>\n
Von links wird tats\u00e4chlich immer eine \"0\" nachgeschoben, durch das \"x\" versuche ich nur zu verdeutlichen, dass man sich einfach nur das h\u00f6chste Bit geholt hat. Es ist eine 0. Der Rest des Schrittweite-Parts wertet nun diesen gewonnenen Wert aus:<\/p>\n
(0 & 1) * 3 + 32<\/pre>\n
0 UND 1 (als Bitvergleich gesehen) ergibt \"Falsch\", also eine 0.
\n0 multipliziert mit 3 ergibt 0, plus 32 eine 32.
\nUnd diese 32 wird nun als putchar(32); ausgegeben - ein Leerzeichen.<\/p>\n
Bei a=6 resultiert aus dem Bitvektor 01000110 allerdings:<\/p>\n
xxxxxx01<\/pre>\n
01 UND 1 ergibt ein \"Wahr\", also eine 1. (Wir pr\u00fcfen mit diesem Bitvergleich offensichtlich nur den kleinsten Bitteil)
\n1 multipliziert mit 3 ergibt 3, plus 32 eine 35.
\nputchar(35) liefert - richtig - das Zeichen \"#\".<\/p>\n
Die zweite for()-Schleife hat keinen Ausf\u00fchrungsteil und durchl\u00e4uft sich daher einfach nur selbst. (Sie hat ja auch schon genug zu tun...)<\/p>\n
Insgesamt kann man also sehen, dass dieses kleine Programm die eine oder andere Programmierkenntnis schon erfordert:<\/p>\n