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
Confused about mailing lists and their use? Read about mailing lists on Wikipedia and check out these guidelines on proper formatting of your messages.