Openwall GNU/*/Linux - a small security-enhanced Linux distro for servers
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Date: Sat, 3 Sep 2011 06:45:21 +0400
From: Solar Designer <solar@...nwall.com>
To: john-users@...ts.openwall.com
Subject: Re: When did you start?

On Wed, Aug 31, 2011 at 10:34:24PM +0200, groszek wrote:
> On 08/31/2011 09:44 PM, Solar Designer wrote:
> > John the Ripper 1.0 was released in 1996.  John the Ripper 1.5 was an
> > almost complete rewrite, worked on in 1997-1998 and released in 1998.
> > Versions beyond 1.5 build upon that code base.
> > 
> > A prototype for what became John the Ripper's incremental mode was first
> > implemented in a separate program in 1995.
[...]
> Hey, that's a pretty interresting piece of history.
> Do you remember what system did you use? And what kind of computer you
> had back in then? Maybe even what speeds were you targetting, for what
> hash type?

Some of the below is off-topic, so let's not continue the discussion
much further.  But since you asked:

When I started with this (pre-John), the fastest computer I had at home
was an AMD 386DX 40 MHz (with Intel's 387 rated for 33 MHz, probably
overclocked to 40 MHz - although I am not sure of that detail), 64 KB
cache, 4 MB and then eventually 8 MB RAM (eight 1 MB 30-pin SIMMs),
120 MB to 540 MB IDE disks (no DMA yet).  It ran Linux 1.2.3 fine (IIRC,
it was Slackware 2.x) with a.out binaries, much later replaced with Red
Hat Linux 4.2 with its 2.0.x kernels and ELF binaries.  Indeed, it also
ran DOS.

This machine did up to about 1000 c/s at DES-based crypt(3) - pretty
much the only relevant hash type at the time.  And, I must admit,
Cracker Jack for DOS was pretty much the optimal choice for it.  I guess
it used specifically 64 KB lookup tables (although it was closed-source
and I never looked at the code).  Crack and (later) early versions of
John the Ripper were slower on this machine, not trying to optimize for
this specific cache size.  The numbers could be like 500 c/s for Crack
and 800 c/s for John, although I might recall these incorrectly.

This machine was used to run early prototypes of what later became
John's incremental mode.

Then in 1996 I got a Pentium 120 MHz, where Cracker Jack would show
awful performance (for that machine) - something like 2500 c/s.  Thus,
John the Ripper 1.0 was developed as a drop-in replacement for Cracker
Jack, but optimized for 486 and Pentium instead of for 386.  It was
compiled with DJGPP for DOS and released as binary-only.  It achieved
slightly more than 10000 c/s on the P-120.  Crack's performance on
Pentiums was somewhere inbetween Jack and John.

Slightly later, phk's MD5-crypt for FreeBSD became relevant, still only
seen on FreeBSD itself at the time.  Thus, I added its initial support
to John the Ripper, without the generic formats framework yet (it didn't
appear until the rewrite for 1.5).  IIRC, the original C code's speed
(from FreeBSD) was 60 c/s on P-120.  Later I slowly improved it to 300 c/s
on that same machine (with many kinds of optimizations).

In 1997, I got an Alpha toy at home - a faulty Multia, with 21066 at
166 MHz.  (It was given to me as faulty.)  I managed to get it to work
by under-clocking its L2 cache via certain writes to IPRs (internal
processor registers) early at bootup.  It did 30000 c/s with
non-bitslice yet 64-bit DES code.  It's this machine that I
wrote/debugged alpha.S on.  (Whereas sparc.S, now removed from the tree,
was written/debugged remotely on a friend's 32-bit SPARC machine over
dialup in 1996.)  I never got to try bitslice on this Alpha.  Its
disease progressed, so it started to fail before my code would have a
chance to run (and write to the IPRs).

In 1998, I bought a better Alpha motherboard+CPU - 164SX 1 MB cache,
21164PC 533 MHz.  128 MB RAM (two SDRAM DIMMs, 128-bit memory bus).
(The much faster LX would cost substantially more at the time.  Going
for 164LX and a 600 MHz 21164A CPU would double the price.  And 600 MHz
was the highest available clock rate at the time, not only Alpha, but in
general.  IIRC, the fastest Intel CPU was a Pentium II at 450 MHz at the
time, and it was pricey too.  Dual-Celeron was affordable, though.)

This one is still alive, although it's also awfully slow by modern
standards.  With JtR's bitslice DES code, I got it to do 215k c/s by
year 2000 (in 1998-1999, lacking some code optimizations, the speed was
slightly lower - maybe 180k c/s).  I think it might do 240k c/s with
current code (I may actually try that).  Anyway, this was a 20x speedup
over just 2-3 years at the time, which was impressive.  (Even more
impressive was the Alpha's advantage at floating-point code, which I
also ran on it, but it was irrelevant to John.)

In 1999, I got a couple of MicroVAX 3100-80 toys.  KA47 CPU, 50 MHz,
up to 72 MB RAM (one of them actually has 72 MB).  With some effort, I
managed to compile John the Ripper under OpenVMS with already outdated
gcc 2.5 (whatever I could find in binary form for OpenVMS/VAX).  IIRC,
the speed was similar to the 386's.  I never released those code changes -
they were too dirty.  (Later I installed OpenBSD 2.7 onto one of these
machines, which also compiled John.)

(Jean-loup Gailly contributed the John/OpenVMS stuff a bit later,
developed independently and in a cleaner fashion.  BTW, some of you
might "know" him for gzip.)

Also in 1999, I bought a used HP 712/80 (PA-RISC).  It was pretty fast
for its 80 MHz, outperforming the P-120 on many tests - e.g., it did
bitslice DES efficiently, which the Pentium could not (too few
registers).  The PA-RISC has caches untypical for other archs, so John
treats PA-RISC specially for bitslice DES, with virtual vector size of
256 bits (even though these are 32- or 64-bit machines, with their SIMD
extensions being irrelevant to bitslice DES).  IIRC, on this specific
machine it was 1 KB on-chip code prefetch, plus 128 KB of fast off-chip
L1 cache.  So it was optimal to use tiny loops (smaller than usual)
operating on larger amounts of data.  Large L1 caches are typical for
PA-RISC (with 128 KB probably being the minimum).

I only got a faster x86 box of my own in 2000, for Owl development
(P3-550 on ASUS P2B-D, actually upgraded to dual CPUs in 2001, which
happened to involve some soldering of the slotkets and use of an
undocumented pin on newer P3 Coppermine CPUs.)
Earlier x86/MMX code in John was developed/debugged remotely.

Then I got an Ultra 5 (UltraSparc IIi) and then also an Ultra 10
(ditto), for Owl development/builds for SPARC (which we did up to and
including Owl 2.0 released in 2006; ditto for Alpha).

Oh, when I started with John, I also still had a EC-1841 in working
order - a Soviet-made IBM PC/XT compatible computer:
http://www.leningrad.su/museum/show_calc.php?n=248
(IIRC, it actually ran at 4.0 MHz, not 4.77 MHz, but was nevertheless
20% to 30% faster than the original XT.)
It had a mouse precisely like this: http://rk86.com/frolov/mouse1.htm
I also still have these two Soviet programmable calculators in working order:
http://www.leningrad.su/museum/show_calc.php?n=38
http://www.leningrad.su/museum/show_calc.php?n=157
No, they don't run John. ;-(

I hope that's more than enough to satisfy your curiosity.

Alexander

Powered by blists - more mailing lists

Your e-mail address:

Powered by Openwall GNU/*/Linux - Powered by OpenVZ