Scrypt
Algoritma

Algoritma aşağıdaki parametreleri içerir:
Parola - Hash edilecek karakter dizisi.
Tuz - Gökkuşağı Tablosu saldırılarına karşı korumak için hash değerini değiştiren bir karakter dizisi
N - işlemci/bellek maliyeti parametresi.
p - Paralelleştirme parametresi; p ≤ (232 - 1) * hLen / MFLen denklemini sağlayan pozitif bir tam sayı.
dkLen - türetilmiş anahtarın (oktet cinsinden) amaçlanan çıktı uzunluğu; dkLen≤(232 - 1) * hLen denlemini sağlayan pozitif bir tam sayı.
r - Ardışık hafızanın okuma boyutunu ve performansını hassas şekilde ayarlayan blok boyutu parametresi. Yaygın olarak kullanılan değer 8'dir.
hLen - Hash fonksiyonunun oktet uzunluğu (SHA256 için 32).
MFlen - Karıştırma işlevinin çıktısının oktet cinsinden uzunluğu (aşağıdaki SMix). RFC7914'te r*128 olarak tanımlanmıştır.
Function scrypt
Inputs:
      Passphrase:             Bytes    string of characters to be hashed
      Salt:                   Bytes    random salt
      CostFactor (N):         Integer  CPU/memory cost parameter
      BlockSizeFactor (r):    Integer  blocksize parameter (8 is commonly used)
      ParallelizationFactor (p): Integer  Parallelization parameter. (1..232-1 * hLen/MFlen)
      DesiredKeyLen:          Integer  Desired key length in bytes
   Output:
      DerivedKey:             Bytes    array of bytes, DesiredKeyLen long

   Step 1. Generate expensive salt
   blockSize ← 128*BlockSizeFactor  //Length (in bytes) of the SMix mixing function output (e.g. 128*8 = 1024 bytes)

   Use PBKDF2 to generate initial 128*BlockSizeFactor*p bytes of data (e.g. 128*8*3 = 3072 bytes)
   Treat the result as an array of p elements, each entry being blocksize bytes (e.g. 3 elements, each 1024 bytes)
   [B0...Bp−1] ← PBKDF2HMAC-SHA256(Passphrase, Salt, 1, blockSize*ParallelizationFactor)

   Mix each block in B 2CostFactor times using ROMix function (each block can be mixed in parallel)
   for i ← 0 to p-1 do
      Bi ← ROMix(Bi, 2CostFactor)

   All the elements of B is our new "expensive" salt
   expensiveSalt ← B0∥B1∥B2∥ ... ∥Bp-1  //where ∥ is concatenation
 
   Step 2. Use PBKDF2 to generate the desired number of bytes, but using the expensive salt we just generated
   return PBKDF2HMAC-SHA256(Passphrase, expensiveSalt, 1, DesiredKeyLen);
PBKDF2 (P, S, c, dkLen) notasyonu [rfc:2898 RFC] 2898'de tanımlandığı zaman ve c değeri iterasyon miktarını belirttiği zaman.
Bu gösterim, RFC 7914 tarafından PBKDF2'nin c=1 iken olan kullanımını belirtmek için kullanılır.
Function ROMix(Block, Iterations)

   Create Iterations copies of X
   X ← Block
   for i ← 0 to Iterations−1 do
      Vi ← X
      X ← BlockMix(X)

   for i ← 0 to Iterations−1 do
      j ← Integerify(X) mod Iterations 
      X ← BlockMix(X xor Vj)

   return X
Burada RFC 7914 Integerify(X)'i X'in son 64 baytının little-endian(en önemli byte en sağda olan) A1 tam sayısı olarak yorumlamasının sonucu olarak tanımlar.
İterasyonlar N'in karesine eşit olduğu için, X'in son 64 baytı içinden sadece ilk Tavan(N / 8) olan ve little-endian tam sayı olan  A2 olarak yorumlanan baytlar, Integerify (X) 'mod yineleme =  A1 mod yineleme = A2 mod yineleme  denkleminin hesaplanmasında kullanılır.
Function BlockMix(B):

    The block B is r 128-byte chunks (which is equivalent of 2r 64-byte chunks)
    r ← Length(B) / 128;

    Treat B as an array of 2r 64-byte chuncks
    [B0...B2r-1] ← B

    X ← B2r−1
    for i ← 0 to 2r−1 do
        X ← Salsa20/8(X xor Bi)  //Salsa20/8 hashes from 64-bytes to 64-bytes
        Yi ← X

    return ← Y0∥Y2∥...∥Y2r−2 ∥ Y1∥Y3∥...∥Y2r−1
Salsa20/8, Salsa20'nin 8'lik versiyon olduğu durumda  .