948 lines
32 KiB
Rust
948 lines
32 KiB
Rust
use std::{process::Stdio, str::FromStr};
|
|
|
|
use argon2::{
|
|
Algorithm, Argon2, Params, PasswordHash, PasswordHasher, PasswordVerifier, Version,
|
|
password_hash::{SaltString, rand_core::OsRng},
|
|
};
|
|
use base64::{Engine as _, engine::general_purpose::STANDARD};
|
|
use md5::{Digest as _, Md5};
|
|
use pwhash::{
|
|
HashSetup,
|
|
bcrypt::{self as pw_bcrypt, BcryptSetup, BcryptVariant},
|
|
sha1_crypt, sha256_crypt, sha512_crypt, unix, unix_crypt,
|
|
};
|
|
use rand::RngCore;
|
|
use sha1::Sha1;
|
|
use sha2::{Sha256, Sha512};
|
|
use subtle::ConstantTimeEq;
|
|
use tokio::{io::AsyncWriteExt, process::Command};
|
|
|
|
use crate::{
|
|
config::AppConfig,
|
|
db::{Db, Dialect, Table, row_i64},
|
|
error::{AppError, AppResult},
|
|
};
|
|
|
|
const CRYPT64: &[u8; 64] = b"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
|
|
|
|
/// Password schemes intentionally kept compatible with PostfixAdmin/Dovecot/Courier.
|
|
/// Unknown `dovecot:METHOD` values are delegated to `doveadm pw` without a shell.
|
|
pub const SUPPORTED_SCHEMES: &[&str] = &[
|
|
"ARGON2ID",
|
|
"ARGON2ID.B64",
|
|
"ARGON2I",
|
|
"ARGON2I.B64",
|
|
"BLF-CRYPT",
|
|
"BLF-CRYPT.B64",
|
|
"CRYPT",
|
|
"SHA512-CRYPT",
|
|
"SHA512-CRYPT.B64",
|
|
"SHA512.B64",
|
|
"SHA512",
|
|
"SHA256-CRYPT",
|
|
"SHA256-CRYPT.B64",
|
|
"SHA256",
|
|
"SHA1-CRYPT",
|
|
"SHA1",
|
|
"SHA1.B64",
|
|
"SHA",
|
|
"SSHA",
|
|
"MD5-CRYPT",
|
|
"md5crypt",
|
|
"PLAIN-MD5",
|
|
"MD5",
|
|
"MD5RAW",
|
|
"PLAIN",
|
|
"CLEAR",
|
|
"cleartext",
|
|
"SYSTEM",
|
|
"AUTHLIB",
|
|
"courier:md5",
|
|
"courier:md5raw",
|
|
"courier:sha1",
|
|
"courier:ssha",
|
|
"courier:sha256",
|
|
"php_crypt",
|
|
"php_crypt:DES",
|
|
"php_crypt:MD5",
|
|
"php_crypt:BLOWFISH",
|
|
"php_crypt:SHA256",
|
|
"php_crypt:SHA512",
|
|
"dovecot:METHOD",
|
|
];
|
|
|
|
pub fn supported_schemes() -> &'static [&'static str] {
|
|
SUPPORTED_SCHEMES
|
|
}
|
|
|
|
pub fn validate_new_password(config: &AppConfig, password: &str) -> AppResult<()> {
|
|
if password.chars().count() < config.password.min_length {
|
|
return Err(AppError::bad_request(format!(
|
|
"Password must contain at least {} characters",
|
|
config.password.min_length
|
|
)));
|
|
}
|
|
let letters = password.chars().filter(|c| c.is_alphabetic()).count();
|
|
let digits = password.chars().filter(|c| c.is_ascii_digit()).count();
|
|
if letters < config.password.min_letters {
|
|
return Err(AppError::bad_request(format!(
|
|
"Password must contain at least {} letters",
|
|
config.password.min_letters
|
|
)));
|
|
}
|
|
if digits < config.password.min_digits {
|
|
return Err(AppError::bad_request(format!(
|
|
"Password must contain at least {} digits",
|
|
config.password.min_digits
|
|
)));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Generate a random password that satisfies the configured policy
|
|
/// (PostfixAdmin `generate_password()`).
|
|
pub fn generate_password(config: &AppConfig) -> String {
|
|
const LETTERS: &[u8] = b"abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ";
|
|
const DIGITS: &[u8] = b"23456789";
|
|
let length = config
|
|
.password
|
|
.min_length
|
|
.max(config.password.min_letters + config.password.min_digits)
|
|
.max(12);
|
|
let mut rng = rand::rng();
|
|
let mut pick = |set: &[u8]| set[(rng.next_u32() as usize) % set.len()] as char;
|
|
let mut chars: Vec<char> = Vec::with_capacity(length);
|
|
for _ in 0..config.password.min_digits.max(2) {
|
|
chars.push(pick(DIGITS));
|
|
}
|
|
while chars.len() < length {
|
|
chars.push(pick(LETTERS));
|
|
}
|
|
// Fisher-Yates shuffle so the digits are not always in front.
|
|
let mut rng = rand::rng();
|
|
for i in (1..chars.len()).rev() {
|
|
let j = (rng.next_u32() as usize) % (i + 1);
|
|
chars.swap(i, j);
|
|
}
|
|
chars.into_iter().collect()
|
|
}
|
|
|
|
/// Verify an existing PostfixAdmin hash. The format stored in the database wins
|
|
/// over the currently configured format whenever it identifies itself.
|
|
pub async fn verify(config: &AppConfig, password: &str, stored: &str, username: &str) -> bool {
|
|
if password.is_empty() || stored.is_empty() {
|
|
return false;
|
|
}
|
|
|
|
if let Some(result) = verify_native(password, stored) {
|
|
return result;
|
|
}
|
|
|
|
let configured = config.password.scheme.trim();
|
|
let mechanism = configured.to_ascii_uppercase();
|
|
|
|
// Legacy PostfixAdmin formats without a self-identifying prefix.
|
|
if (mechanism == "MD5" || mechanism == "MD5RAW") && is_hex_digest(stored, 32) {
|
|
return ct_eq(hex_md5(password).as_bytes(), stored.as_bytes());
|
|
}
|
|
let legacy_des = mechanism == "PHP_CRYPT:DES"
|
|
|| mechanism == "SYSTEM"
|
|
|| (mechanism == "AUTHLIB"
|
|
&& config
|
|
.password
|
|
.authlib_default_flavor
|
|
.eq_ignore_ascii_case("crypt"));
|
|
if legacy_des && stored.len() == 13 && stored.bytes().all(is_crypt_char) {
|
|
return unix_crypt::verify(password, stored);
|
|
}
|
|
if matches!(mechanism.as_str(), "CLEAR" | "CLEARTEXT") {
|
|
return ct_eq(password.as_bytes(), stored.as_bytes());
|
|
}
|
|
|
|
let method = prefixed_method(stored)
|
|
.map(|value| value.to_ascii_uppercase())
|
|
.or_else(|| mechanism.strip_prefix("DOVECOT:").map(str::to_owned))
|
|
.unwrap_or_else(|| mechanism.clone());
|
|
|
|
verify_with_doveadm(config, password, stored, &method, username)
|
|
.await
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
pub async fn hash(config: &AppConfig, password: &str, username: &str) -> AppResult<String> {
|
|
validate_new_password(config, password)?;
|
|
hash_unchecked(config, password, username).await
|
|
}
|
|
|
|
/// Hashes an application-internal bearer secret with Argon2id regardless of the
|
|
/// mailbox password scheme. Used for single-use recovery tokens only.
|
|
pub fn hash_internal_secret(secret: &str) -> AppResult<String> {
|
|
let salt = SaltString::generate(&mut OsRng);
|
|
let hash = Argon2::default()
|
|
.hash_password(secret.as_bytes(), &salt)
|
|
.map_err(|e| AppError::config(format!("argon2 failed: {e}")))?
|
|
.to_string();
|
|
Ok(format!("{{ARGON2ID}}{hash}"))
|
|
}
|
|
|
|
/// Implements PostfixAdmin `$CONF['encrypt']`-style schemes.
|
|
pub async fn hash_unchecked(
|
|
config: &AppConfig,
|
|
password: &str,
|
|
username: &str,
|
|
) -> AppResult<String> {
|
|
let configured = config.password.scheme.trim();
|
|
if configured.is_empty() {
|
|
return Err(AppError::config("password.scheme cannot be empty"));
|
|
}
|
|
let mechanism = configured.to_ascii_uppercase();
|
|
|
|
if mechanism == "PHP_CRYPT" || mechanism.starts_with("PHP_CRYPT:") {
|
|
return hash_php_crypt(configured, password);
|
|
}
|
|
if mechanism == "AUTHLIB" {
|
|
return hash_authlib(config, password);
|
|
}
|
|
if let Some(flavor) = mechanism.strip_prefix("COURIER:") {
|
|
return hash_courier(flavor, password);
|
|
}
|
|
if let Some(method) = mechanism.strip_prefix("DOVECOT:") {
|
|
if let Some(value) = hash_native_named(method, password)? {
|
|
return Ok(value);
|
|
}
|
|
return hash_with_doveadm(config, password, method, username).await;
|
|
}
|
|
|
|
if let Some(value) = hash_native_named(&mechanism, password)? {
|
|
return Ok(value);
|
|
}
|
|
|
|
// PostfixAdmin historically delegates unsupported Dovecot-compatible methods.
|
|
hash_with_doveadm(config, password, &mechanism, username).await
|
|
}
|
|
|
|
fn hash_native_named(mechanism: &str, password: &str) -> AppResult<Option<String>> {
|
|
let value = match mechanism {
|
|
"ARGON2ID" => format!("{{ARGON2ID}}{}", hash_argon(password, Algorithm::Argon2id)?),
|
|
"ARGON2I" => format!("{{ARGON2I}}{}", hash_argon(password, Algorithm::Argon2i)?),
|
|
"ARGON2ID.B64" => {
|
|
let inner = hash_argon(password, Algorithm::Argon2id)?;
|
|
format!("{{ARGON2ID.B64}}{}", STANDARD.encode(inner.as_bytes()))
|
|
}
|
|
"ARGON2I.B64" => {
|
|
let inner = hash_argon(password, Algorithm::Argon2i)?;
|
|
format!("{{ARGON2I.B64}}{}", STANDARD.encode(inner.as_bytes()))
|
|
}
|
|
"BLF-CRYPT" | "BCRYPT" => format!("{{BLF-CRYPT}}{}", bcrypt_hash(password, 10)?),
|
|
"BLF-CRYPT.B64" => {
|
|
let inner = bcrypt_hash(password, 10)?;
|
|
format!("{{BLF-CRYPT.B64}}{}", STANDARD.encode(inner.as_bytes()))
|
|
}
|
|
"CRYPT" | "SYSTEM" => format!("{{CRYPT}}{}", bcrypt_hash(password, 10)?),
|
|
"SHA512-CRYPT" => format!("{{SHA512-CRYPT}}{}", sha512_hash(password, None)?),
|
|
"SHA512-CRYPT.B64" | "SHA512.B64" => {
|
|
let inner = sha512_hash(password, None)?;
|
|
format!("{{SHA512-CRYPT.B64}}{}", STANDARD.encode(inner.as_bytes()))
|
|
}
|
|
"SHA512" => format!(
|
|
"{{SHA512}}{}",
|
|
STANDARD.encode(Sha512::digest(password.as_bytes()))
|
|
),
|
|
"SHA256-CRYPT" => format!("{{SHA256-CRYPT}}{}", sha256_hash(password, None)?),
|
|
"SHA256-CRYPT.B64" => {
|
|
let inner = sha256_hash(password, None)?;
|
|
format!("{{SHA256-CRYPT.B64}}{}", STANDARD.encode(inner.as_bytes()))
|
|
}
|
|
"SHA256" => format!(
|
|
"{{SHA256}}{}",
|
|
STANDARD.encode(Sha256::digest(password.as_bytes()))
|
|
),
|
|
"SHA1-CRYPT" => format!(
|
|
"{{SHA1-CRYPT}}{}",
|
|
sha1_crypt::hash(password)
|
|
.map_err(|e| AppError::config(format!("SHA1-CRYPT failed: {e}")))?
|
|
),
|
|
"SHA1" => format!(
|
|
"{{SHA1}}{}",
|
|
STANDARD.encode(Sha1::digest(password.as_bytes()))
|
|
),
|
|
"SHA1.B64" => format!(
|
|
"{{SHA1.B64}}{}",
|
|
STANDARD.encode(Sha1::digest(password.as_bytes()))
|
|
),
|
|
"SHA" => format!(
|
|
"{{SHA}}{}",
|
|
STANDARD.encode(Sha1::digest(password.as_bytes()))
|
|
),
|
|
"SSHA" => hash_ssha(password),
|
|
"MD5-CRYPT" => {
|
|
let salt = random_crypt_salt(8);
|
|
format!("{{MD5-CRYPT}}{}", md5_crypt(password, &salt))
|
|
}
|
|
"MD5CRYPT" => {
|
|
let salt = random_crypt_salt(8);
|
|
md5_crypt(password, &salt)
|
|
}
|
|
"PLAIN-MD5" => format!("{{PLAIN-MD5}}{}", hex_md5(password)),
|
|
// Historical `$CONF['encrypt'] = 'md5'` is unprefixed hex MD5.
|
|
"MD5" => hex_md5(password),
|
|
"MD5RAW" => format!("{{MD5RAW}}{}", hex_md5(password)),
|
|
"PLAIN" => format!("{{PLAIN}}{password}"),
|
|
"CLEAR" => format!("{{CLEAR}}{password}"),
|
|
// Historical PostfixAdmin `cleartext` stores the password without a prefix.
|
|
"CLEARTEXT" => password.to_owned(),
|
|
_ => return Ok(None),
|
|
};
|
|
Ok(Some(value))
|
|
}
|
|
|
|
fn hash_courier(flavor: &str, password: &str) -> AppResult<String> {
|
|
let value = match flavor {
|
|
"MD5" => format!(
|
|
"{{MD5}}{}",
|
|
STANDARD.encode(Md5::digest(password.as_bytes()))
|
|
),
|
|
"MD5RAW" => format!("{{MD5RAW}}{}", hex_md5(password)),
|
|
"SHA" | "SHA1" => format!(
|
|
"{{SHA}}{}",
|
|
STANDARD.encode(Sha1::digest(password.as_bytes()))
|
|
),
|
|
"SSHA" => hash_ssha(password),
|
|
"SHA256" => format!(
|
|
"{{SHA256}}{}",
|
|
STANDARD.encode(Sha256::digest(password.as_bytes()))
|
|
),
|
|
_ => {
|
|
return Err(AppError::config(format!(
|
|
"unsupported Courier password flavor: {flavor}"
|
|
)));
|
|
}
|
|
};
|
|
Ok(value)
|
|
}
|
|
|
|
fn hash_authlib(config: &AppConfig, password: &str) -> AppResult<String> {
|
|
let flavor = config.password.authlib_default_flavor.trim();
|
|
let canonical = flavor.to_ascii_uppercase();
|
|
let body = match canonical.as_str() {
|
|
"MD5RAW" => hex_md5(password),
|
|
"MD5" => STANDARD.encode(Md5::digest(password.as_bytes())),
|
|
"SHA" | "SHA1" => STANDARD.encode(Sha1::digest(password.as_bytes())),
|
|
"CRYPT" => des_crypt_hash(password, "authlib crypt")?,
|
|
_ => {
|
|
return Err(AppError::config(format!(
|
|
"authlib_default_flavor '{flavor}' is unsupported; use md5raw, md5, SHA or crypt"
|
|
)));
|
|
}
|
|
};
|
|
Ok(format!("{{{flavor}}}{body}"))
|
|
}
|
|
|
|
#[allow(deprecated)]
|
|
fn des_crypt_hash(password: &str, label: &str) -> AppResult<String> {
|
|
unix_crypt::hash(password).map_err(|e| AppError::config(format!("{label} failed: {e}")))
|
|
}
|
|
|
|
fn hash_php_crypt(specification: &str, password: &str) -> AppResult<String> {
|
|
let parts: Vec<&str> = specification.split(':').collect();
|
|
let method = parts
|
|
.get(1)
|
|
.copied()
|
|
.filter(|s| !s.is_empty())
|
|
.unwrap_or("SHA512")
|
|
.to_ascii_uppercase();
|
|
let difficulty = parts.get(2).copied().filter(|s| !s.is_empty());
|
|
let prefix = parts.get(3).copied().unwrap_or("");
|
|
|
|
let hash = match method.as_str() {
|
|
"DES" => des_crypt_hash(password, "php_crypt:DES")?,
|
|
"MD5" => md5_crypt(password, &random_crypt_salt(8)),
|
|
"BLOWFISH" => {
|
|
let cost = parse_range_u32(difficulty, 10, 4, 31, "BLOWFISH cost")?;
|
|
bcrypt_hash(password, cost)?
|
|
}
|
|
"SHA256" => {
|
|
let rounds = parse_optional_rounds(difficulty, 1000, 999_999_999, "SHA256 rounds")?;
|
|
sha256_hash(password, rounds)?
|
|
}
|
|
"SHA512" => {
|
|
let rounds = parse_optional_rounds(difficulty, 1000, 999_999_999, "SHA512 rounds")?;
|
|
sha512_hash(password, rounds)?
|
|
}
|
|
_ => {
|
|
return Err(AppError::config(format!(
|
|
"unsupported php_crypt method: {method}"
|
|
)));
|
|
}
|
|
};
|
|
Ok(format!("{prefix}{hash}"))
|
|
}
|
|
|
|
fn hash_argon(password: &str, algorithm: Algorithm) -> AppResult<String> {
|
|
let params = if algorithm == Algorithm::Argon2i {
|
|
Params::new(32_768, 4, 1, None)
|
|
} else {
|
|
Params::new(65_536, 3, 1, None)
|
|
}
|
|
.map_err(|e| AppError::config(format!("invalid Argon2 parameters: {e}")))?;
|
|
let argon = Argon2::new(algorithm, Version::V0x13, params);
|
|
let salt = SaltString::generate(&mut OsRng);
|
|
argon
|
|
.hash_password(password.as_bytes(), &salt)
|
|
.map_err(|e| AppError::config(format!("Argon2 failed: {e}")))
|
|
.map(|hash| hash.to_string())
|
|
}
|
|
|
|
fn bcrypt_hash(password: &str, cost: u32) -> AppResult<String> {
|
|
pw_bcrypt::hash_with(
|
|
BcryptSetup {
|
|
cost: Some(cost),
|
|
variant: Some(BcryptVariant::V2y),
|
|
..Default::default()
|
|
},
|
|
password,
|
|
)
|
|
.map_err(|e| AppError::config(format!("bcrypt failed: {e}")))
|
|
}
|
|
|
|
#[allow(deprecated)] // Legacy PostfixAdmin compatibility; SHA256-CRYPT is not recommended for new deployments.
|
|
fn sha256_hash(password: &str, rounds: Option<u32>) -> AppResult<String> {
|
|
let result = match rounds {
|
|
Some(rounds) => sha256_crypt::hash_with(
|
|
HashSetup {
|
|
salt: None,
|
|
rounds: Some(rounds),
|
|
},
|
|
password,
|
|
),
|
|
None => sha256_crypt::hash(password),
|
|
};
|
|
result.map_err(|e| AppError::config(format!("SHA256-CRYPT failed: {e}")))
|
|
}
|
|
|
|
fn sha512_hash(password: &str, rounds: Option<u32>) -> AppResult<String> {
|
|
let result = match rounds {
|
|
Some(rounds) => sha512_crypt::hash_with(
|
|
HashSetup {
|
|
salt: None,
|
|
rounds: Some(rounds),
|
|
},
|
|
password,
|
|
),
|
|
None => sha512_crypt::hash(password),
|
|
};
|
|
result.map_err(|e| AppError::config(format!("SHA512-CRYPT failed: {e}")))
|
|
}
|
|
|
|
fn hash_ssha(password: &str) -> String {
|
|
let mut salt = [0u8; 4];
|
|
rand::rng().fill_bytes(&mut salt);
|
|
let mut digest = Sha1::new();
|
|
digest.update(password.as_bytes());
|
|
digest.update(salt);
|
|
let mut bytes = digest.finalize().to_vec();
|
|
bytes.extend_from_slice(&salt);
|
|
format!("{{SSHA}}{}", STANDARD.encode(bytes))
|
|
}
|
|
|
|
/// Returns `Some(result)` when the stored representation is self-identifying.
|
|
/// Returns `None` for legacy unprefixed formats that require configuration.
|
|
fn verify_native(password: &str, stored: &str) -> Option<bool> {
|
|
if let Some(payload) = stored
|
|
.strip_prefix("{PLAIN}")
|
|
.or_else(|| stored.strip_prefix("{CLEAR}"))
|
|
.or_else(|| stored.strip_prefix("{CLEARTEXT}"))
|
|
{
|
|
return Some(ct_eq(password.as_bytes(), payload.as_bytes()));
|
|
}
|
|
|
|
if stored.starts_with("$1$")
|
|
|| stored.starts_with("$2")
|
|
|| stored.starts_with("$5$")
|
|
|| stored.starts_with("$6$")
|
|
|| stored.starts_with("$sha1$")
|
|
|| stored.starts_with('_')
|
|
{
|
|
return Some(unix::verify(password, stored));
|
|
}
|
|
let (method, payload) = split_prefixed(stored)?;
|
|
let method = method.to_ascii_uppercase();
|
|
let result = match method.as_str() {
|
|
"PLAIN" | "CLEAR" | "CLEARTEXT" => ct_eq(password.as_bytes(), payload.as_bytes()),
|
|
"MD5-CRYPT" => md5_crypt_verify(password, payload),
|
|
"BLF-CRYPT" | "BCRYPT" => pw_bcrypt::verify(password, payload),
|
|
"CRYPT" => unix::verify(password, payload),
|
|
"SHA1-CRYPT" => sha1_crypt::verify(password, payload),
|
|
"SHA256-CRYPT" => sha256_crypt::verify(password, payload),
|
|
"SHA512-CRYPT" => sha512_crypt::verify(password, payload),
|
|
"BLF-CRYPT.B64" => verify_b64_unix(password, payload, UnixKind::Bcrypt),
|
|
"SHA256-CRYPT.B64" => verify_b64_unix(password, payload, UnixKind::Sha256),
|
|
"SHA512-CRYPT.B64" => verify_b64_unix(password, payload, UnixKind::Sha512),
|
|
"MD5" => ct_eq(
|
|
STANDARD.encode(Md5::digest(password.as_bytes())).as_bytes(),
|
|
payload.as_bytes(),
|
|
),
|
|
"MD5RAW" | "PLAIN-MD5" => ct_eq(hex_md5(password).as_bytes(), payload.as_bytes()),
|
|
"SHA" | "SHA1" | "SHA1.B64" => ct_eq(
|
|
STANDARD
|
|
.encode(Sha1::digest(password.as_bytes()))
|
|
.as_bytes(),
|
|
payload.as_bytes(),
|
|
),
|
|
"SHA256" => ct_eq(
|
|
STANDARD
|
|
.encode(Sha256::digest(password.as_bytes()))
|
|
.as_bytes(),
|
|
payload.as_bytes(),
|
|
),
|
|
"SHA512" => ct_eq(
|
|
STANDARD
|
|
.encode(Sha512::digest(password.as_bytes()))
|
|
.as_bytes(),
|
|
payload.as_bytes(),
|
|
),
|
|
"SSHA" => verify_ssha(password, payload),
|
|
"ARGON2I" | "ARGON2ID" | "ARGON2D" => verify_argon(password, payload),
|
|
"ARGON2I.B64" | "ARGON2ID.B64" | "ARGON2D.B64" => STANDARD
|
|
.decode(payload)
|
|
.ok()
|
|
.and_then(|raw| String::from_utf8(raw).ok())
|
|
.is_some_and(|hash| verify_argon(password, &hash)),
|
|
_ => return None,
|
|
};
|
|
Some(result)
|
|
}
|
|
|
|
enum UnixKind {
|
|
Bcrypt,
|
|
Sha256,
|
|
Sha512,
|
|
}
|
|
|
|
fn verify_b64_unix(password: &str, payload: &str, kind: UnixKind) -> bool {
|
|
let Ok(raw) = STANDARD.decode(payload) else {
|
|
return false;
|
|
};
|
|
let Ok(hash) = String::from_utf8(raw) else {
|
|
return false;
|
|
};
|
|
match kind {
|
|
UnixKind::Bcrypt => pw_bcrypt::verify(password, &hash),
|
|
UnixKind::Sha256 => sha256_crypt::verify(password, &hash),
|
|
UnixKind::Sha512 => sha512_crypt::verify(password, &hash),
|
|
}
|
|
}
|
|
|
|
fn verify_argon(password: &str, payload: &str) -> bool {
|
|
let Ok(parsed) = PasswordHash::new(payload) else {
|
|
return false;
|
|
};
|
|
Argon2::default()
|
|
.verify_password(password.as_bytes(), &parsed)
|
|
.is_ok()
|
|
}
|
|
|
|
fn verify_ssha(password: &str, payload: &str) -> bool {
|
|
let Ok(decoded) = STANDARD.decode(payload) else {
|
|
return false;
|
|
};
|
|
if decoded.len() < 21 {
|
|
return false;
|
|
}
|
|
let (expected, salt) = decoded.split_at(20);
|
|
let mut digest = Sha1::new();
|
|
digest.update(password.as_bytes());
|
|
digest.update(salt);
|
|
let actual = digest.finalize();
|
|
ct_eq(&actual[..], expected)
|
|
}
|
|
|
|
fn is_crypt_char(byte: u8) -> bool {
|
|
byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'/')
|
|
}
|
|
|
|
fn split_prefixed(stored: &str) -> Option<(&str, &str)> {
|
|
let rest = stored.strip_prefix('{')?;
|
|
let end = rest.find('}')?;
|
|
let method = &rest[..end];
|
|
if method.is_empty() {
|
|
return None;
|
|
}
|
|
Some((method, &rest[end + 1..]))
|
|
}
|
|
|
|
fn prefixed_method(stored: &str) -> Option<&str> {
|
|
split_prefixed(stored).map(|(method, _)| method)
|
|
}
|
|
|
|
async fn verify_with_doveadm(
|
|
config: &AppConfig,
|
|
password: &str,
|
|
stored: &str,
|
|
method: &str,
|
|
username: &str,
|
|
) -> AppResult<bool> {
|
|
validate_doveadm_method(method)?;
|
|
let mut command = doveadm_command(config)?;
|
|
command.args(["-s", method, "-t", stored]);
|
|
if method.eq_ignore_ascii_case("DIGEST-MD5") {
|
|
if username.is_empty() {
|
|
return Err(AppError::config("dovecot:DIGEST-MD5 requires username"));
|
|
}
|
|
command.args(["-u", username]);
|
|
}
|
|
command
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped());
|
|
let mut child = command.spawn()?;
|
|
if let Some(mut stdin) = child.stdin.take() {
|
|
stdin.write_all(password.as_bytes()).await?;
|
|
stdin.write_all(b"\n").await?;
|
|
}
|
|
let output = child.wait_with_output().await?;
|
|
Ok(output.status.success())
|
|
}
|
|
|
|
async fn hash_with_doveadm(
|
|
config: &AppConfig,
|
|
password: &str,
|
|
scheme: &str,
|
|
username: &str,
|
|
) -> AppResult<String> {
|
|
validate_doveadm_method(scheme)?;
|
|
let mut command = doveadm_command(config)?;
|
|
command.args(["-s", scheme]);
|
|
if scheme.eq_ignore_ascii_case("DIGEST-MD5") {
|
|
if username.is_empty() {
|
|
return Err(AppError::config("dovecot:DIGEST-MD5 requires username"));
|
|
}
|
|
command.args(["-u", username]);
|
|
}
|
|
command
|
|
.stdin(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.stdout(Stdio::piped());
|
|
let mut child = command.spawn()?;
|
|
if let Some(mut stdin) = child.stdin.take() {
|
|
// doveadm getpass() asks twice when generating a hash.
|
|
stdin.write_all(password.as_bytes()).await?;
|
|
stdin.write_all(b"\n").await?;
|
|
stdin.write_all(password.as_bytes()).await?;
|
|
stdin.write_all(b"\n").await?;
|
|
}
|
|
let output = child.wait_with_output().await?;
|
|
if !output.status.success() {
|
|
return Err(AppError::config(format!(
|
|
"doveadm pw failed: {}",
|
|
String::from_utf8_lossy(&output.stderr).trim()
|
|
)));
|
|
}
|
|
let value = String::from_utf8_lossy(&output.stdout).trim().to_owned();
|
|
if value.is_empty() {
|
|
return Err(AppError::config("doveadm pw returned an empty hash"));
|
|
}
|
|
Ok(value)
|
|
}
|
|
|
|
fn doveadm_command(config: &AppConfig) -> AppResult<Command> {
|
|
let mut parts = config.password.doveadm.split_whitespace();
|
|
let program = parts
|
|
.next()
|
|
.ok_or_else(|| AppError::config("password.doveadm is empty"))?;
|
|
let trailing: Vec<&str> = parts.collect();
|
|
let has_pw = trailing.contains(&"pw");
|
|
let mut command = Command::new(program);
|
|
command.args(&trailing);
|
|
if !has_pw {
|
|
command.arg("pw");
|
|
}
|
|
Ok(command)
|
|
}
|
|
|
|
fn validate_doveadm_method(method: &str) -> AppResult<()> {
|
|
if method.is_empty()
|
|
|| !method
|
|
.bytes()
|
|
.all(|b| b.is_ascii_uppercase() || b.is_ascii_digit() || matches!(b, b'-' | b'.'))
|
|
{
|
|
return Err(AppError::config(format!(
|
|
"invalid doveadm password method: {method}"
|
|
)));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Refresh the mailbox password-expiry timestamp using the parent domain policy.
|
|
pub async fn refresh_mailbox_expiry(config: &AppConfig, db: &Db, username: &str) -> AppResult<()> {
|
|
if !db.has_column(Table::Mailbox, "password_expiry").await? {
|
|
return Ok(());
|
|
}
|
|
let Some((_, domain)) = username.rsplit_once('@') else {
|
|
return Ok(());
|
|
};
|
|
let days = if config.features.password_expiration
|
|
&& db.has_column(Table::Domain, "password_expiry").await?
|
|
{
|
|
let table = db.table(Table::Domain);
|
|
let sql = db.q(&format!(
|
|
"SELECT password_expiry FROM {table} WHERE domain=? LIMIT 1"
|
|
));
|
|
sqlx::query(&sql)
|
|
.bind(domain)
|
|
.fetch_optional(db.pool())
|
|
.await?
|
|
.as_ref()
|
|
.map(|row| row_i64(row, "password_expiry"))
|
|
.unwrap_or(0)
|
|
} else {
|
|
0
|
|
};
|
|
let days = if (1..=36_500).contains(&days) {
|
|
days
|
|
} else {
|
|
0
|
|
};
|
|
let expr = if days == 0 {
|
|
"'9999-12-31 23:59:59'".to_owned()
|
|
} else {
|
|
match db.dialect() {
|
|
Dialect::MySql => format!("DATE_ADD(CURRENT_TIMESTAMP, INTERVAL {days} DAY)"),
|
|
Dialect::Postgres => format!("CURRENT_TIMESTAMP + INTERVAL '{days} days'"),
|
|
Dialect::Sqlite => format!("datetime('now','+{days} days')"),
|
|
}
|
|
};
|
|
let mailbox = db.table(Table::Mailbox);
|
|
let sql = db.q(&format!(
|
|
"UPDATE {mailbox} SET password_expiry={expr} WHERE username=?"
|
|
));
|
|
sqlx::query(&sql).bind(username).execute(db.pool()).await?;
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_optional_rounds(
|
|
value: Option<&str>,
|
|
min: u32,
|
|
max: u32,
|
|
label: &str,
|
|
) -> AppResult<Option<u32>> {
|
|
match value {
|
|
None => Ok(None),
|
|
Some(raw) => {
|
|
let parsed = u32::from_str(raw)
|
|
.map_err(|_| AppError::config(format!("invalid {label}: {raw}")))?;
|
|
if !(min..=max).contains(&parsed) {
|
|
return Err(AppError::config(format!(
|
|
"invalid {label}: {parsed}; expected {min}..={max}"
|
|
)));
|
|
}
|
|
Ok(Some(parsed))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn parse_range_u32(
|
|
value: Option<&str>,
|
|
default: u32,
|
|
min: u32,
|
|
max: u32,
|
|
label: &str,
|
|
) -> AppResult<u32> {
|
|
Ok(parse_optional_rounds(value, min, max, label)?.unwrap_or(default))
|
|
}
|
|
|
|
fn is_hex_digest(value: &str, len: usize) -> bool {
|
|
value.len() == len && value.bytes().all(|b| b.is_ascii_hexdigit())
|
|
}
|
|
|
|
fn hex_md5(password: &str) -> String {
|
|
format!("{:x}", Md5::digest(password.as_bytes()))
|
|
}
|
|
|
|
fn ct_eq(a: &[u8], b: &[u8]) -> bool {
|
|
a.len() == b.len() && bool::from(a.ct_eq(b))
|
|
}
|
|
|
|
fn random_crypt_salt(len: usize) -> String {
|
|
let mut rng = rand::rng();
|
|
let mut bytes = vec![0u8; len];
|
|
rng.fill_bytes(&mut bytes);
|
|
bytes
|
|
.into_iter()
|
|
.map(|b| CRYPT64[(b as usize) & 63] as char)
|
|
.collect()
|
|
}
|
|
|
|
pub fn md5_crypt_verify(password: &str, stored: &str) -> bool {
|
|
let mut parts = stored.split('$');
|
|
if parts.next() != Some("") || parts.next() != Some("1") {
|
|
return false;
|
|
}
|
|
let Some(salt) = parts.next() else {
|
|
return false;
|
|
};
|
|
ct_eq(md5_crypt(password, salt).as_bytes(), stored.as_bytes())
|
|
}
|
|
|
|
/// Native MD5-CRYPT retained for exact PostfixAdmin 3.x/4.x compatibility.
|
|
pub fn md5_crypt(password: &str, raw_salt: &str) -> String {
|
|
let password = password.as_bytes();
|
|
let salt = raw_salt.split('$').next().unwrap_or(raw_salt).as_bytes();
|
|
let salt = &salt[..salt.len().min(8)];
|
|
|
|
let mut ctx = Md5::new();
|
|
ctx.update(password);
|
|
ctx.update(b"$1$");
|
|
ctx.update(salt);
|
|
|
|
let mut alt = Md5::new();
|
|
alt.update(password);
|
|
alt.update(salt);
|
|
alt.update(password);
|
|
let alt = alt.finalize();
|
|
|
|
let mut remaining = password.len();
|
|
while remaining > 16 {
|
|
ctx.update(&alt[..]);
|
|
remaining -= 16;
|
|
}
|
|
ctx.update(&alt[..remaining]);
|
|
|
|
let mut n = password.len();
|
|
while n > 0 {
|
|
if n & 1 != 0 {
|
|
ctx.update([0u8]);
|
|
} else if let Some(first) = password.first() {
|
|
ctx.update([*first]);
|
|
}
|
|
n >>= 1;
|
|
}
|
|
let mut digest: [u8; 16] = ctx.finalize().into();
|
|
|
|
for i in 0..1000usize {
|
|
let mut loop_ctx = Md5::new();
|
|
if i & 1 != 0 {
|
|
loop_ctx.update(password);
|
|
} else {
|
|
loop_ctx.update(digest);
|
|
}
|
|
if i % 3 != 0 {
|
|
loop_ctx.update(salt);
|
|
}
|
|
if i % 7 != 0 {
|
|
loop_ctx.update(password);
|
|
}
|
|
if i & 1 != 0 {
|
|
loop_ctx.update(digest);
|
|
} else {
|
|
loop_ctx.update(password);
|
|
}
|
|
digest = loop_ctx.finalize().into();
|
|
}
|
|
|
|
let mut encoded = String::with_capacity(22);
|
|
b64_from_24(digest[0], digest[6], digest[12], 4, &mut encoded);
|
|
b64_from_24(digest[1], digest[7], digest[13], 4, &mut encoded);
|
|
b64_from_24(digest[2], digest[8], digest[14], 4, &mut encoded);
|
|
b64_from_24(digest[3], digest[9], digest[15], 4, &mut encoded);
|
|
b64_from_24(digest[4], digest[10], digest[5], 4, &mut encoded);
|
|
b64_from_24(0, 0, digest[11], 2, &mut encoded);
|
|
format!("$1${}${encoded}", String::from_utf8_lossy(salt))
|
|
}
|
|
|
|
fn b64_from_24(b2: u8, b1: u8, b0: u8, count: usize, out: &mut String) {
|
|
let mut value = (u32::from(b2) << 16) | (u32::from(b1) << 8) | u32::from(b0);
|
|
for _ in 0..count {
|
|
out.push(CRYPT64[(value & 0x3f) as usize] as char);
|
|
value >>= 6;
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn md5crypt_known_vector() {
|
|
let hash = md5_crypt("password", "hfT7jp2q");
|
|
assert_eq!(hash, "$1$hfT7jp2q$G3yf0NUx7mUkX.LIFWQxN.");
|
|
assert!(md5_crypt_verify("password", &hash));
|
|
assert!(!md5_crypt_verify("wrong", &hash));
|
|
}
|
|
|
|
#[test]
|
|
fn verifies_postfixadmin_reference_vectors() {
|
|
let cases = [
|
|
("{SHA1}cojt0Pw//L6ToM8G41aOKFIWh7w=", true),
|
|
("{SHA1.B64}cojt0Pw//L6ToM8G41aOKFIWh7w=", true),
|
|
("{PLAIN}test123", true),
|
|
("{CLEAR}test123", true),
|
|
("{CLEARTEXT}test123", true),
|
|
("{SHA256}7NcYcNGWMxapfjrDQIyYNa2M8PPBvHA1J8MCZVNPda4=", true),
|
|
(
|
|
"{SHA512}2u9JU7l4M2XK1mFSI3IFBsxGxRZ80Wq1APpZeqCP+WTrJPsZaH8012Zfd4/LbFNY/ApbgeFmLPkPc6JnHFP5kQ==",
|
|
true,
|
|
),
|
|
("{PLAIN-MD5}cc03e747a6afbbcbf8be7668acfebee5", true),
|
|
("{MD5-CRYPT}$1$AIjpWveQ$2s3eEAbZiqkJhMYUIVR240", true),
|
|
(
|
|
"{BLF-CRYPT}$2y$05$cEEZv2h/NtLXII.emi2TP.rMZyB7VRSkyToXWBqqz6cXDoyay166q",
|
|
true,
|
|
),
|
|
(
|
|
"{SHA512-CRYPT}$6$MViNQUSbWyXWL9wZ$63VsBU2a/ZFb9f/dK4EmaXABE9jAcNltR7y6a2tXLKoV5F5jMezno.2KpmtD3U0FDjfa7A.pkCluVMlZJ.F64.",
|
|
true,
|
|
),
|
|
(
|
|
"{CRYPT}$2y$05$ORqzr0AagWr25v3ixHD5QuMXympIoNTbipEFZz6aAmovGNoij2vDO",
|
|
true,
|
|
),
|
|
(
|
|
"{SHA256-CRYPT}$5$CFly6wzfn2az3U8j$EhfQPTdjpMGAisfCjCKektLke5GGEmtdLVaCZSmsKw2",
|
|
true,
|
|
),
|
|
("{SSHA}ZkqrSEAhvd0FTHaK1IxAQCRa5LWbxGQY", true),
|
|
(
|
|
"{ARGON2ID}$argon2id$v=19$m=65536,t=3,p=1$eaXP376O9/VxleLw9OQIxg$jOoDyECeRRV4eta3eSN/j0RdBgqaA1VBGAA/pbviI20",
|
|
true,
|
|
),
|
|
(
|
|
"{ARGON2I}$argon2i$v=19$m=32768,t=4,p=1$xoOcAGa27k0Sr6ZPbA9ODw$wl/KAZVmJooD/35IFG5oGwyQiAREXrLss5BPS1PDKfA",
|
|
true,
|
|
),
|
|
(
|
|
"{ARGON2ID.B64}JGFyZ29uMmlkJHY9MTkkbT02NTUzNix0PTMscD0xJEljdG9DWko1T04zWlYzM3I0TVMrNEEkMUVtNTJRWkdsRlJzNnBsRXpwVmtMeVd4dVNPRUZ2dUZnaVNhTmNlb08rOA==",
|
|
true,
|
|
),
|
|
("{MD5}zAPnR6avu8v4vnZorP6+5Q==", true),
|
|
("{MD5RAW}cc03e747a6afbbcbf8be7668acfebee5", true),
|
|
];
|
|
for (stored, expected) in cases {
|
|
assert_eq!(verify_native("test123", stored), Some(expected), "{stored}");
|
|
assert_eq!(
|
|
verify_native("not-the-password", stored),
|
|
Some(false),
|
|
"{stored}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn verifies_postfixadmin_b64_crypt_vectors() {
|
|
let cases = [
|
|
"{SHA512-CRYPT.B64}JDYkR2JwY3NiZXNMWk9DdERXbiRYdXlhdEZTdy9oa3lyUFE0d24wenpGQTZrSlpTUE9QVWdPcjVRUC40bTRMTjEzdy81aWMvWTdDZllRMWVqSWlhNkd3Q2Z0ZnNjZEFpam9OWjl3OU5tLw==",
|
|
"{SHA256-CRYPT.B64}JDUkUTZZS1ZzZS5sSVJoLndodCR6TWNOUVFVVkhtTmM1ME1SQk9TR3BEeGpRY2M1TzJTQ1lkbWhPN1YxeHlD",
|
|
"{BLF-CRYPT.B64}JDJ5JDA1JEhlR0lBeGFHR2tNUGxjRWpyeFc0eU9oRjZZZ1NuTWVOTXFxNWp4bmFwVjUwdGU3c2x2L1VT",
|
|
];
|
|
for stored in cases {
|
|
assert_eq!(verify_native("test123", stored), Some(true), "{stored}");
|
|
assert_eq!(verify_native("wrong", stored), Some(false), "{stored}");
|
|
}
|
|
}
|
|
#[test]
|
|
fn verifies_legacy_php_crypt_des_vector() {
|
|
assert!(unix_crypt::verify("test123", "VXAXutUnpVYg6"));
|
|
assert!(!unix_crypt::verify("wrong", "VXAXutUnpVYg6"));
|
|
}
|
|
}
|