Taggat med: md5

🐈 Hashcat och oclHashcat nu öppen källkod

hashcat

Hashcat och oclHashcat har nu släppts som öppen källkod på Github. Verktygen används för att knäcka lösenord och är ett bra alternativ till John the Ripper. Att Hashcat nu är öppen källkod kommer eventuellt göra att stöd för fler plattformar och algoritmer kommer in snabbare samt så är det bra för många av oss som jobbar med slutna projekt.

World’s fastest and most advanced GPGPU-based password recovery utility

Främst används oclHashcat för dess stöd när det gäller GPU:er och (AMD) OpenCL samt (Nvidia) CUDA.

Även så stödjer hashcat hela 170 olika lösenordshashar från vanliga såsom MD5, SHA-512, SHA-3 och mer ovanliga såsom Streebog, Juniper, Lastpass och 1Password.

Hashcat Prestada

För att förstå hur bra prestanda hashcat har så finnes följande exempel med fyra olika datorer utrustade med diverse hårdvara:

  • PC1: Windows 7, 32 bit
  • Catalyst 14.9
  • 1x AMD hd7970
  • 1000mhz core clock
  • oclHashcat v1.35
  • PC2: Windows 7, 64 bit
  • ForceWare 347.52
  • 1x NVidia gtx580
  • stock core clock
  • oclHashcat v1.35
  • PC3: Ubuntu 14.04, 64 bit
  • ForceWare 346.29
  • 8x NVidia Titan X
  • stock core clock
  • oclHashcat v1.36
  • PC4: Ubuntu 14.04, 64 bit
  • Catalyst 14.9
  • 8x AMD R9 290X
  • stock core clock
  • oclHashcat v1.35

 

Hash Type PC1 PC2 PC3 PC4
MD5 8581 Mh/s 2753 Mh/s 115840 Mh/s 92672 Mh/s
SHA1 3037 Mh/s 655 Mh/s 37336 Mh/s 31552 Mh/s
SHA256 1122 Mh/s 355 Mh/s 14416 Mh/s 12288 Mh/s
SHA512 414 Mh/s 104 Mh/s 4976 Mh/s 4552 Mh/s
SHA-3 (Keccak) 179 Mh/s 92 Mh/s 3400 Mh/s 2032 Mh/s
RipeMD160 1810 Mh/s 623 Mh/s 23936 Mh/s 20016 Mh/s
Whirlpool 65845 kh/s 85383 kh/s 1480000 kh/s 1122304 kh/s
LM 1388 Mh/s 450 Mh/s 15616 Mh/s 16392 Mh/s
NTLM 16916 Mh/s 4185 Mh/s 250360 Mh/s 175808 Mh/s
NetNTLMv1 9108 Mh/s 2330 Mh/s 56448 Mh/s 97800 Mh/s
NetNTLMv2 589 Mh/s 200 Mh/s 7944 Mh/s 6496 Mh/s
WPA/WPA2 142 kh/s 48 kh/s 2096 kh/s 1536 kh/s

Länk till Github:

Framtidssäkra krypteringen

Kryptoframtiden

Går det att sia in i framtiden om hur och vilka krypteringsalgoritmer som kommer att bestå?

Både Ja och Nej. Vi kan däremot titta i backspegeln och se vad vi har lärt oss av historien, vilka algoritmer som varit säkra och vilka som knäckts. För att jobba med krypton handlar om att alltid vara på tårna och följa vad som händer i omvärlden gällande nya rön, forskningsrapporter och best practices.

Det gäller att ha en plan för den dagen ett byte ska ske. Hur migrerar vi från SHA1 till SHA256? Kan vi byta hashfuktion på ett enkelt sätt eller blir vi kvar med MD5?

För de handlar inte enbart om att välja bra och trendiga algoritmer, det gäller även att bygga ett förtroende över tid.

Men skulle jag blicka framåt så är ChaCha20 + Poly1305 av Daniel J Bernstein (DJB), Peter Schwabe och Tanja Lange helt klart intressant som nu fått RFC-nummer 7539.

Så klart är elliptiska kurvor (ECC) intressant men titta innan framförallt på arbetet som DJB genomfört i samband med SafeCurves. Och när det gäller end-to-end kryptering så titta på axolotl (som nu WhatsApp använder).

krypto memeHåll Er borta från SHA1, 3DES, MD5 samt snake oil där utvecklare eller tillverkare skryter med löjligt stora nyckellängder eller oknäckbara system.

Och glöm framförallt inte att valet av algoritmer bara är en liten del av ett mycket större arbete som omfattar nyckelhantering, signering, kodgranskning, lökprincipen, patchning och uppsäkrade system och framförallt användare som ska använda systemet samt utbildas.

Så lagrar Facebook lösenord

På en konferens nyligen så avslöjade Facebook hur de lagrar sina lösenord. Eller rättare skrivet hur de hashar sina lösenord.

  1. $cur  = ’plaintext’
  2. $cur  = md5($cur)
  3. $salt = randbytes(20)
  4. $cur  = hmac_sha1($cur, $salt)
  5. $cur  = cryptoservice::hmac($cur)
  6.         [= hmac_sha256($cur, $secret)]
  7. $cur  = scrypt($cur, $salt)
  8. $cur  = hmac_sha256($cur, $salt)

1. Det första steget är tämligen självförklarande.

2. Gör först en MD5 av lösenordet. Detta ligger troligtvis kvar pga historia då detta troligtvis enbart var det enda steget. Om en användare loggar in och enbart har en md5 så kommer lösenordet att uppdateras med det nya systemet enligt nedan.

3. En salt på 160 bitar är genererad slumpmässigt. För att förhindra kollisioner så bör den vara minst 64 bitar pga antalet användare och övriga bitar är troligtvis för att framtidssäkra.

4. En HMAC med sha1 skapas som sedan skickas in i nästa steg.

5. Detta steg är för att inneha en central kontrolldel och att förhindra offline eller online forceringsattacker mot lösenord.

7-8. scrypt för att försvåra forcering samt skapande av regnbågstabeller. Vi har många gånger tidigare skrivit om scrypt. Samt sista steget är för att göra databasen med lösenord mindre.

Facebook håller även koll på lösenordsdumpar som publiceras på internet och förekommer ditt lösenord i en sådan dump så kommer Facebook att varna dig.

Bedömt så har Facebook lagt mycket kraft bakom lösenordshashningen och det ser mycket bra ut.

Joachim Strömbergson
Joachim Strömbergson

Joachim Strömbergson som är säkerhetsexpert på företaget Assured som också har tittat på Facebooks sätt att lagra lösenord kommenterar enligt följande:

För att sammanfatta min känsla efter 5 sekunder är att man är duktig och använder seed, man har till och med vad som ser ut att vara ytterligare en hemlighet vilket gör det än svårare att försöka göra regnbågsattacker. Vidare använder man dessutom scrypt för att införa work factor som försvårar uttömmande sökning.

Källa på informationen är det som Facebook uppgav vid konferensen Real World Crypt 2015.

Uppdatering: Per Thorsehim tipsar även om att Alec Muffett från Facebook höll en presentation vid konferensen Passwords 2014 i Norge där han berättar mer i detalj:

Facebook lösenord

Kryptouppdateringar i Microsoft Windows

Windows krypteringMicrosoft meddelade för ett tag sedan att man avser att stärka krypteringen i Windows under perioden 2012-2013 och nedan kan du se några av förbättringarna som håller på att införas.

Många av dessa förändringar är redan inbyggda i Windows 8 samt Windows Server 2012 och är även nu åtgärdade för att fungera på äldre operativsystem.

Generellt så gäller förändringarna vilka krypteringsalgoritmer som används men även längden på nycklar.

Microsoft Security Advisory 2661254
This update set a mandatory key length for RSA keys of 1024 bits or stronger by restricting the use of certificates with RSA keys less than 1024 bits in length.

Microsoft Security Advisory 2813430
This update establishes functionality that enables consumers to update trusted and disallowed Certificate Trust Lists (CTL) in non-internet connected environments. CTL’s are a list of approved hashes or certificates approved by a trusted third party. This update allows customers more control in which parties they trust.

Microsoft Security Advisory 2862966
This update established a framework for managing asymmetric cryptography by adding features for monitoring and directly controlling which cryptographic algorithms are used (RSA, DSA or ECDSA), options to set minimum key length as well as to set which hashing algorithms will be permitted for code signing and other functions. All functionality is documented in detail on Microsoft TechNet.

Microsoft Security Advisory 2862973
This update released today as Downloadable Content (DLC) gives customers the option to restrict the use of certificates that utilize the MD5 hashing algorithm as part of their digital signature. We recommend that customers download and test the update in their environment at the earliest opportunity, this will be especially useful for environments that have little or no inventory of their cryptographic and certificate dependencies. This update will only affect MD5 as used in server authentication, code signing and time stamping. There are exceptions for certain certificates and timestamps, please see KB 2862973 for additional details. Microsoft is planning to release this update through Windows Update on February 11, 2014 after customers have a chance to assess the impact of this update and take necessary actions in their enterprise.

John the Ripper ute i ny version

Lösenordsknäckningsverktyget (woh, långt ord) John the Ripper är nu ute i version 1.7.9. Största ändringen är att OMP-patcharna (OpenMP) nu finns med som standard.

Changelog enligt följande (engelska)

  • Added optional parallelization of the MD5-based crypt(3) code with OpenMP.
  • Added optional parallelization of the bitslice DES code with OpenMP.
  • Replaced the bitslice DES key setup algorithm with a faster one, which significantly improves performance at LM hashes, as well as at DES-based crypt(3) hashes when there’s just one salt (or very few salts).
  • Optimized the DES S-box x86-64 (16-register SSE2) assembly code.
  • Added support for 10-character DES-based tripcodes (not optimized yet).
  • Added support for the “$2y$” prefix of bcrypt hashes.
  • Added two more hash table sizes (16M and 128M entries) for faster processing of very large numbers of hashes per salt (over 1M).
  • Added two pre-defined external mode variables: “abort” and “status”, which let an external mode request the current cracking session to be aborted or the status line to be displayed, respectively.
  • Made some minor optimizations to external mode function calls and virtual machine implementation of John the Ripper.
  • The “–make-charset” option now uses floating-point rather than 64-bit integer operations, which allows for larger CHARSET_settings in params.h.
  • Added runtime detection of Intel AVX and AMD XOP instruction set extensions, with optional fallback to an alternate program binary.
  • In OpenMP-enabled builds, added support for fallback to a non-OpenMP build when the requested thread count is 1.
  • Added relbench, a Perl script to compare two “john –test” benchmark runs, such as for different machines, “make” targets, C compilers, optimization options, or/and versions of John the Ripper.
  • Additional public lists of “top N passwords” have been merged into the bundled common passwords list, and some insufficiently common passwords were removed from the list.

JtR kan i sedvanlig ordning laddas hem här: http://www.openwall.com/john/

Så använder du molnet för lösenordsknäckning

Visste du att Amazon hyr ut datorkapacitet per timme? Ja, det vet nog de flesta. Men få vet att de även hyr ut kapacitet där en GPU (läs kraftfullt grafikkort) ingår. Från 2$ per timme så kan du få tillgång till en mycket kraftfull server för att utföra lösenordsknäckning med, här tänkte vi ge en liten guide till hur du kan komma igång och knäcka lösenord i molnet.

1. Skaffa ett Amazon Web Services-konto och gå in på EC2-konsollen för US-east.

2. Dra igång en ny server med ”Launch instance”-knappen och välj sedan Community AMIs fliken där du söker efter följande serverkopia: ami-aa30c7c3

3. Gå igenom alla steg och ställ in så du kan logga in på servern med ssh. Det kan vara lite bökigt om det är första gången du använder Amazon EC2.

När du väl kommit in så följer du denna guide:

1
2
3
4
# wget  http://developer.download.nvidia.com/compute/cuda/3_2/sdk/gpucomputingsdk_3.2.12_linux.run
# chmod +x gpucomputingsdk_3.2.12_linux.run
# ./gpucomputingsdk_3.2.12_linux.run
(Tryck bara enter på alla frågor)

Nu måste vi installer g++ kompilatorn:

1
# yum install automake autoconf gcc-c++

Sedan måste vi kompilera biblioteken:

1
2
3
# cd ~/NVIDIA_GPU_Computing_SDK/C/
# make lib/libcutil.so
# make shared/libshrutil.so

Dax att ladda hem och bygga + installera CUDA-Multiforcer:

1
2
3
4
5
6
7
# cd ~/NVIDIA_GPU_Computing_SDK/C/
# wget http://www.cryptohaze.com/releases/CUDA-Multiforcer-src-0.7.tar.bz2 -O src/CUDA-Multiforcer.tar.bz2
# cd src/
# tar xjf CUDA-Multiforcer.tar.bz2
# cd CUDA-Multiforcer-Release/argtable2-9/
# ./configure && make && make install
# cd ../

Tyvärr så är dess Makefile lite felaktig så vi måste byta ut nedan rad

1
CCFILES := -largtable2 -lcuda

så den istället ser ut så här:

1
LINKFLAGS := -largtable2 -lcuda

Sen är det bara att skriva make, om allt gick bra så bör du ha en fil här: ~/NVIDIA_GPU_Computing_SDK/C/bin/linux/release/CUDA-Multiforcer. Du kan sedan exekvera mjukvaran på följande sätt:

1
2
3
4
# export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
# export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
# cd ~/NVIDIA_GPU_Computing_SDK/C/src/CUDA-Multiforcer-Release/
# ../../bin/linux/release/CUDA-Multiforcer -h SHA1 -f test_hashes/Hashes-SHA1-Full.txt –min=1 –max=6 -c charsets/charset-upper-lower-numeric-symbol-95.chr

Grattis! Du har nu en helt egen lösenordsforcerare i molnet. Glöm inte att använda exempelvis -h FASTMD5 om det är MD5 du vill knäcka.

Grafikkortet som används i våra tester var NVIDIA Tesla M2050.

Gällande prestanda så får vi 487.3 miljoner MD5-försök per sekund.

Denna guide baseras på detta blogginlägg.

John the Ripper 1.7.7

Nu har den populära knäckningsprogrammvaran John the Ripper släppts i en ny version, nämligen 1.7.7.

Ändringar är enligt följande (på engelska):

* Added Intel AVX and AMD XOP instruction sets support for bitslice DES (with C compiler intrinsics). New make targets: linux-x86-64-avx, linux-x86-64-xop, linux-x86-avx, and linux-x86-xop (these require recent versions of GCC and GNU binutils).
* A ”dummy” ”format” is now supported (plaintext passwords encoded in hexadecimal and prefixed with ”$dummy$”) – for faster testing and tuning of custom wordlists, rule sets, .chr files, and external modes on already known or artificial passwords, as well as for testing of future and modified versions of John itself.
* Apache ”$apr1$” MD5-based password hashes are now supported along with the FreeBSD-style MD5-based crypt(3) hashes that were supported previously. Hashes of both of these types may be loaded for cracking simultaneously.
* The ”–salts” option threshold is now applied before removal of previously cracked hashes for consistent behavior with interrupted and continued sessions.
* The ”Idle = Y” setting (which is the default) is now ignored for OpenMP-enabled hash types when the actual number of threads is greater than 1. (Unfortunately, it did not work right at least with GNU libgomp on Linux.)
* When a cracking session terminates or is interrupted, John will now warn the user if the cracked passwords printed to the terminal while cracking are potentially incomplete. It will advise the user to use the ”–show” option to see the complete set of cracked passwords with proper post-processing.
* When loading hashes specified on a line on their own (feature introduced in 1.7.6), the loader will now ignore leading and trailing whitespace.
* Unless a hash type is forced from the command line, the loader will now print warnings about additional hash types seen in the input files (beyond the hash type autodetected initially).
* For use primarily by the jumbo patch (and later by future enhancements to the official versions as well), the loader now includes logic to warn the user of ambiguous hash encodings (e.g. LM vs. NTLM vs. raw-MD5, all of which may be represented as 32 hexadecimal characters) and of excessive partial hash collisions, which it works around (these are typically caused by an incomplete implementation of a new hash type).
* The ”unique” and ”unshadow” programs have been made significantly faster.
* ”DateTime”, ”Repeats”, ”Subsets”, ”AtLeast1-Simple”, ”AtLeast1-Generic”, and ”Policy” external mode samples have been added to the default john.conf.
* The self-tests have been enhanced to detect more kinds of program bugs.
* A few minor bug fixes and enhancements were made.

John the Ripper 1.7.7 kan ladda hem här:

Ny attack mot MD5

En ny attack mot MD5 har presenterats som gör det enklare att hitta kollisioner.

$ sed -r 's/(..)(..)(..)(..)/\4\3\2\1/g' m0.hex | xxd -r -p | md5sum
cee9a457e790cf20d4bdaa6d69f01e41  -
$ sed -r 's/(..)(..)(..)(..)/\4\3\2\1/g' m1.hex | xxd -r -p | md5sum
cee9a457e790cf20d4bdaa6d69f01e41  -

Se Reddit

Ny sårbarhet i SSL

En sårbarhet har identifierats i det förfarande som MD5 används tillsammans med signering av SSL certifikat. Genom att kombinera två äldre publika attacker:

Så har säkerhetsforskarna Alexander Sotirov, Jacob Appelbaum lyckats att skapa egna SSL-certifikat för godtycklig domän. De skulle exempelvis vara möjligt att skapa ett giltigt certifikat för swedbank.se med hjälp av denna attack. Dock så måste denna attack kombineras med någon annan attack mot exempelvis DNS.

We have identified a vulnerability in the Internet Public Key Infrastructure (PKI) used to issue digital certificates for secure websites. As a proof of concept we executed a practical attack scenario and successfully created a rogue Certification Authority (CA) certificate trusted by all common web browsers. This certificate allows us to impersonate any website on the Internet, including banking and e-commerce sites secured using the HTTPS protocol.

Our attack takes advantage of a weakness in the MD5 cryptographic hash function that allows the construction of different messages with the same MD5 hash. This is known as an MD5 ”collision”. Previous work on MD5 collisions between 2004 and 2007 showed that the use of this hash function in digital signatures can lead to theoretical attack scenarios. Our current work proves that at least one attack scenario can be exploited in practice, thus exposing the security infrastructure of the web to realistic threats.

HD Moore på BreakingPoint Labs har skrivit en lång och utförligt inlägg om detta: breakingpointsystems.com/community/blog/Attacking-Critical-Internet-Infrastructure.

Läs även:

MD5 considered harmful today

Creating a rogue CA certificate

Uppföljaren till MD5 är här: MD6

Det har för några år sedan uppdagats att MD5 inte är speciellt säker att använda längre så därför satte Ronald L. Rivest igång ett arbete med att ta fram nästa generations hash-funktion nämligen MD6. Med hjälp av ett team på över 15 personer så har MD6 nu lanserats under konferensen CRYPTO ’08.

Se presentationen här:

people.csail.mit.edu/rivest/Rivest-TheMD6HashFunction.ppt

Enligt följande skriver Hal Finney om MD6:

Ron Rivest presented his (along with a dozen other people’s) new hash,
MD6, yesterday at Crypto. I am not a hash guru although I’ve implemented
SHA and its ilk many times, so I can’t guarantee all my notes are correct.
I will compare it somewhat with SHA as that is what I know.

SHA-1 is a Merkle Damgard hash, meaning that it runs a compression
function that takes as input the chaining value from the previous
compression function block, along with the next block of input, and
compresses that, creating the next chaining value for the next block.

MD6 is a tree hash, so the leaf nodes run the compression function which
takes successive blocks of input and compress it down to a chaining
value. These chaining values are then fed up to a parent node, which
uses the same compression function to produce its own chaining value,
and so on up to the root node. I think the tree branching factor was 4 –
each node has 4 children. There is also an alternative serial mode for
use by memory limited devices, but I don’t recall any details on that.

A unique feature of MD6 is that the input to the compression function is
very large – 512 bytes. SHA-1 takes 64 bytes. MD6 is oriented around 64
bit words, so this input is considered to be 64 words. The MD6 chaining
variable is 1024 bits or 16 words – compare to the hash width for the
SHA family ciphers: 160 for SHA-1, 256 or 512 for SHA-256 and SHA-512.
Per NIST’s spec, the largest hash output for SHA-3 is 512 bits, so
MD6 intentionally uses a double width chaining variable internally,
and truncates it for output.

The compression function of MD6 is particularly unusual, combining
simple steps with a large number of rounds. In SHA-1 the first thing you
do is to take the 16 32-bit input words and expand them into an 80-word
key array, each word in the expanded input being a function of certain
previous words. Then you run an unbalanced Feistel using the expanded
inputs.

MD6 starts off with something similar, using a somewhat more complex
expansion algorithm, and going on far longer. To my surprise, this is
the whole compression function! The last 16 words of this process are the
output chaining value. There is no Feistel network or any other mechanism.

In more detail, the 64 (64-bit) input words are prefixed by two sets
of about a dozen words – sorry, I don’t remember exactly how big these
were. One set is a constant value, and the other set includes a variety
of ”environmental” information about the circumstances of this instance
of the compression function. This includes global information like how
wide the hash is that will finally be derived by truncating the final
chaining value; the location of this compression function block in the
hash tree, including in particular whether we are the last (root) node;
and other such data. One notable value here is an optional per-hash key,
for creating a keyed hash, of up to 8 words (512 bits). These prepended
blocks bring the full input size up to about 87 or 89 words – again I
apologize, I am working strictly from memory here.

Now this input begins to be extended. Each additional word is a function
of about 5 of the previous 89 words. They did a search to choose the
best 5 offsets in order to maximize diffusion. The combining function
is quite simple though, composed solely of xors, ands, one right shift
and one left shift. Rivest mentioned that this made it reversible –
a desirable feature as it guarantees that no entropy is lost. At first
I was unclear how doing x = x ^ (x >> 5) for example is reversible,
for example, but then I got it. The shift amounts change each step,
again optimized by a computer search for good mixing.

But the really important point here is that there are a huge number
of such steps. The function is expressed in rounds of 16 steps
each. MD6-256 uses 104 rounds; MD6-512 uses 168. Multiply times 16 and
you are performing this extend step on the order of 2000 times. Again,
the last 16 words are the output of the compression function.

Rivest gave a lot of performance information. Because of the tree
structure, the function is highly parallellizable, and scales almost
linearly with the number of CPU cores available. With 1 core, it is not
super fast: MD6-256 on a 64-bit CPU is 77 MB/sec; MD6-512 is 49 MB/sec.
For comparison, SHA-512 is 202 MB/sec on the same setup. They need about
3 cores to match the speed of SHA-512.

He also presented a number of cryptanalytic results. There is provable
security against differential cryptanalysis, by virtue of the large number
of rounds; also security against side channels. A SAT solver and another
technique could only do something with about 11 rounds, versus the 100+
rounds in the function. The tree structure is also shown to preserve
strong properties of the compression function.

Overall it seemed very impressive. The distinctive features are the tree
structure, very wide input blocks, and the enormous number of rounds.
The cryptanalysis results were favorable. However Adi Shamir stood up
and expressed concern that his new Cube attack might apply. Rivest seemed
confident that the degree of MD6 would be several thousand, which should
be safe from Shamir’s attack, but time will tell.

Apologies again to the enormous number of authors if I have any serious
errors above. And thanks to Ron Rivest for publicizing this hash design
several months before the due date (October 31), potentially giving an
advantage to his competitotrs. He emphasized that his goal is to produce
the best possible outcome for the whole process.

Hal Finney