Phantom type for PBKDF2
Modulepassword-3.0.4.0Haskell2010
Data.Password.PBKDF2
PBKDF2
The PBKDF2 algorithm is one of the oldest and most solid password algorithms out there. It has also, however, been shown to be the least secure out of all major password algorithms. The main reason for this is that it doesn't make use of any memory cost or other method of making it difficult for specialized hardware attacks, like GPU cracking attacks.
It is still, however, used all over the world, since it has been shown to be a very reliable way to encrypt passwords. And it is most definitely better than trying to develop a password algorithm on your own, or god-forbid, not using any encryption on your stored passwords.
Other algorithms
Seeing as PBKDF2 is shown to be very weak in terms of protection
against GPU cracking attacks, it is generally advised to go with
Bcrypt, if not Scrypt
or Argon2.
When unsure, Bcrypt
would probably be the safest option, as it has no memory cost which
could become a problem if not properly calibrated to the machine
doing the password verifications.
- 7 types
- 9 values
- Packagepassword-3.0.4.0
- Exports16
- LanguageHaskell2010
- LicenceBSD-3-Clause
- SourcePBKDF2.hs
Plain-text Password
2 declarationsA plain-text password.
This represents a plain-text password that has NOT been hashed.
You should be careful with Password. Make sure not to write it to logs or store it in a database.
You can construct a Password by using the mkPassword function or as literal
strings together with the OverloadedStrings pragma (or manually, by using
fromString on a String). Alternatively, you could also use some of the
instances in the password-instances
library.
Construct a Password
Hash Passwords (PBKDF2)
2 declarationsA hashed password.
This represents a password that has been put through a hashing function. The hashed password can be stored in a database.
Constructors
Instances4Eq, Ord, Read, Show
Eq (PasswordHash a)Defined in password-types-1.0.0.0 · Data.Password.TypesOrd (PasswordHash a)Defined in password-types-1.0.0.0 · Data.Password.TypesRead (PasswordHash a)Defined in password-types-1.0.0.0 · Data.Password.TypesShow (PasswordHash a)Defined in password-types-1.0.0.0 · Data.Password.Types
Verify Passwords (PBKDF2)
2 declarationsCheck a Password against a PasswordHash PBKDF2.
Returns PasswordCheckSuccess on success.
let pass = mkPassword "foobar"passHash <- hashPassword passcheckPassword pass passHashPasswordCheckSuccess
Returns PasswordCheckFail if an incorrect Password or PasswordHash PBKDF2 is used.
let badpass = mkPassword "incorrect-password"checkPassword badpass passHashPasswordCheckFail
This should always fail if an incorrect password is given.
\(Blind badpass) -> let correctPasswordHash = hashPasswordWithSalt testParams salt "foobar" in checkPassword badpass correctPasswordHash == PasswordCheckFailThe result of checking a password against a hashed version. This is
returned by the checkPassword functions.
Constructors
PasswordCheckSuccessThe password check was successful. The plain-text password matches the hashed password.
PasswordCheckFailThe password check failed. The plain-text password does not match the hashed password.
Instances3Eq, Read, Show
Eq PasswordCheckDefined in password-3.0.4.0 · Data.Password.InternalRead PasswordCheckDefined in password-3.0.4.0 · Data.Password.InternalShow PasswordCheckDefined in password-3.0.4.0 · Data.Password.Internal
Hashing Manually (PBKDF2)
5 declarationsHash a password using the PBKDF2 algorithm with the given PBKDF2Params.
N.B.: If you have any doubt in your knowledge of cryptography and/or the PBKDF2 algorithm, please just use hashPassword.
Default parameters for the PBKDF2 algorithm.
defaultParamsPBKDF2Params {pbkdf2Salt = 16, pbkdf2Algorithm = PBKDF2_SHA512, pbkdf2Iterations = 25000, pbkdf2OutputLength = 64}
Extracts PBKDF2Params from a PasswordHash PBKDF2.
Returns 'Just PBKDF2Params' on success.
let pass = mkPassword "foobar"passHash <- hashPassword passextractParams passHash == Just defaultParamsTrue
Parameters used in the PBKDF2 hashing algorithm.
Constructors
PBKDF2Paramspbkdf2Salt :: Word32Bytes to randomly generate as a unique salt, default is 16
pbkdf2Algorithm :: PBKDF2AlgorithmWhich algorithm to use for hashing, default is PBKDF2_SHA512
pbkdf2Iterations :: Word32Rounds to hash, default is 25,000
pbkdf2OutputLength :: Word32Output key length in bytes, default is 64
Limits are min: 1, max: the amount of entropy of the hashing algorithm. This is limited automatically to 16, 20, 32, 64 for MD5, SHA1, SHA256, SHA512, respectively.
Instances2Eq, Show
Eq PBKDF2ParamsDefined in password-3.0.4.0 · Data.Password.PBKDF2Show PBKDF2ParamsDefined in password-3.0.4.0 · Data.Password.PBKDF2
Type of algorithm to use for hashing PBKDF2 passwords.
N.B.: PBKDF2_MD5 and PBKDF2_SHA1 are not considered very secure.
Instances2Eq, Show
Eq PBKDF2AlgorithmDefined in password-3.0.4.0 · Data.Password.PBKDF2Show PBKDF2AlgorithmDefined in password-3.0.4.0 · Data.Password.PBKDF2
Hashing with salt (DISADVISED)
Hashing with a set Salt is almost never what you want to do. Use hashPassword or hashPasswordWithParams to have automatic generation of randomized salts.
Hash a password with the given PBKDF2Params and also with the given Salt instead of a randomly generated salt using pbkdf2Salt from PBKDF2Params. (cf. hashPasswordWithParams) Using hashPasswordWithSalt is strongly disadvised and hashPasswordWithParams should be used instead. Never use a static salt in production applications!
let salt = Salt "abcdefghijklmnop"hashPasswordWithSalt defaultParams salt (mkPassword "foobar")PasswordHash {unPasswordHash = "sha512:25000:YWJjZGVmZ2hpamtsbW5vcA==:JRElYYrOMe9OIV4LDxaLTgO9ho8fFBVofXoQcdngi7AcuH6Amvmlj2B0y6y1UtQciXXBepSCS+rpy8/vDDQvoA=="}
(Note that we use an explicit Salt in the example above. This is so that the example is reproducible, but in general you should use hashPassword. hashPassword (and hashPasswordWithParams) generates a new Salt everytime it is called.)
Generate a random 16-byte PBKDF2 salt
A salt used by a hashing algorithm.
Constructors
Unsafe debugging function to show a Password
1 declarationThis is an unsafe function that shows a password in plain-text.
unsafeShowPassword ("foobar" :: Password)"foobar"
You should generally not use this function in production settings, as you don't want to accidentally print a password anywhere, like logs, network responses, database entries, etc.
This will mostly be used by other libraries to handle the actual password internally, though it is conceivable that, even in a production setting, a password might have to be handled in an unsafe manner at some point.
Setup for doctests.
0 declarations:set -XFlexibleInstances:set -XOverloadedStrings
Import needed libraries.
import Data.Password.Typesimport Data.ByteString (pack)import Test.QuickCheck (Arbitrary(arbitrary), Blind(Blind), vector)import Test.QuickCheck.Instances.Text ()
instance Arbitrary (Salt a) where arbitrary = Salt . pack <$> vector 16instance Arbitrary Password where arbitrary = fmap mkPassword arbitrarylet testParams = defaultParams{ pbkdf2Iterations = 5000 }let salt = Salt "abcdefghijklmnop"