如何写一个加密压缩脚本

wen 实用脚本 2026-08-01 2

本文目录导读：

如何写一个加密压缩脚本

基础版：使用 7-Zip 加密压缩（推荐）
进阶版：Python 跨平台脚本
Linux Shell 脚本版本
自动化定时备份版本（集成cron任务）
使用建议

基础版：使用 7-Zip 加密压缩（推荐）

Windows 批处理脚本

@echo off
setlocal enabledelayedexpansion
REM ============================================
REM 加密压缩脚本 - Windows 版本
REM ============================================
REM 配置
set "SEVENZIP=C:\Program Files\7-Zip\7z.exe"
set "SOURCE_DIR=%USERPROFILE%\Documents\backup"
set "DEST_DIR=D:\backups"
set "PASSWORD=YourStrongPassword123!"
REM 检查7-Zip是否安装
if not exist "%SEVENZIP%" (
    echo [错误] 未找到7-Zip，请先安装
    exit /b 1
)
REM 创建目标目录
if not exist "%DEST_DIR%" mkdir "%DEST_DIR%"
REM 生成带时间戳的文件名
set "TIMESTAMP=%date:~0,4%%date:~5,2%%date:~8,2%_%time:~0,2%%time:~3,2%"
set "FILENAME=backup_%TIMESTAMP%.7z"
REM 执行加密压缩
"%SEVENZIP%" a -t7z "%DEST_DIR%\%FILENAME%" "%SOURCE_DIR%\*" -mx=9 -p"%PASSWORD%" -mhe -r
if %errorlevel% == 0 (
    echo [成功] 加密压缩完成: %FILENAME%
) else (
    echo [错误] 加密压缩失败
    exit /b 1
)
endlocal

进阶版：Python 跨平台脚本

#!/usr/bin/env python3
"""
加密压缩脚本 - Python版本
支持 Windows/Linux/Mac
需要安装: pip install py7zr pyzipper
"""
import os
import sys
import time
import getpass
import argparse
from pathlib import Path
from datetime import datetime
try:
    import py7zr
    import pyzipper
except ImportError:
    print("请安装依赖: pip install py7zr pyzipper")
    sys.exit(1)
class EncryptedArchive:
    def __init__(self, source, dest, password, format_type='7z'):
        self.source = Path(source)
        self.dest = Path(dest)
        self.password = password
        self.format_type = format_type
    def create_7z(self):
        """创建加密的7z压缩包"""
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"backup_{timestamp}.7z"
        filepath = self.dest / filename
        # 加密参数: AES256加密
        options = {
            'method': 'AES-256',
            'password': self.password,
            'headers_encrypted': True  # 加密文件头，增强安全性
        }
        try:
            with py7zr.SevenZipFile(
                str(filepath), 
                'w', 
                password=self.password,
                filters=[{'id': py7zr.FILTER_LZMA2, 'preset': 9}]
            ) as archive:
                archive.set_encrypted_header(True)
                archive.writeall(str(self.source))
            return filepath
        except Exception as e:
            print(f"创建7z压缩包失败: {e}")
            return None
    def create_zip(self):
        """创建加密的ZIP压缩包"""
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"backup_{timestamp}.zip"
        filepath = self.dest / filename
        try:
            with pyzipper.AESZipFile(
                str(filepath), 
                'w',
                compression=pyzipper.ZIP_LZMA,
                encryption=pyzipper.WZ_AES,
                compresslevel=9
            ) as archive:
                archive.setpassword(self.password.encode())
                archive.writeall(src=str(self.source), arcname=self.source.name)
            return filepath
        except Exception as e:
            print(f"创建ZIP压缩包失败: {e}")
            return None
    def run(self):
        """执行压缩"""
        if not self.source.exists():
            print(f"源路径不存在: {self.source}")
            return None
        self.dest.mkdir(parents=True, exist_ok=True)
        if self.format_type.lower() == '7z':
            result = self.create_7z()
        elif self.format_type.lower() == 'zip':
            result = self.create_zip()
        else:
            print(f"不支持的格式: {self.format_type}")
            return None
        if result:
            size_mb = result.stat().st_size / (1024 * 1024)
            print(f"压缩完成:")
            print(f"  文件: {result}")
            print(f"  大小: {size_mb:.2f} MB")
            # 验证压缩包
            if self.format_type.lower() == '7z':
                self.verify_7z(result)
            else:
                self.verify_zip(result)
        return result
    def verify_7z(self, filepath):
        """验证7z压缩包"""
        try:
            with py7zr.SevenZipFile(str(filepath), 'r', password=self.password) as archive:
                names = archive.getnames()
                print(f"验证通过，包含 {len(names)} 个文件")
        except Exception as e:
            print(f"验证失败: {e}")
    def verify_zip(self, filepath):
        """验证ZIP压缩包"""
        try:
            with pyzipper.AESZipFile(str(filepath), 'r') as archive:
                archive.setpassword(self.password.encode())
                file_info = archive.namelist()
                print(f"验证通过，包含 {len(file_info)} 个文件")
        except Exception as e:
            print(f"验证失败: {e}")
def main():
    parser = argparse.ArgumentParser(description='加密压缩脚本')
    parser.add_argument('-s', '--source', required=True, help='要压缩的源文件或目录')
    parser.add_argument('-d', '--dest', default='./backups', help='输出目录')
    parser.add_argument('-p', '--password', help='加密密码 (不提供则交互式输入)')
    parser.add_argument('-f', '--format', default='7z', choices=['7z', 'zip'], help='压缩格式')
    args = parser.parse_args()
    # 获取密码
    password = args.password
    if not password:
        password = getpass.getpass("请输入加密密码: ")
        confirm = getpass.getpass("确认密码: ")
        if password != confirm:
            print("密码不匹配!")
            sys.exit(1)
    # 创建并运行
    archive = EncryptedArchive(args.source, args.dest, password, args.format)
    result = archive.run()
    if not result:
        sys.exit(1)
if __name__ == "__main__":
    main()

Linux Shell 脚本版本

#!/bin/bash
# ============================================
# 加密压缩脚本 - Linux/Mac 版本
# 使用方法: ./encrypt_backup.sh [源目录] [目标目录]
# ============================================
set -e
# 配置
SOURCE_DIR="${1:-$HOME/documents/backup}"
DEST_DIR="${2:-$HOME/backups}"
PASSWORD="${BACKUP_PASSWORD:-}"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
FILENAME="backup_${TIMESTAMP}.tar.gz"
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'
# 日志函数
log() {
    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}"
}
error() {
    echo -e "${RED}[错误] $1${NC}"
    exit 1
}
# 检查依赖
check_dependencies() {
    command -v openssl >/dev/null 2>&1 || error "需要安装 openssl"
    command -v tar >/dev/null 2>&1 || error "需要安装 tar"
}
# 获取密码
get_password() {
    if [ -z "$PASSWORD" ]; then
        echo -n "请输入加密密码: "
        read -s PASSWORD
        echo
        echo -n "确认密码: "
        read -s CONFIRM_PASSWORD
        echo
        if [ "$PASSWORD" != "$CONFIRM_PASSWORD" ]; then
            error "密码不匹配"
        fi
    fi
    if [ ${#PASSWORD} -lt 8 ]; then
        error "密码长度至少8个字符"
    fi
}
# 检查源目录
check_source() {
    [ -d "$SOURCE_DIR" ] || error "源目录不存在: $SOURCE_DIR"
    [ -r "$SOURCE_DIR" ] || error "源目录不可读: $SOURCE_DIR"
}
# 创建加密压缩
create_encrypted_archive() {
    log "开始加密压缩..."
    # 创建临时文件储存加密密钥
    TMP_KEY_FILE=$(mktemp)
    chmod 600 "$TMP_KEY_FILE"
    # 主执行函数
    main() {
        # 检查依赖
        check_dependencies
        # 获取密码
        get_password
        # 检查源目录
        check_source
        # 创建目标目录
        mkdir -p "$DEST_DIR" || error "无法创建目标目录"
        # 执行加密压缩
        log "压缩并加密: $FILENAME"
        tar czf - -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")" | \
            openssl enc -aes-256-cbc -salt -pbkdf2 -k "$PASSWORD" > "$DEST_DIR/$FILENAME"
        if [ $? -eq 0 ]; then
            log "加密压缩完成: $DEST_DIR/$FILENAME"
            ls -lh "$DEST_DIR/$FILENAME"
        else
            error "加密压缩失败"
        fi
        # 清理临时文件
        rm -f "$TMP_KEY_FILE"
    }
    main "$@"
}
# 解析命令行参数
while [[ $# -gt 0 ]]; do
    case $1 in
        -s|--source)
            SOURCE_DIR="$2"
            shift 2
            ;;
        -d|--dest)
            DEST_DIR="$2"
            shift 2
            ;;
        -p|--password)
            PASSWORD="$2"
            shift 2
            ;;
        -h|--help)
            echo "用法: $0 [-s 源目录] [-d 目标目录] [-p 密码]"
            exit 0
            ;;
        *)
            echo "未知参数: $1"
            exit 1
            ;;
    esac
done
# 执行主函数
create_encrypted_archive

自动化定时备份版本（集成cron任务）

#!/usr/bin/env python3
"""
自动化定时加密备份脚本
配合 cron/scheduler 使用
"""
import os
import sys
import json
import logging
import schedule
import time
from datetime import datetime
from pathlib import Path
from encrypt_backup import EncryptedArchive
class AutoBackup:
    def __init__(self, config_path):
        self.config = self.load_config(config_path)
        self.setup_logging()
    def load_config(self, config_path):
        """加载配置文件"""
        with open(config_path, 'r') as f:
            return json.load(f)
    def setup_logging(self):
        """设置日志"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('backup.log'),
                logging.StreamHandler()
            ]
        )
    def cleanup_old_backups(self):
        """清理旧备份"""
        max_backups = self.config.get('max_backups', 30)
        dest = Path(self.config['dest'])
        backups = sorted(dest.glob('*'))
        if len(backups) > max_backups:
            for old in backups[:-max_backups]:
                old.unlink()
                logging.info(f"删除旧备份: {old}")
    def run_backup(self, profile=None):
        """执行备份"""
        profiles = self.config['profiles']
        if profile:
            profiles = [p for p in profiles if p['name'] == profile]
        for prof in profiles:
            try:
                logging.info(f"开始备份: {prof['name']}")
                archive = EncryptedArchive(
                    source=prof['source'],
                    dest=self.config['dest'],
                    password=self.config['password'],
                    format_type=self.config.get('format', '7z')
                )
                result = archive.run()
                if result:
                    logging.info(f"备份成功: {result}")
                # 清理旧备份
                self.cleanup_old_backups()
            except Exception as e:
                logging.error(f"备份失败 {prof['name']}: {e}")
    def schedule_backups(self):
        """设置定时任务"""
        schedule = self.config.get('schedule', {})
        if schedule.get('daily', False):
            at_time = schedule.get('daily_time', '02:00')
            schedule.every().day.at(at_time).do(self.run_backup)
            logging.info(f"已设置每日 {at_time} 备份")
        if schedule.get('weekly', False):
            day = schedule.get('weekly_day', 'monday')
            at_time = schedule.get('weekly_time', '03:00')
            getattr(schedule.every(), day).at(at_time).do(self.run_backup)
            logging.info(f"已设置每周{day} {at_time} 备份")
    def run(self):
        """主循环"""
        # 立即执行一次
        self.run_backup()
        # 设置定时任务
        self.schedule_backups()
        logging.info("备份服务已启动")
        # 持续运行
        while True:
            schedule.run_pending()
            time.sleep(60)
if __name__ == "__main__":
    if len(sys.argv) > 1:
        backup = AutoBackup(sys.argv[1])
        backup.run()
    else:
        print("用法: python auto_backup.py config.json")

配置文件 config.json 示例：

{
    "password": "YourStrongPassword123!",
    "dest": "D:/backups",
    "format": "7z",
    "max_backups": 30,
    "schedule": {
        "daily": true,
        "daily_time": "02:00",
        "weekly": false
    },
    "profiles": [
        {
            "name": "documents",
            "source": "D:/Documents"
        },
        {
            "name": "photos",
            "source": "D:/Photos"
        }
    ]
}

使用建议

选择加密方式：
- 7z: 压缩率好，支持AES-256加密
- ZIP: 兼容性好，Windows原生支持
- tar.gz+openssl: Linux系统常用
密码安全管理：
- 使用环境变量存储密码
- 避免在脚本中硬编码密码
- 定期更换密码
测试验证：
- 首次使用前小范围测试
- 定期抽查备份能否正常解压
错误处理：
- 添加日志记录
- 失败时邮件/短信通知
- 保留足够的磁盘空间

根据你的需求,可以选择适合的实现方案，如果还有不明白的地方，可以告诉我你具体的使用场景，我可以给出更针对性的建议。