Wikimedia data dumps (SSL link) — includes descriptions of dumps and instructions for use

Link page to downloads (static Wikipedia pages and Wikimedia database backups)

Actual dumps

This is exactly the kind of thing that Bittorrent was designed to download and distribute

Aand as always,

Our friends at the Electronic Frontier Foundation — show them some love

Amnesty International and the American Civil Liberties Union — often misguided, often really really nice to have around

The TOR Project — a fantastic means to securely and (mostly) anonymously browse the web.  Please don’t abuse it, please share bandwidth generously.  Have a look at Vidalia, their plug-and-play privacy proxy

Information is good, information wants to be free.  Go for it.

It takes a bit of time to get this right, but it’s definitely doable if you prepare, do your research, and follow instructions.  As always, if anything goes wrong, don’t blame me.

The first step is to find an Intel-based laptop that is compatible with OS X.  MyMacNetbook.com has a great, recently updated compatibility chart, (in addition to a lot of other great guides and links) but there are other resources out there.

I bought my like-new Dell notebook on EBay UK, for about 250 pounds including shipping.  The exact model was a Dell Inspiron 1011 Mini 10V N270 1.6Ghz 160GB, with 1GB of memory.

The first step was to upgrade the memory to 2GB.  This was not trivial, but there are plenty of guides out there.  Here is one, here is another, both with plenty of pictures.  A 2GB DIMM cost me about US $40 on Amazon.

I replaced the standard 3-cell battery with a new 6-cell one from Dell.  Not cheap at US $135 (much more if you buy in Europe, but then again, who would?), but very much worth it.

The forums at MyDellMini.com are the next step.  If you have a different model laptop, best check the MyMacNetbook.com site above.

At the time I wrote this, Dell bios version A06 worked with the newest NetBookInstaller.

First, install Snow Leopard 10.6.2 as described in this guide.  Here is another good-looking guide to getting 10.6.2 onto your laptop — you can use any external USB drive with enough space (8GB or larger) to prepare as a boot device from the original 10.6.2 boot DVD/image.  The above guide has instructions on how to do that.

Then, upgrade to 10.6.4.  The specific 10.6.4 thread for the Mini 10v is here.  Go through the ENTIRE thread and make sure you have the LATEST version of NBI (NetBookInstaller) by Meklort.

Enjoy.  The latest trackpad drivers are included in NBI.  Meklor’s blog has updated lid sleep kernel extensions, that I have not yet played with.

Fine.  Just don’t use it to send private messages.  Private messages are insecure and impractical.  Use email instead.

Facebook now sends you notifications when you receive private messages.   Notifications from Facebook come from an email address formatted like “notification+<something>@facebookmail.com”.  SMTP Reply-to is “noreply <noreply@facebookmail.com>”.  In order to reply, you must log into Facebook.  Unlike notifications of status updates or wall messages, you cannot reply via email.

Here is a list of reasons why you should not send private messages via Facebook’s messaging system, and should use email instead.

• Facebook does not force website encryption.  I check my emails via Google secure imap or SSL.  Facebook allows you to use a secure login page.   However, while this will show you an SSL-secured landing page when you log in, any links from there (e.g. other people’s walls) are unencrypted.  Furthermore, the “reply to this message” link in the message notification from Facebook is always unencrypted.  Unless you use a tool like HTTPS Everywhere or a browser that supports universal SSL enforcement via configuration settings, you are at risk of revealing login information.  Please read my post about Firesheep to see how easy it is to steal a Facebook account over an insecure (e.g. public wireless) connection.
• Facebook does not allow the use of cryptography when sending emails.  This does not concern (although it should) the majority of people, but tools like PGP or GPG allow me to easily encrypt my mails, even while they are stored on a server like Google’s.  I use a GPG plugin for my Mac mail client, which permits me to easily and quickly encrypt/decrypt emails.
• Facebook is a marketing organization.  It already knows a lot about you, via your photos, posts, tags, games, comments, profile information, likes, dislikes, group memberships, where you connect from, what external links you click on, apps, and any number of other tools.  The company has changed its privacy policies and data handling procedures (thankfully, for the better in their last iteration) numerous times, often without consulting its subscribers.  They provide a free service and have to pay for it somehow
• Even if you do not believe that Facebook is “bad” (it’s just a company), in the wrong hands, that information is potentially damaging and sensitive (e.g. if someone breaks into a Facebook account — see the above link to the Firesheep article to learn how easy this is to do.)  It is easier to secure an email account than a Facebook account.
• Email allows you to properly thread and follow conversations.  It also includes previous mails in a back-and-forth conversation.  Facebook messages do not, unless you log into Facebook.  They are a pain in the ass to track in an email client.  Which leads to the next problem, that
• Facebook messages are not accessible offline.  Email is.  If I want to go through an email conversation while I’m on a plane, I can list all the messages in that one thread, sorted by topic.  If I only have an email conversation in the form of Facebook notifications, I have to manually search through them and will probably miss a bunch of information.
• On a related note, you cannot easily sort Facebook messages by sender.  People who like to tag emails by who sent them in one convenient place, forget it.
• It is not possible to auto-reply to Facebook messages (e.g. if I’m on holidays).
• Facebook messages do not allow rich text or attachments.   If you use rich text, forget it — no images, formatting, etc.
• Many workplaces frown on Facebook use, while tolerating access to personal email sites, or maybe they just don’t notice, as your Hotmail interface isn’t as likely to have a bunch of friends’ wall photos (LOL GEORGE WITH INFLATABLE SHEEP).
• Facebook includes the IP address of the sender in every message notification.
• Facebook messages received via email are cluttered.   Especially on mobile devices, Facebook message notifications suck.  Compare the following two for a one-line email:

This

versus this

It floors me that intelligent, busy people who wouldn’t think twice about lashing out at someone for wasting their time, would tolerate this kind of crap.

I do not “trust” Google, where I host two email domains, nor do I in any way claim that they are “better” in this regard than Facebook.  I understand that, all claims to “do no evil” aside, they also provide a free service, but I accept the premise of giving up a certain amount of privacy in return for a service, and my personal experience leads me to believe that they’re pretty decent overall.   I find their terms of service adequate for my email needs.   I also do not send photos of myself being a drunken idiot via Gmail, nor do I frequently comment on links labeled with the equivalent of “lol sheep porn” (or whatever my friends decide to post on Facebook that day).

Furthermore, Google is by far not the only email provider — you can host your own email service, with a provider that offers far stricter terms of service and data privacy.

Email is not 100% secure, even if the link between you and your email server is encrypted.  First, content can be included in a mail that exploits vulnerabilities in your browser, email client, or operating system.  Some such exploits do not even require you to click on them.  However, many of these can be prevented, or at least mitigated, with a reasonable virus scanner, frequent software security updates, and a bit of personal awareness.

Second, email between providers (i.e. from your server to the recipient’s server) often traverses insecure links.  These can be shared “big pipes”, used by any number of data services.  Unless you use strong encryption (see PGP/GPG above), a malicious systems administrator, determined intruder, government agency, or Internet service provider, could sniff and intercept your mails.  That is, if they really wanted to (they probably don’t).  Even strong encryption is no guarantee against the most resourceful attacker, but a vast vast vast majority of the time, it makes it more trouble than it is worth.  But even if it is not encrypted, it is unlikely that an attacker who is not highly resourceful and determined will be able to access your mail traffic this way.

I know that all your friends “are on Facebook”.  It’s a neat toy for sharing events, photos, and snarky comments.  But please, for the love of god, do not use it as an email replacement.  It’s not, and you should know better.

Please check the above for yourself.  To the best of my knowledge, everything in this posting was true as of the posting date.  Facebook has since made changes, something it continually does, sometimes for the better, but usually for the words. YMMV.

Google Maps and Earth use an XML-like format called ‘KML‘ for storing placemarks and map info (or ‘KMZ’, which is just zipped kml — useful for larger amounts of info, like map overlays and the likes.

Unfortunately, it appears that Google Earth is a lot more tolerant of slight errors in KML files than the Google Maps API, which is used by applications like the excellent WordPress Geo Mashup plugin I use on this site.

I have a basic collection of placemarks to show where I’ve traveled and lived, it’s sort of a map diary of mine.  Google Earth is a convenient way of dealing with it, since unlike Google Maps, it allows you to put placemarks in folders/subfolders.  The downside is that you can’t have access to this information online, which is not an issue for me since I usually carry a laptop around anyway.

I use yellow and red pushpins,

which worked fine in Google Earth, but found that when I exported my placemarks KML file to Google Maps (either on maps.google.com or here), most-but-not-all were replaced by blue markers.

I finally figured out that Google Earth tends to sort of randomly assign placemark styles (defined via the <styleUrl> tag early in the KML file) to places — so even if you’ve manually set all your placemarks to use the same yellow pushpin, you may find your placemarks using 300 different placemark styles.  For some reason, a lot of them were horribly munged, referring to URLs rather than styles defined earlier in the file.  Google Maps got confused.  I have no idea why this happened, but it’s obnoxious.

To fix it, I also realized that you can recursively set placemark styles for all placemarks at once — create a placemark folder in Google Earth, put all your placemarks and placemark subfolders in it, then set the placemark style for the folder and everything in it to the placemark you want.

Then, go through your placemarks and individually fix the ones you want to be different.

Even though the KML file will still have many styles for placemarks, you’ll notice that Google Earth speeds up a bit, and Google Maps now understands all your icons.

This was on my old site before I moved. Maybe someone will find it interesting.  The original site seems to be offline, so I  thought it best to make sure it stayed available just in case.

-John

David Barroso Berrueta

http://voodoo.somoslopeor.com

<tomac@somoslopeor.com>

Copyright © 2003 David Barroso Berrueta. Palencia (Spain)

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled “GNU Free Documentation License”.

Remote OS Fingerprinting is becoming more and more important, not only for security pen-testers,but for the black-hat. Just because Nmap is getting popularity as the tool for guessing which OS is running in a remote system, some security tools have been developed to fake Nmap in its OS Fingerprinting purpose. This paper describes different solutions to defeat Nmap and behave like another chosen operating system, as well as a demonstration on how can be accomplished.

1. Introduction

2. Reasons to hide your OS to the entire world

3. Nmap

4. Linux solutions

4.1. IP Personality

4.2. Stealth patch

4.3. Fingerprint Fucker

4.4. IPlog

5. *BSD solutions

5.1. Blackhole

5.2. Fingerprint Fucker

5.3. OpenBSD packet filter

5.4. FreeBSD TCP_DROP_SYNFIN

6. General solutions

7. More things to play with

8. Conclusion

References

A. GNU Free Documentation License

A.1. PREAMBLE

A.2. APPLICABILITY AND DEFINITIONS

A.3. VERBATIM COPYING

A.4. COPYING IN QUANTITY

A.5. MODIFICATIONS

A.6. COMBINING DOCUMENTS

A.7. COLLECTIONS OF DOCUMENTS

A.8. AGGREGATION WITH INDEPENDENT WORKS

A.9. TRANSLATION

A.10. TERMINATION

A.11. FUTURE REVISIONS OF THIS LICENSE

A.12. ADDENDUM: How to use this License for your documents

1. Introduction

The purpose of this paper is to try to enumerate and briefly describe all applications and technics deployed for defeating Nmap OS Fingerprint, but in any case, security by obscurity is not good approach; it can be a good security measure but please take into account that is more important to have a tight security environment (patches, firewalls, ids, …) than hiding your OS.

Learning which Operating System is running in a remote system can be very valuable for both the pen-tester and the black-hat. Suppose that they find an open port in their (approved or not) penetration; knowing the OS makes easier to find and execute an exploit against that service, because often an exploit is OS version specific, and an exploit for Sendmail running on HP-UX won’t work for Sendmail running on AIX, or being more accurate, an AIX 4.3.3 exploit could not work in a system running 4.3.3 with the latest maintenance code applied. Fyodor (Nmap’s author) has written a detailed article about remote OS Fingerprint, describing some different methods to successfully detect the remote OS, from the basic ones, to the more powerful ones.

In the beginning, guessing the remote OS was done grabbing the banner that a specific service was serving. For example, a typical telnet or FTP banner was always shown to the entire world, telling which OS was running, or if the banner has been changed or removed, some service commands could be executed to know the OS (remember the SYST in the FTP). Other basic ways to know the OS could be searching for HINFO entries in the DNS server, or trying to get information using snmp (lot of devices have enabled by default snmp access using the ‘public’ community string). Even searching for the target company jobs posting in the Internet, dumpster diving looking for OS manuals, or social engineering are valid methods for trying to know the remote OS.

Then, some more advanced network solutions were deployed, taking advantage of each OS vendor TCP/IP stack implementation. The idea is to send some crafted packets to the remote OS and wait for its answer. Those packets are “nasty” packets, crafted with uncommon TCP options or with ‘impossible’ options. Each OS has its own TCP/IP stack implementation, there isn’t a common stack implementation for every OS and this issue allows to create a classification of different OS and versions according to their answers. Playing around with those tricky packets is how remote OS Fingerprinting tools work; some of them using the TCP/IP protocol, and others using the ICMP protocol.

There is a paper about ‘Defeating TCP/IP Stack Fingerprinting‘ that describes in high level the design and implementation of a TCP/IP Stack fingerprint scrubber. That paper outlines why and how you can defeat TCP/IP OS Fingerprinting, so I am not going to talk too much about that; therefore I will focus on the solutions available out there.

Perhaps you are wondering why do you want to spend your precious time changing your Linux kernel to hide your real OS version against Nmap ‘bad purposes’ users. Maybe the following reasons can convince you:

• Revealing your OS makes things easier to find and successfully run an exploit against any of your devices.
• Having and unpatched or antique OS version is not very convenient for your company prestige. Imagine that your company is a bank and some users notice that you are running an unpatched box. They won’t trust you any longer! In addition, these kind of ‘bad’ news are always sent to the public opinion.
• Knowing your OS can also become more dangerous, because people can guess which applications are you running in that OS (data inference). For example if your system is a MS Windows, and you are running a database, it’s highly likely that you are running MS-SQL.
• It could be convenient for other software companies, to offer you a new OS environment (because they know which you are running).
• And finally, privacy; nobody needs to know the systems you’ve got running.

Nmap is one of such tools. It sends seven TCP/IP crafted packets (called tests) and waits for the answer. Results are checked against a database of known results (OS signatures database). This database is a text file that contains the result answered (signature) by each OS known. Thus, if the answer matches any of the entries in the database, we can guess that the remote OS is the same that the one in the database. Some Nmap packets are sent to an open port and the others to a closed port; depending on that results, the remote OS is guessed. A sample entry could be:

/* OS Comment. Yes, we want to be a Sega Dreamcast console */

Fingerprint Sega Dreamcast

/* ISN predictibilty; TD: time dependant */

TSeq(Class=TD%gcd=<780%SI=<14)

/* Test 1 result: SYN packet with some options to an open port. We got

a SYN+ACK, acknowledgment seq +1, window size 0x1d4c, don’t fragment

bit not activated, and only the MSS returned */

T1(DF=N%W=1D4C%ACK=S++%Flags=AS%Ops=M)

/* Test 2 result: Null packet with options to an open port. We got a

ACK+RST, acknowledgment seq, window size 0×0, don’t fragment bit not

activated */

T2(Resp=Y%DF=N%W=0%ACK=S%Flags=AR%Ops=)

/* Test 3 result: SYN, FIN, URG, PSH with options to an open

port. We got a SYN+ACK, acknowledgment seq +1, window size 0x1d4c,

don’t fragment bit not activated, and only the MSS returned */

T3(Resp=Y%DF=N%W=1D4C%ACK=S++%Flags=AS%Ops=M)

/* Test 4 result: ACK packet to an open port. We got a RST,

acknowledgment seq, window size 0×0, don’t fragment bit not activated */

T4(DF=N%W=0%ACK=S%Flags=R%Ops=)

/* Test 5 result: SYN with options to a closed port. We got a

ACK+RST, acknowledgment seq, window size 0×0, don’t fragment bit not

activated */

T5(DF=N%W=0%ACK=S%Flags=AR%Ops=)

/* Test 6 result: ACK with options to a closed port. We got a RST,

acknowledgment seq, window size 0×0, don’t fragment bit not activated */

T6(DF=N%W=0%ACK=S%Flags=R%Ops=)

/* Test 7 result: FIN, PSH, URG with options to a closed port. We

got a ACK+RST, acknowledgment seq+1, window size 0×0, don’t fragment

bit not activated */

T7(DF=N%W=0%ACK=S++%Flags=AR%Ops=)

/* Port unreachable message result. No response */

PU(Resp=N)

Then, if we want to defeat Nmap and tell the attacker that we are running a different operating system, we only need to fake the responses to the Nmap tests. The solution that is going to describe is only valid for defeating Nmap and not other remote OS Fingerprinting tools. In the Conclusion section, other tools will be mentioned, as well as some recommendations for the pen-tester and/or the attacker.

Methods to defeat Nmap OS Fingerprinting in Linux are written as kernel modules, or at least, as patches to the Linux kernel. The reason is that if the aim is to change Linux TCP/IP stack behavior, and if we want to achieve it, we need to do it in the kernel layer.

Three kernel module solutions are going to be described, all of them independent from the Linux kernel tree; you have to download them and patch your kernel to add the feature. The first one requires netfilter enabled in your kernel (what I think it’s a must if you want to start to have a secure system), but the other two don’t.

The first and probably, best option is IP Personality. It’s netfilter module (then, only available for 2.4 Linux kernels) that allows us to change the IP stack behavior and ‘personality’, having multiple network personalities depending on parameters that you can specify as an iptables rule. Actually, we can change the following options:

• TCP Initial Sequence Number (ISN)
• TCP initial window size
• TCP options (their types, values and order in the packet)
• IP ID numbers
• answers to some pathological TCP packets
• answers to some UDP packets

An IP Personality overall summary is that we can change the way we answer to some packets, and we can specify which packets we want to answer in such way (it could be depending on the source ip address, the destination port, or, and that’s we are going to use, those crafted packets coming from Nmap)

Installation is fairly straight forward and well explained in the INSTALL file provided by the package; for our test purposes, our test box is a stable Debian box running a 2.4.19 kernel. By default, IP Personality netfilter module is not available in latest kernel, so we need to patch our kernel sources. Patch for adding IP Personality feature to our netfilter core is available in the IP Personality site. We also need to patch the iptables command so that it can recognize our new feature available. Once the kernel is patched and compiled, we need to reboot our box just because the patch also modifies other netfilter files (the connection tracking).

Next step is include our iptables rules related to IP Personality in our working kernel. Before doing it, we run Nmap to check our current OS:

# nmap (V. 3.10ALPHA4) scan initiated Wed Feb 19 20:26:52 2003 as: nmap -sS -O -oN nmap1.log 192.168.0.19

Interesting ports on 192.168.0.19:

(The 1597 ports scanned but not shown below are in state: closed)

Port State Service

22/tcp open ssh

25/tcp open smtp

80/tcp open http

143/tcp open imap2

Remote operating system guess: Linux Kernel 2.4.0 – 2.5.20

Uptime 106.832 days (since Tue Nov 5 00:29:33 2002)

# Nmap run completed at Wed Feb 19 20:26:58 2003 — 1 IP address (1 host up) scanned in 7.957 seconds

Now, we can reboot to run our new patched kernel and add the iptables rules needed to fake Nmap OS guess:

voodoo:~/ippersonality-20020819-2.4.19/samples#/usr/local/sbin/iptables -t mangle -A PREROUTING -s 192.168.0.50 -d192.168.0.19 -j PERS –tweak dst –local –conf dreamcast.confi

voodoo:~/ippersonality-20020819-2.4.19/samples#/usr/local/sbin/iptables -t mangle -A OUTPUT -s 192.168.0.19 -d192.168.0.50 -j PERS –tweak src –local –conf dreamcast.conf

What we are doing with those filter rules is:

• The first one means that all packets coming from 192.168.0.50 (me) against 192.168.0.19 (server) have to be mangled and rewritten simulating a Dreamcast behavior. The PREROUTING chain is the one that can do that.
• The second one means that all packets coming from 192.168.0.19 (server) against 192.168.0.50 (me) have to be mangled and rewritten simulating a Dreamcast behavior. As is a packet going out the server, the OUTPUT chain is the responsible for that.

Checking our set-up:

voodoo:~/ippersonality-20020819-2.4.19/samples#/usr/local/sbin/iptables -L -t mangle

Chain PREROUTING (policy ACCEPT)

target prot opt source destination

PERS all 192.168.0.50 192.168.0.19 tweak:dst local id:Dreamcast

Chain INPUT (policy ACCEPT)

target prot opt source destination

Chain FORWARD (policy ACCEPT)

target prot opt source destination

Chain OUTPUT (policy ACCEPT)

target prot opt source destination

PERS all 192.168.0.19 192.168.0.50 tweak:src local id:Dreamcast

Chain POSTROUTING (policy ACCEPT)

target prot opt source destination

It’s time to see if Nmap can report that we are still running a Linux kernel 2.4.0-2.5.20 or perhaps we can find out that our OS has changed:

# nmap (V. 3.10ALPHA4) scan initiated Wed Feb 19 21:49:18 2003 as: nmap -sS -O -oN nmap2.log 192.168.0.19

Interesting ports on 192.168.0.19:

(The 1597 ports scanned but not shown below are in state: closed)

Port State Service

22/tcp open ssh

25/tcp open smtp

80/tcp open http

143/tcp open imap2

Remote operating system guess: Sega Dreamcast

# Nmap run completed at Wed Feb 19 21:49:23 2003 — 1 IP address (1 host up) scanned in 5.886 seconds

As you can see, we’ve fooled Nmap with our response. It’s easy to choose the OS we want to ‘run’ in the Nmap OS fingerprint and tell IP Personality to behave like that chosen OS. Let’s take a look to the dreamcast.conf file that we’ve specified when adding our iptables rules:

/* Our new OS identification */

id “Dreamcast”;

/* only incoming packets will be mangled and TCP window sizes will not be changed*/

tcp {

incoming yes;

outgoing no;

max-window 32768;

}

/* We need to emulate the Dreamcast ISN time dependant generator; this can be done with the fixed-inc generator and a small increment */

tcp_isn {

type fixed-inc 2;

initial-value random;

}

tcp_options {

keep-unknown yes;

keep-unused no;

isolated-packets yes;

code { copy(mss); }

}

/* now we have to follow nmap Dreamcast signature and answer like a Dreamcast */

tcp_decoy {

code {

if (option(mss)) { /* nmap has mss on all of its pkts */

set(df, 0);

if (listen) {

if (flags(syn&ece)) { /* nmap test 1 */

set(win, 0x1D4C);

set(ack, this + 1);

set(flags, ack|syn);

insert(mss, this+1);

reply;

}

if (flags(null)) { /* nmap test 2 */

set(win, 0);

set(ack, this);

set(flags, ack|rst);

reply;

}

if (flags(syn&fin&urg&push)) { /* nmap test 3 */

set(win, 0x1D4C);

set(ack, this + 1);

set(flags, ack|syn);

insert(mss, this+1);

reply;

}

if (ack(0) && flags(ack) && !flags(syn|push|urg|rst)) { /* nmap test 4 */

set(win, 0);

set(ack, this);

set(flags, rst);

reply;

}

} else {

set(win, 0);

if (flags(syn) && !flags(ack)) { /* nmap test 5 */

set(ack, this);

set(flags, ack|rst);

reply;

}

if (ack(0) && flags(ack) && !flags(syn|push|urg|rst)) { /* nmap test 6 */

set(ack, this);

set(flags, rst);

reply;

}

if (flags(fin&push&urg)) { /* nmap test 7 */

set(ack, this + 1);

set(flags, ack|rst);

reply;

}

}

}

}

}

/* No ICMP response for connections to closed UDP ports */

udp_unreach {

reply no;

df no;

max-len 56;

tos 0;

mangle-original {

ip-len 32;

ip-id same;

ip-csum zero;

udp-len 308;

udp-csum same;

udp-data same;

}

}

IP Personality is even more powerful. You can set up a Linux firewall/router that will change the answer of the hosts behind it. All your hosts protected by that Linux router can appear to be Sega Dreamcast consoles to any attacker!

There is also a great Nmap patch in the same site, named osdet, that allows us to OS Fingerprint an ip address (using Nmap engine), but with the fancy add-on that we can see the packets that are sent and their answer in tcpdump output format. Sometimes it’s very helpful and easier to understand the OS Fingerprint technique watching the packets flowing on our screen (all Nmap tests and its answers).

The solution that we are going to describe is the stealth patch, available from Security Technologies. It’s available as a kernel modules for Linux kernels 2.2.x (and in a near future for 2.4.x) ,and as a kernel patch (without module support for Linux kernel 2.4.x). We’re going to test the patch for the 2.4.19 kernel. When patched, two new options appear in our config file:

• IP: TCP Stack Options: option that we have to choose if want to use the stealth patch. If you select this option, it’s enable by default when you boot your system. To disable them, you need to execute:

• echo 0 > /proc/sys/net/ipv4/tcp_ignore_ack
• echo 0 > /proc/sys/net/ipv4/tcp_ignore_bogus
• echo 0 > /proc/sys/net/ipv4/tcp_ignore_synfin

• Log all dropped packets: logs all packets with bad options.

This patch simply discards the TCP/IP packets received with the following matches:

1. Packets with both SYN and FIN activated (tcp_ignore_synfin) (QueSO probe).
2. Bogus Packets: if the TCP header has the res1 bit active (one of the reserved bits, then it’s a bogus packet) or it does not have any of the following activated: ACK, SYN, RST, FIN (Nmap test 2).
3. Packets with FIN, PUSH and URG activated (Nmap test 7).

This is a simpler solution than the one described earlier. We cannot behave like any other Operating System, we just silently drop all ‘strange’ packets that are supposed to be destinated to guess our OS, and hope that it will be enough to fool our attacker, or at least, make the things harder. These kernel modifications are easy to understand, and it would be relatively easy to add our own homemade ‘bad packets’ detection.

Fingerprint Fucker is a kernel module available for Linux kernel 2.2.x which also can hide your OS and behave like another. It’s a kernel module which accepts parameters from the command line to configure the answer. By default, it simulates a VAX. There is also another file, called fing_parses.c, which parses a Nmap signature file and loads the Fingerprint Fucker module with the right parameters (when executing fing_parses, you have to specify which OS you want to emulate). It also waits for receiving a Nmap bogus packet, and then answers as you have configured. As far I’ve seen, only some Nmap tests are treated (T1, T2 and T7).

IPlog is a TCP/IP logger that also detects some scans (XMAS, FIN, SYN, …). For our purposes, it has an option (-z) that allows to fool Nmap queries, and, although we can’t behave as other OS, we can completely fool Nmap when guessing remotely our OS.

Now it’s time to run IPlog to check the results:

voodoo:~#iplog -o -L -z -i eth0

The options are the following: -o (don’t fork and stay in foreground), -L (results to stdout), -z (fool Nmap), -i eth0 (listen to eth0).If I run a Nmap against the box, iplog starts to write a lot of information to stdout, about all connections made, and even which type of scanning is being performed; I’ve included only the relevant information about Nmap OS Fingerprinting in the iplog’s output:

Feb 20 13:20:54 TCP: SYN scan detected [ports 10082,1430,770,815,440,86,848,797,560,5998,...] from 192.168.0.50 [port 49047]

Feb 20 13:20:56 TCP: Bogus TCP flags set by 192.168.0.50:49054 (dest port 22)

Feb 20 13:20:56 UDP: dgram to port 1 from 192.168.0.50:49047 (300 data bytes)

Feb 20 13:20:56 ICMP: 192.168.0.50: port is unreachable to (udp: dest port 1, source port 49047)

Feb 20 13:20:58 UDP: dgram to port 1 from 192.168.0.50:49047 (300 data bytes)

Feb 20 13:20:58 ICMP: 192.168.0.50: port is unreachable to (udp: dest port 1, source port 49047)

Feb 20 13:21:01 UDP: dgram to port 1 from 192.168.0.50:49047 (300 data bytes)

Feb 20 13:21:01 ICMP: 192.168.0.50: port is unreachable to (udp: dest port 1, source port 49047)

Feb 20 13:21:04 TCP: Xmas scan detected [ports 1,9,49055,49056,49054] from 192.168.0.50 [ports 49060,49056,49054,9]

Feb 20 13:21:05 UDP: dgram to port 1 from 192.168.0.50:49047 (300 data bytes)

Feb 20 13:21:05 ICMP: 192.168.0.50: port is unreachable to (udp: dest port 1, source port 49047)

Feb 20 13:21:12 TCP: null scan detected [ports 9,49056,49060,49054] from 192.168.0.50 [ports 49055,9,1,49056,49054,...]

Feb 20 13:21:13 TCP: FIN scan detected [ports 49060,49054,9,1] from 192.168.0.50 [ports 1,9,49055,49056,49054,...]

Feb 20 13:21:56 TCP: SYN scan mode expired for 192.168.0.50 – received a total of 1647 packets (33440 bytes).

Feb 20 13:21:56 TCP: Xmas scan mode expired for 192.168.0.50 – received a total of 33812 packets (676300 bytes).

Feb 20 13:22:03 TCP: null scan mode expired for 192.168.0.50 – received a total of 16462 packets (329300 bytes).

Feb 20 13:22:04 TCP: FIN scan mode expired for 192.168.0.50 – received a total of 16343 packets (326860 bytes)

Iplog does recognize the bogus TCP flags, null packet, … every Nmap OS Fingerprint attempt. That’s why it can act accordingly and send a fake answer to fool Nmap. Nmap output is the following:

# nmap (V. 3.10ALPHA4) scan initiated Thu Feb 20 13:20:54 2003 as: nmap -vv -sS -O -oN nmap3.log 192.168.0.19

Insufficient responses for TCP sequencing (1), OS detection may be less accurate

Insufficient responses for TCP sequencing (1), OS detection may be less accurate

Insufficient responses for TCP sequencing (1), OS detection may be less accurate

Interesting ports on voodoo (127.0.0.1):

(The 1599 ports scanned but not shown below are in state: closed)

Port State Service

22/tcp open ssh

25/tcp open smtp

80/tcp open http

143/tcp open imap2

No exact OS matches for host (If you know what OS is running on it, see http://www.insecure.org/cgi-bin/nmap-submit.cgi).

TCP/IP fingerprint:

SInfo(V=3.10ALPHA4%P=i586-pc-linux-gnu%D=2/20%Time=3E54C833%O=9%C=1)

T1(Resp=Y%DF=Y%W=7FFF%ACK=S++%Flags=AS%Ops=MNNTNW)

T2(Resp=Y%DF=N%W=0%ACK=O%Flags=BA%Ops=)

T2(Resp=Y%DF=Y%W=100%ACK=O%Flags=BARF%Ops=)

T2(Resp=Y%DF=Y%W=100%ACK=O%Flags=BPF%Ops=)

T3(Resp=Y%DF=N%W=0%ACK=O%Flags=BA%Ops=)

T4(Resp=Y%DF=Y%W=0%ACK=O%Flags=R%Ops=)

T5(Resp=Y%DF=Y%W=0%ACK=S++%Flags=AR%Ops=)

T6(Resp=Y%DF=Y%W=0%ACK=O%Flags=R%Ops=)

T7(Resp=Y%DF=N%W=0%ACK=O%Flags=BA%Ops=)

T7(Resp=Y%DF=Y%W=0%ACK=S++%Flags=AR%Ops=)

PU(Resp=Y%DF=N%TOS=C0%IPLEN=164%RIPTL=148%RID=E%RIPCK=E%UCK=E%ULEN=134%DAT=E)

# Nmap run completed at Thu Feb 20 13:21:07 2003 — 1 IP address (1 host up) scanned in 13.633 seconds

As you can see, iplog answers to all the packets with specific options; we can have a look to iplog source code:

file iplog_tcp.c, line 99:

if (opt_enabled(FOOL_NMAP) &&

((tcp_flags & TH_BOG) || (tcp_flags == TH_PUSH) || (tcp_flags == 0) ||

((tcp_flags & (TH_SYN | TH_FIN | TH_RST)) && (tcp_flags & TH_URG)) ||

((tcp_flags & TH_SYN) && (tcp_flags & (TH_FIN | TH_RST)))))

That ‘if’ statement means that if we have executed iplog with the ‘-z’ switch (fool Nmap), and the TCP header options are:

• bogus (use of the reserved bits), or
• only PUSH , or
• NULL (no options), or
• SYN+URG, FIN+URG, RST+URG, or
• SYN+FIN, SYN+RST

then it will create a new packet for answering with the options we want (some options depend on the machine time, for example DF, that’s why sometimes is 1 and other 0, or the window size which is defined as current_time & 1).

Of course we could change the file iplog_tcp.c so that iplog always behave as a Sega Dreamcast for those nasty packets, but we do not have the flexilibity to have multiple personalities or specify that we want to behave as a Dreamcast only for a specific traffic or ip address. It’s a good idea to answer in this way to abnormal packets, but it’s better to have the control and be more granular.

5.1. Blackhole

Blackhole is a special option present in the *BSD kernel to control system behavior when someone is connecting to closed TCP or UDP ports. There are two options that we can change:

sysctl -w net.inet.tcp.blackhole=[0 | 1 | 2]

sysctl -w net.inet.udp.blackhole=[0 | 1]

The TCP blackhole behaves as following: if the value is 0, whenever a packet connects a TCP closed port, it returns a RST. If the value is 1, if a SYN packet connects a TCP closed port, it’s dropped; and if the value is 2, if any packet tries to connect to a TCP closed port, it’s dropped.

The UDP blackhole is similar; if the value is 0, any connection to an UDP closed port, returns an ICMP port unreachable; if the value is 1, it does not return the ICMP port unreachable.

If we enable these settings in paranoid mode, tests 5, 6, 7 and the unreachable port test won’t work when running Nmap to remotely guess the OS, so we’ll not be able to know the OS.

There is also another Fingerprint fucker for the FreeBSD systems, written by Darren Reed, that simply rewrites the TCP/IP stack and sends packets with other settings (different window size, ttl, …) trying to hide its real OS.

The OpenBSD packet filter can also be configured to try to defeat remote OS Fingerprint. There are some options in the pf.conf configuration file (Traffic Normalization) where you can change some IP fields (DF bit, TTL, MSS, ID), as you can see in pf.conf’s man page:

no-df

Clears the don’t-fragment bit from a matching ip packet.

min-ttl _number_

Enforces a minimum ttl for matching ip packets.

max-mss _number_

Enforces a maximum mss for matching tcp packets.

random-id

Replaces the IP identification field with random values to compen-

sate for predictable values generated by many hosts. This option

only applies to outgoing packets that are not fragmented after the

optional fragment reassembly.

FreeBSD kernel has got a special option, TCP_DROP_SYNFIN, which actually drops all packets with the SYN and FIN flags activated (Nmap test #3 sends a SYN+FIN+PSH+URG TCP packet); this special option could be also a valid method for defeating Nmap when performing its tests (be sure to activate it at startup in /etc/rc.conf).

We saw when talking about IP Personality, that we could set up a linux router protecting our internal network, and that router could fool Nmap and other OS Fingerprinting tools when trying to remotely guess our internal network hosts’ OS. If we haven’t got a linux box, but we’ve got a Checkpoint FW-1, then we can do something similar because of the fw-1 INSPECT language. Using this language, it’s easy to create your own ‘packet inspector’ for the packets that are going through your fw-1. There is a reference in the FW-1 mailing list describing a fw-1 service to manage those bogus packets:

Next solution won’t allow us to hide or change our OS, but we’ll be able to create as many virtual devices as we want with every valid Operating System you can imagine. This idea is being applied to the honeypots field, just because you can create a entire C class virtual network with lots of different OS flying around; the black-hat can be easily attracted by all those boxes running so many vulnerable services…It could be an attacker’s heaven.

Honeypots in general, and this approach in particular, can be highly recommended not only for learning the black-hat tools and tactics, but for also divert attackers to your honeynet and not your production boxes. It can also make attackers think that you have an entire farm of a specific OS (the virtual one) and hide your real OS.

The package I’m going to briefly describe is honeyd, from Niels Provos. One of its greatest feature is that we can give each virtual device a specific OS personality. That personality is also fed by a standard nmap fingerprinting file, allowing us to become the OS we want. I’m not going to deeply describe this great tool, I’m only going to run the sample config file to demonstrate what it can do.

After installing it, there is a file which name is config.localhost with a lot of virtual devices configured in. For instance, if we get the device 10.0.0.1 definition:

route entry 10.0.0.1

route 10.0.0.1 link 10.0.0.0/24

[snip]

create routerone

set routerone personality “Cisco 7206 running IOS 11.1(24)”

set routerone default tcp action reset

add routerone tcp port 23 “router-telnet.pl”

[snip]

bind 10.0.0.1 routerone

[snip]

The high level explanation is that we have a device which ip address is 10.0.0.1, which will act as a Cisco 7206 running IOS 11.1(24), will reset all TCP connections except for connections to TCP port 23, because then the script router-telnet.pl (an emulation of the telnet daemon) will be executed. Well, let’s run Nmap to check the OS running in the virtual device we’ve just created:

# nmap (V. 3.10ALPHA4) scan initiated Thu Feb 20 16:17:44 2003 as: nmap -v -sS -oN nmap4.log -O 10.0.0.1

Warning: OS detection will be MUCH less reliable because we did not find at least 1 open and 1 closed TCP port

Interesting ports on 10.0.0.1:

(The 1604 ports scanned but not shown below are in state: filtered)

Port State Service

23/tcp open telnet

Remote OS guesses: Cisco 7206 running IOS 11.1(24), Cisco 7206 (IOS 11.1(17)

TCP Sequence Prediction: positive increments

Difficulty=26314 (Worthy challenge)

IPID Sequence Generation: Incremental

# Nmap run completed at Thu Feb 20 16:20:42 2003 — 1 IP address (1 host up) scanned in 178.847 seconds

Again, when receiving Nmap bogus packets, honeyd answers with the device’s personality we’ve chosen.

As stated in the IP Personality Limitations, changing your TCP/IP stack behavior when receiving Nmap bogus packets can create some troubles:

• some characteristics of OS are related to the host architecture (for instance page sizes on various CPU) which could lead to performance issues;
• some of these changes are more “political” choices of the IP stack (initial sequence numbers, window sizes, TCP options available…). Tweaking those allow to fool a scanner but might break regular connectivity by changing network parameters. It could also make the system weaker if the emulated IP stack is not as strong as the initial one

In my opinion, it’s pretty clear that we can’t rely on only one security tool to remotely guess the Operating System. This paper has shown that it’s very easy to fool Nmap (and other similar tools) when trying to profile a remote device, and that all those attempts can be properly logged by the remote administrator. To successfully remotely fingerprint an OS, all possible methods have to be gathered, starting with the simpler ones (banner grabbing, seeking for job posts, social engineering, …) to the more complex ones (network fingerprinting). Every open service in a remote device has to be properly analyzed (banner, responses, behavior against attacks, DoS, known errors) and documented. It could be even possible (although not ethical) to run some tools that are known to crash specific OS versions (nuke, land, teardrop, …) to clarify our guess.

Although all these solutions can be modified to detect and fool any other TCP/IP fingerprint tool (just knowing which packets are sent), it is highly recommended to use various tools when doing a remote OS Fingerprint. Nmap is perhaps the most widely used, but there is another tool that also works great: Xprobe. Xprobe also has got a signatures database (not updated very often), and the final guess it’s a probabilistic guess (fuzzy matching) depending on various answers. One of xprobe’s biggest problem is that it’s rarely updated and it includes very few signatures. Nmap detects the remote OS if its tests’ result is exactly equal to that OS signature in the database, but you can run Nmap with the switch ( –osscan_guess or –fuzzy, and then it performs a more aggressive OS guess trying to find the best match available in its signatures database. There is a paper about Xprobe specification and usage where explains why its idea and implementation seems to be so good and so valid. I think it should be executed as a partner with Nmap, in case you can send both TCP and ICMP packets against the target host. Xprobe could be an effective tool in poorly secured networks, just because it sends ICMP timestamps and ICMP netmask requests, which can become suspicious for a network administrator. It does not sent bogus packets (uncommon TCP packets, since the reserved bits are rarely used) to detect the remote OS, it simply sends ‘normal’ traffic (ICMP) to the target host, making harder (if not impossible) to detect such packets (and therefore, act accordingly). This approach was first used in sing (Send Internet Nasty Garbage), which can be executed with the -O switch for doing OS Fingerprint (with the ICMP type you choose). It should be difficult to any IDS or network implementation to detect that those ICMP packets have other function, just because there are a huge number of those ICMP packets daily in our networks. On the other hand, ICMP now is getting blocked by default from almost every network environment, making impossible to do an ICMP OS remote fingerprint, but usually you can find some TCP services in those network environments and shoot your Nmap packets.

Just for being accurate, there is also another OS Fingerprint tool, named p0f; p0f listens to your network looking for the first SYN in a TCP connection and grabs that packet options. If it matches with its signature database, then we can guess the OS; again, changing any of the options that p0f is looking for, will completely fool it. If, for instance, using IP Personality, we change every packet’s window size, we can fake our responses and fool p0f.

Administrators should also carefully configure all their devices for not showing anything that can be used for identified them (banners, issue, common services open by default, …) and run one of these tools that can log the OS Fingerprint attempts, because it’s very likely that, those ip addresses wanting to know your OS, will be attacking your network in a short period of time. Besides, setting up a linux router using IP Personality and fooling everyone outside your network that you’re using a different OS (with any of the options shown in this paper), could be a good security measure.

Matthew Smart, Robert Malan, and Farnan Jahanian, Defeating TCP/IP Stack Fingerprinting, Usenix Security Symposium 2000, URL:http://www.usenix.org/publications/library/proceedings/sec2000/smart.html .

Fyodor, Remote OS Detection via TCP/IP Stack Fingerprinting, June 11, 2002, URL: http://www.insecure.org/nmap/nmap-fingerprinting-article.html .

Gael Roualland and Jean-Marc Saffroy, IP Personality, URL: http://ippersonality.sourceforge.net/ .

Sean Trifero and Derek Callaway, Stealth, URL: http://www.innu.org/%7Esean/ .

Ryan McCabe, IPlog, URL: http://ojnk.sourceforge.net/stuff/iplog.readme .

Fusys and |CyRaX|, Fingerprint Fucker, URL: http://www.s0ftpj.org/tools/fingfuck.tgz .

FreeBSD, Blackhole, URL: http://www.gsp.com/cgi-bin/man.cgi?section=4&topic=blackhole .

Darren Reed, Fingerprint Fucker, URL: http://packetstormsecurity.org/UNIX/misc/bsdfpf.tar.gz .

OpenBSD, pf.conf manual, URL: http://www.openbsd.org/cgi-bin/man.cgi?query=pf.conf&sektion=5&arch=i386&apr .

FreeBSD, Kernel Options, URL: http://www.freebsd.org/doc/en_US.ISO8859-1/articles/dialup-firewall/kernel.html .

Alfredo Andr�s Omella, Trying to stop the security tool queSO, URL: http://www.phoneboy.com/fom-serve/cache/82.html , October, 6th, 1998.

Niels Provos, Honeyd – Network Rhapsody for You”, URL: http://www.citi.umich.edu/u/provos/honeyd/ .

Gael Roualland and Jean-Marc Saffroy, IP Personality Limitations, URL: http://ippersonality.sourceforge.net/doc/ippersonality-en-2.html .

Fyodor Yarochkin and Ofir Arkin, Xprobe, URL: http://www.sys-security.com/html/projects/X.html .

Fyodor Yarochkin and Ofir Arkin, Xprobe2 – A’Fuzzy’ Approach to Remote Active Operating System Fingerprinting, URL: http://www.sys-security.com/archive/papers/Xprobe2.pdf.

Alfredo Andr�s Omella, Sing, URL: http://sing.sourceforge.net , October, 6th, 1998.

Michael Zalewski and William Stearns, p0f, URL: http://www.stearns.org/p0f/ .

Version 1.2, November 2002

Copyright (C) 2000,2001,2002 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

The purpose of this License is to make a manual, textbook, or other functional and useful document “free” in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.

This License is a kind of “copyleft”, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.

We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The “Document”, below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as “you”. You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.

A “Modified Version” of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.

A “Secondary Section” is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.

The “Invariant Sections” are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.

The “Cover Texts” are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.

A “Transparent” copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not “Transparent” is called “Opaque”.

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.

The “Title Page” means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, “Title Page” means the text near the most prominent appearance of the work’s title, preceding the beginning of the body of the text.

A section “Entitled XYZ” means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as “Acknowledgements”, “Dedications”, “Endorsements”, or “History”.) To “Preserve the Title” of such a section when you modify the Document means that it remains a section “Entitled XYZ” according to this definition.

The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.

You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and you may publicly display copies.

If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document’s license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:

1. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.
2. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.
3. State on the Title page the name of the publisher of the Modified Version, as the publisher.
4. Preserve all the copyright notices of the Document.
5. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.
6. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in theAddendum below.
7. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document’s license notice.
8. Include an unaltered copy of this License.
9. Preserve the section Entitled “History”, Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled “History” in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.
10. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the “History” section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.
11. For any section Entitled “Acknowledgements” or “Dedications”, Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.
12. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.

M. Delete any section Entitled “Endorsements”. Such a section may not be included in the Modified Version.

1. Do not retitle any existing section to be Entitled “Endorsements” or to conflict in title with any Invariant Section.
2. Preserve any Warranty Disclaimers.

If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version’s license notice. These titles must be distinct from any other section titles.

You may add a section Entitled “Endorsements”, provided it contains nothing but endorsements of your Modified Version by various parties–for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.

You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled “History” in the various original documents, forming one section Entitled “History”; likewise combine any sections Entitled “Acknowledgements”, and any sections Entitled “Dedications”. You must delete all sections Entitled “Endorsements”.

You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an “aggregate” if the copyright resulting from the compilation is not used to limit the legal rights of the compilation’s users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document’s Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.

Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.

If a section in the Document is Entitled “Acknowledgements”, “Dedications”, or “History”, the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.

You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License “or any later version” applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.

To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:

Copyright (c) YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled “GNU Free Documentation License”.

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the “with…Texts.” line with this:

with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.

If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.

If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.

This is not intended to be a technically intricate document to allow a systems administrator to understand why an application or server is not working correctly. Rather, it is meant as a step-by-step guide for a relative technical novice to narrow down possible causes for an unreachable server, before having to call a helpdesk.

Some of this stuff is pretty basic, so just skip around until you find something you can use.  A lot of it is highly out of date, as I wrote it in 2001.

N.b. all output is from entering these commands on a laptop running FreeBSD (Unix); syntax may vary depending on your operating system.

I. Protocols & Ports

Out of academic interest, it might be useful for you to take a look at the OSI (Open Systems Interconnect) model. This is a theoretical, schematic model for looking at network connections- rather than being a written-in-stone classification for different levels of network traffic, it’s meant to allow you to think about parts of network connections a bit more abstractly, and to help you figure out what does what.

Here the main concepts you should consider:

A. Internet Protocol (IP)

Most of the Internet, and most local area networks (LANs) function based on the IP protocol, also referred to as IP version 4 (IPv4.) IP addresses are unique on the internet, and usually look like this:

205.171.14.93

Each of these four ‘octals’ is an 8-bit number, and cannot be higher than 255.  IP addresses are parts of ‘subnets’, or ‘ranges’, which are assigned by organizations such as IANA and RIPE. In order to be properly visible, all IP addresses you want a single machine to reach on the internet must be unique. Likewise, it is a bad idea to simply grab an IP on your local network and assume it will work–you may run into an ‘IP conflict’ which will make your network administrator, and possibly another user, very unhappy.

B. Transmission Control Protocol (TCP)

TCP is the backbone of internet traffic. Simply put, it is a means to transport ’packets’ between applications in a way that assures delivery. Every TCP packet
has a unique identifier (“sequence number”) which is incremented with each packet in a given connection. TCP connections look as follows:

Client –> Server “SYN” (Synchronize)
Client <– Server “SYN/ACK” (Synchronize Acknowledged)
Client <– Server “ACK” (Acknowledge)
Client <-> Server “ACK” (at this point the connection is “established”
Client –> Server “FIN” (Finish)
Client <– Server “FIN/ACK” (Finish Acknowledged)
Client <– Server “RST” (Reset–the connection is now dead.)

Depending on the type of connection, not all of these are necessary–for example, the server may just “RST” the connection without prompting, effectively cutting it off.

C. Unreliable Datagram Protocol (UDP)

UDP is a lot faster than TCP, as it does not do any error checking. Concordantly, it is used for applications where you don’t care so much if the occasional chunk does not arrive. Internet video streaming is a typical application of UDP.

D. Internet Control Message Protocol (ICMP)

ICMP is a way for traffic on the internet to decide where to go, whether hosts are reachable, etc. It advises hosts that a next hop may not be available for traffic.

E. Stacks

An IP stack is an area of virtual memory allotted in a machine to dealing with network connections. All incoming and outgoing network connections are dealt with in this stack.

F. Ports

A “port” is a virtual address configured on a server to listen to connections. It is analogous to a mailbox in a highrise apartment building. Each application has a unique port, although many individual connections of the same type can be handled by a single port. Ports 1-512 by convention are “privileged”, meaning they are supposed to only be handled by applications approved by a server administrator.

Ports 512-1024 are “privileged”, which implies that they are not to be used by applications run by a mere mortal user. However, whether this convention is adhered to or not is up to a server’s administrator.

For a list of commonplace ports, look at

http://www.iana.org/assignments/port-numbers

II. What’s happening?

You may be seeing that a server “just isn’t reachable”. This be due to a number of reasons–there’s no way to predict all of them, but this might give you a few hints as to what the cause could be.

Let’s do some preliminary testing.

A. Machine Settings (Very Basic)

First, check to see that you are on the net. Can you reach anything? Do any of your networked applications work? Are Windows network drives accessible? Can you access any web pages at all? If not, check the following:

• Is the cable plugged in? If you have a link light on your network card, is it lit?
• Do you have a default route? Is your interface configured?

Under Windows, run the command

ipconfig

in a DOS Window. If you see an entry for ‘Default Gateway’, you’re set.

Under Unix, run

ifconfig -a

and

netstat -rn|grep default

Ifconfig (InterFace Config) allows you to see the configuration of all your active network interfaces. Netstat is a general network utility command;  If netstat -an shows you a default gateway, you should be okay.

• Are your general settings correct? Compare your station with others on your local network. If you have a network administrator handy, check your settings against what he gave you. Can you ping them? Can they ping you? Can you ping your default gateway? See below for details on Ping.

B. ICMP/Ping

First, let’s find out whether a host responds to basic pings. “Ping” (Packet InterNet Groper) is a common implementation of the ICMP protocol, and used to probe hosts. On Unix servers, it is usually found in /usr/sbin or /usr/bin, and on Windows machines it sits in c:\windows\system32\ or c:\winnt\system32.

The Syntax of this command is

ping <hostname> (or IP address)

Successful pings generally mean that a server’s address is reachable, and look like this:

bolo:[15:23]~> ping www.berkeley.edu
PING arachne.berkeley.edu (169.229.131.109): 56 data bytes
64 bytes from 169.229.131.109: icmp_seq=0 ttl=237 time=180.286 ms
64 bytes from 169.229.131.109: icmp_seq=1 ttl=237 time=173.291 ms
^C
— arachne.berkeley.edu ping statistics —
3 packets transmitted, 2 packets received, 33% packet loss
round-trip min/avg/max/stddev = 173.291/176.788/180.286/3.497 ms

Under Solaris, ‘ping -s ‘ will return this same result. ‘Ping‘ by itself just will return ‘ is alive.’

If your client station does not know how to get to a net (it does not have a ‘route’), or does not have a default gateway, you will see something like

bolo:[15:25]~> ping www.cnn.comPING cnn.com (207.25.71.5): 56 data bytes
ping: sendto: No route to host
ping: sendto: No route to host
ping: sendto: No route to host
^C
— cnn.com ping statistics —
13 packets transmitted, 0 packets received, 100% packet loss

When you try to reach a remote address, you may pass many network devices (“routers”) on the way. If you are trying to reach an address that they don’t know how to get to, you could see

bolo:[15:28]~> ping 10.0.0.1
PING 10.0.0.1 (10.0.0.1): 56 data bytes
36 bytes from Serial10-1-0.GW3.ZUR4.ALTER.NET (146.188.39.89): Destination Host Unreachable
Vr HL TOS Len ID Flg off TTL Pro cks Src Dst
4 5 00 5400 ae7e 0 0000 3c 01 0384 192.168.1.254 10.0.0.1

Lastly, if your output looks as follows, it is possible that there is a firewall or similar security device in the way, which is not permitting ICMP traffic. This does not mean that the host is down, just that it cannot be pinged.

bolo:[15:32]~> ping 165.222.187.100
PING 165.222.187.100 (165.222.187.100): 56 data bytes
^C
— 165.222.187.100 ping statistics —
32 packets transmitted, 0 packets received, 100% packet loss

C. Traceroute

Traceroute is a program which allows you to find out which hops your traffic passes on the way to a target server. It is usually found in the same location as ping, both under Unix and Windows. Traceroute’s main function is to allow you a look at whether the path a transmission takes from client to server looks sane. A successful traceroute means that the host is up and running, and that there is a proper route to it. Traceroute output looks like this:

soda:[6:38]~> traceroute www.berkeley.edu
traceroute to arachne.berkeley.edu (169.229.131.109), 64 hops max, 40 byte packets
1 gig6-1v247.snr1.CS.Berkeley.EDU (128.32.247.1) 0.744 ms 0.655 ms 0.610 ms
2 vlan241.inr-201-eva.Berkeley.EDU (128.32.255.161) 0.858 ms 0.761 ms 0.818 ms
3 vlan209.inr-203-eva.Berkeley.EDU (128.32.255.2) 0.861 ms 0.986 ms 0.774 ms
4 arachne.Berkeley.EDU (169.229.131.109) 0.781 ms 0.717 ms 0.732 ms

It can also look as follows. This does not mean that the server is necessarily down or unreachable, but could imply that there is a firewall/security device in the middle:

soda:[6:39]~> traceroute www.google.com
traceroute to www.google.com (216.239.33.101), 64 hops max, 40 byte packets
1 gig6-1v247.snr1.CS.Berkeley.EDU (128.32.247.1) 0.777 ms 0.663 ms 0.612 ms
2 vlan241.inr-201-eva.Berkeley.EDU (128.32.255.161) 0.870 ms 0.736 ms 0.785 ms
3 gigE2-0.inr-000-eva.Berkeley.EDU (128.32.0.193) 0.599 ms 0.537 ms 0.515 ms
4 pos3-0.c2-berk-gsr.Berkeley.EDU (128.32.0.90) 0.692 ms 0.579 ms 0.559 ms
5 SUNV–BERK.POS.calren2.net (198.32.249.14) 1.810 ms 1.852 ms 1.992 ms
6 STAN–SUNV.POS.calren2.net (198.32.249.74) 2.230 ms 2.167 ms 2.236 ms
7 PAIX-7206–STAN-3.ATM.calren2.net (198.32.249.186) 3.346 ms 2.836 ms 2.906 ms
8 paix.exodus.net (198.32.176.15) 3.071 ms 3.164 ms 3.503 ms
9 ibr02-g1-0.paix01.exodus.net (206.79.9.242) 3.875 ms 2.931 ms 2.848 ms
10 bbr01-p6-0.sntc03.exodus.net (209.185.9.241) 3.404 ms 3.320 ms 3.366 ms
11 dcr04-g4-0.sntc03.exodus.net (216.33.153.68) 5.334 ms 3.382 ms 9.461 ms
12 csr01-ve242.sntc03.exodus.net (216.33.153.181) 4.482 ms 3.876 ms 4.251 ms
13 google-exodus.exodus.net (64.68.64.210) 4.574 ms 3.610 ms 4.610 ms
14 exbi1-gige-1-3.net.google.com (216.239.47.2) 5.256 ms 5.382 ms 5.315 ms
15 * * *
16 * * *
17 * *^C

Lastly, you may see the next block of output–this implies that there is a firewall in the middle which allows traces to the final destination, but not to itself (thus nobody can identify it as a hop in the middle):

soda:[6:43]~> traceroute altavista.digital.com
traceroute to altavista.digital.com (209.73.180.1), 64 hops max, 40 byte packets
1 gig6-1v247.snr1.CS.Berkeley.EDU (128.32.247.1) 0.837 ms 0.668 ms 0.685 ms
2 vlan241.inr-201-eva.Berkeley.EDU (128.32.255.161) 1.465 ms 0.785 ms 0.754 ms
3 fast4-1-0.inr-new-666-doecev.Berkeley.EDU (128.32.0.73) 1.779 ms 2.628 ms 2.364 ms
4 qsv-juniper–ucb-gw.calren2.net (128.32.0.70) 3.717 ms 3.283 ms 3.259 ms
5 svl-edge-09.inet.qwest.net (65.113.32.209) 3.247 ms 2.917 ms 3.361 ms
6 svl-core-01.inet.qwest.net (205.171.14.93) 3.315 ms 3.632 ms 2.802 ms
7 sjo-core-01.inet.qwest.net (205.171.5.99) 3.831 ms 2.907 ms 3.094 ms
8 sfo-core-02.inet.qwest.net (205.171.5.123) 4.591 ms 4.839 ms 5.857 ms
9 jfk-core-01.inet.qwest.net (205.171.5.113) 66.522 ms 67.079 ms 67.408 ms
10 jfk-core-03.inet.qwest.net (205.171.230.6) 66.856 ms 66.065 ms 67.102 ms
11 jfk-edge-04.inet.qwest.net (205.171.30.114) 66.596 ms 66.322 ms 66.156 ms
12 63.148.0.22 (63.148.0.22) 74.506 ms 74.240 ms 73.975 ms
13 * * *
14 altavista.com (209.73.180.1) 74.845 ms 73.763 ms 74.196 ms

Traceroute and ping are two different applications. Furthermore, traceroute on Windows and NT are not the same type of traffic. Windows traceroute uses “ICMP ECHO REQUEST” to see whether routes to a host are alive. Unix and Cisco traceroute is generally based on UDP.  Some firewalls allow one, but not the other; if you suspect a firewall between your client and the target server, try traceroute from both types of platforms.

D. Telnet

Telnet is a very basic login application designed to emulate a mainframe terminal.  However, telnet has the ability to connect to any TCP ports to show you whether a service is even listening or not. On Inix, telnet is normally located in /usr/bin/, in Windows it should be in C:\{Windows,Win98,WINNT}\System32.

On Unix, you can telnet to a given port for an application using the syntax

telnet hostname portnumber

Based on the documentation in section I.F., to see if my webserver on www.switch.ch is listening on the default http port, I would try the following:

bolo:[17:07]~> telnet www.switch.ch 80
Trying 130.59.10.30…
Connected to etna.switch.ch.
Escape character is ‘^]’.

This means that I have a connection established to the server. In effect, what I have just done is “faked” the same sort of connection that a web browser (Netscape, Opera, Internet Explorer) makes to a webserver. Under Windows NT/9x telnet, the equivalent of this is when the server address is displayed in the telnet window’s title bar. Don’t forget to change the port number from the default ‘telnet’ (port 23) before connecting.   Windows 2000 telnet works like Unix telnet.

If my service uses TCP and I get this prompt, and I am still having connection difficulties, I can rule out that there is a firewall or routing problem; the issue is most likely with the server’s configuration or my client application.

Another possible response to a telnet attempt, this time to the SMTP (Simple Mail Transport Protocol, the most-used Internet email standard) port on an address not configured to receive SMTP mail, may yield this:

bolo:[17:15]~> telnet cfpa11.berkeley.edu 25
Trying 128.32.124.189…
telnet: connect to address 128.32.124.189: Connection refused
telnet: Unable to connect to remote host

This means that the target has sent me a “RST”, or “RESET” TCP packet in response to my attempt to “SYN”. It’s effectively telling me, no, I’m not paying attention to this port. The server is not configured correctly, or the program on the server which is supposed to be listening on the port isn’t even running.

Telnet can also yield this:

bolo:[17:15]~> telnet www.google.com 12345
Trying 216.239.37.101…
telnet: connect to address 216.239.37.101: Operation timed out
telnet: Unable to connect to remote host

This usually indicates the presence of a firewall or other similar security filter in front of or on the server which explicitly disallows connections to port 12345.  Under Windows NT/9x telnet, you will see ‘Telnet (none)’ in the title bar, and the cursor will be an hourglass.

III. What’s Happening on the Server?

Now, let’s see if you can log into your server. If you are able to telnet/ssh/rlogin to your Unix server, or have console/remote desktop access to a Windows NT server on which your network server

A. What’s listening to what?

On your unix server, you can have a look at some locally defined ports in the file /etc/services.  Furthermore, the file /etc/inetd.conf specifies which of these services your inetd, which is the program run by Unix at startup to listen to network connections, has an actual program (server) associated with it. This means that when Inetd “sees” a connection arriving on a given port, it starts a service to deal with it.

However, this is not the only way to run servers. Different types of Unix (Linux, Solaris, AIX, etc.) have various methods for starting servers via scripts at boot. The easiest way to look at this is (on the server!) to run the commands

netstat -an

or

lsof -i (if installed)

To see which services are (supposedly) listening on which ports. If you don’t understand these commands, see whether there is a manual page by running the command

man netstat (or lsof)

This should explain the syntax to you in the usual clear, concise Unix manual page language. In short, for netstat -an, you may see these keywords:

CLOSED, LISTEN, SYN_SENT, SYN_RECEIVED, ESTABLISHED, CLOSE_WAIT, FIN_WAIT_1,
CLOSING, LAST_ACK, FIN_WAIT_2, TIME_WAIT

Consult the netstat man page for the meaning of these. However, if you see your port listed with one of these comments, it means something’s happening with it. Windows NT also has a netstat command, which should be located in your System32 directory.

Lsof (LiSt Open Files) with the -i argument should tell you which actual application is using which port. Have a look at its output, and see if it looks reasonable.

Under Windows, there isn’t much I can tell you except to look at your Task Manager (taskmgr.exe), and your services (under ‘Administrative Tools’), and to not run servers on Windows

B. Sniffing

Lastly, if you have administrator rights on your server, you can run a sniffer for traffic reaching the server. Under Solaris, ‘snoop’ is an example, while BSD-based systems may have ‘tcpdump’ installed. Windows systems generally require an additional piece of software to be installed. RTFM is left to the user. The point behind this is to see whether traffic from your client address actually reaches the server. Generally, sniffers let you sort traffic by destination port or source IP address, allowing you to see whether traffic from the client even reaches your server system.

Please please be aware of the legal/administrative consequences of sniffing network traffic on a system–you may see things people don’t want you to see, such as passwords or confidential data. This is why most sniffer software is restricted to use by people with administrator rights.

IV. Common Services

A server can be down for a number of reasons. Let’s take a few common applications and what could cause them to not respond.

A. Hyper Text Transfer Protocol (HTTP), Web Pages

Some common errors found on webservers are listed at

http://offline.home.cern.ch/offline/web/http_error_codes.html

CERN came up with the World Wide Web, so they should know. By the way, the above is an example of a “Uniform Resource Locator”, or “URL”, which is nothing more than a means of specifying a protocol/application (in this case, HTTP, but can be FTP, Gopher, telnet, etc etc) an address, and a path (the stuff after the first single “/”).

These mean that, while the webserver you are trying to access is listening, there is some problem either with your client (browser) or the web server.

B. Web Applications

If you are behind a firewall, or a proxy server, you may have troubles with certain applications (java applets for example) which your browser attempts to download. Specifically, this can be caused by an application attempting to access a server which your firewall does not allow, even though the application was actually installed via regular HTTP.

Certain multimedia applications, such as RealPlayer and other streaming media clients require various other ports to be opened–this means that your browser understands that a certain kind of file a webserver is giving it should be opened with a specific application, and the application then handles its own traffic.

C. File Transfer Protocol (FTP)

FTP can either be via anonymous FTP (what you usually see when you have a URL in
your browser window starting with ‘ftp://‘) or interactively, either via command-line
ftp from Unix or Windows, or a graphical client such as ‘CuteFTP’ or ‘WS_FTP’.

There are two types of FTP, active and passive.

Active FTP opens a connection from your client to the server, which is used for passing ’administrative’ information–this includes your login and password. However, the FTP server then opens a connection back to you for the actual file transfer, regardless of what direction the file actually flows in (whether you ‘PUT’ or ‘GET’ the file from the server.) Certain firewalls can have trouble with this.

Passive FTP is an answer to this; it only opens the first connection from client to server, and all data also flows over this ‘channel’. However, both the client and server must understand passive mode.

V. My Server is Slow!

As so often happens, servers slow down. There are a few things you can do, without server access.

A. Ping the server

If the ‘Round-trip’ times you see in your ping are above a few hundred milliseconds, there is possibly a problem with the network between your client and server. This can be due to any number of factors; Use traceroute to see where the bottleneck is.

B. Check client load

Self-Explanatory. However, everything else shouuld be slow as well.

C. Check server load

On the server, if it’s an NT server you can run taskmgr to see what the server load is.

On Unix, there are a number of commands you can look at; these include (insofar as they are installed)

top
uptime
vmstat
ps
dmesg

You can also look at syslog and messages (in /var/log/ or /var/adm/) for some further information.

I can’t tell you what proper output of these will look like, but they will give you information on what could be wrong with a given application

D. Check network load

Are you connected to a switch or a hub? Ethernet, the underlying protocol for many IP connections, is essentially a ‘shared medium’. This means, that if two machines on a local physical segment simultaneously try to transmit data, you have what is called a ‘collision’.  The more collisions you get, the slower things are. A hub creates a larlge physical segment, leading to the possibility of collisions, while a switch is designed to separate so-called ’collision domains’.

Make sure that your network card speed is correct. Some network cards try to ‘autonegotiate’ their speed with whatever switch/hub port they are connected to; sometimes this breaks. Make sure with the network administrator that both your station and the network device are trying to communicate at the same speed.

While you’re at it, have them check network traffic load on that port, as well. Most network devices allow ‘polling’ of their load, via a protocol called SNMP (Simple Network Management Protocol). It could simply be a case of putting too much data on a slow line, such as downloading enormous files over a modem link.

E. Check the cable, network hardware

Ethernet/Cat5/UTP cabling can be sensitive to various factors, such as errors introduced by radiation from nearby fluorescent lighting, untwisting of the wires (UTP = “unshielded twisted pair”), etc.

Your network staff can also usually check logfiles on a router/switch/hub for errors, or run a debug command on the device. Network hardware does occasionally break, as do network interface cards (NIC) on servers and clients.

VI. Compendium

If you can’t figure out what’s wrong at this point, you’ll probably need help (helpdesk, USETNET newsgroup, etc.) Remember that the more information you supply from system debug commands, the easier it’ll be to help you find out where your problem lies.

(c) 2001 John Morgan Salomon