2013-03-05T23:26:00+01:00

Für alle, die weiterhin meinen tollenn hust Beiträgen folgen möchten, können den RSS Feed des neuen Blogs abonnieren.

Feed: http://feeds.feedburner.com/blogbasis

BlogURL: http://blogbasis.net/

Ich würde mich freuen, wenn ihr dort ab und zu mal vorbeischaut :)

Beste Grüße, und bis zum nächsten Eintrag,

gehaxelt

]]>

2013-03-03T19:26:00+01:00

Ich möchte in diesem Blogpost beschreiben, wieso ich den Blog (gehaxelt.in/blog/) in der nächsten Zeit nicht weiter befüllen werde.

Probleme und deren Lösungen

Vielleicht hat man beim Lesen des Bloggs erkannt, dass ich oft Tutorials/Anleitung zur Lösung verschiedener Probleme geschrieben habe. Zu einem sind mir diese Probleme selbst widerfahren, andererseits wollte ich damit Leuten weiterhelfen, welche ggf. die gleichen Probleme haben.

So sind bisher 260 Blogartikel innerhalb von rund 1 1/2 Jahren zusammen gekommen. Dafür, dass ich den Blog alleine beschrieben habe, finde ich es eine gute Leistung :P

Nunja, was bringen alle die Tutorials, wenn diese von niemanden gefunden werden? Ich hatte vor ein paar Wochen über meine Probleme mit Google berichtet.

Das Google

Google nimmt den Blog bzw. die Inhalte unter der Domain (www.gehaxelt.in) langsam aus dem Index. Das nennt sich u.a. “Slow Death”, welcher zustande kommt, wenn man über längeren Zeitraum gegen die Richtlinien von Google verstößt. Traurig ist nur, dass man von den eigentlich “Webmaster Tools” keine entsprechende Nachricht bekommt, dass etwas schief geht.

Nunja, nach ein wenig Überlegung war klar, dass ich aus Sicht von Google Duplicate Content angeboten hatte, da ich über einen gewissen Zeitraum die Inhalte über www.gehaxelt.in/blog bzw. gehaxelt.in/blog angeboten hatte. Das war ohne 301/302 Weiterleitung. Diese nachträglich hinzuzufügen brachte auch nicht wirklich was.

Einmal im Slow Death, immer im Slow Death. Soweit ich mich informiert hatte, kann das einige Monate dauern, bis die Seiten aus dem Index verschwunden sind. Genau das war nun bei mir der Fall. Alle paar Tage sind zwischen 2 und 5 Seiten aus dem Index verschwunden, sodass ich mittlerweile nur noch bei 18 von 260 Seiten bin. Ich gehe stark davon aus, dass in den kommenden 2-3 Wochen wir bei 0 angelangt sind.

Meine Recherche ergab außerdem, dass man nicht mehr so leicht in den Index aufgenommen wird. Man kann zwar eine Bitte an Google stellen, doch gehe ich mit sehr hocher Wahrscheinlichkeit davon aus, dass so ein “kleiner” Blog nicht wieder aufgenommen wird. Vielleicht wird der Blog in ein bis zwei Jahren wieder indexiert.

Das Ende

Ich muss sagen, mir fällt es schwer, mich von diesem Blog zu verabschieden. Deswegen werde ich den Blog online lassen und die zwei Jahre abwarten, bis man vielleicht wieder in den Index kommt, bzw. den Lesern, welche von anderen Seiten auf meine Artikel kommen, noch ein wenig Lesespaß zu gewähren.

Denn was bringt mir ein Blog mit gewissen Tutorials, wenn die nicht gefunden werden? Ich finde das dann einfach nur schade, und ich finde es krass, wie “abhängig” man von Suchmaschinen ist.

Die Zukunft

Die Zukunft wird so aussehen, dass ich mit dem Bloggen aufhöre - Schreck gekriegt? - Das war nämlich ein Scherz. Das Blogging ist ein Teil von mir geworden, sodass ich mir das Hobby nicht entgehen lassen möchte :)

Ich habe ein wenig überlegt, und stehe nun vor zwei Optionen:

Neuer Blog aufgehaxelt.de

Ich könnte mir einfach die Domain gehaxelt.de kaufen und darauf den Blog entsprechend fortführen und auf meinen alten im Archiv verlinken. Dann könnte ich ganz normal weiterbloggen. Wäre aber etwas langweilig. Ich könnte dann behaupten, den Blog alleine zu betreiben, und alle Beiträge darauf selbst verfasst zu haben.

Neuer Mutli-Blog

Ich hatte mir überlegt, dass ich eine Art Multiblog aufmachen könnte. Die Domain würde dann allgemeiner gefasst werden, und ich würde dann Bekannte mit darauf bloggen lassen. So ein Projekt wäre mal was Neues und Abwechslungsreiches. Doch mit der Idee kommen auch schon die nächsten Probleme:

Was für ein CMS nutzt man? Octopress/Wordpress/Kirby…
Was für Themen behandelt man? Technik/Politik/”Alles durcheinander”
Was für Leute dürfen Bloggen? Kurze Vorstellung/nur Bekannte/Egal wer
Was ergibt für eine Qualität der Beiträge?

So ein Projekt könnte dann mehr Themen/Aspekte beleuchten, usw, was meiner Meinung sehr interessant sein kann. Man könnte so eine größere Leserschaft erreichen.

Die Entscheidung

Ich denke, ich werde das Projekt “Multiblog” mal in Angriff nehmen. Sollte es nicht funktionieren, kann ich dort auch noch alleine Weiterbloggen.

Joa, damit sage ich mal nun danke für das Lesen des Artikels, und den neuen Blog gebe ich dann per Twitter bekannt, sobald er fertig ist.

Vielen besten Dank an EUCH, und falls ihr mal Lust habt, etwas auf dem neuem Blog zu schreiben, würde ich mich darüber riesig freuen :)

Gruß

gehaxelt

]]>

2013-02-26T20:05:00+01:00

In diesem Blogpost erkläre ich, wie ihr Metasploit auf eurem Raspberry Pi installiert.

Softwarevorraussetzungen

Zunächst müssen wir einige Pakete aus dem Repository installieren:

sudo apt-get -y install \
  build-essential zlib1g zlib1g-dev \
  libxml2 libxml2-dev libxslt-dev locate \
  libreadline6-dev libcurl4-openssl-dev git-core \
  libssl-dev libyaml-dev openssl autoconf libtool \
  ncurses-dev bison curl wget postgresql \
  postgresql-contrib libpq-dev \
  libapr1 libaprutil1 libsvn1 \
  libpcap-dev screen

Dieser Prozess ist nach ungefähr 15 Minuten abgeschlossen. Dann können wir Ruby in Kombination mit RVM installieren.

RVM & Ruby installieren

Die Installation dauerte bei 105 Minuten, sodass ihr nach den folgenden Befehlen erstmal einen Kaffee trinken könnt :)

Ich habe den Prozess innerhalb eines Screens gestartet. Falls die Verbindung zum Pi abbricht, läuft die Installation munter weiter.

Den Screen starten wir mittels:

screen -S rvm

Von diesem könnt ihr euch mit “Strg+A+D” trennen.

Möchtet ihr wieder dort rein, dann geht das folgendermaßen:

screen -r rvm

Im Screen führt ihr dann die Installation aus. Wer aus Sicherheitsgründen den Inhalt einer Webseite nicht direkt in die Shell pipen möchte, der kann sich das Script erstmal herunterladen, anschauen und ausführen.

Die schnellere Variante:

curl -L https://get.rvm.io | bash -s stable --ruby

Dauer:

real    104m26.266s
user    83m48.590s
sys     4m19.720s

Nachdem die Installation abgeschlossen ist, müssen wir das RVM-Script neu laden:

source ~/.rvm/scripts/rvm

Als nächstes erzeugen wir unser Default-Gemset:

rvm use --create --default 2.0.0@msf

Metasploit herunterladen

Ich habe für Metasploit einen extra Ordner angelegt:

pi@raspberrypi ~ $ mkdir metasploit
pi@raspberrypi ~ $ cd metasploit/

Ich gehe hier davon mal aus, dass man einen GitHub Account besitzt, und einen SSH-Key vom Pi hinterlegt:

ssh-keygen -t rsa -f ~/.ssh/github
vim ~/.ssh/config
Host github.com
  IdentityFile ~/.ssh/github

Nun können wir das Metasploit-Repository klonen (wir sind immer noch im ~/metasploit):

git clone [email protected]:rapid7/metasploit-framework.git .

Nachdem der Prozess erfolgreich abgeschlossen wurde, müssen wir postgresql starten, damit wir in Metasploit mit Datenbanken arbeiten können:

sudo /etc/init.d/postgresql start

Nachdem Postgresql gestartet ist, müssen wir für Metasploit noch einen Benutzer anlegen:

sudo su postgres
createuser msf_user -P

Wir geben zweimal ein Passwort, sowie dreimal ein “Nein” als Antwort.

createdb --owner=msf_user msf_database
exit

Damit haben wir dann die entsprechende Datenbank angelegt und die switch-user Umgebung verlassen.

Final Step

Nun können wir das erste Mal Metasploit starten. Ihr solltet Metasploit mit dem Parameter “-L” aufrufen, da es sonst zu einem Haufen Fehlermeldungen kommt.

ruby ./msfconsole -L

Nachdem wir ein paar Minuten gewartet haben, begrüßt uns die MSFConsole.

Zuletzt möchten wir noch die Datenverbindung einrichten:

db_connect msf_user:PASSWORT@localhost/msf_database

Nun sollte uns Metasploit das auch bestätigen:

db_status

Fazit

Ihr könnt nun auch auf dem kleinen Pi große Exploits ausnutzen :D Zumindest, wenn ihr die entsprechende Geduld aufweisen könnt, denn die Eingabe bzw. die Verarbeitung dauert ein Weilchen.

Gruß

gehaxelt

]]>

2013-02-25T00:02:00+01:00

In diesem Blogpost möchte ich wieder etwas aus der technischen Informatik aufgreifen, nämlich die Automaten und deren Umsetzung auf Hardwarebasis.

Dazu möchte ich einen kleinen Ampel-Automaten basteln.

Unter einem Ampel-Automaten stelle ich mir einen Automat vor, welcher 3 Zustände kennt: rot, gelb & grün. Ich habe mich hierbei für einen Moore-Automaten entschieden, bei dem die Ausgabe nur vom Zustand und nicht von der Eingabe abhängt.

Der Zustandsgraph

Ich zeichne zunächst einen Zustandsgraphen des Automaten, damit die Umsetzung später leichter fällt.

Man erkennt drei Kringel, welche in zwei Hälften geteilt sind. In der oberen Hälfte steht der Zustandsname und in der unteren die entsprechende Ausgabe des Zustandes.

Der Start signalisiert uns den Anfangszustand des Automaten.

Auf den Pfeilen steht der Folgezustand in den der Automat unter dem anliegenden Eingangssignal wechselt. Bei den Schlaufen bleibt der Automat bei seinem aktuellen Zustand.

Die Kodierung & Ausgabe

Wir müssen nun unsere Zustände und die Ausgabe kodieren.

Die Ausgabe habe ich im oberen Bild schon kodiert (2-Bit-Wort in der unteren Hälfte), sodass diese später auf den 1-zu-4 Demultiplexer passt.

Die Zustände rot, gelb und grün kodieren wir ähnlich:

rot: 00
gelb: 01
grün: 10

Daraus ergibt sich die folgende Zustandsübergangstabelle:

q0,q1 sind die entsprechenden Bits, die unseren Zustand kodieren. E ist das Eingabesignal unter welchen der Automat in den nächsten Zustand wechselt. q0’,q1’ kodieren dem nach den Folgezustand. Die Ausgabe ist vom aktuellen Zustand abhängig und wir mittels A0 bzw. A1 kodiert.

Die Funktionen

Jetzt sind wir so weit, dass wir aus unserer Zustandsübergangstabelle die entsprechenden Funktionen für q0’, q1’, A0 & A1 auslesen können. Das machen wir, in dem wir die Minterme der jeweiligen Funktion auslesen und zu einer DNF verodern.

$\begin{align*} q0' &= \overline{q_0}q_1E + q_0\overline{q_1}E\\ q1' &= \overline{q_0} \overline{q_1}E + q_0\overline{q_1}E\\ A_0 &= q_0\overline{q_1}\\ A_0 &= \overline{q_0}q_1\\ \end{align*}$

Das Schaltbild

Nachdem wir nun die Funktionen ausgelesen haben, können wir das nun als Schaltbild zeichnen:

S = Switch; Dort muss eine Spannung anliegen, welche durch den Multiplexer durchgeschaltet wird.
T = Takt; Gibt den Takt an, mit welchem die MS-D-FFs geschaltet werden. 
E = Eingabe; Ist die Eingabe unter welcher der Automat seinen Zustand wechselt.

Wir haben nun unseren Ampel-Automaten soweit fertiggstellt. Man könnte sich z.B. im Conrad die entsprechenden Bauteile kaufen und zusammen löten. Ggf. bräuchte man noch alle paar logische Einheiten einen Signalverstärker, damit bei dem Multiplexer noch eine Spannung anliegt.

In diesem Schaltbild nutzen wir zwei Blackboxen, nämlich zweimal einen Master-Slave-D-Flipflop (MS-D-FF) und einmal einen 1-zu-4 Demultiplexer (Demux)

Diese sind nichts anderes als eine Kombination der verschiedenen Operatoren (AND,NOT,OR).

Demultiplexer

Ein Demultiplexer verteilt ein Eingangssignal wahlweise über die Steuersignale auf einen Ausgang.

Das Schaltbild des oben dargestellten 1-zu-4 Demultiplexers kann so aussehen:

Man hat also eine Reihe an Verundungen, sodass immer entsprechend nur ein Signal an den entsprechenden Ausgang durchgeleitet wird.

Master-Slave-D-Flipflop

Ein MS-D-Flipflop ist taktflankengesteuert. D.h. dieser ändert den an Q anliegenden Wert erst, wenn der Takt von 0 auf 1 wechselt.

Ein Master-Slave-D-Flipflop besteht aus zwei D-Flipflops.

Ein einfaches D-Flipflop (Latch) sieht so aus:

Bei einem MS-D-Flipflop sind zwei D-Flipflops in Reihe geschaltet, und der Takt des zweiten D-Flipflops ist negiert:

Der MS-D-Flipflop speichert den an D anliegenden Wert für einen Taktzyklus.

Fazit

Ich bin am Überlegen, ob ich mir die entsprechenden Bausteine bei Conrad bestelle und Just-For-Fun die Ampel mal zusammen löte und an meinen Raspberry Pi stecke. Ich finde die Automaten relativ interessant, da man damit tolle Sachen umsetzen kann. Dadurch das die entsprechend benötigten Bausteine preisgünstig erworben werden können, erhöht es den Reiz umso mehr :D

Gruß

gehaxelt

]]>

2013-02-24T14:39:00+01:00

Mein Bruder macht zur Zeit sein MSA und wird eine Präsentation zum Thema “Inwieweit verändern Smartphone die Mobilkommunikation?” halten.

Er möchte eine dazu eine kleine Umfrage veranstalten und diese auswerten.

Ich würde mich freuen wenn ihr ihn dabei unterstützt in dem ihr an der Umfrage teilnehmt.

Ich bette hier die mit Google-Drive erstelle Umfrage ein:

Wird geladen…

Vielen Dank für die Teilnahme!

Gruß

gehaxelt

]]>

2013-02-20T20:27:00+01:00

Da sich @malte70 einen kurzen Artikel über die Installation eines Raspberry Pi Betriebssystems gewünscht hat, kommt nun der entsprechende Artikel dazu.

Das Betriebssystem

Ich nutze auf meinem Raspberry Pi das Raspbian als Betriebssystem, welches man sich auch zunächst herunterladen muss, bevor man es auf die SD-Karte packt.

Ich empfehle das “Raspbian wheezy”.

Die SD Karte

Eine gute Liste mit kompatiblen SD Karten findet man auf der hinterlegten Seite. Ich selbst nutze eine 16 GB Class 10 SD Karte, welche mich vom Speed nicht sehr überzeugt (gefühlt langsamer als Class 4 - 2GB), jedoch waren 2 GB recht knapp bemessen.

Es bietet sich also schon eine 4GB Karte an.

Die “Installatino”

Nachdem ihr die beidenn oben genannten Sachen beisammen habt, dann können wir das Image auf die SD Karte überspielen. Dazu werden wir das Programm “dd” nutzen.

Wer sich mit diesem Programm nicht genau auskennt, sollte die man-page lesen. Das sture Kopieren der Befehle ist nicht zu empfehlen.

Ich gehe davon aus, dass wir das Image in einem Ordner liegen haben, in dem wir uns befinden und dass die SD Karte im Rechner eingesteckt ist.

Mit dem folgenden Kommando starten wir dann die Überspielung des Images auf die SD Karte:

Achtung: Alle Daten auf der Karte gehen dabei verloren.

sudo dd if=./image.iso of=/dev/mmcblk0

Die SD Karte wird an meinem Laptop unter dem Device /dev/mmcblk0 erkannt. Dorthin muss dann auch entsprechend das Image hin.

SD Karte ausreizen

Nachdem der Schreibprozess nach einigen Minuten abgeschlossen ist, kann man die SD Karte aus dem Rechner entfernen und in den Raspberry Pi einführen.

Nachdem der Pi gebootet ist, ruft ihr

sudo raspi-config

auf und geht im Menu auf “overscan”. Diese Option erweitert dann die Partitionsgrößen auf die maximal vorhandene Größe.

Backup der SD Karte

Nachdem man einige Male mit dem Raspbian gespielt hat, und das Betriebssystem in seinem Zustand “speichern” möchte, dann kann man “dd” in umgekehrte Richtung anwenden. Wir erstellen also ein komplettes Image der SD Karte, welches man später ggf. wieder einspielen kann.

sudo dd if=/dev/mmcblk0 of=./image_backup.iso

Fazit

Damit wäre es dann auch schon getan. Ihr habt das Raspbian auf der SD Karte für die Pi eingerichtet. Eine Backupmöglichkeit, bevor ihr auf andere Systeme umsteigt, oder andere Experimente macht, habt ihr nun auch.

Gruß

gehaxelt

]]>

2013-02-20T17:09:00+01:00

In diesem Beitrag möchte ich beschreiben, wie man seinen Raspberry Pi twittern lassen kann.

Zunächst müssen wir einen Kommandozeilen-Twitterclient installieren. Ich habe mich dabei für “twidge” entschieden.

Twige auf dem Pi einrichten

Twige muss man natürlich noch einrichten.

Twidge installieren

Wenn man Raspbian nutzt, dann kann man twigde direkt aus dem Repositories installieren:

sudo apt-get install twidge

Twidge konfigurieren

Ich habe mir einen neuen Twitteraccount für diese Aktion angelegt. Wer meinem Pi folgen möchte, kann das gerne tun (@Gehaxeltspi).

twigde setup

An dieser Stelle bekommt ihr von Twigde eine URL ausgespuckt, über die ihr Twidge den Zugriff auf euren Twitteraccount freigeben könnt. Nachdem ihr euch authentifiziert habt und die Konfiguration durch das Eingeben des Auth-Codes getan ist, seid ihr fertig.

Twige nutzen

Für einfach Tweets reicht diese Zeile:

twigde update "Mein Pi kann jetzt twittern"

Eine Übersicht über die möglichen Kommandos bekommt ihr mit “twigde lscommands”:

pi@raspberrypi ~ $ twidge lscommands
All available commands:
Name                 Description
-------------------- -------------------------------------------------------
dmsend               Send direct message
block                Start blocking someone
follow               Start following someone
lsarchive            List recent status updates you posted yourself
lscommands           Display a list of all available commands
lsdm                 List recent direct messages to you
lsdmarchive          List recent direct messages you sent
lsblocking           List people you are blocking
lsfollowers          List people that follow you
lsfollowing          List people you are following
lsrecent             List recent updates from those you follow
lsreplies            List recent replies to you
lsrt                 List recent retweets from those you follow
lsrtarchive          List recent retweets you made yourself
lsrtreplies          List others' retweets of your statuses
setup                Interactively configure twidge for first-time use
unblock              Stop blocking someone
unfollow             Stop following someone
update               Update your status

Ihr könnt eurer Kreativität freien Lauf lassen und ein paar nette Scripte schreiben. Mein Pi schickt mir nun täglich seine Uptime ^^

Gruß

gehaxelt

]]>

2013-02-17T22:35:00+01:00

Ein Kumpel bat mich heute darum einen CS:GO Server aufzusetzen. Dabei kam es beim Starten des Servers zu einem Datei-Not-Found-Fehler und dessen Fix möchte ich hier kurz festhalten.

Der Fehler

Da ich einen 64-Bit Server am Laufen habe und das Spiel scheinbar nur auf 32-bit Ebene läuft, benötigt es 32bit Dateien.

Nachdem ich der Installationanleitung gefolgt bin, und den Server startete, begrüßte mich folgende Fehlermeldung:

dlopen failed trying to load: /home/steam/.steam/sdk32/steamclient.so
with error: /home/steam/.steam/sdk32/steamclient.so: cannot open shared object file: No such file or directory
Looking up breakpad interfaces from steamclient

Der Server lief zwar munter weiter, jedoch konnte sich der Spieler nicht einloggen.

Die Lösung

Die Lösung bestand darin einen Ordner und einen Symlink zu erstellen.

Zunächst der Ordner:

mkdir ~/.steam

Danach der symbolische Link der linux32-Files zum sdk32:

ln -s /home/steam/steamcmd/linux32 /home/steam/.steam/sdk32

Bitte beachtet, dass ich die “steamcmd.sh” im Ordner “steamcmd” ausgeführt habe, und die Pfade bei Euch anders sein können.

Danach ließ sich der Server korrekt starten, denn es wurde folgende Zeile im Log festgehalten:

Server waking up from hibernation
Client "Der Zocker" connected (188.x.xxx.xx:27005).

Falls ihr also demnächst einen CS:GO Server einrichten möchtet, dann sollte das Problem nicht mehr zum Scheitern führen.

Gruß

gehaxelt

]]>

2013-02-14T19:55:00+01:00

Wer noch ein Ticket für die CebIT 2013 braucht, oder noch keins hat, kann an der kostenlosen Verlosung des Heise-Verlags teilnehmen.

Die Verlosung

Der Heise-Verlag, genauer die C’t, verlost auch dieses Jahr CebIT 2013 Tickets unter ihren Lesern.

Die Teilnahme ist ganz einfach, man braucht nur irgendeine C’t bei sich zu Hause liegen haben, denn man muss eine Quizfrage beantworten und eine Email, an die das Eticket geschickt wird, angeben.

Die Verlosung findet hier statt

Die Quizfrage

Man muss eine dort genannte Quizfrage beantworten, welche immer die gleiche ist. Wer entsprechend eine (alte) C’t bei sich liegen hat, kann in dieser nach der Lösung schauen. (Tipp: Eine der ersten Seiten)

Andernfalls kann man auch den Weg des Brute-Forces nehmen, wenn man mehrere Emailaddressen und keine Ahnung hat.

Viel Erfolg!

PS: So wie es aussieht, werde ich Samstags auf der CebIT sein. Wer sich ggf. mal treffen möchte, kann sich ja mal melden.

Gruß

gehaxelt

]]>

2013-02-13T23:17:00+01:00

Funktionsweise der Umwandlung eines Strings in einen Hexstring und umgekehrt in Python.

Vor ein paar Tagen wurde ich gefragt, ob ich wisse, wie ein String, z.B. “Hallo” in den entsprechenden Hexwert umgewandelt wird. Da ich zunächst passen musste und dies nicht auf mir sitzen lassen wollte, habe ich nochmal scharf nachgedacht.

Da ich mal Base64 in Python umgesetzt hatte und man dort die Zeichen zunächst in ihre binäre Darstellung gebracht hat, dachte ich mir, man könnte das bei Hex auch mal so versuchen.

Die Vermutung hat sich bestätigt, denn nach den ersten Zeilen Python-Code konnte ich die Ausgabe meiner StrToHex Funktion erfolgreich mit einem Onlinedienst verifizieren.

Die Umwandlung ist also kein Geheimnis mehr:

Lese das erste Zeichen aus dem String
Wandle das Zeichen in den entsprechenden ASCII-Zeichenwert um
Rechne die Decimalzahl in eine Hexadecimal um
Füge das Ergebnis an einen Ergebnisstring an
Wiederhole Schritt 1 bis 4, solange noch Zeichen im String sind.

StrToHex

def StrToHex(string):
    hex_str=''
    for char in string:
        int_char = ord(char)
        hex_num = hex(int_char).lstrip("0x")
        hex_str+=hex_num
    return hex_str

HexToStr

def HexToStr(string):
    clear_str=''
    for counter in xrange(0,len(string),2) :
        hex_char=string[counter]+string[counter+1]
        clear_str+=unhexlify(hex_char)
    return clear_str

Aufrufe

print StrToHex("Hallo")
print HexToStr(StrToHex("Hallo"))

Fazit

Man kann das alles noch schöner implementieren, jedoch soll das hier nur die grobe Funktionsweise darstellen.

Gruß

gehaxelt

]]>

2013-02-11T00:49:00+01:00

Ich habe gestern Abend ein kleines Python Script geschrieben, welches logische Ausdrücke auswerten kann.

Dieses mögchte ich vorstellen und ein wenig die Funktionsweise von Scanner/Parser & Compiler erklären.

Der Quelltext

Den (unschönen) Quelltext findet ihr in meinem entsprechenden GitHub-Repository. Diesen solltet ihr euch zunächst anschauen, damit ihr wisst wie dieser im Ganzen aussieht, auch wenn ich ihn hier Stück für Stück auseinander nehmen werde.

Was sind logische Ausdrücke

Ein logischer (boolscher) Ausdruck ist ein Term welcher aus boolschen Operatoren bzw. Operanden besteht und zu wahr (T) oder falsch (F) ausgewertet werden kann.

Dabei gibt es viele verschiedene Operationen. Die bekanntesten sind folgende: and, or, not; dessen Wahrheitstafel so aussehen:

and:

a|b|y
-----
0|0|0
0|1|0
1|0|0
1|1|0

or:

a|b|y
-----
0|0|0
0|1|1
1|0|1
1|1|1

not:

a|y
---
0|1
1|0

Entsprechend kann man mit Kombinationen dieser Operatoren einen Ausdruck bilden:

T and not F == T
F or F and T == F
...

Dabei sollte man beachten, das der Operator “not” am stärksten bindet, gefolgt vom “and” und zuletzt vom “or”, bzw. den anderen Operatoren. Somit entfällt in den meisten Fällen die Klammerung, wie wir es von der *-+-Rechnung kennen.

Erklärung des Codes

Der Code macht eigentlich nichts anderes als die gegebene Grammatik auf die Eingabe anzuwenden. Die Eingabe wird zunächst gescannt, danach geparst und zuletzt evaluiert.

Die Grammatik

Die Grammatik lässt sich wie folgt beschreiben:

S        -> Operand | not S | ( S Operator S )
Operand  -> T | F
Operator -> or | and | -> | <-> | xor 

S ist dabei die Starteingabe. Es gibt also 3 Möglichkeiten eine valide Eingabe zu machen:

S ist ein Operand, dann wird abgebrochen.
S ist “not”, danach folgt wieder S (rekursiv)
S ist “(“, dann muss S, ein Operator, wieder ein S und “)” folgen.
Operand ist “T” oder “F”
Operator ist “or”, “and”, “->”, ”<->” oder “xor”

Nach dieser Grammatik wird unser Programm die Eingabe auswerten. Mögliche Eingaben wären zum Beispiel:

T
F
not T
not (T or F)
(not T or (F xor T))

Folgende Eingaben wären hingegen nicht korrekt:

T or F
not T or
and or not T

Der Scanner

Die Aufgabe des Scanners ist es, die einzelnen Eingaben bzw. Token zu seperieren und in eine Liste zu überführen. Das erledigt für uns der folgende Code:

#Scan Tokens
def scan(inputstr):
    try:
        tokens = []
        token = ""
        for char in inputstr:
            if char == "(":
                tokens.append("(")
            elif char == ")":
                tokens.append(")")
            elif char == "T":
                tokens.append("T")
            elif char == "F":
                tokens.append("F")
            elif char == " ":
                if not token == "":
                    tokens.append(token)
                    token=""
                else:
                    pass
            else:
                token+=char
        return tokens
    except:
        return "Scanning error"

Wir haben ein Array “tokens”, in dem alle Tokens abgespeichert werden. Die Variable “token” nutzen wir, um mehrbuchstabige Tokens einzulesen (and,or,sad). Wichtig hierbei ist, dass auch nicht valide Zeichenketten, wie “andor” vorkommen können. Diese werden dann erst später beim Parser behandelt. Der Scanner nutzt als Trennzeichen hier das Leerzeichen ” “.

Für die folgende Eingabe sieht die zurückgegebene Liste so aus:

-> % ./logicparser.py "(T or (blubb and T))"
['(', 'T', 'or', '(', 'blubb', 'and', 'T', ')', ')']

Wie schon erwähnt, ist das keine Fehlfunktion des Scanners, wenn dort falsche Zeichenketten eingelesen werden. Diese werden im nächsten Schritt verarbeitet.

Der Parser

Der Parser wendet nun die Grammatik auf die übergebene Liste mit Tokens an. Dabei können Syntaxfehler erkannt werden, und das Parsing bricht ab. Es kann sinnvoll sein, den Parser eine möglichst gut evaluierbare Ausgabe erzeugen zu lassen.

Dazu nutze ich diesen Teil des Codes, wobei “parse” aufgerufen wird:

#Parses and, or,...
def parseOperator(tokens):
    token, tokens = getToken(tokens)
    if token == "and":
        return ["and",tokens]
    elif token == "or":
        return ["or",tokens]
    elif token == "->":
        return ["->",tokens]
    elif token == "<->":
        return ["<->",tokens]
    elif token == "xor":
        return ["xor",tokens]
    else:
        return ["error",tokens]

# Parses close
def parseClose(tokens):
    token, tokens = getToken(tokens)
    if token == ")":
        return ["",tokens]
    else:
        return ["error",tokens]

#Parses an expression
def parseExpr(tokens):
    token, tokens = getToken(tokens)
    if token == "T":
        return ["T",tokens]
    elif token == "F":
        return ["F",tokens]
    elif token == "not":
        exp1, rest1 = parseExpr(tokens)
        return [["not",exp1],rest1]
    elif token == "(":
        exp1, rest1     = parseExpr(tokens)
        operator, rest2 = parseOperator(rest1)
        exp2, rest3     = parseExpr(rest2)
        exp4,rest4      = parseClose(rest3)
        if exp4 == "error":
            return ["error_close",[]]
        return [[operator,exp1,exp2],rest4]
    else:
        ["error_end",[]]  

#Parse tokens
def parse(tokens):
    try: 
    
        expr, rest = parseExpr(tokens)

        if len(rest) > 0 or (expr == "error"):
            return "error"
        return expr
    except:
        return "Parsing error"

Wobei ich dafür noch eine Hilfsfunktion brauche, welche aus einer Liste mir das erste Element sowie die Restliste zurückgibt:

#Returns the first token and the rest list
def getToken(tokens):
    if len(tokens) > 0:
        token = tokens[0]
        del tokens[0]
        return [token,tokens]
    else:
        return ["error_end",[]]

Was passiert jetzt genau?

Wie schon gesagt, wird die Funktion “parse” mit der vom Scanner erzeugten Liste aufgerufen. Diese Funktion ruft dann die Funktion “parseExpr” auf, welche die eigentliche Arbeit übernimmt, und eine Token-Liste bzw. eine Restliste zurückgibt. Ist die Restliste nicht leer, oder ist die Expression ein Fehler, so wird ein “Parsing Error” ausgegeben. Hier würde man dann auch merken, wenn es eine falsche Zeichenkette in der Eingabe gab.

Was genau macht jetzt “parseExpr”?

Wenn man sich den Quellcode fix anschaut, dann erkennt man auf den ersten Blick zwei leichte Dinge: Falls das erste Token ein “T” oder “F” ist, so wird der boolsche Wert zurückgegeben. Damit hätten wir den Teil “Operand” der Grammatik abgedeckt. Die dritte Bedingung deckt den Fall “not S” ab, indem “parseExpr” rekursiv mit der Restliste (S) aufgerufen wird. Der Ergebnis wird dann in einer Unterliste zurückgegeben.

Kommen wir nun zum etwas interessanterem Teil:

elif token == "(":
    exp1, rest1     = parseExpr(tokens)
    operator, rest2 = parseOperator(rest1)
    exp2, rest3     = parseExpr(rest2)
    exp4,rest4      = parseClose(rest3)
    if exp4 == "error":
        return ["error_close",[]]
    return [[operator,exp1,exp2],rest4]

Damit möchten wir den dritten Fall der Grammatik abdecken, nämlich das erst eine öffnende Klammer, gefolgt von einem Operanden, einem Operator, dem rechten Operanden und einer schließenden Klammer in der Liste auftritt. Der Indikator ist die öffnende Klammer “(“.

Danach muss der linke Operand folgen, welcher selbst wieder ein Ausdruck sein kann. Das stellen wir mit “parseExpr” sicher. Den Operator stellen wir mit der zusätzlichen Funktion “parseOperator” fest, indem der Funktion die neue Restliste übergeben wird. Zurück bekommen wir einen Operator, sowie eine neue Restliste. Auf diesen muss dann wieder eine Expression und schließlich eine schließende Klammer folgen.

Schlägt eines der Parseschritte fehl, so kommt es zu einem Fehler. Ansonsten wird eine Liste mit einer Unterliste, sowie der Restliste zurück gegeben.

Damit wäre der schwierigste Schritt getan, und das ganze sieht dann so aus:

-> % ./logicparser.py "(T or (F and T))"
['or', 'T', ['and', 'F', 'T']]

Wie man sieht, nutze ich die polnische Notation zur Darstellung der Unterlisten. Das vereinfacht später die Evaluation, da der Operator vorne steht und der zweite Eintrag der linke bzw. der dritte Eintrag der rechte Operand ist.

Nachdem wir nun eine syntaktisch und semantisch korrekte Expression haben, müssen wir diese nur noch auswerten. Das erledigt die “logiceval” Funktion.

Der Evaluator

Zuletzt folgt der Evaluator, welcher den geparsten Ausdruck auswertet. Das geschieht mittels Rekursion:

def logiceval(expr):
    try:
        token, tokens = getToken(expr)

        if token == "T":
            return True
        elif token == "F":
            return False
        elif token == "not":
            return not logiceval(getToken(tokens))
        elif token == "and":
            return logiceval(getToken(tokens)) and logiceval(getToken(getToken(tokens)))
        elif token == "or":
            return logiceval(getToken(tokens)) or logiceval(getToken(getToken(tokens)))
        elif token == "->":
            left = logiceval(getToken(tokens))
            if left:
                return False
            else:
                return True 
        elif token == "<->":
            left = logiceval(getToken(tokens))
            right = logiceval(getToken(getToken(tokens)))
            if (left and right) or (not left and not right):
                return True
            else:
                return False
        elif token == "xor":
            left = logiceval(getToken(tokens))
            right = logiceval(getToken(getToken(tokens)))
            if (left and not right) or (not left and right):
                return True
            else:
                return False
        else:
            return "error"
    except:
        return "Evaluation error"

Die Funktion schnappt sich aus der Tokenliste das erste Token und fängt dann an zu vergleichen. Wenn es ein Operand ist, dann muss nur noch der Wahrheitswert zurückgegeben werden.

Bei einer der möglichen Unterlisten muss zunächst geprüft werden, welcher Operator verwendet werden soll und entsprechend ein Schritt bzw. zwei Schritte von links der linke bzw. rechte Operand bestimmt werden. Dies passiert rekursiv, sodass bei den Operationen irgendwann nur noch die Wahrheitswerte links bzw. rechts stehen, welche dann miteinander verknüpft werden können. Bei der Implikation (->) reicht es das darauf folgende Token auszuwerten, denn es gibt bei der Implikation nur einen Fall, in der False zurückgegeben wird. Man kann nämlich nicht von etwas Wahrem auf etwas falsches schließen. Die anderen Operationen werden entsprechend berechnet.

Fazit

Wenn man eine bestimmte Grammatik gegeben hat, dann ist es ohne weiteres möglich ein Programm zu schreiben, welches die syntaktische Korrektheit einer Eingabe überprüft. Ich hoffe, ich konnte euch das Prinzip vom Scanner/Parser ein wenig näher bringen.

Gruß

gehaxelt

]]>

2013-02-09T22:12:00+01:00

Ich möchte einen kurzen Blogpost darüber loswerden, wie man unter Linux Programme untersucht. Dazu möchte ich die Tools “strings”, “ltrace”, “strace” und “ldd” vorstellen.

strings

Das Tool “strings” gibt es im Paket “binutils”, welches soweit vorinstalliert sein sollte. Mit diesem Tool kann man sich alle Zeichenketten einer Datei ausgeben lassen. Das kann nützlich sein, wenn man in einer Binary nach Zeichenketten sucht, z.B. C&C-Server eines Trojaners.

strings /usr/bin/ls

Möchte man sich noch die Offsets der Strings anzeigen lassen, so kann man die Option “-t” nutzen. Diese unterscheidet zwischen drei Ausgabeformaten: o für octal, x für hexadecimal, d für decimal.

strings -t x /etc/passwd

strace & ltrace

Möchte ein Programm nicht das machen was es soll oder hängt es sich, ohne Ausgabe auf dem stderr Kanal, auf, dann kann man strace bzw. ltrace nutzen, um ggf. die Ursache herauszufinden. Dabei führen diese Tools das übergeben Programm aus und protokollieren die entsprechenden Aufrufe.

Die beiden Tools kann man in den gleichnamigen Paketen nachinstallieren:

sudo apt-get install ltrace strace

strace

Strace protokolliert alle Systemaufrufe des ausgeführten Programms. Man erkennt dann z.B. welche Dateien ausgeführt, geöffnet, geschlossen usw. werden und welche Rückgabewerte erzeugt werden.

Sieht man z.B. bei einem “open” einen negativen Rückgabewert (-1), und das Programm bricht daraufhin ab, kann das darauf hindeuten, dass die im Aufruf angegeben Datei nicht gefunden werden konnte.

Hier ein Strace von “mkdir testing”:

gehaxelt@LagTop [09:50:09] [~/temp] [master *]
-> % strace mkdir testing
execve("/usr/bin/mkdir", ["mkdir", "testing"], [/* 51 vars */]) = 0
brk(0)                                  = 0x1e68000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=195863, ...}) = 0
mmap(NULL, 195863, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f7311aa6000
close(3)                                = 0
open("/usr/lib/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0 \33\2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2035539, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f7311aa5000
mmap(NULL, 3853456, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7f7311508000
mprotect(0x7f73116ac000, 2093056, PROT_NONE) = 0
mmap(0x7f73118ab000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1a3000) = 0x7f73118ab000
mmap(0x7f73118b1000, 15504, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7f73118b1000
close(3)                                = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f7311aa4000
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f7311aa3000
arch_prctl(ARCH_SET_FS, 0x7f7311aa4700) = 0
mprotect(0x7f73118ab000, 16384, PROT_READ) = 0
mprotect(0x60b000, 4096, PROT_READ)     = 0
mprotect(0x7f7311ad6000, 4096, PROT_READ) = 0
munmap(0x7f7311aa6000, 195863)          = 0
brk(0)                                  = 0x1e68000
brk(0x1e89000)                          = 0x1e89000
open("/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=2098672, ...}) = 0
mmap(NULL, 2098672, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7f7311307000
close(3)                                = 0
mkdir("testing", 0777)                  = 0
close(1)                                = 0
close(2)                                = 0
exit_group(0)                           = ?
+++ exited with 0 +++

Man kann sich auch eine kurze Statistik zu den ausgeführten Systemaufrufen anzeigen lassen. Dazu ruft man strace mit der Option “-c” auf.

gehaxelt@LagTop [09:58:04] [~/temp] [master *]
-> % strace -c mkdir testing
mkdir: das Verzeichnis „testing“ kann nicht angelegt werden: Die Datei existiert bereits
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
  -nan    0.000000           0        18           read
  -nan    0.000000           0         4           write
  -nan    0.000000           0        18        11 open
  -nan    0.000000           0         9           close
  -nan    0.000000           0         7           fstat
  -nan    0.000000           0        12           mmap
  -nan    0.000000           0         4           mprotect
  -nan    0.000000           0         3           munmap
  -nan    0.000000           0         4           brk
  -nan    0.000000           0         1         1 access
  -nan    0.000000           0         1           execve
  -nan    0.000000           0         1         1 mkdir
  -nan    0.000000           0         1           arch_prctl
------ ----------- ----------- --------- --------- ----------------
100.00    0.000000                    83        13 total

ltrace

Im Gegensatz zu strace protokolliert ltrace nur die Aufrufe von externen Bibliotheken (librarys).

Beispiel mit rm -r testing:

gehaxelt@LagTop [10:04:36] [~/temp] [master *]
-> % ltrace rm -r testing
__libc_start_main(0x401c10, 3, 0x7fff4010fa18, 0x409b70 
strrchr("rm", '/')                                                                                = nil
setlocale(LC_ALL, "")                                                                             = "LC_CTYPE=de_DE.UTF-8;LC_NUMERIC="...
bindtextdomain("coreutils", "/usr/share/locale")                                                  = "/usr/share/locale"
textdomain("coreutils")                                                                           = "coreutils"
__cxa_atexit(0x4035f0, 0, 0, 0x736c6974756572)                                                    = 0
isatty(0)                                                                                         = 1
getopt_long(3, 0x7fff4010fa18, "dfirvIR", 0x40a6a0, nil)                                          = 114
getopt_long(3, 0x7fff4010fa18, "dfirvIR", 0x40a6a0, nil)                                          = -1
__lxstat(1, "/", 0x7fff4010f7a0)                                                                  = 0
malloc(128)                                                                                       = 0xa74110
strlen("testing")                                                                                 = 7
realloc(0, 4352)                                                                                  = 0xa741a0
malloc(272)                                                                                       = 0xa752b0
memcpy(0xa753b8, "", 0)                                                                           = 0xa753b8
strlen("testing")                                                                                 = 7
malloc(279)                                                                                       = 0xa753d0
memcpy(0xa754d8, "testing", 7)                                                                    = 0xa754d8
__fxstatat(1, 0xffffff9c, 0xa754d8, 0xa75448)                                                     = 0
malloc(272)                                                                                       = 0xa754f0
memcpy(0xa755f8, "", 0)                                                                           = 0xa755f8
malloc(32)                                                                                        = 0xa75610
free(0xa754f0)                                                                                    = 
free(0xa75610)                                                                                    = 
memmove(0xa741a0, "testing\0", 8)                                                                 = 0xa741a0
strrchr("testing", '/')                                                                           = nil
malloc(32)                                                                                        = 0xa75610
openat(0xffffff9c, 0xa741a0, 0x30900, 0x7fff4010f860)                                             = 3
fdopendir(3, 0xa741a0, 0x30900, -1)                                                               = 0xa75640
__errno_location()                                                                                = 0x7f74035886a8
readdir(0xa75640)                                                                                 = 0xa75668
readdir(0xa75640)                                                                                 = 0xa75680
readdir(0xa75640)                                                                                 = 0
closedir(0xa75640)                                                                                = 0
geteuid()                                                                                         = 1000
__fxstatat(1, 0xffffff9c, 0xa741a0, 0x7fff4010f700)                                               = 0
faccessat(0xffffff9c, 0xa741a0, 2, 512)                                                           = 0
unlinkat(0xffffff9c, 0xa741a0, 512, 1)                                                            = 0
free(0xa753d0)                                                                                    = 
free(0xa752b0)                                                                                    = 
__errno_location()                                                                                = 0x7f74035886a8
__errno_location()                                                                                = 0x7f74035886a8
free(0)                                                                                           = 
free(0xa741a0)                                                                                    = 
free(0xa75610)                                                                                    = 
free(0xa74110)                                                                                    = 
exit(0 
__fpending(0x7f7403394240, 0, 0, 4)                                                               = 0
fileno(0x7f7403394240)                                                                            = 0
__freading(0x7f7403394240, 0, 0, 4)                                                               = 1
fileno(0x7f7403394240)                                                                            = 0
lseek(0, 0, 1)                                                                                    = -1
fclose(0x7f7403394240)                                                                            = 0
__fpending(0x7f7403394160, 0, 0x7f7403395800, 0xfbad000c)                                         = 0
fileno(0x7f7403394160)                                                                            = 1
__freading(0x7f7403394160, 0, 0x7f7403395800, 0xfbad000c)                                         = 0
__freading(0x7f7403394160, 0, 4, 0xfbad000c)                                                      = 0
fflush(0x7f7403394160)                                                                            = 0
fclose(0x7f7403394160)                                                                            = 0
__fpending(0x7f7403394080, 0, 0x7f7403395800, 0xfbad000c)                                         = 0
fileno(0x7f7403394080)                                                                            = 2
__freading(0x7f7403394080, 0, 0x7f7403395800, 0xfbad000c)                                         = 0
__freading(0x7f7403394080, 0, 4, 0xfbad000c)                                                      = 0
fflush(0x7f7403394080)                                                                            = 0
fclose(0x7f7403394080)                                                                            = 0
+++ exited (status 0) +++

In der Ausgabe sieht man die Librarycalls und deren Rückgabewerte. Das kann ebenfalls für Debugging-/Analysezwecke hilfreich sein.

Nützlich kann auch die Fähigkeit, an laufende Prozesse anzudocken, sein. Dazu muss man die Option “-p” gefolgt von einer ProzessID aufrufen:

ltrace -p $(pgrep vlc)

Mit “pgrep” kann man sich die ProzessID eines Prozesses mit dem als Parameter übergebenen Namen zurückgeben lassen.

Ldd

Auf den Hinweis von @robertmarquardt möchte ich den Artikel um das Programm “ldd” erweitern.

Mit dem Programm kann man sich die die Abhängigkeit eines Programms von externen Bibliotheken anzeigen.

Beispiel:

gehaxelt@LagTop [10:32:11] [~] 
-> % ldd /usr/bin/ls
  linux-vdso.so.1 (0x00007fffc4bff000)
  librt.so.1 => /usr/lib/librt.so.1 (0x00007f237c63b000)
  libcap.so.2 => /usr/lib/libcap.so.2 (0x00007f237c437000)
  libacl.so.1 => /usr/lib/libacl.so.1 (0x00007f237c22e000)
  libc.so.6 => /usr/lib/libc.so.6 (0x00007f237be81000)
  libpthread.so.0 => /usr/lib/libpthread.so.0 (0x00007f237bc65000)
  libattr.so.1 => /usr/lib/libattr.so.1 (0x00007f237ba60000)
  /lib/ld-linux-x86-64.so.2 (0x00007f237c843000)

Falls eine benötigte Bibliothek fehlt, dann kann man diese so ausfindig machen.

Danke hier nochmal für den Hinweis.

Fazit

Falls mal ein Programm nicht so will, wie es soll, bieten strace & ltrace erste Anlaufstellen, um nach der Ursache des Problems zu suchen.

Gruß

gehaxelt

]]>

2013-02-06T22:51:00+01:00

Da mein Vserver eigentlich nur am idlen war, habe ich mal boinc darauf installiert und lasse ihn jetzt an Malariacontrol mitrechnen.

Wie man BIONC auf einem Server installiert, könnt ihr nun erfahren.

Die Installation von Boinc

Zunächst müsst ihr boinc installieren. Das klappt meistens über den Paketmanager:

sudo apt-get install boinc

Danach legen wir in unserem Homeverzeichnis einen Ordner für Boinc ein:

mkdir ~/boinc

Wir starten dann BOINC als Daemon im Hintergrund:

boinc --daemon --dir ~/boinc

Nutzung

Wir können nun über boinccmd mit dem Daemon kommunizieren und Kommandos erteilen. Dazu brauchen wir jedoch ein Passwort, welches wir in der Datei gui_rpc_auth.cfg finden:

cat ~/boinc/gui_rpc_auth.cfg

Die Basis des Befehls sieht dann so aus:

boinccmd --host localhost --passwd $(< ~/boinc/gui_rpc_auth.cfg) [COMMAND]

Wir lesen das Passwort einfach aus der Datei aus und nutzen es zum Login.

Möchten wir uns nun bei einem Projekt anmelden, dann benötigen wir die Projekturl des Projekts. In meinem Beispiel ist das http://www.malariacontrol.net/. Dann können wir einen Account erstellen:

boinccmd --host localhost --passwd $(< ~/boinc/gui_rpc_auth.cfg) --create_account http://www.malariacontrol.net/ [email protected] mypasswd myusername

Wobei ihr die drei letzten Parameter entsprechend bearbeiten müsst. Ihr bekommt daraufhin einen AcccessKey zum Projekt. Diesen solltet ihr zumindest bis zum nächsten Befehl behalten.

Wir melden uns beim Projekt an:

boinccmd --host localhost --passwd $(< ~/boinc/gui_rpc_auth.cfg) --project_attach http://www.malariacontrol.net/ ACCESSKEY

Nun können wir endlich Gas geben:

boinccmd --host localhost --passwd $(< ~/boinc/gui_rpc_auth.cfg) --project http://www.malariacontrol.net/ resume

Daraufhin sollte der Server die entsprechenden Dateien herunterladen und anfangen diese zu berechnen. Das sieht man auch schön, wenn man htop bzw. top ausführt.

Wenn ihr beobachten wollt, wie der Server rechnet, dann könnt ihr euch die Tasks ausgeben lassen. Ein less ist dazu recht nützlich:

boinccmd --host localhost --passwd $(< ~/boinc/gui_rpc_auth.cfg) --get_tasks | less

Ihr könnt aber auch direkt den Projektstatus abrufen (Hier kann es etwas dauern, bis Informationen erscheinen):

boinccmd --host localhost --passwd $(< ~/boinc/gui_rpc_auth.cfg) --get_project_status

Möchtet ihr euch anzeigen lassen, wie viele WorkUnits der Server insgesamt fertig abgeschlossen hat, dann nutzt diesen Einzeiler:

boinccmd --host localhost --passwd $(< ~/boinc/gui_rpc_auth.cfg) --get_tasks | grep 'final CPU time:'| grep -v '0.00' | wc -l

Weitere Informationen bzw. Bedienungsmöglichkeiten könnt ihr per help herausfinden:

boinccmd --help
boinc --help

Performance meines VServers

Ich habe einen Vserver Light der 2. Klasse bei Netcup.de, und mir wurde folgende Leistung zugesichert:

2GhZ CPU Leistung
1-2Gig RAM
80 GB HDD
unlimited Traffic

Für einen Preis von 5€ (ohne MwST) im Monat finde ist das recht akzeptabel.

Es laufen dort 5 BOINC-Prozesse und die WUs werden im Schnitt zwischen 5.000 und 9.000 CPU-Sekunden berechnet.

   final CPU time: 7814.488000
   final CPU time: 4777.643000
   final CPU time: 5211.726000
   final CPU time: 2257.945000
   final CPU time: 5392.225000
   final CPU time: 4949.873000
   final CPU time: 1592.095000
   final CPU time: 9263.575000
   final CPU time: 2414.539000
   final CPU time: 6221.625000
   final CPU time: 5475.894000
   final CPU time: 5753.368000
   final CPU time: 4568.025000
   final CPU time: 2859.147000
   final CPU time: 5751.723000
   final CPU time: 4887.621000
   final CPU time: 3243.495000
   final CPU time: 5252.564000
   final CPU time: 5301.635000

Umgerechnet sollte jeder BOINC-Prozess in 3 Stunden eine WU fertig rechnen. Das sind dann 8 Stück pro Tag. Multipliziert mit den 5 Prozessen wären wir dann bei 40 WU die mein Vserver täglich dem Projekt beisteuert.

Ich finde es besser ein Projekt zu unterstützen, als den Server einfach idlen zu lassen :)

Gruß

gehaxelt

]]>

2013-02-06T01:45:00+01:00

Ich habe vor ein paar Monaten meine Fahrprüfung erfolgreich bestanden, und war zuvor auf der Suche nach Tipps und Tricks und deswegen möchte ich für die Leser, welche den Lappen noch nicht haben, mal ein wenig Offtopic gehen :)

Ich möchte nur ein paar Tipps bzw. Tricks geben bzw. Behauptungen widerlegen was die praktische Fahrprüfung angeht.

1. Der Prüfer lässt dich mit Absicht durchfallen

Diesen Kommentar liest man im Internet sehr häufig. Ich kann das für meinen Fall jedoch nicht bestätigen. Mein Prüfer war ein älterer Herr und für die erste Prüfung am Morgen sehr gut gelaunt. Er war sehr nett und “hilfsbereit”, denn auf meine Naivität in eine enge Parklücke einzuparken schlug er mir eine größere vor. Wer dieses (deutliche) Zeichen nicht erkennt, ist dann selber schuld. Ein weiteres Mal bat er mich “doch die Spiegel der parkenden Autos dran zu lassen”; demnach etwas weiter links zu fahren. Den Prüfern geht es hauptsächlich darum zu schauen, ob man sich im Straßenverkehr korrekt verhalten kann. Kleine Fehler können jedem vorkommen und führen nicht gleich zum Durchfall (Wortspiel ^^).

2. Ich bin total aufgeregt und mache Fehler

Falls man an der sog. Prüfungsangst leidet, dann sollte man was dagegen unternehmen. Ansonsten ist es auch nicht schlimm, etwas aufgeregt zu sein. Ich war es selbst, bis ich ins Auto eingestiegen bin. Die Fahrt war schnell zu Ende und es fühlte sich ganz normal, wie eine Fahrstunde, an nur dass sich zwei Herren nebenbei unterhielten und der Prüfer die Anweisungen gab. Wenn man auf den Prüfer vor der Prüfstelle wartet, dann ggf. aussteigen und nochmal tief ein- und ausatmen. Das hilft.

3. Ich fahre dort lang, wo mein Prüfer das möchte

Natürlich sollt ihr nicht anfangen, einfach irgendwo langzufahren, doch ein paar Kleinigkeiten kann man selbst entscheiden. Fährt man z.B. auf eine Kreuzung zu, oder hat sich bereits falsch eingeordnet, dann sollte man keine Manöver machen, sondern das dem Prüfer ganz normal sagen, dass man leider nicht mehr in die gewünschte Richtung weiterfahren kann. Eine Ausrede zum nur noch links abbiegen, um keinen Schulterblick mehr machen zu müssen, ist das allerdings nicht. Weist euch der Prüfer an in eine Straße einzubiegen und ihr seht das es nicht erlaubt ist, da entsprechende Schilder aufgestellt wurden, dann solltet ihr dem Prüfer deutlich machen dass ihr diese Situation korrekt erkannt habt, und eine neue Anweisung einfordern.

4. Ich bin doch nicht zu schnell gefahren

Der Prüfer hat normalerweise den Blick auf euren Tacho und kann erkennen bzw. abschätzen, wie schnell ihr fahrt. Es sollte klar sein, dass man die Geschwindigkeitsbegrenzungen nicht überschreiten darf. Ich bin deshalb in meiner Prüfung immer ungefähr 2-5 Km/h bewusst langsamer gefahren, als es erlaubt war. Das kann zwar einige Fahrer hinter euch verärgern, aber ihr habt das gute Recht dazu und diese müssen auch Rücksicht auf euch nehmen. Keinesfalls sollte wegen den Dränglern die Geschwindigkeitsbegrenzung überschritten werden.

5. Ich stehe beim ersten Einparkversuch nicht korrekt

Wenn ihr es beim ersten Mal nicht passend in die Lücke packt, dann könnt ihr natürlich nachbessern. Bei niemanden muss es sofort beim ersten Versuch klappen. Allerdings sollte man keine 5 Minuten brauchen, bis das Auto endlich eingeparkt ist.

6. In unklaren Situationen lieber bremsen

In der Theorie wird einem beigebracht, dass man in unklaren Situationen bremsen bzw. anhalten und sich ggf. mit anderen Verkehrsteilnehmern verständigen soll. Das das in der Praxis kaum möglich bzw. utopisch ist, sollte fast klar sein. Trotzdem solltet ihr in unklaren Situationen (Habe ich vorfahrt?) nicht einfach weiterfahren, sondern ggf. leicht abbremsen, um mehr Zeit zu haben die Situation zu erkennen und zu meistern. Keinesfalls sollte das an jeder kleinen Kreuzung der Fall werden.

7. Die Prüfung ist zu Ende, wenn 45 Minuten vorbei sind.

Aus einigen Ecken habe ich gehört, dass die Prüfung zu Ende sei, wenn die Prüfungsdauer (meist 30 bis 45 Minuten) zu Ende ist. Das heißt, man bräuchte nur langsam anfahren, etc um Zeit zu schinden. Wenn man das schon machen möchte, dann sollte es dem Prüfer nicht auffallen, denn sonst zählt das als Erschleichung der Prüfung und das bewirkt das Gegenteil. Ich hatte meinen Prüfer zu diesem Thema gefragt und er antwortete mir, dass die Prüfung zu Ende sei, wenn man bei der Prüfungsstelle wieder angekommen ist. Damit wäre Zeitschindung eher ein Nachteil als Vorteil. Die Prüfung fühlt sich sowieso relativ kurz an, denn es ist nur halb zu lang, wie eine normale 80-90 minütige Fahrstunde.

8. Die Theoriefrage am Ende ist schwer

Am Ende jeder Fahrprüfung stellt der Prüfer noch eine Frage zur Technik bzw. dem technischen Umgang mit dem Auto. Hierfür empfehle ich die Wiederholung der Abstände im Straßenverkehr, sowie die Mechanik “unter der Haube”, und alles, was so mit dem Auto zu tun haben könnte. Die Beantwortung der Frage ist Teil der Prüfung, und sollte nach Möglichkeit korrekt sein.

Zusammenfassung

Hier mal noch eine kurze Zusammenfassung: Seid einfach entspannt, nicht aufgeregt und fahrt so, als würdet ihr “alleine” fahren und eine Stimme aus dem Off gibt die Anweisungen. Zeigt dem Prüfer, dass ihr im Straßenverkehr zurecht kommt. Bei allem was ihr macht solltet ihr sicher wirken, was die Vorsicht natürlich nicht ausschließt.

Vielleicht helfen dem einen oder anderen diese Tipps und allen anderen sorry für Offtopic :)

Gruß

gehaxelt

]]>

2013-02-06T00:52:00+01:00

In diesem Blogpost möchte ich die verschiedenen Arten der Rekursion vorstellen.

Man kann in der Programmierung Rekursion verwenden um Schleifen zu “simulieren”, was z.B. in funktionalen Programmiersprachen von Vorteil ist, da es dort keine Variablen und somit keine Schleifen gibt.

Unterteilung

Man unterteilt in die direkte bzw. indirekte Rekursion. Bei der direkten Rekursion ruft sich eine Funktion wieder selbst auf. Bei der indirekten Rekursion ruft die Funktion eine andere Funktion auf, welche wiederum die aufrufende Funktion aufruft.

Zitat:

Um die Rekursion zu verstehen, muss man zunächst die Rekursion verstehen

Direkte Rekursion

Bei der direkten Rekursion unterscheidet man vier verschiedene Arten:

Repetitive Rekursion

Bei der repetitiven Rekursion ruft sich die Funktion mit einem veränderten Parameter auf:

$\begin{align*} f(x) &= f(x-1) \end{align*}$

Beispiel:

def func(x,y):
  if x == 0:
      return y
  y=y+x
  return func(x-1,y)

Lineare Rekursion

Bei der linearen Rekursion wird der übergebene Parameter mit dem Rekursionsergebnis verrechnet:

$\begin{align*} f(x) &= x*f(x-1) \end{align*}$

Beispiel:

def func(x):
  if x == 0:
      return 1
  return x*func(x-1)

Baumartige Rekursion

Die baumartige Rekursion kommt zum Einsatz, wenn man das Ergebnis aus zwei verschiedenen Rekursionsaufrufen berechnet.

$\begin{align*} f(x) &= f(x-1) + f(x-2) \end{align*}$

Beispiel:

def func(x):
  if x == 1:
      return 0 
  return func(x-1) + func(x-2)

Geschachtelte Rekursion

Bei der geschachtelten Rekursion ist das Ergebnis des Rekursionsaufrufes Parameter eines Rekursionsaufrufes.

$\begin{align*} f(x) &= f(x - f(x-1)) \end{align*}$

Beispiel:

def func(x):
  if x == 1:
      return 0
  return func(x - func(x-1))

Verschränkte Rekursion

Bei der verschränkten Rekursion rufen sich zwei Funktionen gegenseitig auf.

$\begin{align*} f(x) &= g(x-1)\\ g(x) &= f(x-2) \end{align*}$

Beispiel:

def func(x):
  if x== 0:
      return 1
  return g(x-1)

def g(x):
  if x== 1:
      return 0
  return f(x-1)

Fazit

Ihr habt nun eine kleine Übersicht über die verschiedenen Rekursionsarten.

Gruß

gehaxelt

]]>

2013-02-05T23:51:00+01:00

Ich möchte mal über meine Probleme mit Google berichten, denn Google scheint meinen Blog nicht mehr zu mögen. Zumindest listet der Suchmaschinenanbieter nur noch Teile meines Blogs.

Wer mir auf Twitter folgt und fleißig meine Tweets liest wird gemerkt haben, dass ich mich ein wenig über Google beschwert habe. Das Problem liegt nämlich darin dass Google bei der Indexierung meiner hust tollen Blogposts antiproportional vorgeht. Umso mehr ich schreibe, umso weniger Seiten des Blogs werden bei Google in der Suche gelistet.

Ein Überblick

Übersicht über meine Sitemap in den Webmastertools:

Übersicht über den aktuellen Indexierungsstatus:

Von einem Tag auf den anderen waren dann Artikel, welche über mehrere Tage gelistet wurden, einfach nicht mehr auffindbar. Beispiel “Google cache nutzen gehaxelt” oder “Logik Tison Methode gehaxelt” führen zu keinen Ergebnissen mehr.

Nachdem ihr nun einen Überblick über mein Problem habt, kann ich mit der Schilderung fortfahren.

Mein Anti-SEO

Ich muss zugeben, dass ich meinen Blog eine Zeit lang nicht wirklich SEO konform betrieben habe, doch da waren noch einige Artikel auffindbar.

Ich möchte mal kurz meine damalige Blogkonstellation vorstellen:

Unter der Domain gehaxelt.in wurde folgende .htaccess angewendet:

RewriteEngine On
RewriteBase /
RewriteCond %{HTTP_HOST} ^gehaxelt\.in$ [NC]
RewriteRule ^(.*)$ http://www.gehaxelt.in/$1 [R=301,L]

Das sollte sicherstellen, dass ggf. verlinkte Inhalte von gehaxelt.in/blog auf die richtige Domain www.gehaxelt.in/blog weitergeleitet werden. Das sollte auch mit einem 301-Redirect passieren, was laut Google empfohlen wird.

Unter der www.gehaxelt.in Domain nutzte ich noch folgende .htaccess, um ggf. bei Fehlern auf meinen Blog zu verweisen:

ErrorDocument 400 http://www.gehaxelt.in/blog/
ErrorDocument 401 http://www.gehaxelt.in/blog/
ErrorDocument 403 http://www.gehaxelt.in/blog/
ErrorDocument 404 http://www.gehaxelt.in/blog/
ErrorDocument 500 http://www.gehaxelt.in/blog/

Wie ich erst letztens festgestellt habe, ist das aus SEO-Sicht nicht sehr gut, da der Webserver dann eine 302-Weiterleitung gefolgt von einem 200-Status draus macht. Die Suchmaschine glaubt dann demnach, dass die Seite existiert.

Ähnlich war es mit www.gehaxelt.in, denn wenn man auf die Root-Ebene der Domain zugreifen wollte, dann löste das einen 404 aus, welcher dann per ErrorDocument auf den Blog weiterleitete. Genauso wie oben per 302 + 200.

Eine robots.txt und die Sitemap.xml waren korrekt erstellt und genutzt. Bis dahin funktionierte alles ein wenig, zumindest hatte ich den Artikelschwund nicht bemerkt.

Meine Versuche es zu retten

Nunja, nachdem ich feststellen musste, dass das nicht wirklich optimal ist, und Google nur Bruchteile meines Bloges indexiert, galt es etwas zu ändern.

Zunächst habe ich nach der Anleitung vom Computer Heimwerker die Fehlerdokumente korrekt angelegt.

Des Weiteren habe ich den Regex unter gehaxelt.in etwas präsizer formuliert, sodass nur noch gehaxelt.in/blog/-Artikel wirklich per 301 Weitergeleitet werden. Sollte man nun einfach auf gehaxelt.in/ gehen, dann wird man per 301 auf www.gehaxelt.in/blog/ weitergeleitet. Das löse ich unter anderem mit der folgenden PHP-Datei, welche ebenfalls im Documentroot der www.gehaxelt.in Domain liegt.

.htaccess:

RewriteEngine On
RewriteBase /
RewriteCond %{HTTP_HOST} ^gehaxelt\.in$ [NC]
RewriteRule blog/(.*)$ http://www.gehaxelt.in/blog/$1 [R=301,L]
RewriteRule misc/(.*)$ http://www.gehaxelt.in/misc/$1 [R=301,L]

index.php für 301 Redirect:

header("HTTP/1.1 301 Moved Permanently");
header("Location:http://www.gehaxelt.in/blog/index.html");
exit;
?>

Nachdem nun alle Weiterleitungen soweit korrigiert waren, viel mir auf, dass in der Octopress-Konfiguration noch eine Baustellen vorhanden waren. So war die Root-URL auf http://gehaxelt.in/ gelegt, und nicht auf www.gehaxelt.in. Zudem haben die Links im canoncial-Metatag nicht wirklich gestimmt, denn dort schlich sich immer ein “/” zu viel ein.

Die Umstellung der URLs sollte auch der Grund gewesen sein, weswegen beim Phasenkasper.de mal wieder alle meine RSS Einträge in seinem Reader landeten. Falls ihr mich wegen diesen Ungeschicktheiten (welche ich leider nicht hätte besser lösen können?) nicht mehr abonniert, so habe ich es mir selbst verschuldet ;)

Nach ein wenig Recherche und dem Hinweis aus Richtung des TacticalCode Blogs legte ich bei den Google Webmastertools noch die präferierte Domain auf www.gehaxelt.in und reichte die Sitemap erneut ein.

Der Wiederaufbau fing versprechend an, denn Google sagte mir am nächsten Tag, es habe 76 Seiten bereits wieder indexiert. Nach weiteren 2 Tagen wollte es mich aber enttäuschen, indem es wieder 5 Seiten aus dem Index nahm, sodass zur Zeit nur noch 71 der 245 Seiten meines Blogs auffindbar sind.

Hoffnung stirbt zuletzt, doch Ausschluss ist doof

Ich werde die Indexierung die nächsten Tage/Woche/Monate weiter beochbachten, denn was anderes bleibt mir meiner Meinung nicht übrig. Ich finde es doch ein wenig schade, denn ich möchte gerne mein hust Halbwissen bzw. meine Problemlösungen mit Euch und dem Internet teilen. Zumindest kamen täglich moderate 20 bis 30 (neue) Leser über Google & Co auf meinen Blog.

Falls ihr also noch Tipps habt bzw. euch auffällt, was ich (noch) falsch mache bzw. besser machen könnte, dann freue ich mich auf euer Feedback.

Gruß

gehaxelt

]]>

2013-02-03T00:33:00+01:00

In diesem Blogpost soll es um VHDL und dessen Simulation auf Linuxrechnern gehen.

VHDL steht für Very High Speed Integrated Circuit Hardware Description Language und dient zur Schaltungssynthese, z.B. für Prozessoren.

Was genau ist VHDL?

Wie schon gesagt, ist VHDL eine Art Programmiersprache für Logikschaltungen. Es wurde vor einiger Ewigkeit entwickelt und laut meinem Prof nutzen es die großen Firmen, wie Intel oder AMD, um ihre Prozessoren zu designen bzw. zu optimieren.

Denn wie schon im letzten Blogpost über die Tison Methode vorgestellt, kann man vieles einfacher machen, wenn man an bestimmten Stellen optimiert. Das können die Designwerkzeuge für einen übernehmen.

Wie programmiert man darin?

Bisher wurden uns zwei Grundlegende Dinge beigebracht, nämlich das es Entitäten und Architekturen gibt. Die Entitäten beschreiben die Ein- bzw. Ausgänge des Moduls und in der Architecture ist der eigentliche Verhaltenscode abgelegt.

Dazu mal ein Beispiel:

entity andor is
  port( x,y: in bit;
      z: out bit);
end entity andor;

architecture behave of andor is
  signal w : bit;
  begin
      w <= (x or y);
      z <= (x and y) or w;
end architecture behave;

Zunächst sagen wir in der Entität, dass es zwei Eingänge und einen Ausgang geben soll.

In der Architecture nehmen wir uns zunächst ein Zusatzbit w, welches die Disjunktion von x und y speichern soll. Auf den Ausgang z legen wir dann die Verundung bzw. Verorderung der Werte.

Schaltnetz & Wertetabelle

Das Schaltnetz dazu sieht so aus:

Falls jemand ein nettes Tool kennt, mit dem man schöne Schaltnetze erstellen kann, dann werde ich hier eins nachreichen.

x|y|z
-----
0|0|0
0|1|1
1|0|1
1|1|1

Wie man es aus der Wertetabelle erkennt, macht unsere Funktion nichts weiter als ein einfaches “or” nur etwas umständlicher, aber das ist auch erstmal egal.

Testbench

Wenn wir die Schaltung simulieren wollen, dann müssen wir uns eine Testbench schreiben, also unsere Komponente als Blackbox betrachten und die Ein- bzw. Ausgabe protokollieren.

Eine Testbench könnte so aussehen:

entity testbench is
end entity testbench;

architecture behave of testbench is
  signal testx, testy, testz: bit;
  
  component andor is
      port( x,y: in bit;
          z: out bit);
  end component andor;
  
  begin 
      gate1: andor
          port map(x => testx, y => testy, z => testz);
          
  testx <= '0', '1' after 100 ns, '0' after 200 ns, '1' after 300 ns;
  testy <= '0', '1' after 200 ns;
  
end architecture behave;

Schaltung simulieren

Ich komme nun zum eigentlichen Inhalt des Blogposts, nämlich dem Simulieren der Schaltung mit ghdl und gtkwave.

Diese beiden Tools müssen wir zunächst installieren:

sudo apt-get install ghdl gktwave

Nachdem die Installation fertig ist, können wir den oben geschriebenen Code in eine Datei “projekt.vhdl” schreiben und abspeichern.

Danach führen wir folgende Kommandos hintereinander aus:

ghdl -a projekt.vhdl

Das analysiert den Code, und zeigt ggf. Syntaxfehler auf.

ghdl -e testbench

Wir geben die Entität an, welche erstellt werden soll.

ghdl -r testbench

Das führt eine Simulation der Schaltung aus.

Jetzt möchten wir noch den VCD Code aus der erstellten Datei “testbench” auspacken.

./testbench --vcd=testbench.vcd

Diesen Dump können wir uns dann mittels gtkwave anzeigen lassen.

gtkwave testbench.vcd

Nachdem man dort die Variablen “importiert” hat, und ein wenig rangezoomt (Time->Zoom->Zoom to best fit)hat, dann kann man die Verläufe sehr gut nachvollziehen.

Fazit

Man braucht also nicht unbedingt übertrieben teuere Software um VHDL-Code bzw. entsprechend entworfene Schaltungen zu Simulieren. Das alles geht auch mit mehreren open source Tools.

Gruß

gehaxelt

]]>

2013-02-01T22:53:00+01:00

Octopress fügt im Description-Metatag standardmäßig einen Auszug des (ersten) Artikels ein.

Das kann für die Startseite bzw. Homepage natürlich etwas störend sein.

Möchte man auf der Startseite eine feste Description platzieren, dann kann man der folgenden Anleitung folgen.

Für die Änderungen brauchen wir keine großen Programme bzw. Tools außer die Standard-Linux-Kommandos.

Zweite Headerdatei anlegen

Wir gehen in unserem Octopressordner in die Vorgaben unter _includes.

cd octopress/_includes/

Dann erstellen wir eine Kopie der head.html und nennen diese indexhead.html.

cp head.html indexhead.html

In dieser Datei entfernen wir den Code, welcher im Description-Metatag vorhanden ist, und ersetzen diesen durch unseren statischen.

Damit hätten wir das Schwierigste schon getan.

Zweite Layoutdatei anlegen

Nachdem wir die neue Headerdatei angelegt haben können wir eine zweite Layoutdatei anlegen, in welcher wir auf die entsprechende Headerdatei verweisen.

Dazu wechseln wir in den Layoutordner:

cd octopress/_layouts

Dann kopieren wir wie zuvor die default.html und bennen diese index.html.

cp default.html index.html

Diese müssen wir ein wenig bearbeiten in dem wir

% include head.html %

 % include indexhead.html %

ändern.

Index.html anpassen

Zuletzt müssen wir noch die index.html im Source-Ordner anpassen in dem wir ganz oben das Layout auf index setzen.

---
layout: index
---

Fazit

Mit diesen Schritten kann man das Description-Meta-Tag der Startseite getrennt zu den Unterseiten setzen.

Das ist vielleicht für einige SEO-Aspekte interessant.

Gruß

gehaxelt

]]>

2013-01-31T21:55:00+01:00

Interessiert ihr euch für freie Software und möchtet dazu ganz kostenlos ein Buch erhalten? Dann folgt der kurzen Anleitung ohne Nebenwirkungen.

Heute wurde ich in der Uni auf das Buch “Freie Software - zwischen Privat- und Gemeineigentum” hingewiesen, welches man sich kostenfrei und ohne Versandkosten bestellen kann.

Ich habe mir eben mein Exemplar bestellt, und werde ggf. berichten, wenn ich in ferne Zukunft das Buch gelesen habe.

Hier ist der Link zur kostenfreien Bestellung: http://www.bpb.de/shop/buecher/schriftenreihe/36110/freie-software-zwischen-privat-und-gemeineigentum

Viel Spaß beim Lesen

Gruß

gehaxelt

]]>

2013-01-31T20:58:00+01:00

Ein kurzer Blogpost darüber, wie man Javascript “obfuscaten” kann. Man kann clientseitig ausgeführte Sprachen eigentlich kaum unveränderbar machen, da diese eben beim Client ablaufen, und dieser diese bearbeiten kann.

Trotzdem gibt es einige Möglichkeiten den Eingriff zu erschweren.

Heutzutage basieren viele Webanwendungen auf Javascript bzw. Ajax, welche clientseitig ablaufen und wo Manipulationspotential seitens des Benutzers besteht.

Da man als Programmierer die Manipulation bestmöglich verhindern möchte, aber dies eben nicht möglich ist, kann man einige Tricks nutzen, um Javascript zu “obfuscaten”, also unleserlich zu machen. Serverseitige Checks der Eingaben sind natürlich ein muss.

Code Beispiel

Nehmen wir mal folgendes Code-Beispiel, welches wir der Reihe nach obfuscaten bzw. unleserlich machen wollen:

function doSomeThing() {
  alert("Hallo " + someName());
}

function someName() {
  var str = "Mega";
  return str + "Hacker";
}

doSomeThing();

Das Script macht eigentlich nicht viel, denn es gibt eine Alert-Box mit dem String “Hall MegaHacker” aus. Also nichts komplexes ;)

JS Minifier/Compressor

Zunächst können wir den Code durch einen “Minifier” jagen, sodass unnötige Zeichen entfernt werden und der Code kompakter wird. Dies wird normalerweise dazu genutzt, um die Ladezeiten von Webseiten zu optimieren.

Bei größeren bzw. umfangreicheren Scripten werden Variablen gekürzt und zusammengefasst, etc.

In unserem Beispiel liefert YUI-Compressor folgenden Output:

function doSomeThing(){alert("Hallo "+someName())}function someName(){var a="Mega";return a+"Hacker"}doSomeThing();

Da alles hintereinander in eine Zeile gepackt wird, ist die Leserlichkeit schon etwas geringer, da zu dem die Variablennamen gekürzt werden.

Unter Javascriptcompressor.com kann man noch einen Schritt weiter gehen, und die Variablennamen verkürzen, sowie base62 encoden, sodass folgender Output entsteht:

eval(function(p,a,c,k,e,r){e=String;if(!''.replace(/^/,String)){while(c--)r[c]=k[c]||c;k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}('0 1(){4("5 "+2())}0 2(){6 3="7";8 3+"9"}1();',10,10,'function|doSomeThing|someName|a|alert|Hallo|var|Mega|return|Hacker'.split('|'),0,{}))

Wer jetzt auf den ersten Blick noch erkennt, was diese Funktion macht: Hut ab :)

Wir können aber noch einen Schritt weiter gehen, und den neu generierten Code durch JS-Fuck schicken.

JS-Fuck übersetzt die lesbaren Zeichen in Kombinationen aus [,],(,),!,+ ,sodass man das Script kaum mehr entziffern kann. Jedoch steigt damit auch die Länge bzw. Größe des Scriptes sehr stark an. Darunter kann die Performance leiden.

Für das Beispiel, welches mit YUI minimiert wurde, liefert JS Fuck folgendes:

Hier gehts zur Lösung:

Für das Beispiel, welches mit JS Compressor verkleinert wurde, liefert JS Fuck folgendes:

Hier gehts zur Lösung

Wie schon gesagt nimmt die Länge der Scripte nach der Bearbeitung mit JS Fuck stark zu. So werden aus Beispiel 1 mit 116 Byte plötzlich 503259 Byte (~496KB), also ein Wachstum um mehr als 427500%.

Im zweiten Beispiel ist der Unterschied noch größer. Aus anfänglich 367 Byte werden danach 3528459 Byte (3,4MB), also eine Vergrößerung um stolze 961000%.

Ich verlinke an dieser Stelle auf die entsprechenden Dateien, da die JS-Fuck Scripte wirklich sehr lang und groß sind. Für den alltäglichen Gebrauch auf einer Webseite eigentlich kaum zu empfehlen.

Fazit

Clientseitige Scripte kann man nicht unbedingt vor Manipulation schützen, jedoch diese (sehr) erschweren.

Wenn man dazu entsprechende Tools, wie JS Fuck nutzt, muss man bedenken, dass die Performance bzw. Ladezeit der Seite/des Scripts stark darunter leiden kann.

Trotzdem dürfen nach einer solchen Bearbeitung die serverseitigen Prüfungen nicht wegfallen.

Gruß

gehaxelt

]]>