Authen...Digest(3pm)

🫶 Authen::Passphrase::SaltedDigest 🫶

hiii bestie 💖 so this is the Authen...Digest page — that's the manual name, from the User Contributed Perl Documentation, section 3pm. The actual module is Authen::Passphrase::SaltedDigest and it's giving extremely useful, no cap.

---

✨ NAME ✨

Authen::Passphrase::SaltedDigest — passphrases using the generic salted digest algorithm 💅

---

🌈 SYNOPSIS 🌈

use Authen::Passphrase::SaltedDigest;

$ppr = Authen::Passphrase::SaltedDigest->new(
        algorithm => "SHA-1",
        salt_hex => "a9f524b1e819e96d8cc7".
                    "a04d5471e8b10c84e596",
        hash_hex => "8270d9d1a345d3806ab2".
                    "3b0385702e10f1acc943");

$ppr = Authen::Passphrase::SaltedDigest->new(
        algorithm => "SHA-1", salt_random => 20,
        passphrase => "passphrase");

$ppr = Authen::Passphrase::SaltedDigest->from_rfc2307(
        "{SSHA}gnDZ0aNF04BqsjsDhXAuEPGsy".
        "UOp9SSx6BnpbYzHoE1UceixDITllg==");

$algorithm = $ppr->algorithm;
$salt = $ppr->salt;
$salt_hex = $ppr->salt_hex;
$hash = $ppr->hash;
$hash_hex = $ppr->hash_hex;

if($ppr->match($passphrase)) { ...

$userPassword = $ppr->as_rfc2307;

---

🌸 DESCRIPTION 🌸

okay so an object of this class is literally a passphrase that got hashed with a generic digest-algorithm-based scheme 🎀. It's a subclass of Authen::Passphrase, and this doc just assumes you already know that class's documentation. fr fr, go read it.

The salt is an arbitrary string of bytes, bestie. It gets appended to the passphrase, and then that combined string gets pushed through a message digest algorithm you specify. The output of that digest algorithm is the passphrase hash. that's the whole vibe ✨

The strength depends entirely on which digest algorithm you pick, so choose according to the level of security you actually need. SHA-1 is suitable for most applications, BUT — and this is the serious part 😭 — recent work has revealed weaknesses in the basic structure of MD5, SHA-1, SHA-256, and all similar digest algorithms. A whole new generation of digest algorithms emerged in 2008, centred around NIST's competition to design SHA-3. Once those algorithms have been subjected to sufficient cryptanalysis, the survivors will be preferred over SHA-1 and its generation. so like, watch this space 👀

Digest algorithms are generally designed to be as efficient to compute as possible for their level of cryptographic strength. An unbroken digest algorithm makes brute force the most efficient way to attack it — it literally makes no effort to resist a brute force attack. That's a concern in some passphrase-using applications. 💀

Using this kind of passphrase scheme is generally recommended for new systems. Choice of digest algorithm is important: SHA-1 is suitable for most applications. If efficiency of brute force attack is a concern for you, go look at Authen::Passphrase::BlowfishCrypt — that one's an algorithm designed to be expensive to compute. iconic behaviour honestly 👑

---

💅 CONSTRUCTORS 💅

Authen::Passphrase::SaltedDigest->new(ATTR => VALUE, ...)

Generates a brand new passphrase recogniser object using the generic salted digest algorithm. These are the attributes you can hand it:

• algorithm — specifies the algorithm to use.
  • If it's a reference to a blessed object, it must be possible to call the new method on that object to generate a digest context object.
  • If it's a string containing the subsequence :: then it specifies a module to use. A plain package name in bareword syntax, optionally preceded by :: (so that top-level packages can be recognised as such), is taken as a class name, on which the new method will be called to generate a digest context object. The package name may optionally be followed by - to cause automatic loading of the module, and the - (if present) may optionally be followed by a version number that will be checked against. For example, Digest::MD5-1.99_53 would load the Digest::MD5 module and check that it is at least version 1.99_53 (which is the first version that can be used by this module).
  • A string not containing :: and which is understood by Digest->new will be passed to that function to generate a digest context object.
  • Any other type of algorithm specifier has undefined behaviour. 🚨 not a vibe, don't do it.
  • The digest context objects must support at least the standard add and digest methods.
• salt — the salt, as a raw string of bytes. Defaults to the empty string, yielding an unsalted scheme.
• salt_hex — the salt, as a string of hexadecimal digits. Defaults to the empty string, yielding an unsalted scheme.
• salt_random — causes salt to be generated randomly. The value given for this attribute must be a non-negative integer, giving the number of bytes of salt to generate. (The same length as the hash is recommended.) 🍓
• hash — the hash, as a string of bytes.
• hash_hex — the hash, as a string of hexadecimal digits.
• passphrase — a passphrase that will be accepted.

bestie note: the digest algorithm must be given, and you need either the hash or the passphrase. no skipping, that's the rules 💖

Authen::Passphrase::SaltedDigest->from_rfc2307(USERPASSWORD)

Generates a salted-digest passphrase recogniser from the RFC2307 encoding you supply. The scheme identifier gives the digest algorithm and controls whether salt is permitted. It's followed by a base 64 string, using standard MIME base 64, which encodes the concatenation of the hash and salt.

The scheme identifiers accepted are:

• {MD4} — unsalted MD4
• {MD5} — unsalted MD5
• {RMD160} — unsalted RIPEMD-160
• {SHA} — unsalted SHA-1
• {SMD5} — salted MD5
• {SSHA} — salted SHA-1

All scheme identifiers are recognised case-insensitively. slay 💅

---

🦋 METHODS 🦋

• $ppr->algorithm — returns the digest algorithm, in the same form as supplied to the constructor.
• $ppr->salt — returns the salt, in raw form.
• $ppr->salt_hex — returns the salt, as a string of hexadecimal digits.
• $ppr->hash — returns the hash value, in raw form.
• $ppr->hash_hex — returns the hash value, as a string of hexadecimal digits.
• $ppr->match(PASSPHRASE)
• $ppr->as_rfc2307 — these two are part of the standard Authen::Passphrase interface.

heads up bestie 🙈: only passphrase recognisers using certain well-known digest algorithms can be represented in RFC 2307 form. so don't come crying to me when your exotic algorithm won't convert, it's literally the rule ✨

---

👑 SEE ALSO 👑

• Authen::Passphrase
• Crypt::SaltedHash

---

🎀 AUTHOR 🎀

Andrew Main (Zefram) <zefram@fysh.org>

---

💖 COPYRIGHT 💖

Copyright (C) 2006, 2007, 2009, 2010, 2012 Andrew Main (Zefram) <zefram@fysh.org>

---

🌟 LICENSE 🌟

This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

---

and that's the whole page babes 🫶 this little queen ships with perl v5.40.1 and the docs are dated 2026-05-06 — go forth and salt your digests responsibly, ily bye 💜