**Bcrypt**, Niels Provos ve David Mazières tarafından Blowfish şifreleme yöntemi esas alınarak geliştirilmiş ve ilk kez USENIX’te, 1999 yılında sunulmuş bir parola özet fonksiyonudur. Rainbow table saldırılarına karşı salt kullanmasının yanı sıra adaptif bir fonksiyon olma özelliğine sahiptir. İterasyon sayacı arttırılarak yavaşlatılabilir ve bu sayede kaba kuvvet saldırılarına karşı dirençli kalabilmektedir.

Bcrypt fonksiyonu OpenBSD’nin varsayılan parola özetleme algoritmasıdır ve SUSE Linux gibi bazı Linux dağıtımlarında da kullanılmaktadır.

Ayrıca, bcrypt’in C, C++, C#, Elixir, Go, Java, JavaScript, Perl, PHP, Python ve Ruby gibi dillerde de uygulamaları mevcuttur.

ArkaPlan
--------

Blowfish, blok şifreleme yöntemleri arasında yavaş anahtar hazırlama evresiyle bilinmektedir. Standart durumda alt anahtarlarla başlar, bu durumdaki alt anahtarların bir bölümünde blok şifreleme yapar ve oluşan şifreleri bazı alt anahtarlarla değiştirir. Daha sonra modifiye edilmiş yeni durumda anahtarın bir başka bölümünü şifreler ve oluşan sonucu başka alt anahtarlarla değiştirmede kullanır. Bu şekilde, tüm alt anahtarlar belirlenene dek devam eder.

Provos ve Mazières bu yöntemden yararlanmış ve onu daha da ileriye götürmüştür. Blowfish için yeni bir anahtar oluşturma algoritması geliştirip "Eksblowfish" ("maliyetli anahtar planlama Blowfish") olarak adlandırmışlardır. Anahtar hazırlama aşaması, Blowfish gibi tüm alt anahtarları belirlemede salt ve parola kullanılarak başlar. Ardından standart Blowfish anahtar oluşturma evreleri bunu takip eder ve bu evrelerde bir önceki evredeki alt anahtardan başlanarak, anahtar olarak sırayla salt ve parola kullanılarak devam edilir. Teoride bu standart Blowfish anahtar oluşturma takviminden pek de farklılık gösteriyor değildir. Fakat, bu süreç yeniden anahtar oluşturma evrelerinin ayarlanabilir olması sayesinde istenen ölçüde yavaşlatılabilir. Bu sayede salt veya özete yönelik yapılan kaba kuvvet saldırıları engellenebilir.

Açıklama
--------

Gölge parola dosyasında bulunan bir özet stringdeki "$2a$" veya "$2b$" (veya "$2y$") ön ekleri özet string’in modüler şifre formatındaki bir bcrpyt özeti olduğunu belirtir. Özetin geri kalanı ise maliyet parametresi, 128-bit salt (Radix-64 ile şifrelenmiş 22 karakter) ve 184 bit sonuç özet değeri (Radix-64 ile şifrelenmiş 31 karakter) içerir. Radix-64 unix/crypt alfabesi kullanır ve standart Base-64 değildir. Maliyet parametresi anahtar ilerleme iterasyon sayacı değerini belirtir. 2’nin katları olarak gösterilir ve şifreleme algoritmasının bir girdisidir.

Örneğin gölge parola kaydı `$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy` maliyet parametresinin 10, yani 210 anahtar ilerleme evresi olduğunu gösterir. Salt ise `N9qo8uLOickgx2ZMRZoMye`'dir ve sonuç özet değeri ise `IjZAgcfl7p92ldGxad68LJZdL17lhWy`'dir. Kullanıcının parolası ise standart uygulamada kaydedilmez.

Sürüm geçmişi
-------------

**$ 2 $ (1999)**

Orijinal Bcrypt tanımlarına göre ön ek olarak `$2$` kullanılır. Bu tanımlara göre OpenBSD şifre dosyalarında parolaların kaydedilmesinde **Modular CryptFormat** takip edilir.

* `$1$` : MD5 tabanlı şifreleme ('md5crypt')
* `$2$` : Balon balığı tabanlı şifreleme ('bcrypt')
* `$sha1$` : SHA-1 tabanlı şifreleme ('sha1crypt')
* `$5$` : SHA-256 tabanlı şifreleme ('sha256crypt')
* `$6$` : SHA-512 tabanlı şifreleme ('sha512crypt')

**$ 2a $**

Orijinal tanımlarda non-ASCII karakterlerin veya sıfır sonlayıcıların nasıl değerlendirileceği belirtilmemiştir. Tanımlar aşağıdaki yönergeler dahil edilecek şekilde revize edilmiştir:

* String UTF-8'e göre kodlanmış olmalıdır
* null terminator dahil edilmelidir

Bu değişikliklerle birlikte versiyon `$2a$` olarak değiştirilmiştir

**$ 2x $, $ 2y $ (Haziran 2011)**

Haziran 2011’de BCrypt’in bir PHP uygulaması olan **crypt\_blowfish**’te bir hata keşfedildi. Bu, 8. bit setindeki karakterlerin yanlış değerlendirilmesiyle alakalı bir hataydı. Sistem yöneticilerinin ellerindeki mevcut parola veri tabanlarını `$2a$` 'dan `$2x$`'e geçerek güncellemeleri önerildi. Aynı zamanda **crypt\_blowfish**’in sabit algoritmalarla üretilen özetler için `$2y$`'yi yayınlaması fikri de ortaya atıldı.

Kanonik OpenBSD de dahil olmak üzere kimse 2x/2y fikrini benimsemedi. Bu versiyon yalnızca **crypt\_blowfish** ile sınırlı kaldı.

**$ 2b $ (Şubat 2014)**

Bcrypt’in OpenBSD uygulamasında bir hata tespit edildi. String uzunlukları unsigned char (*i.e.* 8 bit `Byte`) olarak tutuluyordu. Eğer parola 255 karakterden uzunsa taşma meydana geldiği ve 255’te sınırlandığı görüldü.

BCrypt OpenBSD için oluşturulduğu için, bu kütüphanedeki hatadan sonra versiyon numarasının yükseltilmesine karar verildi.

Algoritma
---------

Bcrypt algoritması "*OrpheanBeholderScryDoubt*" metninin Blowfish kullanılarak 64 defa şifrelenmesinin sonucudur. Bcrypt’te standart Blowfish anahtar hazırlama fonksiyonu, daha yavaş anahtar hazırlama fonksiyonuyla (EksBlowfishSetup) değiştirilmiştir:

```
**Function** bcrypt
   **Input:**
      cost:    Number (4..31)                      log2(Iterations). e.g. 12 ==> 212 = 4,096 iterations
      salt:    array of Bytes (16 bytes)           random salt
      password: array of Bytes (1..72 bytes)        UTF-8 encoded password
   **Output:** 
      hash:    array of Bytes (24 bytes)

   //Initialize Blowfish state with expensive key setup algorithm
   *state* {\displaystyle \gets } EksBlowfishSetup(*cost*, *salt*, *password*)   

   //Repeatedly encrypt the text "OrpheanBeholderScryDoubt" 64 times
   *ctext* {\displaystyle \gets } *"OrpheanBeholderScryDoubt"*  //24 bytes ==> three 64-bit blocks
   **repeat** (64)
      *ctext* {\displaystyle \gets } EncryptECB(*state*, *ctext*) //encrypt using standard Blowfish in ECB mode

   //24-byte *ctext* is resulting password hash
   **return** Concatenate(*cost*, *salt*, *ctext*)
```

### Maliyetli anahtar oluşturma

Bcrypt algoritması aşağıdaki mantıkta çalışan "Eksblowfish" anahtar hazırlama algoritmasına bağlıdır:

```
**Function** EksBlowfishSetup
   **Input:**
      cost:    Number (4..31)                      log2(Iterations). e.g. 12 ==> 212 = 4,096 iterations
      salt:    array of Bytes (16 bytes)           random salt
      password: array of Bytes (1..72 bytes)        UTF-8 encoded password
   **Output:** 
      state:   opaque BlowFish state structure
 
   *state* {\displaystyle \gets } InitialState()
   *state* {\displaystyle \gets } ExpandKey(*state*, *salt*, *password*)
   **repeat** (2*cost*)
      *state* {\displaystyle \gets } ExpandKey(state, 0, password)
      *state* {\displaystyle \gets } ExpandKey(state, 0, salt)

    **return** *state*
```

### Expand Key

ExpandKey fonksiyonu aşağıdaki işlemleri yapar:

```
**Function** ExpandKey(*state*, *salt*, *password*)
   **Input:**
      state:   Opaque BlowFish state structure     Internally contains P-array and S-box entries
      salt:    array of Bytes (16 bytes)           random salt
      password: array of Bytes (1..72 bytes)        UTF-8 encoded password
   **Output:** 
      state:   opaque BlowFish state structure
 
   //Mix password into the internal P-array of *state*
   **for** *n* {\displaystyle \gets } 1 **to** 18 **do**
      Pn {\displaystyle \gets } Pn xor *password*[32(n-1)..32n-1] //treat the password as cyclic

   //Encrypt state using the lower 8 bytes of salt, and store the 8 byte result in P1|P2
   *block* {\displaystyle \gets } Encrypt(*state*, *salt*[0..63])
   P1 {\displaystyle \gets } *block*[0..31]  //lower 32-bits
   P2 {\displaystyle \gets } *block*[32..63] //upper 32-bits

   //Continue encrypting state with salt, and storing results in remaining P-array
   **for** *n* {\displaystyle \gets } 2 **to** 9 **do**
      *block* {\displaystyle \gets } Encrypt(*state*, *block* **xor** *salt*[64(n-1)..64n-1]) //encrypt using the current key schedule and treat the salt as cyclic
      P2n-1 {\displaystyle \gets } *block*[0..31] //lower 32-bits
      P2n {\displaystyle \gets } *block*[32..63]  //upper 32-bits

   //Mix encrypted state into the internal S-boxes of *state*
   **for** *i* {\displaystyle \gets } 1 **to** 4 **do**
      **for** *n* {\displaystyle \gets } 0 **to** 127 **do**
         *block* {\displaystyle \gets } Encrypt(*state*, *block* **xor** *salt*[64(n-1)..64n-1]) //as above
         Si[2n]   {\displaystyle \gets } *block*[0..31]  //lower 32-bits
         Si[2n+1] {\displaystyle \gets } *block*[32..63]  //upper 32-bits
    **return** *state*
```

Böylelikle, tüm XOR’lar ve sıfır salt değerleri etkisiz olduğu için `ExpandKey(*state*, 0, *key*)` standart Blowfish anahtar zamanlamasıyla aynıdır. `ExpandKey(*state*, 0, *salt*)` için de benzer şeyler söylenebilir, fakat bu fonksiyon salt değerini 128 bit anahtar olarak kullanır.

Kullanıcı girdisi
-----------------

Bcrypt’in birçok uygulaması OpenBSD’de olduğu gibi parolayı ilk 72 baytı kalacak şekilde kırpar.

Matematiksel algoritma ise 18 adet 32 bit alt anahtar ile (72 octet/byte’a eşdeğer) başlamaya hazır hale gelir. Bcrypt’in orijinal tanımlarında metin tabanlı şifreleri userland’den nümerik değerlere eşleştirmek için önerilen belirli bir metod yoktur. Metinde geçen kısa bir yorum string karakterlerini ASCII olarak şifreleyerek tutmaktan (zorunlu tutmaksızın) bahseder ve şöyle devam eder: "Sonuç olarak, buradaki anahtar argümanı, kullanıcı tarafından seçilen 56 byte’tan küçük(eğer anahtar ASCII string’i ise sonuçlandırma sıfır byte’ı da dahil olmak kaydıyla) bir gizli şifreleme anahtarıdır.

Bu alıntıda geçen "56 byte’tan küçük parolalar" ifadesi önemlidir (zira algoritma 72 byte’a kadar kullanıyor). Provos ve Mazières kısıtlamayla ilgili bir açıklama yapmıyor olsa da, Bruce Schneier’ın Blowfish’in orijinal tanımlamalarındaki ifadesini düşünerek hareket etmiş olabilirler: "Anahtar boyutundaki 448 [bit] limiti, her alt anahtarın her bitinin, anahtarın bir bitine bağlı olmasını sağlamaktadır."

Bcrypt’in farklı uygulamaları birbirinden, parolaları nümerik değerlere ilk dönüştürmelerinde kullandıkları yöntem farklılıklarıyla ayrışmıştır.

Ayrıca bakınız
--------------

* bcrypt aynı zamanda, 2002'de Blowfish tarafından geliştirilen cross-platform dosya şifreleme sistemi aracının da adıdır.
* Argon2 (2015'te Pasword Hashing Competition'ın kazananı)
* <a href="./Crypt%20(C)#Blowfish-based%20scheme" rel="mw:WikiLink" title="Crypt (C)" class="cx-link" data-linkid="127">Crypt (C)#Blowfish</a> tabanlı şema şifreleme – şifre saklama ve doğrulama şeması – Blowfish
* <a href="./Key%20stretching" rel="mw:WikiLink" title="Key stretching" class="cx-link" data-linkid="129">Key stretching</a>
* PBKDF2 (Parola Tabanlı Anahtar Türetme İşlevi 2)
* scrypt

Kaynakça
--------

1. 1 2  Provos, Niels; Mazières, David; Talan Jason Sutton 2012 (1999). "A Future-Adaptable Password Scheme". *Proceedings of 1999 USENIX Annual Technical Conference*. ss. 81-92. 4 Şubat 2012 tarihinde kaynağından arşivlendi. Erişim tarihi: 19 Nisan 2020.
2. ↑  "Commit of first work to repo". 13 Şubat 1997. 27 Eylül 2021 tarihinde kaynağından arşivlendi. Erişim tarihi: 11 Mart 2022.
3. ↑  "SUSE Security Announcement: (SUSE-SA:2011:035)". 23 Ağustos 2011. 4 Mart 2016 tarihinde kaynağından arşivlendi. Erişim tarihi: 20 Ağustos 2015. SUSE's crypt() implementation supports the blowfish password hashing function (id $2a) and system logins by default also use this method.
4. 1 2 3 4 5 6  Whitlock, David. "Bcrypt Elixir: Bcrypt password hashing algorithm for Elixir". *GitHub*. riverrun. 25 Nisan 2019 tarihinde kaynağından arşivlendi.
5. ↑  passlib. "Modular Crypt Format" 15 Kasım 2016 tarihinde Wayback Machine sitesinde arşivlendi..
6. ↑  passlib. "BCrypt" 25 Şubat 2021 tarihinde Wayback Machine sitesinde arşivlendi..
7. ↑  "Modern(-ish) password hashing for your software and your servers: pyca/bcrypt". 18 Kasım 2019. 18 Şubat 2016 tarihinde kaynağından arşivlendi – GitHub vasıtasıyla.
8. ↑  "GitHub - bcgit/bc-java: Bouncy Castle Java Distribution (Mirror)". 18 Kasım 2019. 20 Mayıs 2015 tarihinde kaynağından arşivlendi – GitHub vasıtasıyla.
9. ↑  "Modular Crypt Format — Passlib v1.7.1 Documentation". *passlib.readthedocs.io*. 15 Kasım 2016 tarihinde kaynağından arşivlendi.
10. ↑  "bcrypt password hash bugs fixed, version changes and consequences". *undeadly.org*. 12 Nisan 2011 tarihinde kaynağından arşivlendi.
11. ↑  Designer, Solar. "oss-sec: CVE request: crypt\_blowfish 8-bit character mishandling". *seclists.org*. 30 Haziran 2011 tarihinde kaynağından arşivlendi.
12. ↑  "bcrypt password hash bugs fixed, version changes and consequences". *undeadly.org*. 12 Nisan 2011 tarihinde kaynağından arşivlendi.
13. ↑  "'bcrypt version changes' - MARC". *marc.info*. 30 Temmuz 2013 tarihinde kaynağından arşivlendi.
14. ↑  Schneier, Bruce (1994). "Fast Software Encryption, Description of a New Variable-Length Key, 64-Bit Block Cipher (Blowfish)". *Cambridge Security Workshop Proceedings (December 1993)*. Springer-Verlag. ss. 191-204. 26 Ocak 2014 tarihinde kaynağından arşivlendi. Erişim tarihi: 19 Nisan 2020.
15. ↑  "jBCrypt security advisory". 1 Şubat 2010. 9 Mayıs 2010 tarihinde kaynağından arşivlendi.  And "Changes in CRYPT\_BLOWFISH in PHP 5.3.7". *php.net*. 26 Eylül 2011 tarihinde kaynağından arşivlendi.
16. ↑   29 Ağustos 2015 tarihinde Wayback Machine sitesinde arşivlendi. bcrypt file encryption program homepage
17. ↑  "bcrypt APK for Android - free download on Droid Informer". *droidinformer.org*. 15 Şubat 2020 tarihinde kaynağından arşivlendi.
18. ↑  "T2 package - trunk - bcrypt - A utility to encrypt files". *t2sde.org*. 28 Ekim 2017 tarihinde kaynağından arşivlendi.
19. ↑  "Oracle GoldenGateのライセンス". *docs.oracle.com*. 26 Ekim 2014 tarihinde kaynağından arşivlendi.

Dış bağlantılar
---------------

* crypt\_blowfish, Openwall tarafından sağlanan uygulama 23 Nisan 2020 tarihinde Wayback Machine sitesinde arşivlendi.