Join our Newsletter — 33% off our NHI Course
Authentication, Authorisation & Trust

crypt() Function

← Back to Glossary
By NHI Mgmt Group Updated November 16, 2026 Domain: Authentication, Authorisation & Trust

crypt() is a password-hashing function used by Unix-like systems to derive a stored hash from a password and salt. It is called by authentication code and usually supports specific hash formats through a prefix or library implementation, so its security depends on the algorithm chosen and whether modern, slow hashes are used.

What crypt() Actually Does

crypt() is a password-hashing interface, not a password store. It takes a password and salt, applies a hashing algorithm chosen by the system or library implementation, and returns a derived hash for comparison during authentication. Its practical security value comes from using a modern, deliberately slow algorithm that resists offline guessing.

Because the function is a legacy Unix-like authentication primitive, its behaviour can vary by platform and build. Some implementations support multiple hash formats through prefixes or library-specific extensions, which means the same call may produce very different security properties depending on the selected algorithm.

Why Salted Password Hashing Matters

The salt makes each stored password hash unique, even when two users choose the same password. That blocks simple precomputation attacks and makes large-scale hash cracking less efficient. If the chosen algorithm is weak or fast, however, the salt only forces attackers to work per target rather than preventing guessing altogether.

This is why crypt() should be understood as part of a broader password storage design, not as a guarantee of safety by itself. A strong deployment depends on the algorithm choice, the hash parameters, and the system’s password policy, not just on calling the function correctly.

Algorithm Choice and Legacy Compatibility

Many issues around crypt() come from compatibility pressure. Older formats were designed when computing power was limited, so they are no longer suitable for modern password storage. Newer formats are preferable because they intentionally slow verification and increase the cost of offline attacks.

That compatibility layer is useful when maintaining older Unix-like environments, but it also creates confusion. A system may still accept historic hash prefixes or fallback implementations, so administrators need to know exactly which algorithm is active instead of assuming all crypt() output has the same strength.

Where crypt() Sits in Authentication Workflows

crypt() is usually called by authentication code during login verification, account recovery, or password migration. It does not perform identity proofing, session management, or access control on its own. Its role is narrower: transform a candidate password so the result can be compared with a stored hash value.

That narrow role is still security-critical because a compromise of the password database exposes the hash material to offline attack. If the function is paired with weak algorithms or outdated formats, a stolen hash set becomes much easier to crack and reuse elsewhere.

Operational Consequences of Weak Hashing

Weak password hashing creates concentrated exposure. Once an attacker obtains the stored hashes, the defence shifts from online rate-limiting to offline resistance, which is entirely determined by the hashing scheme already in use. If the scheme is obsolete, password cracking becomes a realistic follow-on path rather than a theoretical one.

For that reason, organisations should treat crypt() as a compatibility interface whose security must be validated, not assumed. The important question is not whether the function exists, but whether the deployed algorithm, salt handling, and password policy still provide meaningful resistance to offline guessing.

Risk and Threat Considerations

Weak or legacy crypt() configurations create a direct password exposure risk because stolen hashes can be attacked offline at high speed. The danger is greatest when the implementation still accepts outdated formats or when operators assume the function name implies modern protection.

Failure mechanism: Attackers obtain the password database, then use GPU-accelerated guessing or precomputed wordlists against hashes derived with an obsolete or fast algorithm. Salt helps, but it does not prevent recovery when the underlying scheme is too weak.

Impact: Successful cracking can expose user credentials, enable account takeover, and allow password reuse attacks across other services if the same password was used elsewhere.

Standards & Framework Alignment

This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.

NIST SP 800-53 Rev 5, NIST SP 800-57 and CIS Controls v8 set the technical controls, while ISO/IEC 27001:2022 defines the regulatory obligations.

FrameworkControl / ReferenceRelevance
NIST SP 800-53 Rev 5IA-5 — Authenticator ManagementCovers password and authenticator lifecycle controls for stored secrets.
IA-2 — Identification and Authentication (Organizational Users)Addresses password-based authentication for user logon workflows.
Recommendation — Require approved password hashing and manage authenticator material through controlled lifecycle policies. Use approved authentication controls that verify users without exposing reusable passwords.
NIST SP 800-57Key ManagementInforms algorithm strength and lifecycle choices for derived secret material.
Recommendation — Select modern, approved algorithms and review their lifecycle suitability for stored secrets.
ISO/IEC 27001:2022A.8.24 — Use of cryptographyDirectly governs cryptographic protection choices for sensitive stored credentials.
Recommendation — Apply cryptographic controls that keep stored password hashes resistant to offline attack.
CIS Controls v8CIS-5 — Account ManagementSupports secure account authentication and lifecycle handling of credentials.
Recommendation — Standardise account authentication methods and retire weak legacy password handling.

Practitioner Guidance

Why practitioners should care: crypt() is often embedded in older authentication paths, so the real control decision is which hash format the system actually uses. Review the implementation rather than assuming all deployments are equivalent.

What to watch for: Legacy hash prefixes, inconsistent library behaviour across hosts, and password verification logic that still accepts weak historical formats are strong signs that the environment needs migration or tighter policy enforcement.

Practitioner takeaway: Use crypt() only as a compatibility layer when necessary, and prefer modern, slow password hashing schemes where the platform supports them.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Reviewed and updated by the NHIMG editorial team on November 16, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org