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服务器密码管理体系，提高系统安全性和管理效率。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
