Icinga2 – check_mssql_health

Das check_mssql_health Modul kann in Icinga2, als auch in Nagios dazu verwendet werden, seine MSSQL Datenbank zu überwachen. Dabei können Checks von Verbindungszeiten, Deadlocks, angemeldete User, existierende Tabellen und viele weitere ausgewählt werden. So macht es das Modul zu einem starken Tool für die Datenbanken. Leider wird check_mssql_health nicht bei der icinga2 respektive nagios mit installiert und muss manuell nachgeholt werden. Ich rede hier von der Installation über den Packet Manager. Die Installation dabei ist aber relativ einfach. Ich gehe davon aus, dass Icinga aus dem Repository heruntergeladen und nach Standard Parametern installiert worden ist.

 

 

Vorbereitung

Um mssql_health vollständig und erfolgreich installieren zu können, müssen einige Vorbereitungen getroffen werden, die ich hier kurz erläutere. Zunächst müssen ein paar Pakete nachinstalliert werden.

apt install libdbd-sybase-perl freetds-common freetds-dev freetds-bin

Dann laden wir die aktuelle mssql_health Version mit wget runter, was in meinem Fall(10.11.2018) die Version 2.6.4.14 ist.

wget https://labs.consol.de/assets/downloads/nagios/check_mssql_health-2.6.4.14.tar.gz

Natürlich müssen wir die tar.gz jetzt noch entpacken und gehen direkt in das neu erstellte Verzeichnis hinein.

tar xvzf check_mssql_health_2.6.4.14
cd check_mssql_health_2.6.4.14

Sobald wir im Verzeichnis sind, fangen wir an mssql_health zu kompilieren. Ich benutze jeweils die default Parameter. Änderungen können sonst mit dem ./configure Command geändert werden.

./configure
make
make install

Wenn die Kompilierung abgeschlossen und das Modul installiert ist, sollten wir überprüfen, ob es nicht doch noch eigene Syntax Errors im Perl Code gibt. Wenn alles soweit in OK ist, kopieren wir das Script in das jeweilige Icinga Verzeichnis

cd plugin-scripts/
perl -c check_mssql_health
cp check_mssql_health /usr/lib/Nagios/plugins

Zuguterletzt müssen wir eine Datenbank-Instanz in der freetds.conf einfügen. Dort ist schon ein Beispiel vorhanden, welches wir einfach für unsere Einstellungen übernehmen können. Falls dieser Eintrag übersprungen wird, kann keine Verbindung mit der Datenbank hergestellt werden.

nano /etc/freetds/freetds.conf

Aus Sicherheitsgründen sollten wir das TDS Protokoll noch auf Version 8.0 ändern. Die anderen Versionen verschicken Username/Passwort im Klartext. Somit hätten wir die Installation + Einrichtung des Modules vollzogen. Machen wir weiter mit der Konfiguration der Datenbank.

 

 

Datenbank einrichten

Das schöne an der Datenbank Einrichtung ist, dass wir hier nicht viel machen müssen. Auf der Projekt Seite steht ein vorgefertigtes Script zur Verfügung. Es ist zu empfehlen sich einen SQL-Benutzer anzulegen und diesen in der dafür vorgesehenen Stelle im Script anzugeben.

declare @dbname varchar(255)
declare @check_mssql_health_USER varchar(255)
declare @check_mssql_health_PASS varchar(255)
declare @check_mssql_health_ROLE varchar(255)
declare @source varchar(255)
declare @options varchar(255)
declare @backslash int

/*******************************************************************/
SET @check_mssql_health_USER = '"icinga"'
SET @check_mssql_health_PASS = 'password'
SET @check_mssql_health_ROLE = 'icinga'
/******************************************************************

PLEASE CHANGE THE ABOVE VALUES ACCORDING TO YOUR REQUIREMENTS

- Example for Windows authentication:
  SET @check_mssql_health_USER = '"[Servername|Domainname]\Username"'
  SET @check_mssql_health_ROLE = 'Rolename'

- Example for SQL Server authentication:
  SET @check_mssql_health_USER = 'Username'
  SET @check_mssql_health_PASS = 'Password'
  SET @check_mssql_health_ROLE = 'Rolename'

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
It is strongly recommended to use Windows authentication. Otherwise
you will get no reliable results for database usage.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

*********** NO NEED TO CHANGE ANYTHING BELOW THIS LINE *************/

SET @options = 'DEFAULT_DATABASE=MASTER, DEFAULT_LANGUAGE=English'
SET @backslash = (SELECT CHARINDEX('\', @check_mssql_health_USER))
IF @backslash > 0
  BEGIN
    SET @source = ' FROM WINDOWS'
    SET @options = ' WITH ' + @options
  END
ELSE
  BEGIN
    SET @source = ''
    SET @options = ' WITH PASSWORD=''' + @check_mssql_health_PASS + ''',' + @options
  END

PRINT 'create Nagios plugin user ' + @check_mssql_health_USER
EXEC ('CREATE LOGIN ' + @check_mssql_health_USER + @source + @options)
EXEC ('USE MASTER GRANT VIEW SERVER STATE TO ' + @check_mssql_health_USER)
EXEC ('USE MASTER GRANT ALTER trace TO ' + @check_mssql_health_USER)
EXEC ('USE MSDB GRANT SELECT ON sysjobhistory TO ' + @check_mssql_health_USER)
EXEC ('USE MSDB GRANT SELECT ON sysjobschedules TO ' + @check_mssql_health_USER)
EXEC ('USE MSDB GRANT SELECT ON sysjobs TO ' + @check_mssql_health_USER)
PRINT 'User ' + @check_mssql_health_USER + ' created.'
PRINT ''

declare dblist cursor for
  select name from sysdatabases WHERE name NOT IN ('master', 'tempdb', 'msdb') open dblist
    fetch next from dblist into @dbname
    while @@fetch_status = 0 begin
      EXEC ('USE [' + @dbname + '] print ''GRANT permissions IN the db '' + ''"'' + DB_NAME() + ''"''')
      EXEC ('USE [' + @dbname + '] CREATE ROLE ' + @check_mssql_health_ROLE)
      EXEC ('USE [' + @dbname + '] GRANT EXECUTE TO ' + @check_mssql_health_ROLE)
      EXEC ('USE [' + @dbname + '] GRANT VIEW DATABASE STATE TO ' + @check_mssql_health_ROLE)
      EXEC ('USE [' + @dbname + '] GRANT VIEW DEFINITION TO ' + @check_mssql_health_ROLE)
      EXEC ('USE [' + @dbname + '] CREATE USER ' + @check_mssql_health_USER + ' FOR LOGIN ' + @check_mssql_health_USER)
      EXEC ('USE [' + @dbname + '] EXEC sp_addrolemember ' + @check_mssql_health_ROLE + ' , ' + @check_mssql_health_USER)
      EXEC ('USE [' + @dbname + '] print ''Permissions IN the db '' + ''"'' + DB_NAME() + ''" GRANTED.''')
      fetch next from dblist into @dbname
    end
close dblist
deallocate dblist

Haben wir das Script ausgeführt, können wir außerhalb von Icinga testen, ob unsere Einstellungen soweit korrekt sind. Hierzu führen wir eine erste Überprüfung durch.

./check_mssql_health –server=wpsql3 –port=1433 –username=icinga –password=<password> --mode=locks-deadlocks –commit

Wenn dieser Check erfolgreich war, haben wir die Datenbank und das mssql_health modul korrekt installiert und eingerichtet. Jedoch fehlen noch die Änderungen in Icinga, damit dieser die Checks überhaupt ausführen kann. Ich hab es soweit eingerichtet, dass ich jedem Host mehrere Serviceobjekte von mssql_health zuweisen kann. Diese Objekte führen unterschiedliche Checks aus. Dazu habe ich einen Command angelegt, der bestimmte Parameter erwartet, aber auch solche die schon fest zugewiesen sind, wie Benutzername und Passwort.

object CheckCommand "checkmssql_health" {
   import "plugin-check-command"

   command = [PluginDir + "/check_mssql_health"]

   arguments = {
   "--server" = "$mssqlhealth_server$"
   "--username" = "$mssqlhealth_username$"
   "--password" = "$mssqlhealth_password$"
   "--mode" = "$mssqlhealth_mode$"
   "--critical" = "$mssqlhealth_critical$"
   "--warning" = "$mssqlhealth_warning$"
   "--commit" = ""

   }

   vars.mssqlhealth_username = "icinga"
   vars.mssqlhealth_password = "passwort"

}

Der erstellte Service geht dabei durch jedes, im Host Objekt angegebene, mssql_health Objekt.

apply Service "mssql_check_health" for (mode => config in host.vars.mssqlhealth_modes){
  import "generic-service"

  check_command = "checkmssql_health"

  vars.mssqlhealth_mode = mode

  vars+=config

  vars.mssqlhealth_critical = config.mssqlhealth_critical
  vars.mssqlhealth_warning = config.mssqlhealth_warning

   assign where ((host.address || host.address6) && host.vars.mssql == "true")
}

Mein Host Objekt sieht dementsprechend so aus und ist gefüllt mit mehreren Modis des Modules.

vars.mssqlhealth_modes["connected-users"] = {
     mssqlhealth_modes = "connected-users"
     mssqlhealth_warning = "1100"
     mssqlhealth_critical = "1500"
  }
vars.mssqlhealth_modes["locks-waits"] = {
     mssqlhealth_modes = "locks-waits"
     mssqlhealth_warning = "1"
     mssqlhealth_critical = "2"
  }
vars.mssqlhealth_modes["locks-deadlocks"] = {
     mssqlhealth_modes = "locks-deadlocks"
     mssqlhealth_warning = "1"
     mssqlhealth_critical = "2"
  }
vars.mssqlhealth_modes["database-backup-age"] = {
     mssqlhealth_modes = "database-backup-age"
     mssqlhealth_warning = "24"
     mssqlhealth_critical = "48"
  }

In „modes“ werden die verfügbaren Modis von mssql_health eingetragen, während die anderen beiden den jeweils kritischen und warnenden Zustand angeben.

Haben wir alles soweit eingerichtet muss selbstverständlich der Icinga Service neugestartet werden, damit die vollzogenen Änderungen überhaupt aktiv werden

service icinga2 restart

Fazit

Wenn alles geschafft ist, haben wir unser Monitoring Tool für MSSQL Datenbanken erweitert und können dementsprechend Checks ausführen. Die Installation von mssql_health an sich ist einfach nur die jeweilige Integration in Icinga bedarf etwas Überlegung. Natürlich kann das Modul auch auf andere Wege in Icinga implementiert werden. Dort stehen alle Möglichkeiten offen. Ich habe mich für diese Integration entschieden, da ich für mich hier die meisten Vorteile sehe. Mit dieser Art der Erstellung müssen nur noch im Host Objekt die einzelnen Modis mit ihren Werten eingeben werden.  So kann auf einfachste Weise ein neuer Check eingefügt werden, ohne den Service bzw. den Command anpacken zu müssen.

Meine Ausrüstung

Über die Zeit hinweg hat sich meine Ausrüstung für die Kamera stetig erweitert und vergrößert. Mittlerweile zähle ich 8 Objektive, 2 Stative und natürlich meine Canon EOS 700D Kamera.
Preislich gehen meine Objektive dabei von 100€ – 800€. Unter anderem verfüge ich über Tele-, Makro- und Weitwinkelobjektive, wobei jedes zu bestimmten Anlässen benutzt wird.

Weitwinkel:

  • Sigma 24mm F1,4 DG HSM Art Objektiv
  • Sigma 10-20 mm F3,5 EX DC HSM-Objektiv
  • Canon EF-S 10-18mm 1:4.5-5.6 IS STM

 

Makro:

  • Sigma 105 mm F2,8 EX Makro DG OS HSM-Objektiv

 

Tele:

  • Tamron SP 150-600mm F/5-6.3 Di VC USD Teleobjektiv
  • Tamron AF SP 70-300mm 4-5.6 Di VC USD
  • Canon Tele-Zoomobjektiv EF-S 55-250mm 1:4-5,6 IS STM

 

Standard-Zoomobjektiv:

  • EF-S 18-55mm 1:3,5-5,6 IS STM

 

Anderes:

  • Sigma USB-Dock für Canon Objektivbajonett
  • HIILIGHT LED Taschenlampe 2500 Extrem Hell – CREE XM-L T6
  • K&F Concept® TM2515 Reisestativ Dreibeinstativ Aluminium Kamerastativ
  • Cullmann ALPHA 2500 Stativ mit 3-Wege-Kopf
  • Glaskugel 8cm klar massiv handpoliert
  • Canon RC-6 Infrarot-Fernauslöser
  • Canon EW-63C Streulichtblende (EF-S 18-55mm f/3.5-5.6 IS STM Objektiv)
  • Canon ET-63 – Gegenlichtblende

Windows Lizenzen auslesen

Gelegentlich, z.B. für Audits oder ähnliches, müssen die verwendeten Lizenzschlüssel der einzelnen Microsoft Server, bestehend aus Betriebssystem und eventuell vorhandener Microsoft Applikation wie z.B. den SQL Server ausgelesen werden. Für beide Operationen gibt es unterschiedliche Scripte im Internet zu finden. Vorstellen werde ich eins für den SQL Server und eins für das Betriebssystem von Microsoft. Beide sollten ihren Nutzen in einer homogenen Microsoft Landschaft ausspielen. Sie können für kommerzielle als auch private Audits genutzt werden.

 

 

SQL Server Lizenz

 

Das Script habe ich gefunden bei:
https://gallery.technet.microsoft.com/scriptcenter/Get-SQL-Server-Product-4b5bf4f8

Voraussetzung ist die Verwendung von Powershell. Es lassen sich lokale Keys als auch remote Keys auslesen. Es stellt die SQL Instanz, die SQL Version und Edition, und natürlich den Lizenz Key bereit.

Beispiele:

Get-SqlServerKeys

Holt die SQL Server Version, Edition und Key der lokalen Maschine

Get-SqlServerKeys sqlservera, sqlserver2014a, sql01

Holt die SQL Version, Edition und Keys für alle Instanzen auf sqlservera, sqlserver2014a und sql01.

Get-SqlServerKeys -CentralMgmtServer sqlserver01

Holt die SQL Server version, Edition und Keys für alle SQL Server Datenbank Instanzen innerhalb des Central Management Server auf sqlserver01

Get-SqlServerKeys -ServersFromFile C:\Scripts\servers.txt -verbose

Holt die SQL Server Version, Edition und Keys für alle SQL Server die in C:\Scripts\servers.txt gelistet sind.

 

Windows Betriebssystem

 

Für die Betriebssystem Lizenz habe ich ein VBS Script in der Microsoft Community gefunden, welches ich euch nicht vorenthalten möchte. Gefunden habe ich es hier:

https://answers.microsoft.com/en-us/insider/forum/insider_wintp-insider_repair/how-to-find-all-windows-version-serial-key/a6d7e4eb-2adf-4e57-8ead-0bd85ec2758d

Kopiert dazu folgende Codezeilen in einem Editor wie z.B. Notepad und speichert es mit der Endung .vbs ab.

Set WshShell = CreateObject("WScript.Shell")
MsgBox ConvertToKey(WshShell.RegRead("HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\DigitalProductId"))

Function ConvertToKey(Key)
Const KeyOffset = 52
i = 28
Chars = "BCDFGHJKMPQRTVWXY2346789"
Do
Cur = 0
x = 14
Do
Cur = Cur * 256
Cur = Key(x + KeyOffset) + Cur
Key(x + KeyOffset) = (Cur \ 24) And 255
Cur = Cur Mod 24
x = x -1
Loop While x >= 0
i = i -1
KeyOutput = Mid(Chars, Cur + 1, 1) & KeyOutput
If (((29 - i) Mod 6) = 0) And (i <> -1) Then
i = i -1
KeyOutput = "-" & KeyOutput
End If
Loop While i >= 0
ConvertToKey = KeyOutput
End Function

 

Sigma 24mm F1,4 DG HSM Art Objektiv

Vor kurzem haben ich mir das Sigma 24mm F1,4 DG HSM Art Objektiv gekauft. Mit dem Kauf habe ich mich schwer getan, da ich als Alternative das Sigma 18-35mm F1,8 DC HSM Art Objektiv im Visier hatte. Beides an für sich ziemlich gute Objektive und von der Sigma ART Reihe, die ohnehin gute Bildqualität liefert. Als ich mich im Internet schlau gemacht habe, haben sich einige für das 18 – 35mm Objektiv, aufgrund seiner Flexibilität, ausgesprochen zudem ist es explizit für den ASP-C Sensor. Andere wiederum sahen den Aspekt, dass das 24mm auch auf Vollformat Kameras verwendet werden kann, falls man in Zukunft eben auf jene umsteigen möchte und die größere Blende.

Warum viel mir die Entscheidung so schwer?

Zum einen natürlich, da das Sigma 18-35 ebenfalls ein sehr gutes Objektiv ist. Man ist ein Stück flexibler mit der 18 – 35mm Brennweite, als es die Festbrennweite vom Sigma 24mm hergibt. Jedoch, und das war für mich entscheidend, hat das 24mm eine Blende von f1,4, was mir mehr Spielraum für die Astrofotografie gibt. So kann ich die ISO runterschrauben um Bild rauschen zu vermeiden. Ebenfalls sollte man bei dem APS-C Sensoren den Crop-Faktor nicht vergessen. Bei meiner Canon EOS 700D liegt der bei 1.6, was aus dem 24mm ungefähr ein 38mm auf dem APS-C Sensor macht. Natürlich wäre hier das andere Objekt mit seinem 18mm wieder im Vorteil. Ein Punkt für das 24mm von Sigma war die Kompatibilität mit dem Vollformat Sensor. Während das 18 – 35mm nur für den APS-C Sensor konstruiert wurde. Also musste ich abwägen, was mir lieber ist. Eine flexiblere Brennweite oder eine größere Blende. Schlussendlich habe ich mich für das 24mm Objektiv entschieden und bereue diese Entscheidung nicht.

Erster Testlauf mit der Kamera

Bisher mache ich mich noch mit dem neuen Objektiv vertraut, aber mein erster Versuch unter Nachthimmel hat mich ins Staunen versetzt. Das Objektiv macht einen soliden und stabilen Eindruck. Es ist das schwerste Weitwinkelobjektiv, welches ich besitze. Mein erster Testlauf fand hinten im Garten statt, es herrschte von umgebenen Häusern Streulicht, die meine Bilder verfälschten, aber selbst hier war ich von dem neuen Objektiv überzeugt. Mein nächster Ort wird weit entfernt von Streulichtern sein, wo ich mich einzig und alleine auf den Sternenhimmel und seine Vielfalt konzentrieren kann. Ich bin gespannt :).

TOTALE MONDFINSTERNIS AM 27.07.2018

Am 27.07.2018 war die totale Mondfinsternis, die ich mir nicht entgehen lassen wollte, schließlich passiert sowas nicht alle Tage. Also habe ich mich für diesen Tag vorbereitet. Mit meiner Canon und dem Tamron SP 150-600mm Teleobjektiv bin ich losgestiefelt und habe mir einen Spot ausgesucht, der weit entfernt von störenden, externen Lichtquellen ist. Während der totalen Mondfinsternis war es für mich extrem schwierig den Fokus zu setzen, aber durch herumprobieren ist es mir schließlich ganz gut gelungen. Da der Mond generell schwer zu sehen war, zu lange Belichtungszeiten aufgrund seiner Bewegungen nicht möglich waren, ging ich mit der ISO Wert auf höhere Werte. Die maximale Blende war mit 6.3 schon erreicht. Leider konnte ich mein Stativ nicht ordentlich standsicher machen, sodass viele Bilder aufgrund des Statives verwackelt wurden. Die Besten Ergebnisse habe ich mit folgenden Werten geschossen.

 

Bild 1:
  • ISO: 800
  • Blende: f/6.3
  • Belichtungszeit: 1/2 Sec
Bild 2:
  • ISO: 3200
  • Blende: f/6.3
  • Belichtungszeit: 1/4 Sec
Bild 3:
  • ISO: 12800
  • Blende: f/6.3
  • Belichtungszeit: 2,4 sec

 

Python Datenbank Klasse

Für Python Datenbank Projekte habe ich eine Klasse geschrieben, die sich um die Verbindung und (bisher) Select und Insert Abfragen kümmert. Beim Definieren wird die Konstruktormethode aufgerufen und die Verbindungsparameter übergeben. Die Objektvariablen bekommen die jeweilige Eingaben zugewiesen.

def __init__(self,host,username,password,database): 
    self.host = host 
    self.username = username 
    self.password = password 
    self.database = database

Connect Methode

Die connect Methode benutzt die Objektvariablen und baut mit diesen Informationen die Verbindung zu der Datenbank auf. self.cnx speichert die erzeugte Session. Somit steht diese Session dem Code weiter zur Verfügung und kann vom nachfolgenden Code mit der cnx Variable aufgerufen werden.  Im Falle von Fehlern bei der Verbindung springt der Code in den Exception Block.

def connect(self): 
    config = { 
        'user': self.username, 
        'password': self.password, 
        'host': self.host, 
        'database': self.database 
    } 
    try: 
        self.cnx = mysql.connector.connect(**config) 
        self.cursor = self.cnx.cursor() 
        print colored("[I] + DB Connection established","green") 
    except mysql.connector.Error as err: 
        if err.errno == errorcode.ER_ACCESS_DENIED_ERROR: 
            print colored("[C] + Wrong Username/Password","red") 
        elif err.errno == errorcode.ER_BAD_DB_ERROR: 
            print colored("[C] + Database Error","red") 
        else: print colored("[C] + " + err,"red"

Query_Select Methode

In der query_select Methode werden, wie der Name schon sagt, die Select Abfragen ausgeführt. Die Funktion erwartet das SQL-Statement und falls vorhanden, die Parameters, die z.B. in der where clause mit angegeben werden können. Die IF-Anweisung überprüft dementsprechend, ob Parameters vorhanden sind und springt zum gültigen Programmblock. Bei der cursor.execute() Methode wird das Statement mit dem übergegebenen Parametern ausgeführt, während cursor.fetchall() alle Ergebnisse zurückliefert und in rtnvalue abspeichert. Tritt eine Exception auf, wird eine Fehlermeldung ausgegeben und die Funktion beendet sich mit einem False State.

def query_select(self,sqlstatement, params): 
    if (params is not None): 
        try: 
            self.cursor.execute(sqlstatement, (params,)) 
            rtnvalue = self.cursor.fetchall() 
            print colored("[I] + executed select with params","green") 
            return rtnvalue 
        except: 
            print colored("[C] + something went wrong while executing select with params:","red") 
            return False 
    else: 
        try: 
            self.cursor.execute(sqlstatement) 
            rtnvalue = self.cursor.fetchall() 
            print colored("[I] + executed select without params","green") 
            return rtnvalue 
        except: 
            print colored("[C] + something went wrong while executing select without params","red") 
            return None

Query_Insert Methode

Ähnlich wie die query_select Funktion funktioniert die query_Insert. Die Methode erwartet die Parameter als Dictionary, andernfalls kann die Funktion nicht richtig abgearbeitet werden, da zwei Variablen mit der key() beziehungsweise values() methode gefüttert werden. Diese genannten Methoden stehen nur Dictionaries zur Verfügung. In der sql Variable wird die Insert Query noch mit dem Spaltennamen in „column“ und die dazügehörigen Werte in „join(repr(e) for e in Values)“ gefüttert. cnx.commit  überträgt die Insert Einträge in die Datenbank. Falls das commit abbricht, springt der Code in die Exception und cnx.rollback() rollt den Insert wieder zurück. Abschließend beendet sich die Funktion mit einem False Statement.

def query_insert(self, sqlstatement, params):
    if (params is not None): 
        columns = ', '.join(params.keys()) 
        values = params.values() 
        sql = sqlstatement % (columns, ', '.join(repr(e) for e in values)) 
        print colored("[I] + " + sql,"yellow") 
        self.cursor.execute(sql) 
    else: 
        print colored("[C] + insert execution failed due missing parameters","red") 
        return False 
    try: 
        self.cnx.commit() 
        print colored("[I] + transaction committed, value added","green") 
        return True 
    except mysql.connector.Error as er: 
        self.cnx.rollback() 
        print colored("[C] + transaction rolled back: " + err.erno,"red") 
        return False

Disconnect Methode

Zum Schluss schliesst der Code die aktuelle Python Datenbankverbindung mit cnx.close().

def disconnect(self): 
   self.cnx.close() 
   print colored("[I] + Connection closed","green")

Vollständiger Code

Hier folgt der Code ohne Unterbrechung und Beschreibung:

import mysql.connector
from mysql.connector import errorcode
from termcolor import colored

class databaseconnection:

host=username=password=database=cnx=cursor=None

def __init__(self,host,username,password,database):
     self.host = host
     self.username = username
     self.password = password
     self.database = database

def connect(self):
    config = {
         'user': self.username,
         'password': self.password,
         'host': self.host,
         'database': self.database
     }
     try:
         self.cnx = mysql.connector.connect(**config)
         self.cursor = self.cnx.cursor()
         print colored("[I] + DB Connection established","green")
     except mysql.connector.Error as err:
         if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
        print colored("[C] + Wrong Username/Password","red")
     elif err.errno == errorcode.ER_BAD_DB_ERROR:
        print colored("[C] + Database Error","red")
     else:
         print colored("[C] + " + err,"red")

    def query_select(self,sqlstatement, params):
         if (params is not None):
             try:
                 self.cursor.execute(sqlstatement, (params,))
                 rtnvalue = self.cursor.fetchall()
                print colored("[I] + executed select with params","green")
                return rtnvalue
            except:
                 print colored("[C] + something went wrong while executing select with params:","red")
                 return False

        else:
            try:
                self.cursor.execute(sqlstatement)
                rtnvalue = self.cursor.fetchall()
                print colored("[I] + executed select without params","green")
                return rtnvalue
            except:
                print colored("[C] + something went wrong while executing select without params","red")
                return None

    def query_insert(self, sqlstatement, params):
        if (params is not None):
            columns = ', '.join(params.keys())
            values = params.values()
            sql = sqlstatement % (columns, ', '.join(repr(e) for e in values))
            print colored("[I] + " + sql,"yellow")
            self.cursor.execute(sql)
        else:
            print colored("[C] + insert execution failed due missing parameters","red")
            return False

        try:
            self.cnx.commit()
            print colored("[I] + transaction committed, value added","green")
            return True
        except mysql.connector.Error as er:
            self.cnx.rollback()
            print colored("[C] + transaction rolled back: " + err.erno,"red")
            return False

    def disconnect(self):
        self.cnx.close()
        print colored("[I] + Connection closed","green")

neues Objektiv Sigma 10 – 20mm

Ich habe mir vor kurzem das Sigma 10-20 mm F3,5 EX DC HSM Objektiv gekauft. Im Lieferumfang war das Objektiv, ein Köcher und eine Gegenlichtblende enthalten. Zwar konnte ich noch nicht viel testen, aber das was ich bisher gesehen habe, kann sich zeigen lassen. Den ersten Versuch habe ich unter der Nacht gemacht.

Sigma Objektiv Church
Church

Bei meinem ersten Bild habe ich eine Blende von f/22 benutzt, bei einer Belichungszeit von 65sec und einem ISO Wert von 100.

Sigma Objektiv Street
Street

 

 

 

 

 

Bei meinem zweiten Bild habe ich ebenfalls eine Blende von f/22 benutzt. Diesmal mit einer Belichtungszeit von 70sec und einem ISO Wert von 100. Bei diesem Bild habe ich 3 unterschiedliche Bilder übereinander gelegt, um die Lichteffekte der Autos zu verstärken.

Ich würde gerne eine Gegenüberstellung zu meinem Canon EF-S 10-18mm 1:4.4-5.6 IS STM machen. Preislich liegt das Sigma Objektiv über dem Canon EF-S 10-18mm. Bei dem Canon konnte ich starke Vignettierung feststellen, die ich bei dem Sigma bisher allerdings nicht ersehen konnte.

 

 

 

 

 

 

Kali USB Wireless Karte installieren

Ich hatte mir für mein Kali System eine zusätzliche USB Wireless Karte geholt. Es war von Amazon die Mini Wlan Stick mit WiFi Dongle 600Mbit/s Dualband (2.4G/150Mbps+5G/433Mbps) USB Wifi Adapter 802.11a/b/g/n/ac. Als Dreingabe war eine CD mit den dazugehörigen Treibern dabei, ebenfalls für Linux. Ich versuchte die Treiber, wie in der Dokumentation beschrieben, ohne eigene Kompilierung zu installieren und bin auf einen Fehler gestoßen.

Compile make driver error: 2
Please check error Mesg

Der Treiber wurde  aufgrund eines veralteten Treibers nicht installiert, da er nicht für meine Linux Version (4.13.0) vorgesehen war.  Für meine Karte brauchte ich die neueren rtl8812AU Treiber.

Ich habe für die neueren Treiber das folgende git Verzeichnis heruntergeladen.

git clone https://github.com/gnab/rtl8812au treiber

Danach bin ich in das treiber Verzeichnis gegangen und habe die install.sh Datei ausgeführt.

chmod +x install.sh
./install.sh

Es könnte, anstatt der install.sh, auch die Kompilierung selber vorgenommen werden. Ich habe mich aber für die automatische Installation entschieden.

Meine neue Karte war somit installiert.

 

 

Raspberry 3 mit Touch

Vor einigen Tagen habe ich mir den Raspberry 3 geholt. Als es dann bei dem Amazon Cyber Monday ein Touchdisplay für das Board zu erwerben gab, habe ich zugeschlagen.  Gekauft habe ich mir ein QuimatTouch Screen 3,5″ mit einem 320 x 480 TFT Monitor. Bei der Lieferung war der Monitor, ein Schutzkoffer, 3x Kühlkörper und ein Touch Pen enthalten. Das Kit kann für den Raspberry 3, 2 und 1 erworben werden.

Hier ist der Link zu meinem Touchdisplay: https://www.amazon.de/gp/product/B06W55HBTX/ref=oh_aui_detailpage_o06_s00?ie=UTF8&psc=1

Installation

Die Installation ist vermeintlich einfach. Das Display einfach mit den Slot in die dafür vorgesehenen GPIO Pins stecken. Zur Installation werde ich selber nichts schreiben, die kann hier https://github.com/goodtft/LCD-show nachgelesen werden. Nach der Installation startet der Raspberry von alleine wieder, jedoch habe ich dort einen Kernel panic bekommen und mein System bootete nicht mehr.

Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(179,2)

Die erste Suche bei google zeigte mir, ich bin nicht alleine. Zur Behebung müsste ich nur in das Noob System gehen und dort in der cmdline.txt das root Verzeichnis von

root=/dev/mmcblk0p2

auf

root=/dev/mmcblk0p6

ändern. Das brachte mir jedoch nicht den gewünschten Erfolg, sonder nur einen veränderten Kernel panic… unknown-block (179,6).

In der Shell, die ich über NOOB geöffnet hatte, habe ich mir /dev/ mal genauer unter die Luppe genommen und fand dort ebenfalls

root=/dev/mmcblk0p7

Ich änderte meine cmdline auf Partition 7. Mein Raspberry bootete wieder und zeigte mir auf meinem kleinen Monitor das Bild an.

DVWA installieren

Damn Vulnerable Web Application: DVWA Damn Vulnerable Web Application: DVWA

Im vorherigen Beitrag habe ich euch erzählt, was DVWA ist. Nun möchte ich euch zeigen, wie DVWA installiert wird. Als Host gilt hier mein Kali Linux System. PHP5 und MYSQL setze ich als Voraussetzung. PHP7 wird von DVWA nicht unterstützt. Falls beide PHP Versionen installiert sind könnt ihr mit a2enmod und a2dismod zwischen den Versionen wechseln.

a2enmod php5.0
a2dismod php7.0

Vorbereitung zur Installation

Für eine erfolgreiche Installation müssen eventuell folgende Pakete nachinstalliert werden.

  • php5 libapache2-mod-p
  • php5-gd
  • php-mysql
apt-get install php5 libapache2-mod-p
apt-get install php5-gd
apt-get install php-mysql

Nun solltet ihr noch einmal eure PHP Version überprüfen.

php5 -v
PHP 5.6.7-1 (cli) (built: Mar 24 2015 12:30:15) 
Copyright (c) 1997-2015 The PHP Group
Zend Engine v2.6.0, Copyright (c) 1998-2015 Zend Technologies
    with Zend OPcache v7.0.4-dev, Copyright (c) 1999-2015, by Zend Technologies

Für die Registrierung des ReCaptcha benötigt ihr ein Google Account. Dort könnt ihr einen ReCaptcha beantragen, denn ihr für die spätere Konfiguration benötigt. Zum Schluss ändern wir die php.ini und setzen den allow_url_include Wert von OFF auf ON.

nano /etc/php5/apache2/php.ini
allow_url_include = ON

Installation von DVWA

Zu allererst benötigen wir die Dateien aus dem dvwa Verzeichnis auf GitHub.

git clone https://github.com/ethicalhack3r/DVWA

Das gerade heruntergeladene Verzeichnis kopieren wir in unser html Verzeichnis und benennen es um.

mv DVWA /var/www/html/
mv DVWA/ dvwa

Bevor wir weitermachen legen wir noch einen MySQL Benutzer auf unsere DB an. Diesen Benutzer geben wir volle Berechtigung.

service apache2 start && service mysql start
mysql
create user 'dvwa'@'localhost' IDENTIFIED BY 'password';
GRANT ALL PRIVILEGES ON *.* TO 'dvwa'@'localhost' WITH GRANT OPTION;

Nehmen wir uns nun weiter die Konfiguration an. Dazu gehen wir in das DVWA Verzeichnis und benennen die Config Datei um.

cd var/www/html/dvwa/config
mv config.inc.php.dist config.inc.php

Weiterhin geben wir in der Config Datei unsere Daten vom Server, Datenbank, DB Benutzer, DB Passwort an. Ebenfalls müssen wir hier unsere von google beantragten ReCaptcha angeben.

Zum Schluss ändern wir noch einige Berechtigungen bevor wir uns auf die Webseite schalten.

chmod -R 777 /var/www/html/dvwa/hackable/uploads/
chmod -R 777 /var/www/html/dvwa/external/phpids/0.6/lib/IDS/tmp/phpids_log.txt

Öffnen wir nun unseren Browser und surfen auf 127.0.0.1/dvwa, sollten wir die Anmeldeseite bekommen.

Die Installation ist nun abgeschlossen. Achtet bittet darauf, dass ihr die Sicherheitseinstellung von „impossible“ auf „LOW“ umstellt. Nun können wir unsere ersten Attacken auf die Webseite machen.