Linux服务器修改密码详解
Linux服务器修改密码详解
目录
概述修改当前用户密码修改其他用户密码批量修改密码密码策略配置常见问题解决安全最佳实践自动化脚本监控和审计总结
概述
在Linux服务器管理中，密码管理是一个重要的安全环节。本指南将详细介绍各种修改密码的方法，包括单用户密码修改、批量密码修改、密码策略配置等，帮助系统管理员更好地管理服务器密码安全。
修改当前用户密码
1. 使用passwd命令
1.1 基本用法
# 修改当前用户密码
passwd
# 系统会提示输入当前密码和新密码
Changing password for user username.
Current password:
New password:
Retype new password:
passwd: all authentication tokens updated successfully.
1.2 非交互式修改
# 使用echo和管道修改密码（不推荐，密码会出现在命令历史中）
echo "newpassword" | passwd --stdin username
# 使用chpasswd命令（推荐）
echo "username:newpassword" | chpasswd
# 使用openssl生成加密密码
openssl passwd -1 "newpassword"
# 输出：$1$salt$hashedpassword
# 使用生成的哈希设置密码
usermod -p '$1$salt$hashedpassword' username
2. 使用usermod命令
# 使用usermod修改密码
usermod -p $(openssl passwd -1 "newpassword") username
# 或者使用crypt函数
usermod -p $(python3 -c "import crypt; print(crypt.crypt('newpassword'))") username
3. 使用chpasswd命令
# 修改单个用户密码
echo "username:newpassword" | chpasswd
# 修改多个用户密码
cat << EOF | chpasswd
user1:password1
user2:password2
user3:password3
EOF
修改其他用户密码
1. 使用sudo权限
1.1 基本用法
# 修改指定用户密码（需要sudo权限）
sudo passwd username
# 或者
sudo chpasswd <<< "username:newpassword"
1.2 批量修改多个用户
# 创建密码文件
cat > passwords.txt << EOF
user1:password1
user2:password2
user3:password3
EOF
# 批量修改密码
sudo chpasswd < passwords.txt
# 删除密码文件（安全考虑）
rm -f passwords.txt
2. 使用root权限
# 切换到root用户
su - root
# 修改用户密码
passwd username
# 或者使用chpasswd
chpasswd <<< "username:newpassword"
3. 使用expect脚本自动化
#!/usr/bin/expect
# 文件名：change_password.exp
set timeout 30
set username [lindex $argv 0]
set newpassword [lindex $argv 1]
spawn passwd $username
expect "New password:"
send "$newpassword\r"
expect "Retype new password:"
send "$newpassword\r"
expect eof
# 使用expect脚本
chmod +x change_password.exp
./change_password.exp username newpassword
批量修改密码
1. 批量修改所有用户密码
1.1 使用循环批量修改
#!/bin/bash
# 文件名：batch_change_passwords.sh
# 设置新密码
NEW_PASSWORD="NewSecurePassword123!"
# 获取所有普通用户（排除系统用户）
USERS=$(awk -F: '$3 >= 1000 && $3 != 65534 {print $1}' /etc/passwd)
echo "开始批量修改用户密码..."
for user in $USERS; do
echo "正在修改用户 $user 的密码..."
echo "$user:$NEW_PASSWORD" | chpasswd
if [ $? -eq 0 ]; then
echo "✓ 用户 $user 密码修改成功"
else
echo "✗ 用户 $user 密码修改失败"
fi
done
echo "批量密码修改完成！"
1.2 从文件读取用户列表
#!/bin/bash
# 文件名：batch_change_from_file.sh
# 检查参数
if [ $# -ne 2 ]; then
echo "用法: $0 <用户列表文件> <新密码>"
echo "用户列表文件格式：每行一个用户名"
exit 1
fi
USER_FILE=$1
NEW_PASSWORD=$2
# 检查文件是否存在
if [ ! -f "$USER_FILE" ]; then
echo "错误：用户列表文件 $USER_FILE 不存在"
exit 1
fi
echo "开始批量修改用户密码..."
while IFS= read -r username; do
# 跳过空行和注释行
[[ -z "$username" || "$username" =~ ^#.*$ ]] && continue
echo "正在修改用户 $username 的密码..."
echo "$username:$NEW_PASSWORD" | chpasswd
if [ $? -eq 0 ]; then
echo "✓ 用户 $username 密码修改成功"
else
echo "✗ 用户 $username 密码修改失败"
fi
done < "$USER_FILE"
echo "批量密码修改完成！"
2. 批量修改特定组用户密码
#!/bin/bash
# 文件名：change_group_passwords.sh
# 设置参数
GROUP_NAME="developers"
NEW_PASSWORD="DevPassword2024!"
echo "开始修改组 $GROUP_NAME 中所有用户的密码..."
# 获取组中的所有用户
GROUP_USERS=$(getent group $GROUP_NAME | cut -d: -f4 | tr ',' '\n')
if [ -z "$GROUP_USERS" ]; then
echo "组 $GROUP_NAME 中没有用户"
exit 0
fi
# 修改每个用户的密码
for user in $GROUP_USERS; do
echo "正在修改用户 $user 的密码..."
echo "$user:$NEW_PASSWORD" | chpasswd
if [ $? -eq 0 ]; then
echo "✓ 用户 $user 密码修改成功"
else
echo "✗ 用户 $user 密码修改失败"
fi
done
echo "组 $GROUP_NAME 中所有用户密码修改完成！"
3. 批量修改过期密码
#!/bin/bash
# 文件名：change_expired_passwords.sh
# 设置新密码
NEW_PASSWORD="NewPassword2024!"
echo "开始修改过期密码..."
# 查找密码过期的用户
EXPIRED_USERS=$(chage -l $(awk -F: '$3 >= 1000 {print $1}' /etc/passwd) | \
awk '/Password expires/ && $NF != "never" {print $1}' | \
sed 's/:$//')
if [ -z "$EXPIRED_USERS" ]; then
echo "没有找到密码过期的用户"
exit 0
fi
echo "找到以下密码过期的用户："
echo "$EXPIRED_USERS"
# 修改过期用户的密码
for user in $EXPIRED_USERS; do
echo "正在修改用户 $user 的密码..."
echo "$user:$NEW_PASSWORD" | chpasswd
if [ $? -eq 0 ]; then
echo "✓ 用户 $user 密码修改成功"
# 强制用户下次登录时修改密码
chage -d 0 $user
else
echo "✗ 用户 $user 密码修改失败"
fi
done
echo "过期密码修改完成！"
密码策略配置
1. 配置密码复杂度要求
1.1 使用pam_pwquality模块
# 编辑PAM配置
sudo vim /etc/pam.d/common-password
# 添加或修改以下行
password requisite pam_pwquality.so retry=3 minlen=12 difok=3 ucredit=-1 lcredit=-1 dcredit=-1 ocredit=-1 reject_username
1.2 配置pwquality.conf
# 编辑pwquality配置文件
sudo vim /etc/security/pwquality.conf
# 密码策略配置
# 最小长度
minlen = 12
# 至少包含一个大写字母
ucredit = -1
# 至少包含一个小写字母
lcredit = -1
# 至少包含一个数字
dcredit = -1
# 至少包含一个特殊字符
ocredit = -1
# 不能包含用户名
reject_username = 1
# 至少包含3个不同字符类
minclass = 3
# 最大重复字符数
maxrepeat = 2
# 不能使用常见密码
badwords = password,123456,admin,root
2. 配置密码过期策略
2.1 使用chage命令
# 查看用户密码策略
chage -l username
# 设置密码过期时间（90天）
chage -M 90 username
# 设置密码警告时间（7天）
chage -W 7 username
# 设置账户过期时间
chage -E 2024-12-31 username
# 设置最小密码年龄（1天）
chage -m 1 username
# 强制用户下次登录时修改密码
chage -d 0 username
2.2 批量设置密码策略
#!/bin/bash
# 文件名：set_password_policy.sh
# 密码策略参数
MAX_DAYS=90 # 密码最大有效期（天）
WARN_DAYS=7 # 密码过期前警告天数
MIN_DAYS=1 # 密码最小有效期（天）
INACTIVE_DAYS=7 # 账户不活跃天数
echo "开始设置密码策略..."
# 获取所有普通用户
USERS=$(awk -F: '$3 >= 1000 && $3 != 65534 {print $1}' /etc/passwd)
for user in $USERS; do
echo "正在设置用户 $user 的密码策略..."
chage -M $MAX_DAYS -W $WARN_DAYS -m $MIN_DAYS -I $INACTIVE_DAYS $user
if [ $? -eq 0 ]; then
echo "✓ 用户 $user 密码策略设置成功"
else
echo "✗ 用户 $user 密码策略设置失败"
fi
done
echo "密码策略设置完成！"
3. 配置登录失败锁定
# 编辑PAM配置
sudo vim /etc/pam.d/common-auth
# 添加以下行
auth required pam_tally2.so deny=5 unlock_time=300 onerr=fail
# 编辑PAM配置
sudo vim /etc/pam.d/common-account
# 添加以下行
account required pam_tally2.so
常见问题解决
1. 密码修改失败
1.1 权限不足
# 错误信息
passwd: Permission denied
# 解决方案
sudo passwd username
# 或者
su - root
passwd username
1.2 密码不符合策略
# 错误信息
BAD PASSWORD: The password fails the dictionary check - it is too simplistic/systematic
# 解决方案
# 1. 使用更复杂的密码
# 2. 临时降低密码策略要求
# 3. 检查pwquality配置
1.3 用户被锁定
# 检查用户状态
passwd -S username
# 解锁用户
sudo passwd -u username
# 或者使用usermod
sudo usermod -U username
2. 批量操作问题
2.1 部分用户密码修改失败
#!/bin/bash
# 文件名：retry_failed_passwords.sh
# 重试失败的密码修改
FAILED_USERS_FILE="failed_users.txt"
NEW_PASSWORD="NewPassword2024!"
if [ ! -f "$FAILED_USERS_FILE" ]; then
echo "没有找到失败用户文件"
exit 0
fi
echo "重试失败的密码修改..."
while IFS= read -r username; do
echo "重试修改用户 $username 的密码..."
echo "$username:$NEW_PASSWORD" | chpasswd
if [ $? -eq 0 ]; then
echo "✓ 用户 $username 密码修改成功"
# 从失败列表中移除
sed -i "/^$username$/d" "$FAILED_USERS_FILE"
else
echo "✗ 用户 $username 密码修改仍然失败"
fi
done < "$FAILED_USERS_FILE"
echo "重试完成！"
2.2 处理特殊字符密码
#!/bin/bash
# 文件名：handle_special_chars.sh
# 处理包含特殊字符的密码
USERNAME="testuser"
PASSWORD="Test@123#456"
# 使用printf处理特殊字符
printf "%s:%s\n" "$USERNAME" "$PASSWORD" | chpasswd
# 或者使用单引号
echo "$USERNAME:$PASSWORD" | chpasswd
3. 系统兼容性问题
3.1 不同Linux发行版差异
#!/bin/bash
# 文件名：detect_distro.sh
# 检测Linux发行版
if [ -f /etc/os-release ]; then
. /etc/os-release
OS=$NAME
VER=$VERSION_ID
elif type lsb_release >/dev/null 2>&1; then
OS=$(lsb_release -si)
VER=$(lsb_release -sr)
elif [ -f /etc/lsb-release ]; then
. /etc/lsb-release
OS=$DISTRIB_ID
VER=$DISTRIB_RELEASE
elif [ -f /etc/debian_version ]; then
OS=Debian
VER=$(cat /etc/debian_version)
elif [ -f /etc/SuSE-release ]; then
OS=openSUSE
VER=$(cat /etc/SuSE-release)
elif [ -f /etc/redhat-release ]; then
OS=RedHat
VER=$(cat /etc/redhat-release)
else
OS=$(uname -s)
VER=$(uname -r)
fi
echo "操作系统: $OS"
echo "版本: $VER"
# 根据发行版选择相应的命令
case $OS in
*Ubuntu*|*Debian*)
echo "使用Debian/Ubuntu命令"
;;
*CentOS*|*RedHat*|*Fedora*)
echo "使用RedHat/CentOS命令"
;;
*openSUSE*)
echo "使用openSUSE命令"
;;
*)
echo "未知发行版，使用通用命令"
;;
esac
安全最佳实践
1. 密码生成策略
1.1 使用随机密码生成器
#!/bin/bash
# 文件名：generate_secure_password.sh
# 生成安全密码
generate_password() {
# 密码长度
LENGTH=${1:-16}
# 生成包含大小写字母、数字和特殊字符的密码
PASSWORD=$(openssl rand -base64 $LENGTH | tr -d "=+/" | cut -c1-$LENGTH)
# 确保包含至少一个大写字母
if [[ ! "$PASSWORD" =~ [A-Z] ]]; then
PASSWORD="${PASSWORD:0:-1}A"
fi
# 确保包含至少一个小写字母
if [[ ! "$PASSWORD" =~ [a-z] ]]; then
PASSWORD="${PASSWORD:0:-1}a"
fi
# 确保包含至少一个数字
if [[ ! "$PASSWORD" =~ [0-9] ]]; then
PASSWORD="${PASSWORD:0:-1}1"
fi
# 确保包含至少一个特殊字符
if [[ ! "$PASSWORD" =~ [!@#\$%^&*] ]]; then
PASSWORD="${PASSWORD:0:-1}!"
fi
echo "$PASSWORD"
}
# 生成多个密码
echo "生成的安全密码："
for i in {1..5}; do
echo "密码 $i: $(generate_password 16)"
done
1.2 使用字典单词组合
#!/bin/bash
# 文件名：generate_memorable_password.sh
# 生成易记忆的安全密码
generate_memorable_password() {
# 常用单词列表
WORDS=("apple" "banana" "cherry" "dragon" "eagle" "forest" "garden" "harbor" "island" "jungle")
# 随机选择3个单词
WORD1=${WORDS[$RANDOM % ${#WORDS[@]}]}
WORD2=${WORDS[$RANDOM % ${#WORDS[@]}]}
WORD3=${WORDS[$RANDOM % ${#WORDS[@]}]}
# 随机数字
NUM1=$((RANDOM % 10))
NUM2=$((RANDOM % 10))
# 随机特殊字符
SPECIALS=("!" "@" "#" "$" "%" "^" "&" "*")
SPECIAL=${SPECIALS[$RANDOM % ${#SPECIALS[@]}]}
# 组合密码
PASSWORD="${WORD1^}${NUM1}${WORD2^}${NUM2}${WORD3^}${SPECIAL}"
echo "$PASSWORD"
}
echo "生成的易记忆密码："
for i in {1..5}; do
echo "密码 $i: $(generate_memorable_password)"
done
2. 密码存储和传输安全
2.1 安全存储密码文件
#!/bin/bash
# 文件名：secure_password_storage.sh
# 安全存储密码
USERNAME="admin"
PASSWORD="SecurePassword123!"
# 创建加密的密码文件
echo "$USERNAME:$PASSWORD" | gpg --encrypt --recipient admin@example.com > passwords.gpg
# 使用加密文件修改密码
gpg --decrypt passwords.gpg | chpasswd
# 删除明文密码文件
rm -f passwords.gpg
2.2 使用SSH密钥认证
#!/bin/bash
# 文件名：setup_ssh_keys.sh
# 设置SSH密钥认证
USERNAME="admin"
echo "为用户 $USERNAME 设置SSH密钥认证..."
# 创建.ssh目录
sudo mkdir -p /home/$USERNAME/.ssh
sudo chmod 700 /home/$USERNAME/.ssh
# 生成SSH密钥对
sudo -u $USERNAME ssh-keygen -t rsa -b 4096 -f /home/$USERNAME/.ssh/id_rsa -N ""
# 设置权限
sudo chown -R $USERNAME:$USERNAME /home/$USERNAME/.ssh
sudo chmod 600 /home/$USERNAME/.ssh/id_rsa
sudo chmod 644 /home/$USERNAME/.ssh/id_rsa.pub
echo "SSH密钥设置完成！"
echo "公钥内容："
cat /home/$USERNAME/.ssh/id_rsa.pub
3. 定期密码轮换
3.1 自动密码轮换脚本
#!/bin/bash
# 文件名：auto_password_rotation.sh
# 自动密码轮换脚本
LOG_FILE="/var/log/password_rotation.log"
ROTATION_DAYS=90
# 记录日志
log_message() {
echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOG_FILE"
}
# 生成新密码
generate_new_password() {
openssl rand -base64 12 | tr -d "=+/" | cut -c1-16
}
# 检查密码是否需要轮换
check_password_rotation() {
local user=$1
local last_change=$(chage -l "$user" | grep "Last password change" | awk '{print $NF}')
if [ "$last_change" = "never" ]; then
return 0
fi
local days_since_change=$(( ( $(date +%s) - $(date -d "$last_change" +%s) ) / 86400 ))
if [ $days_since_change -ge $ROTATION_DAYS ]; then
return 0
fi
return 1
}
# 主函数
main() {
log_message "开始密码轮换检查..."
# 获取所有普通用户
local users=$(awk -F: '$3 >= 1000 && $3 != 65534 {print $1}' /etc/passwd)
local rotated_count=0
for user in $users; do
if check_password_rotation "$user"; then
log_message "用户 $user 需要密码轮换"
# 生成新密码
local new_password=$(generate_new_password)
# 修改密码
echo "$user:$new_password" | chpasswd
if [ $? -eq 0 ]; then
log_message "用户 $user 密码轮换成功"
rotated_count=$((rotated_count + 1))
# 发送邮件通知用户（如果配置了邮件服务）
# echo "您的密码已自动更新为: $new_password" | mail -s "密码更新通知" $user@example.com
else
log_message "用户 $user 密码轮换失败"
fi
fi
done
log_message "密码轮换完成，共轮换 $rotated_count 个用户"
}
# 执行主函数
main
自动化脚本
1. 完整的密码管理脚本
1.1 主脚本
#!/bin/bash
# 文件名：password_manager.sh
# 密码管理主脚本
VERSION="1.0.0"
LOG_FILE="/var/log/password_manager.log"
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 日志函数
log_message() {
local level=$1
local message=$2
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
case $level in
"INFO")
echo -e "${GREEN}[INFO]${NC} $timestamp - $message"
;;
"WARN")
echo -e "${YELLOW}[WARN]${NC} $timestamp - $message"
;;
"ERROR")
echo -e "${RED}[ERROR]${NC} $timestamp - $message"
;;
"DEBUG")
echo -e "${BLUE}[DEBUG]${NC} $timestamp - $message"
;;
esac
echo "[$level] $timestamp - $message" >> "$LOG_FILE"
}
# 显示帮助信息
show_help() {
cat << EOF
Linux密码管理工具 v$VERSION
用法: $0 [选项] [参数]
选项:
-h, --help 显示此帮助信息
-v, --version 显示版本信息
-u, --user USERNAME 指定用户名
-p, --password PASSWORD 指定新密码
-f, --file FILE 从文件读取用户列表
-b, --batch 批量模式
-r, --random 生成随机密码
-l, --length LENGTH 指定密码长度（默认16）
-e, --expire DAYS 设置密码过期天数
-w, --warn DAYS 设置密码警告天数
-s, --status 显示用户密码状态
-c, --check 检查密码策略
-a, --audit 审计密码使用情况
示例:
$0 -u admin -p "NewPassword123!" # 修改单个用户密码
$0 -f users.txt -r -l 20 # 批量生成随机密码
$0 -u admin -e 90 -w 7 # 设置密码策略
$0 -s # 显示所有用户密码状态
$0 -c # 检查密码策略配置
EOF
}
# 检查用户是否存在
check_user_exists() {
local username=$1
if id "$username" &>/dev/null; then
return 0
else
return 1
fi
}
# 生成随机密码
generate_random_password() {
local length=${1:-16}
openssl rand -base64 $length | tr -d "=+/" | cut -c1-$length
}
# 修改单个用户密码
change_single_password() {
local username=$1
local password=$2
if ! check_user_exists "$username"; then
log_message "ERROR" "用户 $username 不存在"
return 1
fi
log_message "INFO" "正在修改用户 $username 的密码..."
echo "$username:$password" | chpasswd
if [ $? -eq 0 ]; then
log_message "INFO" "用户 $username 密码修改成功"
return 0
else
log_message "ERROR" "用户 $username 密码修改失败"
return 1
fi
}
# 批量修改密码
batch_change_passwords() {
local user_file=$1
local password=$2
if [ ! -f "$user_file" ]; then
log_message "ERROR" "用户文件 $user_file 不存在"
return 1
fi
log_message "INFO" "开始批量修改密码..."
local success_count=0
local fail_count=0
while IFS= read -r username; do
# 跳过空行和注释行
[[ -z "$username" || "$username" =~ ^#.*$ ]] && continue
if change_single_password "$username" "$password"; then
success_count=$((success_count + 1))
else
fail_count=$((fail_count + 1))
fi
done < "$user_file"
log_message "INFO" "批量修改完成：成功 $success_count 个，失败 $fail_count 个"
}
# 设置密码策略
set_password_policy() {
local username=$1
local expire_days=$2
local warn_days=$3
if ! check_user_exists "$username"; then
log_message "ERROR" "用户 $username 不存在"
return 1
fi
log_message "INFO" "正在设置用户 $username 的密码策略..."
chage -M "$expire_days" -W "$warn_days" "$username"
if [ $? -eq 0 ]; then
log_message "INFO" "用户 $username 密码策略设置成功"
return 0
else
log_message "ERROR" "用户 $username 密码策略设置失败"
return 1
fi
}
# 显示用户密码状态
show_password_status() {
local username=$1
if [ -n "$username" ]; then
if ! check_user_exists "$username"; then
log_message "ERROR" "用户 $username 不存在"
return 1
fi
chage -l "$username"
else
# 显示所有用户的密码状态
local users=$(awk -F: '$3 >= 1000 && $3 != 65534 {print $1}' /etc/passwd)
for user in $users; do
echo "=== 用户: $user ==="
chage -l "$user" | grep -E "(Last password change|Password expires|Password inactive|Account expires)"
echo
done
fi
}
# 检查密码策略配置
check_password_policy() {
log_message "INFO" "检查密码策略配置..."
# 检查PAM配置
if [ -f /etc/pam.d/common-password ]; then
echo "=== PAM密码策略配置 ==="
grep -E "(pam_pwquality|pam_unix)" /etc/pam.d/common-password
echo
fi
# 检查pwquality配置
if [ -f /etc/security/pwquality.conf ]; then
echo "=== pwquality配置 ==="
grep -v "^#" /etc/security/pwquality.conf | grep -v "^$"
echo
fi
# 检查默认密码策略
echo "=== 默认密码策略 ==="
grep -E "PASS_MAX_DAYS|PASS_MIN_DAYS|PASS_WARN_AGE" /etc/login.defs
}
# 主函数
main() {
local username=""
local password=""
local user_file=""
local batch_mode=false
local random_password=false
local password_length=16
local expire_days=""
local warn_days=""
local show_status=false
local check_policy=false
# 解析命令行参数
while [[ $# -gt 0 ]]; do
case $1 in
-h|--help)
show_help
exit 0
;;
-v|--version)
echo "Linux密码管理工具 v$VERSION"
exit 0
;;
-u|--user)
username="$2"
shift 2
;;
-p|--password)
password="$2"
shift 2
;;
-f|--file)
user_file="$2"
shift 2
;;
-b|--batch)
batch_mode=true
shift
;;
-r|--random)
random_password=true
shift
;;
-l|--length)
password_length="$2"
shift 2
;;
-e|--expire)
expire_days="$2"
shift 2
;;
-w|--warn)
warn_days="$2"
shift 2
;;
-s|--status)
show_status=true
shift
;;
-c|--check)
check_policy=true
shift
;;
*)
log_message "ERROR" "未知选项: $1"
show_help
exit 1
;;
esac
done
# 检查权限
if [ "$EUID" -ne 0 ]; then
log_message "ERROR" "此脚本需要root权限运行"
exit 1
fi
# 执行相应操作
if [ "$show_status" = true ]; then
show_password_status "$username"
elif [ "$check_policy" = true ]; then
check_password_policy
elif [ -n "$expire_days" ] || [ -n "$warn_days" ]; then
if [ -z "$username" ]; then
log_message "ERROR" "设置密码策略需要指定用户名"
exit 1
fi
set_password_policy "$username" "${expire_days:-99999}" "${warn_days:-7}"
elif [ "$batch_mode" = true ]; then
if [ -z "$user_file" ]; then
log_message "ERROR" "批量模式需要指定用户文件"
exit 1
fi
if [ "$random_password" = true ]; then
password=$(generate_random_password "$password_length")
log_message "INFO" "生成的随机密码: $password"
elif [ -z "$password" ]; then
log_message "ERROR" "批量模式需要指定密码或使用随机密码"
exit 1
fi
batch_change_passwords "$user_file" "$password"
elif [ -n "$username" ] && [ -n "$password" ]; then
change_single_password "$username" "$password"
elif [ -n "$username" ] && [ "$random_password" = true ]; then
password=$(generate_random_password "$password_length")
log_message "INFO" "生成的随机密码: $password"
change_single_password "$username" "$password"
else
log_message "ERROR" "参数不足，请使用 -h 查看帮助信息"
exit 1
fi
}
# 执行主函数
main "$@"
1.2 配置文件
# 文件名：password_manager.conf
# 密码管理配置文件
# 日志配置
LOG_FILE="/var/log/password_manager.log"
LOG_LEVEL="INFO"
# 默认密码策略
DEFAULT_PASSWORD_LENGTH=16
DEFAULT_EXPIRE_DAYS=90
DEFAULT_WARN_DAYS=7
DEFAULT_MIN_DAYS=1
# 密码复杂度要求
MIN_LENGTH=12
REQUIRE_UPPERCASE=true
REQUIRE_LOWERCASE=true
REQUIRE_DIGITS=true
REQUIRE_SPECIAL=true
# 批量操作配置
BATCH_TIMEOUT=300
MAX_CONCURRENT_USERS=10
# 通知配置
ENABLE_EMAIL_NOTIFICATION=false
SMTP_SERVER="smtp.example.com"
SMTP_PORT=587
SMTP_USERNAME="noreply@example.com"
SMTP_PASSWORD=""
# 安全配置
ENABLE_PASSWORD_HISTORY=true
PASSWORD_HISTORY_SIZE=5
ENABLE_ACCOUNT_LOCKOUT=true
MAX_LOGIN_ATTEMPTS=5
LOCKOUT_DURATION=300
监控和审计
1. 密码修改日志监控
1.1 实时监控脚本
#!/bin/bash
# 文件名：password_monitor.sh
# 密码修改实时监控脚本
LOG_FILE="/var/log/auth.log"
ALERT_FILE="/var/log/password_alerts.log"
ADMIN_EMAIL="admin@example.com"
# 监控密码修改事件
monitor_password_changes() {
log_message "INFO" "开始监控密码修改事件..."
# 使用tail -f监控日志文件
tail -f "$LOG_FILE" | while read line; do
# 检查密码修改事件
if echo "$line" | grep -q "password changed"; then
local timestamp=$(echo "$line" | awk '{print $1, $2, $3}')
local user=$(echo "$line" | grep -o "for [^ ]*" | awk '{print $2}')
local source=$(echo "$line" | grep -o "from [^ ]*" | awk '{print $2}')
local alert_message="[密码修改警报] 时间: $timestamp, 用户: $user, 来源: $source"
# 记录警报
echo "$alert_message" >> "$ALERT_FILE"
# 发送邮件通知
echo "$alert_message" | mail -s "密码修改警报" "$ADMIN_EMAIL"
# 控制台输出
echo -e "\033[1;33m$alert_message\033[0m"
fi
# 检查登录失败事件
if echo "$line" | grep -q "Failed password"; then
local timestamp=$(echo "$line" | awk '{print $1, $2, $3}')
local user=$(echo "$line" | grep -o "for [^ ]*" | awk '{print $2}')
local source=$(echo "$line" | grep -o "from [^ ]*" | awk '{print $2}')
local alert_message="[登录失败警报] 时间: $timestamp, 用户: $user, 来源: $source"
# 记录警报
echo "$alert_message" >> "$ALERT_FILE"
# 控制台输出
echo -e "\033[1;31m$alert_message\033[0m"
fi
done
}
# 日志函数
log_message() {
local level=$1
local message=$2
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
echo "[$level] $timestamp - $message"
}
# 主函数
main() {
# 检查日志文件是否存在
if [ ! -f "$LOG_FILE" ]; then
log_message "ERROR" "日志文件 $LOG_FILE 不存在"
exit 1
fi
# 创建警报文件
touch "$ALERT_FILE"
# 开始监控
monitor_password_changes
}
# 执行主函数
main "$@"
1.2 定期审计脚本
#!/bin/bash
# 文件名：password_audit.sh
# 密码定期审计脚本
AUDIT_LOG="/var/log/password_audit.log"
REPORT_FILE="/var/log/password_report_$(date +%Y%m%d).txt"
# 生成密码审计报告
generate_audit_report() {
local report_date=$(date '+%Y-%m-%d %H:%M:%S')
cat > "$REPORT_FILE" << EOF
密码审计报告
生成时间: $report_date
========================================
1. 用户密码状态概览
----------------------------------------
EOF
# 获取所有用户
local users=$(awk -F: '$3 >= 1000 && $3 != 65534 {print $1}' /etc/passwd)
local total_users=$(echo "$users" | wc -l)
local expired_users=0
local expiring_soon_users=0
local never_expire_users=0
echo "总用户数: $total_users" >> "$REPORT_FILE"
echo "" >> "$REPORT_FILE"
for user in $users; do
local password_info=$(chage -l "$user" | grep -E "(Last password change|Password expires|Password inactive)")
local last_change=$(echo "$password_info" | grep "Last password change" | awk '{print $NF}')
local expires=$(echo "$password_info" | grep "Password expires" | awk '{print $NF}')
echo "用户: $user" >> "$REPORT_FILE"
echo " 最后修改: $last_change" >> "$REPORT_FILE"
echo " 过期时间: $expires" >> "$REPORT_FILE"
if [ "$expires" = "never" ]; then
never_expire_users=$((never_expire_users + 1))
elif [ "$expires" != "never" ]; then
local days_until_expiry=$(( ( $(date -d "$expires" +%s) - $(date +%s) ) / 86400 ))
if [ $days_until_expiry -lt 0 ]; then
expired_users=$((expired_users + 1))
elif [ $days_until_expiry -le 7 ]; then
expiring_soon_users=$((expiring_soon_users + 1))
fi
fi
echo "" >> "$REPORT_FILE"
done
# 统计信息
cat >> "$REPORT_FILE" << EOF
2. 密码状态统计
----------------------------------------
过期用户数: $expired_users
即将过期用户数: $expiring_soon_users
永不过期用户数: $never_expire_users
3. 安全建议
----------------------------------------
EOF
if [ $expired_users -gt 0 ]; then
echo "- 立即处理 $expired_users 个过期密码用户" >> "$REPORT_FILE"
fi
if [ $expiring_soon_users -gt 0 ]; then
echo "- 提醒 $expiring_soon_users 个即将过期密码的用户" >> "$REPORT_FILE"
fi
if [ $never_expire_users -gt 0 ]; then
echo "- 考虑为 $never_expire_users 个永不过期密码的用户设置过期策略" >> "$REPORT_FILE"
fi
echo "" >> "$REPORT_FILE"
echo "报告生成完成: $REPORT_FILE"
}
# 主函数
main() {
log_message "INFO" "开始生成密码审计报告..."
generate_audit_report
log_message "INFO" "密码审计报告生成完成: $REPORT_FILE"
}
# 日志函数
log_message() {
local level=$1
local message=$2
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
echo "[$level] $timestamp - $message" | tee -a "$AUDIT_LOG"
}
# 执行主函数
main "$@"
总结
1. 关键要点
密码修改方法多样: 包括passwd、chpasswd、usermod等多种命令批量操作支持: 支持从文件读取用户列表进行批量密码修改安全策略配置: 可配置密码复杂度、过期策略、锁定策略等自动化脚本: 提供完整的密码管理脚本，支持各种操作场景
2. 最佳实践建议
使用强密码: 包含大小写字母、数字和特殊字符定期轮换: 设置合理的密码过期时间，强制用户定期更换监控审计: 实时监控密码修改事件，定期生成审计报告权限控制: 严格控制密码修改权限，避免未授权访问
3. 安全注意事项
避免明文存储: 不要在脚本中硬编码密码日志安全: 确保密码相关日志不被未授权访问传输安全: 使用加密通道传输密码信息定期检查: 定期检查密码策略执行情况
4. 适用场景
系统管理: 日常用户密码管理批量操作: 大量用户密码同时修改安全审计: 密码使用情况审计和报告自动化运维: 集成到自动化运维流程中
通过遵循这些最佳实践，可以建立安全、高效的Linux服务器密码管理体系，提高系统安全性和管理效率。