Linux服务器修改密码的最佳实践指南

# 修改当前用户密码
passwd
# 系统会提示输入当前密码和新密码
changing password for user username.
current password: 
new password: 
retype new password: 
passwd: all authentication tokens updated successfully.

# 使用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

# 使用usermod修改密码
usermod -p $(openssl passwd -1 "newpassword") username
# 或者使用crypt函数
usermod -p $(python3 -c "import crypt; print(crypt.crypt('newpassword'))") username

# 修改单个用户密码
echo "username:newpassword" | chpasswd
# 修改多个用户密码
cat << eof | chpasswd
user1:password1
user2:password2
user3:password3
eof

# 修改指定用户密码（需要sudo权限）
sudo passwd username
# 或者
sudo chpasswd <<< "username:newpassword"

# 创建密码文件
cat > passwords.txt << eof
user1:password1
user2:password2
user3:password3
eof
# 批量修改密码
sudo chpasswd < passwords.txt
# 删除密码文件（安全考虑）
rm -f passwords.txt

# 切换到root用户
su - root
# 修改用户密码
passwd username
# 或者使用chpasswd
chpasswd <<< "username:newpassword"

#!/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

#!/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 "批量密码修改完成！"

#!/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 "批量密码修改完成！"

#!/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 中所有用户密码修改完成！"

#!/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 "过期密码修改完成！"

# 编辑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

# 编辑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

# 查看用户密码策略
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

#!/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 "密码策略设置完成！"

# 编辑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

# 错误信息
passwd: permission denied
# 解决方案
sudo passwd username
# 或者
su - root
passwd username

# 错误信息
bad password: the password fails the dictionary check - it is too simplistic/systematic
# 解决方案
# 1. 使用更复杂的密码
# 2. 临时降低密码策略要求
# 3. 检查pwquality配置

# 检查用户状态
passwd -s username
# 解锁用户
sudo passwd -u username
# 或者使用usermod
sudo usermod -u username

#!/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 "重试完成！"

#!/bin/bash
# 文件名：handle_special_chars.sh
# 处理包含特殊字符的密码
username="testuser"
password="test@123#456"
# 使用printf处理特殊字符
printf "%s:%s\n" "$username" "$password" | chpasswd
# 或者使用单引号
echo "$username:$password" | chpasswd

#!/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

#!/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

#!/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

#!/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

#!/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

#!/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

#!/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 "$@"

# 文件名：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

#!/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 "$@"

#!/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 "$@"