View source for Blowfish (cipher)

{{short description|Block cipher}}
{{other uses|Blowfish (disambiguation)}}
<!-- This article is the top result for "blowfish" on Google, so we need a link to the disambiguation page. -->
{{Infobox block cipher
| name          = Blowfish
| caption       = The round function (Feistel function) of Blowfish
| designers     = [[Bruce Schneier]]{{Ref RFC|4949|notes=no}}
| publish date  = 1993{{Ref RFC|4949|repeat=yes}}
| derived from  =
| derived to    = [[Twofish]]
| key size      = 32–448 bits
| block size    = 64 bits
| structure     = [[Feistel network]]
| rounds        = 16
| cryptanalysis = Four rounds of Blowfish are susceptible to a second-order [[differential attack]] (Rijmen, 1997);<ref name="rijmen-phd">{{cite journal
 |author      = Vincent Rijmen
 |author-link = Vincent Rijmen
 |year        = 1997
 |title       = Cryptanalysis and Design of Iterated Block Ciphers
 |journal     = Ph.D. Thesis
 |url         = https://www.cosic.esat.kuleuven.be/publications/thesis-4.ps
 |format      = [[PostScript]]
 |url-status  = dead
 |archive-url  = https://web.archive.org/web/20130508181935/http://www.cosic.esat.kuleuven.be/publications/thesis-4.ps
 |archive-date = 2013-05-08
}}</ref> for a class of [[weak key]]s, 14 rounds of Blowfish can be distinguished from a [[pseudorandom permutation]] (Vaudenay, 1996).
}}
'''Blowfish''' is a [[Symmetric-key algorithm|symmetric-key]] [[block cipher]], designed in 1993 by [[Bruce Schneier]] and included in many cipher suites and encryption products. Blowfish provides a good encryption rate in software, and no effective [[cryptanalysis]] of it has been found to date for smaller files. It is recommended Blowfish should not be used to encrypt files larger than 4GB in size, [[Twofish]] should be used instead.<ref name=":0" /> 

Blowfish has a 64-bit block size and therefore it could be vulnerable to Sweet32 birthday attacks.<ref name=":1" />

Schneier designed Blowfish as a general-purpose algorithm, intended as an alternative to the aging [[Data Encryption Standard|DES]] and free of the problems and constraints associated with other algorithms. At the time Blowfish was released, many other designs were proprietary, encumbered by [[patent]]s, or were commercial or government secrets. Schneier has stated that "Blowfish is unpatented, and will remain so in all countries. The algorithm is hereby placed in the [[public domain]], and can be freely used by anyone."<ref name="blowfish-paper"/>

Notable features of the design include key-dependent [[S-box]]es and a highly complex [[key schedule]].

==The algorithm==
Blowfish has a 64-bit [[block size (cryptography)|block size]] and a variable [[key length]] from 32 bits up to 448 bits.<ref name="blowfish-paper">{{cite journal
 |url         = https://www.schneier.com/paper-blowfish-fse.html
 |title       = Description of a New Variable-Length Key, 64-Bit Block Cipher (Blowfish)
 |author      = Bruce Schneier
 |author-link = Bruce Schneier
 |journal     = Fast Software Encryption, Cambridge Security Workshop Proceedings
 |publisher   = [[Springer-Verlag]]
 |pages       = 191–204
 |year        = 1993
 |url-status  = live
 |archive-url  = https://web.archive.org/web/20140126182135/https://www.schneier.com/paper-blowfish-fse.html
 |archive-date = 2014-01-26
}}</ref> It is a 16-round [[Feistel cipher]] and uses large key-dependent [[S-box]]es. In structure it resembles [[CAST-128]], which uses fixed S-boxes.
[[File:Blowfish diagram.svg|right|thumb|316px|The Feistel structure of Blowfish]]
The adjacent diagram shows Blowfish's encryption routine. Each line represents 32&nbsp;bits. There are five subkey-arrays: one 18-entry P-array (denoted as K in the diagram, to avoid confusion with the Plaintext) and four 256-entry S-boxes (S0, S1, S2 and S3).

Every round ''r'' consists of 4 actions: 
{| class="wikitable"
|'''Action 1'''
|XOR the left half (L) of the data with the ''r'' th P-array entry
|-
|'''Action 2'''
|Use the XORed data as input for Blowfish's F-function
|-
|'''Action 3'''
|XOR the F-function's output with the right half (R) of the data
|-
|'''Action 4'''
|Swap L and R
|}

The F-function splits the 32-bit input into four 8-bit quarters and uses the quarters as input to the S-boxes. The S-boxes accept 8-bit input and produce 32-bit output. The outputs are added [[modular arithmetic|modulo]] 2<sup>32</sup> and XORed to produce the final 32-bit output (see image in the upper right corner).<ref>{{Cite web |title = Cryptography: Description of a New Variable-Length Key, 64-Bit Block Cipher (Blowfish) |url = https://www.schneier.com/cryptography/archives/1994/09/description_of_a_new.html |website = Schneier on Security |access-date = 2015-12-31 |url-status = live |archive-url = https://web.archive.org/web/20160304200440/https://www.schneier.com/cryptography/archives/1994/09/description_of_a_new.html |archive-date = 2016-03-04}}</ref>

After the 16th round, undo the last swap, and XOR L with K18 and R with K17 (output whitening).

Decryption is exactly the same as encryption, except that P1, P2, ..., P18 are used in the reverse order. This is not so obvious because xor is commutative and associative. A common misconception is to use inverse order of encryption as decryption algorithm (i.e. first XORing P17 and P18 to the ciphertext block, then using the P-entries in reverse order).

Blowfish's [[key schedule]] starts by initializing the P-array and S-boxes with values derived from the [[hexadecimal]] digits of [[pi]], which contain no obvious pattern (see [[nothing up my sleeve number]]). The secret key is then, byte by byte, cycling the key if necessary, XORed with all the P-entries in order. A 64-bit all-zero block is then encrypted with the algorithm as it stands. The resultant ciphertext replaces P<sub>1</sub> and P<sub>2</sub>. The same ciphertext is then encrypted again with the new subkeys, and the new ciphertext replaces P<sub>3</sub> and P<sub>4</sub>. This continues, replacing the entire P-array and all the S-box entries. In all, the Blowfish encryption algorithm will run 521 times to generate all the subkeys{{snd}} about 4&nbsp;KB of data is processed.

Because the P-array is 576&nbsp;bits long, and the key bytes are XORed through all these 576&nbsp;bits during the initialization, many implementations support key sizes up to 576&nbsp;bits. The reason for that is a discrepancy between the original Blowfish description, which uses 448-bit keys, and its reference implementation, which uses 576-bit keys. The test vectors for verifying third-party implementations were also produced with 576-bit keys. When asked which Blowfish version is the correct one, Bruce Schneier answered: "The test vectors should be used to determine the one true Blowfish".

Another opinion is that the 448&nbsp;bits limit is present to ensure that every bit of every subkey depends on every bit of the key,<ref name="blowfish-paper"/> as the last four values of the P-array don't affect every bit of the ciphertext. This point should be taken in consideration for implementations with a different number of rounds, as even though it increases security against an exhaustive attack, it weakens the security guaranteed by the algorithm. And given the slow initialization of the cipher with each change of key, it is granted a natural protection against brute-force attacks, which doesn't really justify key sizes longer than 448&nbsp;bits.

==Blowfish in pseudocode==
 P[18]            // ''P-array of 18 elements''
 S[4][256]        // ''S-boxes: 4 arrays of 256 elements''
 
 '''function''' f(x):
     // ''Calculates a function f on a 32-bit input x, using S-boxes and bit manipulation''
     high_byte := (x '''shifted right by''' 24 '''bits''')
     second_byte := (x '''shifted right by''' 16 '''bits''') '''AND''' 0xff
     third_byte := (x '''shifted right by''' 8 '''bits''') '''AND''' 0xff
     low_byte := x '''AND''' 0xff
 
     h := S[0][high_byte] + S[1][second_byte]
     '''return''' (h '''XOR''' S[2][third_byte]) + S[3][low_byte]
 
 '''procedure''' blowfish_encrypt(L, R):
     // ''Encrypts two 32-bit halves L and R using the P-array and function f over 16 rounds''
     '''for''' round := 0 '''to''' 15:
         L := L '''XOR''' P[round]
         R := f(L) '''XOR''' R
         '''swap values of L and R'''
     '''swap values of L and R'''
     R := R '''XOR''' P[16]
     L := L '''XOR''' P[17]
 
 '''procedure''' blowfish_decrypt(L, R):
     // ''Decrypts two 32-bit halves L and R using the P-array and function f over 16 rounds in reverse''
     '''for''' round := 17 '''down to''' 2:
         L := L '''XOR''' P[round]
         R := f(L) '''XOR''' R
         '''swap values of L and R'''
     '''swap values of L and R'''
     R := R '''XOR''' P[1]
     L := L '''XOR''' P[0]
  
 // ''Initializes the P-array and S-boxes using the provided key, followed by key expansion''
 //'' Initialize P-array with the key values''
 key_position := 0
 '''for''' i := 0 '''to''' 17:
     k := 0
     '''for''' j := 0 '''to''' 3:
         k := (k '''shifted left by''' 8 '''bits''') '''OR''' key[key_position]
         key_position := (key_position + 1) '''mod''' key_length
     P[i] := P[i] '''XOR''' k
 
 //'' Blowfish key expansion (521 iterations)''
 L := 0, R := 0
 '''for''' i := 0 '''to''' 17 '''by''' 2:
     blowfish_encrypt(L, R)
     P[i] := L
     P[i + 1] := R
 
 //'' Fill S-boxes by encrypting L and R''
 '''for''' i := 0 '''to''' 3:
     '''for''' j := 0 '''to''' 255 '''by''' 2:
         blowfish_encrypt(L, R)
         S[i][j] := L
         S[i][j + 1] := R

== Blowfish in practice ==
Blowfish is a fast [[block cipher]], except when changing keys. Each new [[key (cryptography)|key]] requires the pre-processing equivalent of encrypting about 4 kilobytes of text, which is very slow compared to other block ciphers. This prevents its use in certain applications, but is not a problem in others.

Blowfish must be initialized with a key. It is good practice to have this key hashed with a [[hash function]] before use.

In one application Blowfish's slow key changing is actually a benefit: the [[password]]-hashing method (crypt $2, i.e. bcrypt) used in [[OpenBSD]] uses an algorithm derived from Blowfish that makes use of the slow key schedule; the idea is that the extra computational effort required gives protection against [[dictionary attack]]s. ''See'' [[key stretching]].

Blowfish has a [[memory footprint]] of just over 4 kilobytes of [[Random Access Memory|RAM]]. This constraint is not a problem even for older desktop and [[laptop computers]], though it does prevent use in the smallest [[embedded systems]] such as early [[smartcard]]s.

Blowfish was one of the first secure block ciphers not subject to any patents and therefore freely available for anyone to use. This benefit has contributed to its popularity in cryptographic software.

[[bcrypt]] is a [[Cryptographic hash function#Password verification|password hashing function]] which, combined with a variable number of iterations (work "cost"), exploits the expensive key setup phase of Blowfish to increase the workload and duration of hash calculations, further reducing threats from brute force attacks.

bcrypt is also the name of a cross-platform file encryption utility developed in 2002 that implements Blowfish.<ref>[https://bcrypt.sourceforge.net "Bcrypt - Blowfish File Encryption"] {{webarchive |url=https://web.archive.org/web/20150829060804/http://bcrypt.sourceforge.net/ |date=2015-08-29}} bcrypt file encryption program homepage (bcrypt.sourceforge.net)</ref><ref>{{cite web|url=http://bcrypt463065.android.informer.com/|title=bcrypt Free Download - whodunnit.tools.bcrypt|website=bcrypt463065.android.informer.com|access-date=7 May 2018|url-status=live|archive-url=https://web.archive.org/web/20160304075720/http://bcrypt463065.android.informer.com/ |archive-date=4 March 2016}}</ref><ref>{{cite web|url=http://www.t2-project.org/packages/bcrypt.html|title=T2 package - trunk - bcrypt - A utility to encrypt files.|website=www.t2-project.org|access-date=7 May 2018|url-status=live|archive-url=https://web.archive.org/web/20170421043425/http://t2-project.org/packages/bcrypt.html|archive-date=21 April 2017}}</ref><ref>{{cite web|url=https://docs.oracle.com/cd/E51849_01/gg-winux/OGGLC/ogglc_licenses.htm|title=Oracle GoldenGateのライセンス|website=docs.oracle.com|access-date=7 May 2018|url-status=live|archive-url=https://web.archive.org/web/20171027233204/https://docs.oracle.com/cd/E51849_01/gg-winux/OGGLC/ogglc_licenses.htm|archive-date=27 October 2017}}</ref>

==Weakness and successors==
Blowfish's use of a 64-bit block size (as opposed to e.g. AES's 128-bit block size) makes it vulnerable to [[birthday attack]]s, particularly in contexts like [[HTTPS]]. In 2016, the SWEET32 attack demonstrated how to leverage birthday attacks to perform plaintext recovery (i.e. decrypting ciphertext) against ciphers with a 64-bit block size.<ref>{{cite web
 |url         = https://sweet32.info/
 |title       = On the Practical (In-)Security of 64-bit Block Ciphers — Collision Attacks on HTTP over TLS and OpenVPN
 |author      = Karthikeyan Bhargavan
 |author2     = Gaëtan Leurent
 |date        = August 2016
 |publisher   = ACM CCS 2016
 |url-status     = live
 |archive-url  = https://web.archive.org/web/20161009174028/https://sweet32.info/
 |archive-date = 2016-10-09
}}</ref> The [[GnuPG]] project recommends that Blowfish not be used to encrypt files larger than 4 GB<ref name=":0">{{cite web |url=https://gnupg.org/faq/gnupg-faq.html#define_fish |title=GnuPG Frequently Asked Questions |quote=Blowfish should not be used to encrypt files larger than 4Gb in size, but Twofish has no such restrictions. |access-date=2018-01-26 |archive-url=https://web.archive.org/web/20171221180749/https://gnupg.org/faq/gnupg-faq.html#define_fish |archive-date=2017-12-21 |url-status=live}}</ref> due to its small block size.<ref name=":1">{{cite web |url=https://gnupg.org/faq/gnupg-faq.html#recommended_ciphers |title=GnuPG Frequently Asked Questions |quote=For a cipher with an eight-byte block size, you’ll probably repeat a block after about 32 gigabytes of data. This means if you encrypt a single message larger than 32 gigabytes, it’s pretty much a statistical guarantee you’ll have a repeated block. That’s bad. For this reason, we recommend you not use ciphers with eight-byte data blocks if you’re going to be doing bulk encryption. It’s very unlikely you’ll have any problems if you keep your messages under 4 gigabytes in size. |access-date=2018-01-27 |archive-url=https://web.archive.org/web/20171221180749/https://gnupg.org/faq/gnupg-faq.html#recommended_ciphers |archive-date=2017-12-21 |url-status=live}}</ref>

A reduced-round variant of Blowfish is known to be susceptible to [[known-plaintext attack]]s on reflectively weak keys. Blowfish implementations use 16 rounds of encryption, and are not susceptible to this attack.<ref>{{cite web
 |url         = http://karbalus.free.fr/sat/docsat/PaperGonzalezTom.pdf
 |title       = A Reflection Attack on Blowfish
 |author      = Tom Gonzalez
 |date        = January 2007
 |publisher   = Journal of LATEX Class Files
 |volume      = 6
 |issue       = 1
 |url-status     = dead
 |archive-url  = https://web.archive.org/web/20151118102822/http://karbalus.free.fr/sat/docsat/PaperGonzalezTom.pdf
 |archive-date = 2015-11-18
 |access-date = 2015-11-17
}}</ref><ref>
{{cite web
 |url             = https://www.iacr.org/archive/fse2007/45930168/45930168.pdf
 |title           = A New Class of Weak Keys for Blowfish
 |author          = Orhun Kara
 |author2         = Cevat Manap
 |name-list-style = amp
 |date            = March 2007
 |publisher       = FSE 2007
 |url-status         = live
 |archive-url      = https://web.archive.org/web/20161005063215/https://www.iacr.org/archive/fse2007/45930168/45930168.pdf
 |archive-date     = 2016-10-05
}}</ref>

Bruce Schneier has recommended migrating to his Blowfish successor, [[Twofish]].<ref name="schneier-interview-dec-2007">
{{cite web
| url = https://www.computerworld.com.au/article/46254/bruce_almighty_schneier_preaches_security_linux_faithful/?pp=3
| title = Bruce Almighty: Schneier preaches security to Linux faithful
| last = Dahna
| first = McConnachie
| date = 2007-12-27
| access-date = 2018-01-26
| work = [[Computerworld]]
| page = 3
| archive-url = https://web.archive.org/web/20161202063854/https://www.computerworld.com.au/article/46254/bruce_almighty_schneier_preaches_security_linux_faithful/?pp=3
| archive-date = 2016-12-02
| quote = At this point, though, I'm amazed it's still being used. If people ask, I recommend Twofish instead.
| url-status = live
}}
</ref>

{{Visible anchor|Blowfish2}} was released in 2005, developed by Alexander Pukall. It has exactly the same design but has twice as many S tables and uses 64-bit integers instead of 32-bit integers. It no longer works on 64-bit blocks but on 128-bit blocks like AES. Blowfish2 is used for example, in [[FreePascal]].<ref>{{cite web |url=https://gitlab.com/freepascal.org/fpc/source/-/blob/main/packages/fcl-base/src/blowfish2.pp?ref_type=heads |website=Gitlab |title=Blowfish2 included in Feepascal |date=16 March 2025 }}</ref><ref>{{cite web |url=https://github.com/robistruck/blowfish2 |website=Github |title=Blowfish2 on Github }}</ref>

==See also==
* [[Twofish]]
* [[Threefish]]
* [[MacGuffin (cipher)|MacGuffin]]

==References==
{{reflist}}

==External links==
{{commons category|Blowfish (cipher)}}
* {{cite web
| url=https://www.schneier.com/blowfish.html
| title=The Blowfish Encryption Algorithm
| author=Bruce Schneier}}

* {{cite web
| url=https://www.schneier.com/blowfish-products.html
| title=Products that Use Blowfish
| author=Bruce Schneier}}

* {{cite web
| url=http://www.users.zetnet.co.uk/hopwood/crypto/scan/cs.html#Blowfish
| title=Standard Cryptographic Algorithm Naming: Blowfish}}

{{Cryptography navbox | block}}

{{DEFAULTSORT:Blowfish (Cipher)}}
[[Category:Feistel ciphers]]
[[Category:Free ciphers]]
[[Category:Articles with example pseudocode]]