Brute-force attack

Short description: Cryptanalytic method for unauthorized users to access data

This article is about the cryptanalytic method. For similarly named methods in other disciplines, see Brute force.

In cryptography, a brute-force attack or exhaustive key search is a cryptanalytic attack that consists of an attacker submitting many possible keys or passwords with the hope of eventually guessing correctly. This strategy can theoretically be used to break any form of encryption that is not information-theoretically secure.[1] However, in a properly designed cryptosystem the chance of successfully guessing the key is negligible.

When cracking passwords, this method is very fast when used to check all short passwords, but for longer passwords other methods such as the dictionary attack are used because a brute-force search takes too long. Longer passwords, passphrases and keys have more possible values, making them exponentially more difficult to crack than shorter ones due to diversity of characters.[2]

Brute-force attacks can be made less effective by obfuscating the data to be encoded making it more difficult for an attacker to recognize when the code has been cracked or by making the attacker do more work to test each guess. One of the measures of the strength of an encryption system is how long it would theoretically take an attacker to mount a successful brute-force attack against it.[3]

Brute-force attacks are an application of brute-force search, the general problem-solving technique of enumerating all candidates and checking each one. The word 'hammering' is sometimes used to describe a brute-force attack,[4] with 'anti-hammering' for countermeasures.[5]

## Contents

* 1 Basic concept
* 2 Theoretical limits
* 3 Credential recycling
* 4 Unbreakable codes
* 5 Countermeasures
* 6 Reverse brute-force attack
* 7 See also
* 8 Notes
* 9 References
* 10 External links

## Basic concept

Brute-force attacks work by calculating every possible combination that could make up a password and testing it to see if it is the correct password. As the password's length increases, the amount of time, on average, to find the correct password increases exponentially.[6]

## Theoretical limits

The 1998 Electronic Frontier Foundation's US$250,000 DES cracking machine contained over 1,800 custom chips and could brute-force a DES key in a matter of days. The photograph shows a DES Cracker circuit board fitted with 64 Deep Crack chips using both sides.

The resources required for a brute-force attack grow exponentially with increasing key size, not linearly. Although U.S. export regulations historically restricted key lengths to 56-bit symmetric keys (e.g. Data Encryption Standard), these restrictions are no longer in place, so modern symmetric algorithms typically use computationally stronger 128- to 256-bit keys.

There is a physical argument that a 128-bit symmetric key is computationally secure against brute-force attack. The Landauer limit implied by the laws of physics sets a lower limit on the energy required to perform a computation of kT * ln 2 per bit erased in a computation, where T is the temperature of the computing device in kelvins, k is the Boltzmann constant, and the natural logarithm of 2 is about 0.693 (0.6931471805599453). No irreversible computing device can use less energy than this, even in principle.[7] Thus, in order to simply flip through the possible values for a 128-bit symmetric key (ignoring doing the actual computing to check it) would, theoretically, require 2128 − 1 bit flips on a conventional processor. If it is assumed that the calculation occurs near room temperature (≈300 K), the Von Neumann-Landauer Limit can be applied to estimate the energy required as ≈1018 joules, which is equivalent to consuming 30 gigawatts of power for one year. This is equal to 30×109 W×365×24×3600 s = 9.46×1017 J or 262.7 TWh (about 0.1% of the yearly world energy production). The full actual computation – checking each key to see if a solution has been found – would consume many times this amount. Furthermore, this is simply the energy requirement for cycling through the key space; the actual time it takes to flip each bit is not considered, which is certainly greater than 0 (see Bremermann's limit).

Modern GPUs are well-suited to the repetitive tasks associated with hardware-based password cracking.

As commercial successors of governmental ASIC solutions have become available, also known as custom hardware attacks, two emerging technologies have proven their capability in the brute-force attack of certain ciphers. One is modern graphics processing unit (GPU) technology,[8] the other is the field-programmable gate array (FPGA) technology. GPUs benefit from their wide availability and price-performance benefit, FPGAs from their energy efficiency per cryptographic operation. Both technologies try to transport the benefits of parallel processing to brute-force attacks. In case of GPUs some hundreds, in the case of FPGA some thousand processing units making them much better suited to cracking passwords than conventional processors. For instance in 2022, 8 Nvidia RTX 4090 GPU were linked together to test password strength by using the software Hashcat with results that showed 200 billion eight-character NTLM password combinations could be cycled through in 48 minutes.[9][10]

Various publications in the fields of cryptographic analysis have proved the energy efficiency of today's FPGA technology, for example, the COPACOBANA FPGA Cluster computer consumes the same energy as a single PC (600 W), but performs like 2,500 PCs for certain algorithms. A number of firms provide hardware-based FPGA cryptographic analysis solutions from a single FPGA PCI Express card up to dedicated FPGA computers. WPA and WPA2 encryption have successfully been brute-force attacked by reducing the workload by a factor of 50 in comparison to conventional CPUs[11][12] and some hundred in case of FPGAs.

A single COPACOBANA board boasting 6 Xilinx Spartans – a cluster is made up of 20 of these.

Advanced Encryption Standard (AES) permits the use of 256-bit keys. Breaking a symmetric 256-bit key by brute-force requires 2128 times more computational power than a 128-bit key. One of the fastest supercomputers in 2019 has a speed of 100 petaFLOPS which could theoretically check 100 trillion (1014) AES keys per second (assuming 1000 operations per check), but would still require 3.67×1055 years to exhaust the 256-bit key space.[13]

An underlying assumption of a brute-force attack is that the complete key space was used to generate keys, something that relies on an effective random number generator, and that there are no defects in the algorithm or its implementation. For example, a number of systems that were originally thought to be impossible to crack by brute-force have nevertheless been cracked because the key space to search through was found to be much smaller than originally thought, because of a lack of entropy in their pseudorandom number generators. These include Netscape's implementation of Secure Sockets Layer (SSL) (cracked by Ian Goldberg and David Wagner in 1995) and a Debian/Ubuntu edition of OpenSSL discovered in 2008 to be flawed.[14][15] A similar lack of implemented entropy led to the breaking of Enigma's code.[16][17]

## Credential recycling

Credential recycling is the hacking practice of re-using username and password combinations gathered in previous brute-force attacks. A special form of credential recycling is pass the hash, where unsalted hashed credentials are stolen and re-used without first being brute-forced.[18]

## Unbreakable codes

Certain types of encryption, by their mathematical properties, cannot be defeated by brute-force. An example of this is one-time pad cryptography, where every cleartext bit has a corresponding key from a truly random sequence of key bits. A 140 character one-time-pad-encoded string subjected to a brute-force attack would eventually reveal every 140 character string possible, including the correct answer – but of all the answers given, there would be no way of knowing which was the correct one. Defeating such a system, as was done by the Venona project, generally relies not on pure cryptography, but upon mistakes in its implementation, such as the key pads not being truly random, intercepted keypads, or operators making mistakes.[19]

## Countermeasures

In case of an offline attack where the attacker has gained access to the encrypted material, one can try key combinations without the risk of discovery or interference. In case of online attacks, database and directory administrators can deploy countermeasures such as limiting the number of attempts that a password can be tried, introducing time delays between successive attempts, increasing the answer's complexity (e.g., requiring a CAPTCHA answer or employing multi-factor authentication), and/or locking accounts out after unsuccessful login attempts.[20] Website administrators may prevent a particular IP address from trying more than a predetermined number of password attempts against any account on the site.[21] Additionally, the MITRE D3FEND framework provides structured recommendations for defending against brute-force attacks by implementing strategies such as network traffic filtering, deploying decoy credentials, and invalidating authentication caches.[22]

## Reverse brute-force attack

In a reverse brute-force attack (also called password spraying), a single (usually common) password is tested against multiple usernames or encrypted files.[23] The process may be repeated for a select few passwords. In such a strategy, the attacker is not targeting a specific user.

## See also

* Bitcoin mining
* Cryptographic key length
* Distributed.net
* Hail Mary Cloud
* Key derivation function
* MD5CRK
* Metasploit Express
* Side-channel attack
* TWINKLE and TWIRL
* Unicity distance
* RSA Factoring Challenge
* Secure Shell

## Notes

1. ↑ Paar, Pelzl & Preneel 2010, p. 7.
2. ↑ Urbina, Ian (2014). "The Secret Life of Passwords. The New Times.". The New York Times. https://www.nytimes.com/2014/11/19/magazine/the-secret-life-of-passwords.html.
3. ↑ Schrittwieser, Sebastian; Katzenbeisser, Stefan (2011), "Code Obfuscation against Static and Dynamic Reverse Engineering", Information Hiding, Lecture Notes in Computer Science (Berlin, Heidelberg: Springer Berlin Heidelberg) 6958: pp. 270–284, doi:10.1007/978-3-642-24178-9_19, ISBN 978-3-642-24177-2, http://dx.doi.org/10.1007/978-3-642-24178-9_19, retrieved 2021-09-05
4. ↑ "Secure your site from Brute force attacks using Sebsoft's Anti Hammering Authentication Plugin #MoodlePlugins #MoodleSecurity". e Learn Magazine. January 16, 2016. https://www.elearnmagazine.com/technology/secure-your-site-from-brute-force-attacks-using-sebsofts-anti-hammering-authentication-plugin-moodleplugins-moodlesecurity/.
5. ↑ "Configure Serv-U to protect against brute force attacks". Solar Winds. https://support.solarwinds.com/SuccessCenter/s/article/Configure-Serv-U-to-protect-against-brute-force-attacks?language=en_US.
6. ↑ "Brute Force Attack: Definition and Examples" (in en). 2020-10-20. https://www.kaspersky.com/resource-center/definitions/brute-force-attack.
7. ↑ Landauer 1961, p. 183-191.
8. ↑ Graham 2011.
9. ↑ Rudisail, B. (17 November 2022). "Password-cracking With High-Performance GPUs: Is There a Way to Prevent It?". Spiceworks. https://www.spiceworks.com/it-security/identity-access-management/articles/tackling-gpu-enabled-password-cracking.
10. ↑ Pires, F. (18 October 2022). "Eight RTX 4090s Can Break Passwords in Under an Hour". Future Publishing. https://www.tomshardware.com/news/eight-rtx-4090s-can-break-passwords-in-under-an-hour.
11. ↑ Kingsley-Hughes 2008.
12. ↑ Kamerling 2007.
13. ↑ "November 2019 | TOP500 Supercomputer Sites". https://www.top500.org/lists/2019/11/.
14. ↑ Viega, Messier & Chandra 2002, p. 18.
15. ↑ CERT-2008.
16. ↑ Ellis 2005.
17. ↑ NSA-2009.
18. ↑ "What is a Pass-the-Hash Attack (PtH)?". 2023-08-04. Archived from the original on 2024-05-15. https://web.archive.org/web/20240515111754/https://www.beyondtrust.com/resources/glossary/pass-the-hash-pth-attack.
19. ↑ Reynard 1997, p. 86.
20. ↑ Burnett & Foster 2004.
21. ↑ Ristic 2010, p. 136.
22. ↑ "Implementing MITRE D3FEND for ATT&CK Technique T1110: Brute Force" (in en). August 25, 2023. https://d3security.com/blog/implementing-mitre-d3fend-for-attck-technique-t1110-brute-force/.
23. ↑ "InfoSecPro.com - Computer, network, application and physical security consultants.". http://www.infosecpro.com/applicationsecurity/a11.htm.

## References

* Adleman, Leonard M.; Rothemund, Paul W.K.; Roweis, Sam; Winfree, Erik (June 10–12, 1996). "On Applying Molecular Computation To The Data Encryption Standard". Princeton University.
* Cracking DES – Secrets of Encryption Research, Wiretap Politics & Chip Design. Electronic Frontier Foundation. 1998. ISBN 1-56592-520-3. https://archive.org/details/crackingdes00elec.
* Burnett, Mark; Foster, James C. (2004). Hacking the Code: ASP.NET Web Application Security. Syngress. ISBN 1-932266-65-8. https://books.google.com/books?id=-WShG0uezvEC.
* Diffie, W.; Hellman, M.E. (1977). "Exhaustive Cryptanalysis of the NBS Data Encryption Standard". Computer 10: 74–84. doi:10.1109/c-m.1977.217750.
* Graham, Robert David (22 June 2011). "Password cracking, mining, and GPUs". erratasec.com. http://erratasec.blogspot.com/2011/06/password-cracking-mining-and-gpus.html.
* Ellis, Claire (March 2005). "Exploring the Enigma". Plus Magazine. http://plus.maths.org/content/exploring-enigma.
* Kamerling, Erik (2007-11-12). "Elcomsoft Debuts Graphics Processing Unit (GPU) Password Recovery Advancement". Symantec. https://community.broadcom.com/symantecenterprise/communities/community-home/librarydocuments/viewdocument?DocumentKey=84d57a16-74eb-4907-85a9-582e169affbc&CommunityKey=1ecf5f55-9545-44d6-b0f4-4e4a7f5f5e68&tab=librarydocuments.
* Kingsley-Hughes, Adrian (2008-10-12). "ElcomSoft uses NVIDIA GPUs to Speed up WPA/WPA2 Brute-force Attack". ZDNet. http://www.zdnet.com/blog/hardware/elcomsoft-uses-nvidia-gpus-to-speed-up-wpawpa2-brute-force-attack/2724.
* Landauer, L (1961). "Irreversibility and Heat Generation in the Computing Process". IBM Journal of Research and Development 5 (3): 183–191. doi:10.1147/rd.53.0183. http://domino.research.ibm.com/tchjr/journalindex.nsf/c469af92ea9eceac85256bd50048567c/8a9d4b4e96887b8385256bfa0067fba2?OpenDocument.
* Paar, Christof; Pelzl, Jan; Preneel, Bart (2010). Understanding Cryptography: A Textbook for Students and Practitioners. Springer. ISBN 978-3-642-04100-6. http://www.crypto-textbook.com.
* Reynard, Robert (1997). Secret Code Breaker II: A Cryptanalyst's Handbook. Jacksonville, FL: Smith & Daniel Marketing. ISBN 1-889668-06-0. https://books.google.com/books?id=3nTmBW0ONEEC&pg=PA86. Retrieved 2008-09-21.
* Ristic, Ivan (2010). Modsecurity Handbook. Feisty Duck. ISBN 978-1-907117-02-2. https://books.google.com/books?id=HnQl5OVtOYgC.
* Viega, John; Messier, Matt; Chandra, Pravir (2002). Network Security with OpenSSL. O'Reilly. ISBN 0-596-00270-X. https://books.google.com/books?id=FBYHEBTrZUwC. Retrieved 2008-11-25.
* Wiener, Michael J. (1996). "Efficient DES Key Search". Practical Cryptography for Data Internetworks (W. Stallings, editor, IEEE Computer Society Press).
* "Technical Cyber Security Alert TA08-137A: Debian/Ubuntu OpenSSL Random Number Generator Vulnerability". United States Computer Emergency Readiness Team (CERT). 2008-05-16. http://www.us-cert.gov/cas/techalerts/TA08-137A.html.
* "NSA's How Mathematicians Helped Win WWII". National Security Agency. 15 Jan 2009. http://www.nsa.gov/about/cryptologic_heritage/center_crypt_history/publications/how_math_helped_win.shtml.

## External links

* RSA-sponsored DES-III cracking contest
* Demonstration of a brute-force device designed to guess the passcode of locked iPhones running iOS 10.3.3
* How We Cracked the Code Book Ciphers[Usurped!] – Essay by the winning team of the challenge in The Code Book

* v
* t
* e

Block ciphers (security summary)

Common
algorithms|

* AES
* Blowfish
* DES (internal mechanics, Triple DES)
* Serpent
* Twofish

Less common
algorithms|

* Camellia
* CAST-128
* GOST
* IDEA
* RC2
* RC5
* RC6
* SEED
* ARIA
* Skipjack
* TEA
* XTEA

Other
algorithms|

* 3-Way
* Akelarre
* Anubis
* BaseKing
* BassOmatic
* BATON
* BEAR and LION
* CAST-256
* Chiasmus
* CIKS-1
* CIPHERUNICORN-A
* CIPHERUNICORN-E
* CLEFIA
* CMEA
* Cobra
* COCONUT98
* Crab
* Cryptomeria/C2
* CRYPTON
* CS-Cipher
* DEAL
* DES-X
* DFC
* E2
* FEAL
* FEA-M
* FROG
* G-DES
* Grand Cru
* Hasty Pudding cipher
* Hierocrypt
* ICE
* IDEA NXT
* Intel Cascade Cipher
* Iraqi
* Kalyna
* KASUMI
* KeeLoq
* KHAZAD
* Khufu and Khafre
* KN-Cipher
* Kuznyechik
* Ladder-DES
* Libelle
* LOKI (97, 89/91)
* Lucifer
* M6
* M8
* MacGuffin
* Madryga
* MAGENTA
* MARS
* Mercy
* MESH
* MISTY1
* MMB
* MULTI2
* MultiSwap
* New Data Seal
* NewDES
* Nimbus
* NOEKEON
* NUSH
* PRESENT
* Prince
* Q
* RC6
* REDOC
* Red Pike
* S-1
* SAFER
* SAVILLE
* SC2000
* SHACAL
* SHARK
* Simon
* SM4
* Speck
* Spectr-H64
* Square
* SXAL/MBAL
* Threefish
* Treyfer
* UES
* xmx
* XXTEA
* Zodiac

Design|

* Feistel network
* Key schedule
* Lai–Massey scheme
* Product cipher
* S-box
* P-box
* SPN
* Confusion and diffusion
* Avalanche effect
* Block size
* Key size
* Key whitening (Whitening transformation)

Attack
(cryptanalysis)|

* Brute-force (EFF DES cracker)
* MITM
* Biclique attack
* 3-subset MITM attack
* Linear (Piling-up lemma)
* Differential
* Impossible
* Truncated
* Higher-order
* Differential-linear
* Distinguishing (Known-key)
* Integral/Square
* Boomerang
* Mod n
* Related-key
* Slide
* Rotational
* Side-channel
* Timing
* Power-monitoring
* Electromagnetic
* Acoustic
* Differential-fault
* XSL
* Interpolation
* Partitioning
* Rubber-hose
* Black-bag
* Davies
* Rebound
* Weak key
* Tau
* Chi-square
* Time/memory/data tradeoff

Standardization|

* AES process
* CRYPTREC
* NESSIE

Utilization|

* Initialization vector
* Mode of operation
* Padding

* v
* t
* e

Cryptographic hash functions & message authentication codes

* List
* Comparison
* Known attacks

Common functions|

* MD5
* SHA-1
* SHA-2
* SHA-3
* BLAKE2

SHA-3 finalists|

* BLAKE
* Grøstl
* JH
* Skein
* Keccak (winner)

Other functions|

* CubeHash
* ECOH
* FSB
* GOST
* HAS-160
* HAVAL
* Kupyna
* LM hash
* MD2
* MD4
* MD6
* MDC-2
* N-Hash
* RIPEMD
* RadioGatún
* SM3
* SWIFFT
* Snefru
* Streebog
* Tiger
* VSH
* Whirlpool

Key derivation functions|

* Argon2
* Balloon
* bcrypt
* crypt
* Lyra2
* PBKDF2
* scrypt

MAC functions|

* DAA
* CBC-MAC
* GMAC
* HMAC
* NMAC
* OMAC/CMAC
* PMAC
* VMAC
* UMAC
* Poly1305
* SipHash

Authenticated
encryption modes|

* CCM
* CWC
* EAX
* GCM
* IAPM
* OCB

Attacks|

* Collision attack
* Preimage attack
* Birthday attack
* Brute-force attack
* Rainbow table
* Side-channel attack
* Length extension attack

Design|

* Avalanche effect
* Hash collision
* Merkle–Damgård construction
* Sponge function
* HAIFA construction

Standardization|

* CRYPTREC
* NESSIE
* NIST hash function competition

Utilization|

* Hash-based cryptography
* Key stretching
* Merkle tree
* Message authentication
* Proof of work
* Salt
* Pepper

* v
* t
* e

Cryptography

* History of cryptography
* Cryptanalysis
* Outline of cryptography

* Symmetric-key algorithm
* Block cipher
* Stream cipher
* Public-key cryptography
* Cryptographic hash function
* Message authentication code
* Random numbers
* Steganography

* Category

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Brute-force attack. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Brute-force_attack&oldid=3977512"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template