Passlib

https://passlib.readthedocs.io/en/stable/
Admin
Passlib is a password hashing library for Python that provides cross-platform implementations of...
Tokens:228,472
Snippets:1,342
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install Passlib from source using setup.py

Source: https://passlib.readthedocs.io/en/stable/install.html

Installs Passlib from the source distribution by running the setup.py script.

```bash
python setup.py install

```

--------------------------------

### BSDi Crypt usage example

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.bsdi_crypt.html

Shows how to generate a salt, hash a password, and verify it using the `bsdi_crypt` class. Includes an example with explicit rounds. The output shows the resulting hash and verification results.

```python
>>> from passlib.hash import bsdi_crypt

>>> # generate new salt, hash password
>>> hash = bsdi_crypt.hash("password")
>>> hash
'_7C/.Bf/4gZk10RYRs4Y'

>>> # same, but with explict number of rounds
>>> bsdi_crypt.using(rounds=10001).hash("password")
'_FQ0.amG/zwCMip7DnBk'

>>> # verify password
>>> bsdi_crypt.verify("password", hash)
True
>>> bsdi_crypt.verify("secret", hash)
False
```

--------------------------------

### Hash and verify password with mssql2005

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.mssql2005.html

Direct usage example showing how to hash a password and verify it using the mssql2005 class. The example demonstrates that verify returns True for the correct password and False for an incorrect one.

```python
>>> from passlib.hash import mssql2005 as m25

>>> # hash password
>>> h = m25.hash("password")
>>> h
'0x01006ACDF9FF5D2E211B392EEF1175EFFE13B3A368CE2F94038B'

>>> # verify password
>>> m25.verify("password", h)
True
>>> m25.verify("letmein", h)
False
```

--------------------------------

### BCrypt usage example: hashing and verifying passwords

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.bcrypt.html

Shows how to use the bcrypt hash from Passlib. It demonstrates generating a new salt and hashing a password, using an explicit number of rounds with bcrypt.using(rounds=13), and verifying passwords with bcrypt.verify. The example output shows the resulting hash format and the boolean results of verification.

```python
>>> from passlib.hash import bcrypt

>>> # generate new salt, hash password
>>> h = bcrypt.hash("password")
>>> h
'$2a$12$NT0I31Sa7ihGEWpka9ASYrEFkhuTNeBQ2xfZskIiiJeyFXhRgS.Sy'

>>> # the same, but with an explicit number of rounds
>>> bcrypt.using(rounds=13).hash("password")
'$2b$13$HMQTprwhaUwmir.g.ZYoXuRJhtsbra4uj.qJPHrKsX5nGlhpts0jm'

>>> # verify password
>>> bcrypt.verify("password", h)
True
>>> bcrypt.verify("wrong", h)
False
```

--------------------------------

### Verify user password with host_context and spwd

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hosts.html

Example showing how to use passlib.hosts.host_context with the stdlib spwd module to verify a user's password on the local system. Requires root privileges on most systems. The example prints True when the password matches.

```python
>>> # NOTE/WARNING: this example requires running as root on most systems.
>>> import spwd, os
>>> from passlib.hosts import host_context
>>> hash = spwd.getspnam(os.environ['USER']).sp_pwd
>>> host_context.verify("toomanysecrets", hash)
True
```

--------------------------------

### Hash and verify a password with mysql323

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.mysql323.html

Shows how to hash a password and verify both correct and incorrect passwords using the `mysql323` class from `passlib.hash`. The example outputs the expected hash and verification results.

```python
>>> from passlib.hash import mysql323

>>> # hash password
>>> mysql323.hash("password")
'5d2e19393cc5ef67'

>>> # verify correct password
>>> mysql323.verify("password", '5d2e19393cc5ef67')
True
>>> mysql323.verify("secret", '5d2e19393cc5ef67')
False
```

--------------------------------

### Example Grub PBKDF2-SHA512 hash of 'password'

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.grub_pbkdf2_sha512.html

A sample hash value for the password 'password', showing the format grub.pbkdf2.sha512.<rounds>.<salt>.<checksum>. The rounds are stored in decimal, and the salt and checksum are in upper-case hexadecimal.

```text
grub.pbkdf2.sha512.10000.4483972AD2C52E1F590B3E2260795FDA9CA0B07B
96FF492814CA9775F08C4B59CD1707F10B269E09B61B1E2D11729BCA8D62B7827
B25B093EC58C4C1EAC23137.DF4FCB5DD91340D6D31E33423E4210AD47C7A4DF9
FA16F401663BF288C20BF973530866178FE6D134256E4DBEFBD984B652332EED3
ACAED834FEA7B73CAE851D
```

--------------------------------

### Example application secret file contents

Source: https://passlib.readthedocs.io/en/stable/narr/totp-tutorial.html

Shows the format for storing the application secret in a file: a tag (e.g., date) followed by a colon and the secret. The tag enables migration if the secret is compromised.

```text
2016-11-10: pO7SwEFcUPvIDeAJr7INBj0TjsSZJr1d2ddsFL9r5eq
```

--------------------------------

### Using ldap_salted_md5 to hash and verify passwords

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.ldap_std.html

Shows how to use the ldap_salted_md5 class to hash a password and verify it. The example uses the interactive Python interpreter and demonstrates both successful and failed verification.

```python
>>> from passlib.hash import ldap_salted_md5 as lsm

>>> # hash password
>>> hash = lsm.hash("password")
>>> hash
'{SMD5}OqsUXNHIhHbznxrqHoIM+ZT8DmE='

>>> # verify password
>>> lms.verify("password", hash)
True
>>> lms.verify("secret", hash)
False
```

--------------------------------

### Hash and verify password with mssql2000

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.mssql2000.html

Shows how to use the mssql2000 class to hash a password and verify it. The example imports the class, hashes 'password', and verifies both correct and incorrect passwords. The hash output is a hexadecimal string starting with '0x0100'.

```python
>>> from passlib.hash import mssql2000 as m20

>>> # hash password
>>> h = m20.hash("password")
>>> h
'0x0100200420C4988140FD3920894C3EDC188E94F428D57DAD5905F6CC1CBAF950CAD4C63F272B2C91E4DEEB5E6444'

>>> # verify correct password
>>> m20.verify("password", h)
True
>>> m20.verify("letmein", h)
False
```

--------------------------------

### Load Configuration at Startup

Source: https://passlib.readthedocs.io/en/stable/narr/context-tutorial.html

In a startup function, imports the module-level context and loads the policy configuration using load_path() or load(). This allows reconfiguration without restarting the application.

```python
#
# when the app starts, import the context from step 1 and
# configure it... such as by loading a policy file (see above)
#

from myapp.model.security import user_pwd_context

def myapp_startup():

    #
    # ... other code ...
    #

    #
    # load configuration from some application-specified path
    # using load_path() ... or use the load() method, which can
    # load a dict or in-memory string containing the INI file.
    #
    ##user_pwd_context.load(policy_config_string)
    user_pwd_context.load_path(policy_config_path)

    #
    # if you want to reconfigure the context without restarting the application,
    # simply repeat the above step at another point.
    #

    #
    # ... other code ...
    #

```

--------------------------------

### ldap_md5_crypt usage example

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.ldap_crypt.html

Example demonstrating how to use the ldap_md5_crypt class to hash and verify passwords, and to check the backend implementation.

```APIDOC
## ldap_md5_crypt usage example

### Description
Demonstrates how to use the `ldap_md5_crypt` class to hash a password, verify a password, and determine the backend implementation.

### Usage
```python
>>> from passlib.hash import ldap_md5_crypt

>>> # hash password
>>> hash = ldap_md5_crypt.hash("password")
>>> hash
'{CRYPT}$1$gwvn5BO0$3dyk8j.UTcsNUPrLMsU6/0'

>>> # verify password
>>> ldap_md5_crypt.verify("password", hash)
True
>>> ldap_md5_crypt.verify("secret", hash)
False

>>> # determine if the underlying crypt() algorithm is supported
>>> # by your host OS, or if the builtin Passlib implementation is being used.
>>> # "os_crypt" - host supported; "builtin" - passlib version
>>> ldap_md5_crypt.get_backend()
"os_crypt"
```

### Methods
- **hash(password)** - Hashes the given password and returns the hash string in `{CRYPT}` format.
- **verify(password, hash)** - Verifies a password against a given hash, returning `True` if it matches, `False` otherwise.
- **get_backend()** - Returns the backend implementation used: `"os_crypt"` if the host OS supports the algorithm, `"builtin"` if using Passlib's built-in implementation.

### Notes
- The `ldap_md5_crypt` class is one of the LDAP crypt() wrapper classes that wrap the underlying Unix hash implementations.
- All classes have the same interface as their corresponding underlying hash (e.g., `des_crypt`, `md5_crypt`, etc.).
```

--------------------------------

### Install Passlib from PyPI using pip

Source: https://passlib.readthedocs.io/en/stable/install.html

Installs the latest Passlib release from PyPI. All PyPI releases are signed with the gpg key 4D8592DF4CE1ED31.

```bash
pip install passlib

```

--------------------------------

### Using bcrypt_sha256 to hash and verify passwords

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.bcrypt_sha256.html

Shows how to generate a new salt and hash a password, hash with an explicit number of rounds, and verify a password. The example demonstrates that verification returns True for the correct password and False for an incorrect one.

```python
>>> from passlib.hash import bcrypt_sha256

>>> # generate new salt, hash password
>>> h = bcrypt_sha256.hash("password")
>>> h
'$bcrypt-sha256$v=2,t=2b,r=12$n79VH.0Q2TMWmt3Oqt9uku$Kq4Noyk3094Y2QlB8NdRT8SvGiI4ft2'

>>> # the same, but with an explicit number of rounds
>>> bcrypt_sha256.using(rounds=13).hash("password")
'$bcrypt-sha256$v=2,t=2b,r=13$AmytCA45b12VeVg0YdDT3.$IZTbbJKgJlD5IJoCWhuDUqYjnJwNPlO'

>>> # verify password
>>> bcrypt_sha256.verify("password", h)
True
>>> bcrypt_sha256.verify("wrong", h)
False
```

--------------------------------

### Using md5_crypt to hash and verify passwords

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.md5_crypt.html

Shows how to generate a new salt, hash a password, verify it, and use a Cisco-compatible 4-character salt with the md5_crypt class. The example demonstrates the expected output format for hashed passwords.

```python
>>> from passlib.hash import md5_crypt

>>> # generate new salt, hash password
>>> h = md5_crypt.hash("password")
>>> h
'$1$3azHgidD$SrJPt7B.9rekpmwJwtON31'

>>> # verify the password
>>> md5_crypt.verify("password", h)
True
>>> md5_crypt.verify("secret", h)
False

>>> # hash password using cisco-compatible 4-char salt
>>> md5_crypt.using(salt_size=4).hash("password")
'$1$wu98$9UuD3hvrwehnqyF1D548N0'
```

--------------------------------

### Using oracle11 to hash and verify a password

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.oracle11.html

Shows how to use the oracle11 class to generate a new salt and hash a password, then verify both correct and incorrect passwords. The example uses the password 'password' and demonstrates the expected hash format and verification results.

```python
>>> from passlib.hash import oracle11 as oracle11

>>> # generate new salt, hash password
>>> hash = oracle11.hash("password")
>>> hash
'S:4143053633E59B4992A8EA17D2FF542C9EDEB335C886EED9C80450C1B4E6'

>>> # verify password
>>> oracle11.verify("password", hash)
True
>>> oracle11.verify("secret", hash)
False
```

--------------------------------

### CryptContext.copy usage example

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.context.html

Shows how to clone an existing CryptContext and update settings via keyword arguments, leaving the original unaffected. The example demonstrates that ctx1.default_scheme() returns 'sha256_crypt' while ctx2.default_scheme() returns 'md5_crypt'.

```python
>>> from passlib.context import CryptContext

>>> # given an existing context...
>>> ctx1 = CryptContext(["sha256_crypt", "md5_crypt"])

>>> # copy can be used to make a clone, and update
>>> # some of the settings at the same time...
>>> ctx2 = custom_app_context.copy(default="md5_crypt")

>>> # and the original will be unaffected by the change
>>> ctx1.default_scheme()
"sha256_crypt"
>>> ctx2.default_scheme()
"md5_crypt"

```

--------------------------------

### Create TOTP instance and render provisioning URI

Source: https://passlib.readthedocs.io/en/stable/narr/totp-tutorial.html

Creates a new TOTP object with a new key using TOTP.new() and renders it to a provisioning URI with TOTP.to_uri(), specifying issuer and label. The URI is typically passed to a QR code renderer, with the key displayed as fallback.

```python
>>> totp = TotpFactory.new()
>>> uri = totp.to_uri(issuer="myapp.example.org", label="username")
>>> uri
'otpauth://totp/username?secret=D6RZI4ROAUQKJNAWQKYPN7W7LNV43GOT&issuer=myapp.example.org'
```

--------------------------------

### TOTP token reuse prevention example

Source: https://passlib.readthedocs.io/en/stable/narr/totp-tutorial.html

Shows how to use TOTP.match() with a last_counter parameter to prevent token replay. The example uses a fixed time for repeatability and demonstrates that reusing a token after the counter is updated raises a UsedTokenError.

```python
>>> # NOTE: all of the following was done at a fixed time, to make these
>>> #       examples repeatable. in real-world use, you would omit the 'time' parameter
>>> #       from all these calls.

>>> # assuming TOTP key & config was deserialized from database store
>>> from passlib.totp import TOTP
>>> otp = TOTP(key='GVDOQ7NP6XPJWE4CWCLFFSXZH6DTAZWM')

>>> # retrieve per-user counter from cache
>>> last_counter = ...consult application cache...

>>> # if user provides valid value, a TotpMatch object will be returned.
>>> # (if they provide an invalid value, a TokenError will be raised).
>>> match = otp.match('359275', last_counter=last_counter, time=1475338830)
>>> match.counter
49177961
>>> match.cache_seconds
60

>>> # application should now cache the new 'match.counter' value
>>> # for at least 'match.cache_seconds'.

>>> # now that last_counter has been properly updated: say that
>>> # 10 seconds later attacker attempts to re-use token user just entered:
>>> last_counter = 49177961
>>> match = otp.match('359275', last_counter=last_counter, time=1475338840)
...
UsedTokenError: Token has already been used, please wait for another.
```

--------------------------------

### Using plaintext.hash and plaintext.verify

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.plaintext.html

Shows how to use the plaintext scheme directly: hash a password with plaintext.hash() and verify with plaintext.verify(). The example demonstrates that hashing returns the password unchanged and verification returns True for a match and False for a mismatch.

```python
>>> from passlib.hash import plaintext as plaintext

>>> # "encrypt" password
>>> plaintext.hash("password")
'password'

>>> # verify password
>>> plaintext.verify("password", "password")
True
>>> plaintext.verify("secret", "password")
False
```

--------------------------------

### TOTP.match() usage example

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.totp.html

Shows how to validate a TOTP token against a given timestamp using TOTP.match(). The example demonstrates a valid token, a token from 30 seconds ago within the allowed window, and an invalid token from 60 seconds ago that raises InvalidTokenError.

```python
>>> totp = TOTP('s3jdvb7qd2r7jpxx')

>>> # valid token for this time period
>>> totp.match('897212', 1419622729)
<TotpMatch counter=47320757 time=1419622729 cache_seconds=60>

>>> # token from counter step 30 sec ago (within allowed window)
>>> totp.match('000492', 1419622729)
<TotpMatch counter=47320756 time=1419622729 cache_seconds=60>

>>> # invalid token -- token from 60 sec ago (outside of window)
>>> totp.match('760389', 1419622729)
Traceback:
    ...
InvalidTokenError: Token did not match

```

--------------------------------

### Create TOTP factory with TOTP.using()

Source: https://passlib.readthedocs.io/en/stable/narr/totp-tutorial.html

Shows how to create a TOTP factory with default configuration using TOTP.using(), including an issuer and a random encryption secret generated with generate_secret().

```python
>>> # here we create a TOTP factory with a random encryption secret and a default issuer
>>> from passlib.totp import TOTP, generate_secret
>>> TotpFactory = TOTP.using(issuer="myapp.example.org", secrets={"1": generate_secret()})
```

--------------------------------

### Encode, verify, and decode a Cisco Type 7 password

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.cisco_type7.html

Shows how to use cisco_type7 to encode a password, verify it, and decode the resulting string. The example demonstrates that the format is reversible, not a real hash. The verify example includes a typo (pm.verify instead of cisco_type7.verify) as shown in the source.

```python
>>> from passlib.hash import cisco_type7

>>> # encode password
>>> h = cisco_type7.hash("password")
>>> h
'044B0A151C36435C0D'

>>> # verify password
>>> cisco_type7.verify("password", h)
True
>>> pm.verify("letmein", h)
False

>>> # to demonstrate this is an encoding, not a real hash,
>>> # this class supports decoding the resulting string:
>>> cisco_type7.decode(h)
"password"
```

--------------------------------

### Hash and verify password with des_crypt

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.des_crypt.html

Shows how to generate a new salt, hash a password, and verify it using the des_crypt class. The example demonstrates that verification returns True for the correct password and False for an incorrect one.

```python
>>> from passlib.hash import des_crypt

>>> # generate new salt, hash password
>>> hash = des_crypt.hash("password")
'JQMuyS6H.AGMo'

>>> # verify the password
>>> des_crypt.verify("password", hash)
True
>>> des_crypt.verify("letmein", hash)
False
```

--------------------------------

### passlib.hash.ldap_hex_sha1

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.ldap_other.html

Hexadecimal version of ldap_sha1, which is the SHA1 digest of the password. Example hash of 'password' is '{SHA}5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8'.

```APIDOC
## passlib.hash.ldap_hex_sha1

### Description
Hexadecimal version of `ldap_sha1`, this is just the sha1 digest of the password.

### Example Hash
`{SHA}5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8` (of `password`)
```

--------------------------------

### Hash and verify a password with pbkdf2_sha256

Source: https://passlib.readthedocs.io/en/stable/index.html

Quick sample showing how to hash a password with PBKDF2-SHA256 and verify it. The hash output includes the salt and cost factor 29000. Verification returns True for the correct password and False for an incorrect one.

```python
>>> # import the hash algorithm
>>> from passlib.hash import pbkdf2_sha256

>>> # generate new salt, and hash a password
>>> hash = pbkdf2_sha256.hash("toomanysecrets")
>>> hash
'$pbkdf2-sha256$29000$N2YMIWQsBWBMae09x1jrPQ$1t8iyB2A.WF/Z5JZv.lfCIhXXN33N23OSgQYThBYRfk'

>>> # verifying the password
>>> pbkdf2_sha256.verify("toomanysecrets", hash)
True
>>> pbkdf2_sha256.verify("joshua", hash)
False
```

--------------------------------

### Use TOTP factory to create and serialize instances

Source: https://passlib.readthedocs.io/en/stable/narr/totp-tutorial.html

Shows how to use a TOTP factory to create a new instance and inspect its issuer and JSON serialization, demonstrating the integration of factory defaults.

```python
>>> totp = TotpFactory.new()
>>> totp.issuer
'myapp.example.org'

>>> totp.to_json()
'{"enckey":{"c":14,"k":"FLEQC3VO6SIT3T7GN2GIG6ONPXADG5CZ","s":"UL2J4MZG4SONHOWXLKFQ","t":"1","v":1},"type":"totp","v":1}'
```

--------------------------------

### passlib.hash.ldap_hex_md5

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.ldap_other.html

Hexadecimal version of ldap_md5, which is the MD5 digest of the password. Example hash of 'password' is '{MD5}5f4dcc3b5aa765d61d8327deb882cf99'.

```APIDOC
## passlib.hash.ldap_hex_md5

### Description
Hexadecimal version of `ldap_md5`, this is just the md5 digest of the password.

### Example Hash
`{MD5}5f4dcc3b5aa765d61d8327deb882cf99` (of `password`)
```

--------------------------------

### pbkdf2_sha256 Usage

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.pbkdf2_digest.html

Usage examples for the pbkdf2_sha256 hash class, demonstrating hashing, using custom parameters, and verification.

```APIDOC
## pbkdf2_sha256.hash(password)

### Description
Generates a new salt and hashes the given password using the PBKDF2-SHA256 algorithm. Returns the resulting modular crypt format hash string.

### Method
hash

### Parameters
- **password** (str) - Required - The password to hash.

### Returns
- **hash** (str) - The resulting hash string in modular crypt format.

### Example
```python
>>> from passlib.hash import pbkdf2_sha256
>>> hash = pbkdf2_sha256.hash("password")
>>> hash
'$pbkdf2-sha256$6400$0ZrzXitFSGltTQnBWOsdAw$Y11AchqV4b0sUisdZd0Xr97KWoymNE0LNNrnEgY4H9M'
```
```

```APIDOC
## pbkdf2_sha256.using(rounds=8000, salt_size=10).hash(password)

### Description
Creates a new hash using an explicit number of rounds and salt length. The `using` method returns a configuration object that can be used to hash passwords with the specified parameters.

### Method
using().hash

### Parameters
- **rounds** (int) - Optional - Number of PBKDF2 rounds to use. Default is 6400.
- **salt_size** (int) - Optional - Length of the generated salt in bytes. Default is 16.
- **password** (str) - Required - The password to hash.

### Returns
- **hash** (str) - The resulting hash string in modular crypt format.

### Example
```python
>>> pbkdf2_sha256.using(rounds=8000, salt_size=10).hash("password")
'$pbkdf2-sha256$8000$XAuBMIYQQogxRg$tRRlz8hYn63B9LYiCd6PRo6FMiunY9ozmMMI3srxeRE'
```
```

```APIDOC
## pbkdf2_sha256.verify(password, hash)

### Description
Verifies a password against a given PBKDF2-SHA256 hash. Returns True if the password matches, False otherwise.

### Method
verify

### Parameters
- **password** (str) - Required - The password to verify.
- **hash** (str) - Required - The hash string to verify against.

### Returns
- **bool** - True if the password matches the hash, False otherwise.

### Example
```python
>>> pbkdf2_sha256.verify("password", hash)
True
>>> pbkdf2_sha256.verify("wrong", hash)
False
```
```

--------------------------------

### mssql2005.using()

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.mssql2005.html

Creates a new configuration object for the mssql2005 hash, accepting optional keywords for salt and relaxed mode.

```APIDOC
## mssql2005.using()

### Description
Creates a new configuration object for the mssql2005 hash, accepting optional keywords for salt and relaxed mode.

### Method
using

### Parameters
#### Optional Keywords
- **salt** (bytes) - Optional - Salt string. If not specified, one will be autogenerated (recommended). Must be 4 bytes in length.
- **relaxed** (bool) - Optional - By default, providing an invalid value for one of the other keywords will result in a ValueError. If relaxed=True, and the error can be corrected, a PasslibHashWarning will be issued instead. Correctable errors include salt strings that are too long.

### Request Example
```python
>>> from passlib.hash import mssql2005 as m25
>>> m25.using(salt=b'\x01\x02\x03\x04')
```

### Response
#### Success Response
- **config** (object) - A configuration object for the hash.

#### Response Example
```python
<passlib.hash.mssql2005 object at ...>
```
```

--------------------------------

### Identify a hash scheme

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hosts.html

Uses linux_context.identify() to determine the hash scheme of a given hash. In this example, it returns 'sha512_crypt'.

```python
>>> linux_context.identify(hash)
'sha512_crypt'

```

--------------------------------

### ldap_salted_sha1 (SSHA)

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.ldap_std.html

Class for LDAP salted SHA1 password hashing. Follows the PasswordHash API. Usage example provided in the documentation.

```APIDOC
## ldap_salted_sha1 (SSHA)

### Description
Stores passwords using LDAP's salted SHA1 format. Follows the PasswordHash API. The hash() and genconfig() methods have no optional keywords.

### Class
`passlib.hash.ldap_salted_sha1`

### Methods
- `hash(password)` - Hashes a password using the LDAP salted SHA1 format.
- `verify(password, hash)` - Verifies a password against an LDAP salted SHA1 hash.
- `genconfig()` - Generates a configuration string (no optional keywords).

### Usage Example
```python
>>> from passlib.hash import ldap_salted_sha1 as lss
>>> hash = lss.hash("password")
>>> hash
'{SSHA}...'
>>> lss.verify("password", hash)
True
>>> lss.verify("secret", hash)
False
```

### Format
`{SSHA}<base64-encoded salted SHA1 digest>`

### Security Warning
These hashes are not secure; they are salted SHA1 digests and vulnerable to brute-force attacks.
```

--------------------------------

### Create TOTP with non-standard alg and period

Source: https://passlib.readthedocs.io/en/stable/narr/totp-tutorial.html

Shows how to create TOTP instances with non-standard algorithm and period using the constructor's new, period, and alg options. Also shows creating an instance from an existing key.

```python
>>> otp2 = TOTP(new=True, period=60, alg="sha256")
>>> otp2.alg
'sha256'
>>> otp2.period
60

>>> otp3 = TOTP(key='GVDOQ7NP6XPJWE4CWCLFFSXZH6DTAZWM')
```

--------------------------------

### ldap_salted_md5 (SMD5)

Source: https://passlib.readthedocs.io/en/stable/lib/passlib.hash.ldap_std.html

Class for LDAP salted MD5 password hashing. Follows the PasswordHash API. Usage example provided in the documentation.

```APIDOC
## ldap_salted_md5 (SMD5)

### Description
Stores passwords using LDAP's salted MD5 format. Follows the PasswordHash API. The hash() and genconfig() methods have no optional keywords.

### Class
`passlib.hash.ldap_salted_md5`

### Methods
- `hash(password)` - Hashes a password using the LDAP salted MD5 format.
- `verify(password, hash)` - Verifies a password against an LDAP salted MD5 hash.
- `genconfig()` - Generates a configuration string (no optional keywords).

### Usage Example
```python
>>> from passlib.hash import ldap_salted_md5 as lsm
>>> hash = lsm.hash("password")
>>> hash
'{SMD5}OqsUXNHIhHbznxrqHoIM+ZT8DmE='
>>> lsm.verify("password", hash)
True
>>> lsm.verify("secret", hash)
False
```

### Format
`{SMD5}<base64-encoded salted MD5 digest>`

### Security Warning
These hashes are not secure; they are salted MD5 digests and vulnerable to brute-force attacks.
```
Tokens:
Raw