Copy Link
Add to Bookmark
Report
Phrack Inc. Volume 02 Issue 22 File 08
==Phrack Inc.==
Volume Two, Issue 22, File 8 of 12
"]}`"`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\
\`\`\ \`\`\
\`\ A Report On The InterNet Worm \`\
\`\ \`\
\`\ By Bob Page \`\
\`\ \`\
\`\ University of Lowell \`\
\`\ Computer Science Department \`\
\`\ \`\
\`\ November 7, 1988 \`\
\`\`\ \`\`\
\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\
Here's the truth about the "Internet Worm." Actually it's not a virus -
a virus is a piece of code that adds itself to other programs, including
operating systems. It cannot run independently, but rather requires that its
"host" program be run to activate it. As such, it has a clear analog to
biologic viruses -- those viruses are not considered live, but they invade host
cells and take them over, making them produce new viruses.
A worm is a program that can run by itself and can propagate a fully working
version of itself to other machines. As such, what was loosed on the Internet
was clearly a worm.
This data was collected through an emergency mailing list set up by Gene
Spafford at Purdue University, for administrators of major Internet sites -
some of the text is included verbatim from that list.
The basic object of the worm is to get a shell on another machine so it can
reproduce further. There are three ways it attacks: sendmail, fingerd, and
rsh/rexec.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
The Sendmail Attack:
In the sendmail attack, the worm opens a TCP connection to another machine's
sendmail (the SMTP port), invokes debug mode, and sends a RCPT TO that requests
its data be piped through a shell. That data, a shell script (first-stage
bootstrap) creates a temporary second-stage bootstrap file called x$$,l1.c
(where '$$' is the current process ID). This is a small (40-line) C program.
The first-stage bootstrap compiles this program with the local cc and executes
it with arguments giving the Internet hostid/socket/password of where it just
came from. The second-stage bootstrap (the compiled C program) sucks over two
object files, x$$,vax.o and x$$,sun3.o from the attacking host. It has an
array for 20 file names (presumably for 20 different machines), but only two
(vax and sun) were compiled in to this code. It then figures out whether it's
running under BSD or SunOS and links the appropriate file against the C library
to produce an executable program called /usr/tmp/sh - so it looks like the
Bourne shell to anyone who looked there.
The Fingerd Attack:
In the fingerd attack, it tries to infiltrate systems via a bug in fingerd, the
finger daemon. Apparently this is where most of its success was (not in
sendmail, as was originally reported). When fingerd is connected to, it reads
its arguments from a pipe, but doesn't limit how much it reads. If it reads
more than the internal 512-byte buffer allowed, it writes past the end of its
stack. After the stack is a command to be executed ("/usr/ucb/finger") that
actually does the work. On a VAX, the worm knew how much further from the
stack it had to clobber to get to this command, which it replaced with the
command "/bin/sh" (the bourne shell). So instead of the finger command being
executed, a shell was started with no arguments. Since this is run in the
context of the finger daemon, stdin and stdout are connected to the network
socket, and all the files were sucked over just like the shell that sendmail
provided.
The Rsh/Rexec Attack:
The third way it tried to get into systems was via the .rhosts and
/etc/hosts.equiv files to determine 'trusted' hosts where it might be able to
migrate to. To use the .rhosts feature, it needed to actually get into
people's accounts - since the worm was not running as root (it was running as
daemon) it had to figure out people's passwords. To do this, it went through
the /etc/passwd file, trying to guess passwords. It tried combinations of: the
username, the last, first, last+first, nick names (from the GECOS field), and a
list of special "popular" passwords:
aaa cornelius guntis noxious simon
academia couscous hacker nutrition simple
aerobics creation hamlet nyquist singer
airplane creosote handily oceanography single
albany cretin happening ocelot smile
albatross daemon harmony olivetti smiles
albert dancer harold olivia smooch
alex daniel harvey oracle smother
alexander danny hebrides orca snatch
algebra dave heinlein orwell snoopy
aliases december hello osiris soap
alphabet defoe help outlaw socrates
ama deluge herbert oxford sossina
amorphous desperate hiawatha pacific sparrows
analog develop hibernia painless spit
anchor dieter honey pakistan spring
andromache digital horse pam springer
animals discovery horus papers squires
answer disney hutchins password strangle
anthropogenic dog imbroglio patricia stratford
anvils drought imperial penguin stuttgart
anything duncan include peoria subway
aria eager ingres percolate success
ariadne easier inna persimmon summer
arrow edges innocuous persona super
arthur edinburgh irishman pete superstage
athena edwin isis peter support
atmosphere edwina japan philip supported
aztecs egghead jessica phoenix surfer
azure eiderdown jester pierre suzanne
bacchus eileen jixian pizza swearer
bailey einstein johnny plover symmetry
banana elephant joseph plymouth tangerine
bananas elizabeth joshua polynomial tape
bandit ellen judith pondering target
banks emerald juggle pork tarragon
barber engine julia poster taylor
baritone engineer kathleen praise telephone
bass enterprise kermit precious temptation
bassoon enzyme kernel prelude thailand
batman ersatz kirkland prince tiger
beater establish knight princeton toggle
beauty estate ladle protect tomato
beethoven euclid lambda protozoa topography
beloved evelyn lamination pumpkin tortoise
benz extension larkin puneet toyota
beowulf fairway larry puppet trails
berkeley felicia lazarus rabbit trivial
berliner fender lebesgue rachmaninoff trombone
beryl fermat lee rainbow tubas
beverly fidelity leland raindrop tuttle
bicameral finite leroy raleigh umesh
bob fishers lewis random unhappy
brenda flakes light rascal unicorn
brian float lisa really unknown
bridget flower louis rebecca urchin
broadway flowers lynne remote utility
bumbling foolproof macintosh rick vasant
burgess football mack ripple vertigo
campanile foresight maggot robotics vicky
cantor format magic rochester village
cardinal forsythe malcolm rolex virginia
carmen fourier mark romano warren
carolina fred markus ronald water
caroline friend marty rosebud weenie
cascades frighten marvin rosemary whatnot
castle fun master roses whiting
cat fungible maurice ruben whitney
cayuga gabriel mellon rules will
celtics gardner merlin ruth william
cerulean garfield mets sal williamsburg
change gauss michael saxon willie
charles george michelle scamper winston
charming gertrude mike scheme wisconsin
charon ginger minimum scott wizard
chester glacier minsky scotty wombat
cigar gnu moguls secret woodwind
classic golfer moose sensor wormwood
clusters gorgeous morley serenity yaco
coffee gorges mozart sharks yang
coke gosling nancy sharon yellowstone
collins gouge napoleon sheffield yosemite
commrades graham nepenthe sheldon zap
computer gryphon ness shiva zimmerman
condo guest network shivers
cookie guitar newton shuttle
cooper gumption next signature
When everything else fails, it opens /usr/dict/words and tries every word in
the dictionary. It is pretty successful in finding passwords, as most people
don't choose them very well. Once it gets into someone's account, it looks for
a .rhosts file and does an 'rsh' and/or 'rexec' to another host, it sucks over
the necessary files into /usr/tmp and runs /usr/tmp/sh to start all over again.
Between these three methods of attack (sendmail, fingerd, .rhosts) it was able
to spread very quickly.
The Worm Itself:
The 'sh' program is the actual worm. When it starts up it clobbers its argv
array so a 'ps' will not show its name. It opens all its necessary files, then
unlinks (deletes) them so they can't be found (since it has them open, however,
it can still access the contents). It then tries to infect as many other hosts
as possible - when it sucessfully connects to one host, it forks a child to
continue the infection while the parent keeps on trying new hosts.
One of the things it does before it attacks a host is connect to the telnet
port and immediately close it. Thus, "telnetd: ttloop: peer died" in
/usr/adm/messages means the worm attempted an attack.
The worm's role in life is to reproduce - nothing more. To do that it needs to
find other hosts. It does a 'netstat -r -n' to find local routes to other
hosts & networks, looks in /etc/hosts, and uses the yellow pages distributed
hosts file if it's available. Any time it finds a host, it tries to infect it
through one of the three methods, see above. Once it finds a local network
(like 129.63.nn.nn for ulowell) it sequentially tries every address in that
range.
If the system crashes or is rebooted, most system boot procedures clear /tmp
and /usr/tmp as a matter of course, erasing any evidence. However, sendmail
log files show mail coming in from user /dev/null for user /bin/sed, which is a
tipoff that the worm entered.
Each time the worm is started, there is a 1/15 chance (it calls random()) that
it sends a single byte to ernie.berkeley.edu on some magic port, apparently to
act as some kind of monitoring mechanism.
The Crackdown:
Three main 'swat' teams from Berkeley, MIT and Purdue found copies of the VAX
code (the .o files had all the symbols intact with somewhat meaningful names)
and disassembled it into about 3000 lines of C. The BSD development team poked
fun at the code, even going so far to point out bugs in the code and supplying
source patches for it! They have not released the actual source code, however,
and refuse to do so. That could change - there are a number of people who want
to see the code.
Portions of the code appear incomplete, as if the program development was not
yet finished. For example, it knows the offset needed to break the BSD
fingerd, but doesn't know the correct offset for Sun's fingerd (which causes it
to dump core); it also doesn't erase its tracks as cleverly as it might; and so
on.
The worm uses a variable called 'pleasequit' but doesn't correctly initialize
it, so some folks added a module called _worm.o to the C library, which is
produced from: int pleasequit = -1; the fact that this value is set to -1 will
cause it to exit after one iteration.
The close scrutiny of the code also turned up comments on the programmer's
style. Verbatim from someone at MIT:
From disassembling the code, it looks like the programmer is really
anally retentive about checking return codes, and, in addition,
prefers to use array indexing instead of pointers to walk through
arrays.
Anyone who looks at the binary will not see any embedded strings - they are
XOR'ed with 81 (hex). That's how the shell commands are imbedded. The
"obvious" passwords are stored with their high bit set.
Although it spreads very fast, it is somewhat slowed down by the fact that it
drives the load average up on the machine - this is due to all the encryptions
going on, and the large number of incoming worms from other machines.
[Initially, the fastest defense against the worm is is to create a directory
called /usr/tmp/sh. The script that creates /usr/tmp/sh from one of the .o
files checks to see if /usr/tmp/sh exists, but not to see if it's a directory.
This fix is known as 'the condom'.]
Now What?
Most Internet systems running 4.3BSD or SunOS have installed the necessary
patches to close the holes and have rejoined the Internet. As you would
expect, there is a renewed interest in system/network security, finding and
plugging holes, and speculation over what will happen to the worm's creator.
If you haven't read or watched the news, various log files have named
the responsible person as Robert Morris Jr., a 23-year old doctoral student at
Cornell. His father is head of the National Computer Security Center, the
NSA's public effort in computer security, and has lectured widely on security
aspects of UNIX.
Associates of the student claim the worm was a 'mistake' - that he intended to
unleash it but it was not supposed to move so quickly or spread so much. His
goal was to have a program 'live' within the Internet. If the reports that he
intended it to spread slowly are true, then it's possible that the bytes sent
to ernie.berkeley.edu were intended to monitor the spread of the worm. Some
news reports mentioned that he panicked when, via some "monitoring mechanism"
he saw how fast it had propagated.
A source inside DEC reports that although the worm didn't make much progress
there, it was sighted on several machines that wouldn't be on its normal
propagation path, i.e. not gateways and not on the same subnet. These machines
are not reachable from the outside. Morris was a summer intern at DEC in '87.
He might have included names or addresses he remembered as targets for
infesting hidden internal networks. Most of the DEC machines in question
belong to the group he worked in.
The final word has not been written...
...it will be interesting to see what happens.
_______________________________________________________________________________
