This is also not a laundry list of what you should learn, check off, and put on your resume — but a bunch of topics to consider gaining some degree of familiarity in.  Many of these I’m by no means an expert in, but I’m at least familiar with the concepts and have the basic understanding needed to figure them out and how they apply to my job.

The Technical Basics

You can’t learn security unless you’re familiar with the technology it deals with.  Learn the fundamentals.   Here is a very incomplete list.  You will never be able to do everything on it, at least not in depth.

It’s only fair to note that I come from an operations / architecture background, and that my primary experience is in network and systems security, plus authentication and cryptography.  Draw your own conclusions.

Operating Systems

Installation and management (systems administration).  My tip:  Start with one of the *BSDs (OpenBSD, FreeBSD, NetBSD) and Linux (any distro — what’s important is figuring out how to use the command line, what files are where, etc.), then Windows.  Set up a bunch of virtual machines (using VMWare or Virtual Box or equivalent).  A lot of companies use Solaris (get a copy of OpenSolaris and play with it) and AIX, although you’re not likely to get access to many of the enterprise-level software they use.  Learn systems administration, buy a good UNIX book.  Learn about jails / chroot and virtual servers.  Understand Windows Group Policy Objects (GPOs).  What is a kernel?  How does an operating system’s boot sequence work?  Where are logfiles kept, what formats are they in, and how do you configure system and application logging?

Coding / Programming

Scripting and programming.  UNIX shell scripting, Perl, C, C++, Java, Python, VB.Net, anything.  I was never good at much of this beyond very basic scripting, and that sucks.  If you go into any kind of either operations or investigation work, you’ll need this.  PHP, ASP, HTML and other high-level “languages” also help.  Understand the difference between compiled and interpreted, low-level vs. high-level languages.

Networking

Understand subnets and know how to calculate network masks.  Learn what routers, switches, and hubs are.  Know the basics of wired and wireless data networking.  Understand how different operating systems and applications deal with networks.  Learn the OSI model.  What are router ACLs?  VLANs?  Know how MAC addresses work

Network Security

What is a firewall and how is it different from a proxy server?  What is a packet filter?  Download something like M0n0wall or pfSense and set it up.  Buy a hub and learn to sniff packets with tcpdump and Wireshark.  Play with Netcat and get two Netcat sessions talking to each other.  Understand NMAP and how it works.  Learn what load balancers, reverse proxies, IDS and IPS do and how they work.  What is host-based vs. network-based IDS?

Applications

Set up Apache and IIS.  Set up MySQL, Microsoft SQL Server, or another relational database, and install multiple databases in a single instance.  How does ODBC work?  Set up a DNS server and learn about DNSSEC.  Set up an SMTP server and get it sending and receiving mails.  Learn about POP, IMAP, SMTP, Exchange, and their secure variants.

Authentication and Encryption

How does LDAP work?  What is Kerberos, NTLM, PAM, SASL?  What are SSH/SFTP/FTPS, and can you get passwordless SSH working?  What is ‘salt’?   Learn how to use John the Ripper and other password crackers (e.g. cain, able).  What are rainbow tables?   Set up sudo.  What is RBAC and how does it work?  Why shadow passwords?  What are file/directory permissions and how are they configured?

Understand the difference between symmetric-key and public-key encryption.  What is SSL / TLS?  Can you set up OpenSSL and issue your own certificate?  What is x.509 and what are digital certificates?  What is a PKI, a smart card, a root certificate, a CRL?  What is a hash?  What are checksums?  Can you set up PGP/GPG?  What is IPSEC, and what are its different implementations?  Can you set up KAME between two hosts?  What are cookies and how do they work / how can they be abused?  What is the difference between encryption, signing, and non-repudiation?

Other Tools

Download and play with BackTrack and learn some of its tools — Wireshark, Kismet, Metasploit, etc. — it also includes some of the applications I mention above.  Play with dsniff and at least familiarize yourself with what its various components do.

Security / Cracking Techniques

What is penetration testing?  White box / grey box / black box testing?  What is SQL injection?  How does XSS work?   What is a buffer overflow?  How does fuzz testing work?  ARP spoofing?  Session hijacking?  Privilege escalation?  How would you sniff network traffic (hint — see above)?  What are different kinds of keyloggers?  What is a virus, a trojan, a man-in-the-middle attack?

Non-Technical Stuff

A lot of security is based around laws and best practices.

Laws

You should be aware of legal issues surrounding the following, across various jurisdictions:

• Privacy
• Data protection
• Wire and communications fraud
• Reporting obligations

Related laws also concern the following

• Financial disclosure and due care (e.g. SOX 404)
• Medical records (e.g. HIPAA)
• Risk management (e.g. Basel II)
• Safety and due care laws
• Contract law

There are a lot of laws that cover things like financial risk, operational risk and liability, intellectual property / secrecy rights, and rules of evidence.  They vary hugely between jurisdictions.  Keep this in mind.

Standards and Best Practices

The past years have seen an increasing degree of standardization and development of frameworks that may at least be useful as references.  A few examples with at least some security relevance:

• COBIT
• ITIL
• ISO 27001
• HL7 (medical)

There are also innumerable organizational requirements and contractual standards (e.g. stock exchange security rules) that a company or group may have to follow.

My personal advice:  give yourself at least a basic idea what the big ones are (in your field and cross-disciplinary), and what they’re about, take what makes sense.

Concepts

What is risk?  What is a vulnerability?  What is a threat?  What is CIA and why is it important?  Figure out the differences between privacy and anonymity.  How is availability calculated?  What’s the difference between a policy, a procedure, and a process?  Who is responsible for what, where, when?

Education and Networking

Courses and Certifications

Technical

I took a few basic Cisco and systems administration classes — these were helpful, but I’m not a big fan of coursework.   Your mileage may vary.  In addition, I’ve done several individual sessions (for example, an NMAP “dojo” with the guy who wrote it) that were pretty helpful.  Most of my knowledge comes from experience and personal learning, though, so I can’t comment.  My general opinion:  great, if you can get someone to pay for it.

Degrees and Diplomas

Groups like Royal Holloway, ETH Zurich, and CERIAS offer diploma courses in information security.  What do I know, I have an undergraduate degree in international relations from Cal, and an MBA.  Not directly academically useful to my career, but very interesting in terms of environment and exposure to people smarter than myself.  That should be your primary goal anyway.

The NSA has a list of accredited schools with information security programs.

Security-Specific

There exist tons of security courses, including SANS trainings, ISC², and others.   I passed the CISSP exam, which was interesting-if-basic, and decided against throwing more money at certifications.  As with the technical courses above, my personal opinion is that if you can get someone to pay for it and to give you the time for it, superb.

Subjective view:  I would be suspicious of any employer that requires technical certification if you have any kind of professional experience.

Dan Guido (see under “Other Resources”) has a list of courses if that’s your thing.

Conferences and Networking

A lot of this field is about meeting people.  Plus, conferences can be a lot of fun (often you end up going out and getting drunk with a bunch of geeks, which is usually rewarding in itself, in addition to actually letting you watch good presentations.)

I’ve attended http://cansecwest.com/ and CERIAS, which are about as completely different as it gets in terms of focus

The downside is that a lot of the security area is about personalities — don’t let that discourage you.  Odds are you’ll never be a vulnerability research rock star with fawning hordes of nerd groupies, but that’s not the goal, right?

Meet people.  Again, meet people.  Get to know them.  Don’t worry so much about making friends with the “big names”, but familiarize yourself with the people in your company, in similar companies, in your city, and in your field.  I run a small security mailing list, originally designed to let IT security types in Switzerland get together for beers and pizza.  Do the same.  Stay in touch — these people are your network (and can be pretty cool to boot.)

Try to help others as much as you can — on forums, and on mailing lists.  In addition to being good karma, it often will help you learn for yourself.

Books and Materials

RFCs are your friends.   They’re written extremely densely, but the information is there.

Sign up for mailing lists, specifically in aspects that interest you (these are often flooded, so don’t try to take in everything at once.)  Security Focus is a good start.

Check a few pages regularly for information on security vulnerabilities.  Secunia and the F-Secure blog are decent.

Other Resources

Dan Guido has a good writeup of what to look for.  Look for pages written by people like Bruce Schneier, there are too many to even start listing.

Career Decisions

What do you want to do?

This is a tough one, seriously.

I wanted to be a UNIX systems administrator, back when tech was still fun.  Then, one day, someone dumped a firewall book on my desk, and said, “you’re the security expert, read up.  Congratulations.”  I bounced around in architecture, operations, compliance, policy, and training work, before ending up doing mainly incident response and risk management.    In fact, most of the people I know who are good at “security stuff” gradually evolved into their roles, rather than deciding early on “I want to do this or that”.

Of course, to be fair, nowadays a lot of the field is more structured.  Your mileage may vary.

This is a really arbitrary, artificial list.  A lot of the following fields overlap heavily:

Operations

Mainly network security and authentication.    Lots of systems administration.  Usually lots of relationships with OS- and application administrators.

Architecture / Development

Designing and creating stuff.  Can be “low-level” (i.e. network security architect, which firewall goes where), or “high-level” (designing policies and rules for putting various types of technologies to different kinds of use.)  Could also involve writing software or configuration files.

Research

Either academic, commercial, or individual (whee, lookit me, I h4x0r3d a web site).  You try to find new vulnerabilities, or work on new security technologies.

Policy and Compliance

The people who write the rules of what companies should do to ensure security.  Relevant to audit.  Generally high-level, deals with laws, best practices, and organizational-level risk management.

What I currently do (security risk assessment) is related to this — I work with projects and try to make sure their technology is reasonably secure and they follow all the rules, then suggest ways they could do things better, pre-emptively.

Penetration and Code Testing

What it sounds like — you get paid to try and break other people’s toys and tell them what they should do better.  Usually nowhere near as fun as it sounds like, as it mostly involves fairly strict limitations (e.g. you can’t take down banking systems, you have to follow strictly defined procedures) and lots of paperwork (letters of authorization, formatted reports, etc.)

Forensics, Investigation, and Incident Response

This is fun, but occasionally frightening and frustrating.  Its main component is following up on abuses of policies and laws.  This includes, but isn’t limited to:  attacks from inside and outside, harassment, violation of technical policies, industrial espionage countermeasures, and electronic fraud investigation.  Also deals with damage control from things like denial of service attacks or other things going wrong.

It tends to also involve cooperation with architecture and operations people, in terms of things like preventative or reactive patch management.  Warning:  may seriously impact your faith in human decency — from the management attitudes and legal techniques you deal with as much as the rancid child pornography you’re likely to be exposed to.

Where do you want to work?

Never forget that, in almost any security job, you’re a service provider whose job is to restrict what people do.

It’s important to figure out if you want to work for yourself (can be very difficult at first), as an employee, or as a contractor.

My experience is mainly in the following fields:

Financial Services

Banks pay well.  They’re among the biggest security consumers.  They tend to have access to lots of new technology and move pretty fast, but are also lots of management.  Can often be very personality-driven, usually more formal than other work environments.  Depends heavily on whether you work in private, retail, or investment banking, insurance, finance, or others.

Medical / Diagnostic

Much slower-moving than finance.  Heavily focused on QA (e.g. data integrity).  Usually lots of very smart people — security is comparatively new to these guys and heavily laws-driven.

Education

Stay away.  Seriously.  My only advice.  Feel free to draw your own conclusions, but in my career, it’s been the most political, ill-paid, big-fish-small-pond nastiness I’ve ever encountered.

Services / IT Products / Consulting

Usually reasonably paid — the advantage is that you’re working with other tech people.  The disadvantage is that, in most cases, your employer often takes a significant chunk of your paycheck.

I have no experience in the following:

Government / Military

Lots of money, salaries generally not that good, new technology but very strict rules.

Industrial

Commercial

Non-profit

….and others.

Most importantly, some pieces of advice that apply to all jobs:

• Always try to talk directly to the manager who’ll be in charge of the group you’re applying to.  Going through HR is often a dead end.
• Never ever lie on resumes.  Don’t be afraid to publicize yourself, though.
• Avoid politics.
• Never burn bridges.

I hope this helps.

Privacy and anonymity are good things.  Bruce Schneier has some great points  – they are essential for democracy, and absence of anonymity is ripe for other kinds of abuse.

All arguments against online privacy and/or anonymity come down to the question, “what do you have to hide?” to which the only useful response is, “nothing, let me film you the next time you use the toilet”.

My first instinct is, “why bother”?  As others have pointed out, staying anonymous online is a myth.  Even if you disconnect yourself from Facebook, webmail accounts, and any support forums you might otherwise use, and religiously heed the dictum that you should never post anything anywhere online that you might not want someone to see, a sufficiently motivated analyst would find what I would refer to as second- and third-tier records, such as credit card bills, bank accounts, social security numbers, driver’s license details, etc. — more than enough for most purposes.

Both privacy and anonymity are, at most, best-effort affairs.  So what is the motivation for this sort of research?  A few plausible scenarios:

1. Identify theft (e.g. constructive, for financial or other gain, or destructive, for defamation/slander)
2. Targeted investigation (e.g. for a job, political office, or crime-related research, etc.)
3. Statistics (e.g. targeted marketing)
4. Trawling (e.g. to find instances of wrongdoing)
5. Other (e.g. digging up dirt, fun)

I would guess that a vast majority of information collection falls into category 3, followed at a distance by category 4.  Category 3 is worrisome mainly if you disagree with it out of principle.  Fair enough. Growing technological capabilities of data cross-correlation systems allow for easy creation of entire profiles from otherwise disconnected bits of information.  The potential for abuse of such a holistic, instantly accessible set of information about you as an individual is immense.

Even in the “right” hands, such as law enforcement (depending on your point of view) and responsible marketing types working under a strong privacy policy, the temptation to misuse data is inevitable.  It is human nature to break rules, even in small ways — we are not automatons.  I won’t go into scenarios about what even a government agency, scrupulously following all laws to the letter, could do with instantaneous, 24/7 knowledge of what you do, where you are, and what you’re thinking (category 4, followed by category 2), let alone a criminal element with stolen data about you (categories 1 and 2). Just in the hands of advertisers alone, the potential for irritation is limitless.

So let’s say that, out of principle, you object to the collection of information in the course of routing activities like online searches and use of free webmail service.  I firmly believe that the best way for individuals to make the collection and correlation of information more difficult is to create as much entropy as is feasible.  You can’t make it impossible, but you can at least make it not as easy.

In addition to at least making an effort to secure your Facebook profile as much as possible, some basic points:

Use GPG or PGP for mail and files.  Most mail clients have easily available plugins.  Make your key available.

When using free services like (highly recommended, by the way) Dropbox, use something like PGPdisk.  You won’t be able to access it via the web interface, but it provides good security for files you share between computers.

Use SSL whenever you can.  Even if you don’t use a commercial ($$) certificate for your own web page, you’re just trying to encrypt traffic.  I recently made the mistake of accessing one of my (non-SSL) website accounts from a public wireless network, and only realized my mistake two seconds after logging in.  Whoops.  Password change time…

Use tor, and the excellent Vidalia package (on the tor site).  Tools like the Firefox torbutton add-on make this a snap.

Tunnel things via SSH, and only use SSH for access to UNIX boxes.  Of course, you’re already doing this.

Search on googlesharing (assuming you trust Moxie Marlinspike more than you trust Google) and use any of the other anonymizing services out there.  If you run your own system, I can also recommend tools like nph-proxy.

And, of course, never post anything online you wouldn’t want someone else to see.

But again, full anonymity and privacy are illusory.  Someone who cares enough can always find out about you, given sufficient tools and determination.  Enter a colleague’s attitude, which I find pretty interesting.

His point is that it’s best to establish patterns of regular usage, that most of what you do is utterly and completely uninteresting to anyone out there beyond statistical correlation with hundreds of millions of other users, and that you can’t realistically expect to hide 90% of your Internet activity anyway.  For those times when you really need to duck under cover, though, you should be technically astute enough to abandon those patterns you’ve established.

His logic, which I can’t refute, states that it’s better to have a public persona, which will provide plausible deniability of the few, specific instances when you really need privacy and anonymity, than to constantly attempt to hide everything you do.

HFT is a hot topic in circles ranging from regulatory and compliance discussion forums, over smaller traders, to conspiracy wingnuts.  Despite the fact that it’s just one technological tool among many to give exchange participants an edge over competitors, I tend to side with the conspiracy theorists, especially insofar as it’s an approach to transactions that by its very definition gives an edge to larger market actors — thus skewing the idea of a “fair market”.  Various individuals have claimed that this goes so far as to allow participants to manipulate prices using fake orders, but I don’t know enough about trading technology to comment on this.

Due to the very technologically intricate and detailed nature of HFT platforms, very few people understand how they work — and overtaxed regulators and security & compliance organizations thus are left in the dust when it comes to ensuring that such solutions do not present a security and operational risk, not just to the companies who run them, but to overall market stability.  Remember, complexity is almost always bad if you can’t reliably understand it with a reasonable grasp of the subject matter.

The article has one particular paragraph that rings very true:

While applications are combed for typical application vulnerabilities like SQL injection or cross-site scripting, they’re not examined for operational vulnerabilities: A rogue trader could, for instance, change a single variable to allow far more risky trades than a bank or its clients intend–the sort of trick that Société Générale trader Jerome Kerviel may have used to make unauthorized trades in 2008 that cost the firm $7 billion.

Yeah, basically.  Many of the people who use these toys are very bright autodidacts, creating customer tools for exotic, structured products.  Even off-the-shelf software is frequently written using what I like to call “functional programming” — i.e. a very smart person with a Visual Basic book coding a solution to an operational requirement without paying attention to best practices that may, in any case, be outside of the scope they care about.  Investment firm management is likely to turn a blind eye to even obvious flaws in such software, due to the fact that traders (a) bring in massive amounts of revenue and (b) are increasingly the only people who understand certain market types.

The rise in black pools and other off-exchange trading will only increase the latter phenomenon; I’ve seen trading floors where it was pretty common for one person to be responsible for a particular exotic product; frequently, this person might even have been the one who helped create the actual market.  Remember, you can trade pretty much anything, as long as you have a willing counterparty…

How do you deal with such issues as a security professional?  To many who are not trained in the black arts of financial transactions, much technological innovation in modern markets is the driving force behind an increased complexity that regulators cannot hope to oversee effectively.  Analyzing security issues in such tools also becomes difficult, even from the inside, even when a company is willing to implement controls — the line between legitimate exploitation of a weaker player’s market position and an actual security intrusion blurs to the point where traditional technical vulnerability analysis is no longer an option.

I don’t have a solution, beyond an innate distrust of anything I don’t understand in detail, but I believe that companies’ willingness to reduce their exposure to security issues stemming from overly complex trading software is  more a philosophical than a policy or technical question — how far are we willing to go to exploit loopholes in the spirit of market regulation?  Are we willing to sacrifice potential high risk + high profit combinations in order to remain in more staid trading areas?

And most importantly, if management won’t listen, as a security guy, can you sufficiently CYA to avoid being caught up in a potential technical or regulatory failure of one of your employer’s systems that’s just too intricate to reliably review for risk?

This was on my old site before I moved. Maybe someone will find it interesting.

-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 particular article lists examples of electronic warfare by regime-friendly groups such as the “Iranian Cyber Army”, recently suspected of numerous attacks against organizations seen as hostile to the Iranian government.  Ironically, these included Chinese search engine baidu.com in retaliation for some perceived slight by the Chinese government — this shortly after several Chinese organizations have become increasingly implicated in online hits against U.S. and other Western government and corporate targets; a recent report in The Associated Press / The Guardian mention the Chinese universities Shanghai Jiaotong and Lanxiang Vocational Institute as sources of the “Aurora” attacks against Google and others.  On a humorous side note, if 1337 xenophobic script kiddies friendly with one totalitarian regime are now going after 1337 xenophobic script kiddies friendly with another totalitarian regime, it might become difficult to figure out who’s on whose side…

That said, there’s not much an outsider with technological know-how can do to help victims of censorship and repression in any country beyond providing them with the education and means to get around official repression of communication with each other and with the outside world, and to avoid being detected by government thugs while doing so.  A friend of mine, when asked to to provide help and information about censorship avoidance to an Iranian group, took a very cautious line, making it very very clear that he was reluctant to offer anything that carried even the slightest possibility of someone being arrested, tortured, or even killed if they were found using it.  I take a bit of a different view — solutions like PGP, TOR, Haystack, anonymous remailers, or SSL enabled CGI proxies, combined with private browsing available on most newer browsers, are powerful stuff, and with a modicum of care on the part of their users, can conspire to throw a hefty wrench into the surveillance machinations of dictatorial spooks.  The best anyone can do is to make users at risk of brutal crackdowns aware of what could possibly go wrong, give them a good head-start on how to use their new toys, and let them be adults about making an educated choice.  After all, in the case of the Iranian protesters, these are people who’re willing to go out on the street and be shot at for what they believe in.

So much for “passive” assistance — giving people better anonymous / encrypted communications tools and the knowledge on how to effectively use them.  What about active help, though?  Beyond the usual low-level stupidity found in IRC channels (e.g. background noise of the “www.bobsautodetailing.com pwn3d by H4X0RZ 4 ALLAH AGAINST 4m3r1kkkAH” variety), attacks on the infrastructure of Western countries and organizations from Russian, Iranian, North Korean, Chinese, and other groups, presumably with at least some tacit blessing from their governments, are pretty common.  Botnets designed to carry out probes and hits on infrastructure, launch DDoS attacks, create economic sabotage, steal sensitive data, and other bad things, are pretty common in the wild.

Cybercrime legislation in most developed countries is designed to pursue and allow prosecution of even casual probes by unauthorized persons.  Whether one agrees with laws or enforcement tactics or not, the goal is to keep anyone, no matter what motivates them, from generally screwing things up by spying, stealing, or vandalizing.  Unless it specifically takes into account intent, the law doesn’t differentiate between amateurs or professionals — it’s all a crime.  Why?   Partially because attacking a person/host/company/government via a network is the technologically easiest, least physically risky way of getting to the goodies, and because it’s often impossible to differentiate between the casual hacker and the much-vaunted bugaboo of organized cybercriminals and government-sponsored electronic espionage.  The idea, I suppose, is that tolerating any intrusion means that the world economic system as we know it will grind to a standstill (or at least your job and mine will be made that much more difficult.)  Maybe, maybe not, but without such laws as a deterrent, I’m sure the barriers to causing grief to legitimate business would be a lot lower.

But what of aiding and abetting attacks against distasteful regimes or their allies / henchmen?  A few years ago, the idea of counter-hacking, or ethical hacking aimed at taking out threats either by sabotaging those responsible or by “cleaning” affected infrastructures when unsuspecting owners could not or would not, was in high discussion.  Most security professionals in my circle of acquaintances seemed to be roundly against this concept, due to the potential for a slippery slope, and for unacceptable collateral damage — plus, what good is it to have and enforce laws against illicit intrusion when the “good guys” themselves are guilty of violating them, even if they are perfectly well-meaning?

Given how hungry my non-technical Iranian friends were for any information about “passive” tools as those described above, I’d imagine groups in opposition to the government (supposedly there’s now a “Green Cyber Army“) would imaginably be equally happy for any assistance from sympathetic types in the West.  As someone strictly in favor of the rule of law, I can’t condone any illegal actions of the sort these guys are indubitably carrying out, but anything that helps cause grief for kiddies hacking in the service of thugs is ok in my book.  A few dozen clicks to waste here and there to waste the bad guys’ bandwidth, a Metasploit download mirror, or an open proxy or TOR gateway probably wouldn’t violate the spirit of the law.  Wink wink.

Partially this stems from the desire to apply financial metrics to risk and security, partially from the need of managers lacking a strong technical background or the ability to acquire this to have easy-to-understand, purely numerical descriptions and graphs of where their money is going.

One of my colleagues recently came up with the concept of an abstract measure of security investment (time, effort, grief, etc.) — the securitron.  As in (hold hands zombie-like out front and repeat in a robot manager voice), “we’re going to need more securitrons!  Throw two hundred additional securitrons at this project!”

For some reason, this came up again during a meeting to discuss increased efficiency of risk management paperwork.  The upshot of this meeting, as with pretty much any business meeting consisting of over three people (and not taking place by the coffee machines, where most productive work gets done), was (a) use your own damn judgment, that’ s what you’re paid for, these are only suggestions, (b) if you still have questions, ask your colleagues, that’s why we sit together, and (c) when will this damn meeting end?

However, an interesting point did arise — the idea that security, risk management, and compliance work tends to end up with reams of paper that may or may not ever be read.  This was the case with all medical regulatory and compliance work I’ve ever done, as well as with pretty much every experience I’ve had in financial services since 2000.

The conclusion?  My personal view is that documentation and paperwork does not make much sense unless it’s in an easily accessible format (e.g. a well-organized database schema accessible by very flexible views to whomever wants to use and evaluate the data.)

Another very important point that my colleague raised, though, was the concept of the “thunk test” — i.e. if a security policy is dropped on a desk and makes a “thunk”, it’s too big to be of any use.  Nothing that heavy can possibly have the elegance and simplicity to be easily enough understood for practical everyday application.  At the risk of advocating the development of tired business doublespeak, I could see a use for a plainly worded non-mealy-mouthed type of goals and rules statement (“don’t leave passwords lying around.  Never talk to strangers.  Don’t pet strange dogs”) for security organizations that actually fits on a single piece of A4 paper (or at least in a document that makes no more than a soft whisper as it’s dropped.)

Now, we are working on finding a good name for a measure of the quantitative relationship between securitrons and reams of paper.

“As a general view, they have excellent memory and strong attention to detail. They are persistent and good at following structures and routines”

So, I got to thinking; one of the discussions I had with colleagues following a recent meeting with a provider of managed security services (see previous post) dealt with the idea that building and maintaining a decent SOC and log/event management procedure is a near-impossible task, due to the difficulty of creating a sustainable operations process; one of my co-workers made the point that most people would tend to get bored with the repetitive nature of looking through logfiles, or even dealing with things like security advisories and updates.

I countered with the assertion that your basic event management and intelligence correlation should, to a large degree, be automated anyway (whether non-dedicated companies can do this as well as, or better than, dedicated outsourcers is a separate discussion that’s probably best investigated on a case-by-case basis.)  However, the routine nature of any IT operations-type job aside, he did have a point that (a) even when you do automate everything, you’ll still want a degree of human second-guessing, and (b) that gets mighty dull.

It seems like a logical conclusion that if Thorkil Sonne is right, and autists (is that a word?) can really be excellent at work that requires focus, consistent attention to detail despite the drudgery involved, and clear rules, why not use these guys for exactly the tasks described above?  Someone who is excellent at pattern detection, and is willing to follow the same process day after day after day would seem to be ideal for an SOC monitoring / log & event analysis position.

I don’t want to come across as somehow insensitive, since I know next to nothing about autism, but purely going by the value proposition put forward by Specialisterne, it seems like a rational conclusion to hire the best people for any given job — whether or not the fact that they are qualified at what they do stems from extraordinary dedication, experience, or a mental condition should be completely irrelevant.  And in the process, maybe do some good for someone who might be difficult to employ otherwise.

]]>Wired Magazine recently published a set of articles titled 12 Shocking Ideas That Could Change the World. Among them was a suggestion by a Danish gentleman named Thorkil Sonne, of Specialisterne, to hire autists.  His reasoning is that people with autism or asperger&#8217;s are good at routine tasks; &#8220;As a general view, they have excellent <a href='http://www.chakraborty.ch/?p=102'>[...]</a>http://www.chakraborty.ch/?feed=rss2&p=1021http://www.chakraborty.ch/?p=102http://feedproxy.google.com/~r/TheShivling/~3/b9bYE9TLwNw/Architecture & DesignFirewallsNetwork SecurityjohnMon, 21 Sep 2009 11:45:35 PDThttp://www.chakraborty.ch/blog/?p=100I had a workshop at the offices of a major international backbone provider today, on the subject of security logging/monitoring/response and DDoS defense for large companies.

1. Tarpits

In the course of providing managed security service, part of the problem faced by these guys is the proliferation of custom exploits and attacks, according to their research up by 59% this year (I’d link to the pdf, but since I’m under NDA with the client I was representing, I’m not entirely sure if it’d be appropriate. You figure it out.) As it turns out, part of their mitigation strategy for quickly identifying new attacks is to set up all non-allocated netblocks they own as gigantic honeynets, for research purposes.

I asked one of their sales guys why they didn’t allocating a small portion of these IPs as tarpits?  It’s not a new technology by anyone’s estimation, and given the sheer scale of IPs they’re using as honeypots, it wouldn’t be a big sacrifice, considering that a single LaBrea installation can trap hundreds of worms and stop older beasties from clogging up the tubes.  His response?  ”Our mission isn’t to save the Internet.”

Honestly though, it should be — it’d be in everyone’s interest, including their own, to minimize capacity used by worms and bots, bandwidth that could be used productively for other purposes.  To this end, I had an idea; I hadn’t been aware of the huge amount of unused IP space available to providers of this size.  I also recall various organizations and individuals having excessive IP allocations removed and thrown back into the pool (a good move, considering that the total filling up of IPv4 space has been predicted with clockwork regularity every year since at least 2000.)

So, why not have IANA and the regional RIRs set it as a condition that 5% of any unused IP space an organization owns must be allocated for the public good — i.e. sticky honeynets / tarpits?

2. Stopping DDoS at the Edge

We started discussing DDoS mitigation strategies for big customers; this particular ISP’s service consists of a cloud-based solution.  Which brings me back to the idea that, since counter-attack is kind of a silly idea when you’re fighting 100,000+ hosts, (plus, do you really want companies / governments deciding whom they get to actively knock off the net?) why don’t we unearth the concept of stopping DDoS at the edge?

This has been around as a concept for some time; it would require a fair amount of coordination on the part of ISPs, and, potentially, governments, considering the magnitude of attacks suffered by Estonia in 2007, as well as China’s and North Korea’s burgeoning military / government-sponsored cyberwar capabilities.  However, it seems to make sense to me that figuring out how to stop baddies getting in is a far more sensible goal than stopping them on the way out.

Remotely Triggered Black Hole Routing is a reasonably fresh approach to this, allowing the remote reconfiguration of BGP routes to drop malicious DDoS traffic.  Older concepts include Diadem, a combination of software and dedicated hardware.

There are a few major problems with the idea:

a) It would require a massive amount of CPU power.

Considering how much time and money is being invested by Cisco and the likes in deep packet inspection technologies (not always for good purposes — caveat, very one-sided article, but the point holds), I wouldn’t find it to be such an insane development goal to create and deploy dedicated edge routers capable of on-the-fly reconfiguration.

b) It would require large amounts of co-operation and coordination

Well, yes.   The Internet is supposed to work on the basis of this.

c) It has the potential to knock innocuous sites offline

This is the biggie; using spoofed source origin IPs, it’s conceivable that anyone could be falsely accused of launching a DDoS and in turn be knocked off.  The ISP I spoke with today actually had the tools to deal with this; they worked on the basis of source IP trust levels for customer IPS deployments.   Roughly speaking, every dodgy-looking connection is checked by the provider against a dynamic database of activity emanating from that IP / IP range over its backbone network.  Connections (not contents) are archived for around two weeks; the security management service informs customers of the trust level of that IP.

This could conceivably be adapted to prevent false accusations of DDoS traffic — for example, by placing modified, heavily audited IDS probes at company networks’ egress points which match “real” traffic emanating from the company with the ISP’s database of traffic claiming to come from this company — bogus connections would thus not be attributed to the innocent victim.  It’d be quite tricky with individual users, but it would make it fairly difficult for a botnet to indirectly knock a company or edge ISP offline by getting backbone carriers to drop its traffic due to spoofing.

d) Would you trust a consortium of governments / ISPs to decide whom to blackhole?

Obviously this is a problem, but I believe that the distributed nature of the Internet is proof against such shenanigans.

Comments?

There is a very strong thread in the article that risk management, while maybe not directly at fault for either acute or systemic failures, is at least partially to blame for it:

“Unfortunately for us all, the Wall St crash of Dec 2008 serves as a complete debunking of the value of risk management. All the big firms that lost billions or went out of business had risk management departments and practices and felt they were taking acceptable risks. Perhaps the risk management departments were wrong, or perhaps management was living with a reality gap.”

This, bluntly, is nonsense.

First, it is not the fault of a risk management department if management fails to accept a demonstrated risk. Risk analysis will, by its very nature, always be an approximate art (no, not a science, you need to hire people with a lot of experience, and maybe a bit of gut instinct, pay them a bunch of money, and be prepared to trust their analysis.)  Otherwise, why would anyone ever address a potential security flaw?

Risk analysis is nothing more than the prioritization of potential problems with a system, process, tool, what have you.  It is at the core of any bug fix, response to security failures, in short, any security event.  And security events do happen, like it or not.  It’s not a perfect world, nobody will ever have all the information, and it is a tired cliché that “hindsight is 20/20″, it’s still true.

Second, a proper risk management process does not just entail handing an incompetent manager a set of gift-wrapped risks on a silver platter and saying, “here you go, enjoy.”  That’s called covering your ass.  Correctly done risk assessment and management consists of accompanying, for example, a development process from a to z and being the additional pair of eyes to spot non-obvious flaws.

Ranum’s ideas about how to help prevent or reduce the probability of something going pear-shaped are all valid.  However, he doesn’t seem to understand that these all constitute part of a correctly designed risk management process.

I am a huge fan of the concept of abstracting functions — i.e. clearly defining what it is you are trying to accomplish with your various bits of software & hardware, defining clear categories for their functionalities, separating them, either physically or logically, and ensuring that everything communicates via clearly defined, standards-compliant interfaces and APIs.

During several early projects of mine, I noticed that the temptation was strong for managers to create all-in-one tools in order to sell the widest package of application functionality conceivable.  This is bad design, if only because different uses and scenarios can have different requirements; addressing these may have unintended network effects on other components of a product, thereby slowing down the whole analysis, development and QA process.

One of my clients has taken the path of a pluggable, modular configuration tool for some of their systems; this is a good model insofar as it allows clear access to different components from a single interface, but the components themselves are not interdependent.

For the purposes of this article, I’d consider using very basic distinguishing criteria like “network / communications device”, “end-user application”, “remote support tool”, whatnot — and in the scope of this article, “security device” and “other.”  I realize that these are fairly theoretical, academic distinctions, but it’s my firm belief that the idea applies in real life. Such a matrix can be multidimensional — criteria could include, on the one hand, what the application is used for, and on the other, how it is deployed or managed, OS type, manufacturer, etc.

For example, one of my projects involved the development of a small network security appliance for a specialized scenario (protecting proprietary devices subject to strong regulatory requirements.)  There was constant pressure from sales & marketing to avoid having multiple physical boxes; the field service types also wanted to prevent having to maintain additional distinct hardware.  This was a good example of when it was right to not listen to our customer and push them to accept the idea of having another little small piece of hardware; integrating the security into pre-existing products would have required a huge amount of adaptation, porting, maintenance, testing and other effort, over multiple architectures, teams, countries, whatnot.

“Security” is a compelling argument for the separation of protective functions from what’s being guarded; there may not be a clear, identifiable exploit that you are addressing, but, using the example of network defense, knowing that your authentication, detection, encryption and filtering tools are autonomous from each other reduces the possibility of single points of failure.  I’m not arguing for an eggshell model of security (crunchy on the outside, squishy on the inside), but it makes things much easier to be able to address an application server’s security requirements without the need to assume that whatever security you implement on an application level is all you will have.

An even more significant reason to keep things separate (physically, via dedicated, standards-compliant hardware, or virtually, via VMs) is cost reduction — support and development are simplified.  Despite the appearance of increased complexity from more components, if you are able to quickly and easily swap out a defective element, or create added functionality whose impact on an unrelated system is controlled through a standardized network interface or code API, you no longer have to worry about breaking things that should be out of scope for whatever it is you’re doing at the moment.