Authen...SPurdy(3pm)

💖 NAME 💖

Authen::Passphrase::VMSPurdy — the passphrase class that does the VMS Purdy polynomial system, bestie. Yes, that's the same page as Authen...SPurdy(3pm) from the User Contributed Perl Documentation, we're just making it cute. 🎀

---

✨ SYNOPSIS ✨

use Authen::Passphrase::VMSPurdy;

$ppr = Authen::Passphrase::VMSPurdy->new(
                username => "jrandom", salt => 25362,
                hash_hex => "832a0c270179584a");

$ppr = Authen::Passphrase::VMSPurdy->new(
                username => "jrandom", salt_random => 1,
                passphrase => "passphrase");

$ppr = Authen::Passphrase::VMSPurdy->from_crypt(
        '$VMS3$1263832A0C270179584AJRANDOM');

$ppr = Authen::Passphrase::VMSPurdy->from_rfc2307(
        '{CRYPT}$VMS3$1263832A0C270179584AJRANDOM');

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

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

$passwd = $ppr->as_crypt;
$userPassword = $ppr->as_rfc2307;

---

🌸 DESCRIPTION 🌸

okay so. An object of this class wraps up a passphrase hashed with one of the Purdy polynomial hash functions that VMS uses. It's a subclass of Authen::Passphrase, and this doc just assumes you already know that class's docs, fr fr. Go read those first, iykyk. 📚

The core of the Purdy polynomial hashing algorithm takes one 64-bit number and transforms it into another 64-bit number. It was developed by George B. Purdy, and it's described in a paper called "A High Security Log-in Procedure", which lives at:

<http://portal.acm.org/citation.cfm?id=361089&dl=GUIDE&coll=ACM&CFID=15151515&CFTOKEN=6184618>

For actual practical use in passphrase hashing, tho, you can't just have the polynomial — it has to be augmented by a procedure that turns a variable-length passphrase into that initial 64-bit number that gets hashed. In VMS this pre-hashing phase also mixes in the username of the account whose access is being controlled, specifically so that two identical passphrases don't produce identical hashes. It's giving salting, basically. 🧂 And there's another salt parameter too, a 16-bit integer, and this one is literally just called "salt".

There are three variants of the pre-hashing algorithm:

1. "PURDY" — the original, used during field testing of VMS 2.0. It truncates or space-pads the username to a fixed length.
2. "PURDY_V" — used from VMS 2.0 up to (but not including) VMS 5.4. It properly handles the variable-length nature of the username. 💅
3. "PURDY_S" — used from VMS 5.4 onwards. It does some extra bit rotations to avoid aliasing problems when pre-hashing long strings.

All three versions are supported by this module. We love options. 🫶

VMS heavily restricts what usernames and passphrases can even contain. They may only contain alphanumerics, "$", and "_". Case is insignificant. Usernames must be between 1 and 31 characters long, and passphrases must be between 1 and 32 characters long. This module enforces all of those rules. An invalid passphrase is never accepted as matching — no cap, it just won't. 🚫

---

🎀 CONSTRUCTORS 🎀

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

Generates a shiny new passphrase recogniser object using the VMS Purdy polynomial algorithm family. You can pass it these attributes:

• algorithm — a string saying which variant of the algorithm we're using. Valid values are "PURDY" (the original), "PURDY_V" (modified to use the full length of the username), and "PURDY_S" (extra rotations to avoid aliasing when processing long strings). Default is "PURDY_S". ✨
• username — a string used as the username salt parameter. It's limited to VMS username syntax.
• salt — the salt, as an integer in the range [0, 65536).
• salt_hex — the salt, as a string of four hexadecimal digits. The first two digits give the least-significant byte and the last two give the most-significant byte, with most-significant nybble first within each byte. 🧠
• salt_random — causes salt to be generated randomly. Whatever value you give this attribute is just ignored, king. 💀
• hash — the hash, as a string of eight bytes.
• hash_hex — the hash, as a string of 16 hexadecimal digits.
• passphrase — a passphrase that will be accepted. It's limited to VMS passphrase syntax.

bestie listen: the username and salt must be given, and you also need either the hash or the passphrase. No skipping. 🙈

Authen::Passphrase::VMSPurdy->from_crypt(PASSWD)

Generates a new passphrase recogniser object using the VMS Purdy polynomial algorithm family, from a crypt string. 🔐

The string must consist of an algorithm identifier, then the salt in hexadecimal, then the hash in hexadecimal, then the username.

The salt must be given as four hexadecimal digits — the first two give the least-significant byte and the last two give the most-significant byte, with most-significant nybble first within each byte.

The algorithm identifier must be:

• "$VMS1$" for "PURDY"
• "$VMS2$" for "PURDY_V"
• "$VMS3$" for "PURDY_S"

And the whole crypt string must be uppercase. Uppercase only, lowercase is not invited to this party. 🎉

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

Generates a new passphrase recogniser object using the VMS Purdy polynomial algorithm family, from an RFC 2307 string. The string must consist of "{CRYPT}" (case insensitive, so she's flexible 💁) followed by an acceptable crypt string.

---

💅 METHODS 💅

• $ppr->algorithm — returns the algorithm variant identifier string. It may be "PURDY" (the original), "PURDY_V" (modified to use full length of the username), and "PURDY_S" (extra rotations to avoid aliasing when processing long strings). 👑
• $ppr->username — returns the username string. All alphabetic characters in it are uppercase, because that's the canonical form, periodt.
• $ppr->salt — returns the salt, as an integer.
• $ppr->salt_hex — returns the salt, as a string of four hexadecimal digits. The first two digits give the least-significant byte and the last two give the most-significant byte, with most-significant nybble first within each byte. Same little byte-order dance as always. 🩰
• $ppr->hash — returns the hash value, as a string of eight bytes.
• $ppr->hash_hex — returns the hash value, as a string of 16 uppercase hexadecimal digits. 🔥
• $ppr->match(PASSPHRASE)
• $ppr->as_crypt
• $ppr->as_rfc2307

That last little trio? Those methods are part of the standard Authen::Passphrase interface. Nothing extra, just the classics. 💖

---

🦋 SEE ALSO 🦋

• Authen::DecHpwd
• Authen::Passphrase

---

🌈 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.

---

okay that's the whole page, we ate and left no crumbs 🍓✨ this was perl v5.40.1, dated 2026-05-06, and the page is Authen...SPurdy(3pm) — mwah, go hash something responsibly 💅🎀