Linux命令-openssl（强大的安全套接字层密码库）

RisunJan2026-06-07 8:09

openssl 是 OpenSSL 工具集的命令行接口，用于处理 SSL/TLS 加密、证书管理、加密操作和网络测试。它是 Linux 系统中最常用的加密工具。

📦 基本语法

bash 复制代码 
openssl 命令 [选项] [参数]

🎯 主要功能模块

  1. 证书管理：生成、查看、转换证书
  2. 密钥操作：生成、管理 RSA/ECC 密钥
  3. 加密解密：对称/非对称加密
  4. 摘要生成：MD5、SHA 等哈希计算
  5. 网络测试：SSL/TLS 连接测试
  6. 随机数生成：生成加密随机数

💡 常用命令分类

1. 证书管理

bash 复制代码 
# 查看证书信息
openssl x509 -in 证书.crt -text -noout

# 查看证书请求（CSR）
openssl req -in 请求.csr -text -noout

# 查看私钥信息
openssl rsa -in 私钥.key -text -noout

# 证书格式转换
openssl x509 -in 证书.crt -out 证书.der -outform DER  # PEM转DER
openssl x509 -in 证书.der -inform DER -out 证书.pem   # DER转PEM

# 验证证书链
openssl verify -CAfile 根证书.crt 中间证书.crt 证书.crt

2. 密钥生成和管理

bash 复制代码 
# 生成 RSA 私钥（2048位）
openssl genrsa -out 私钥.key 2048

# 生成带密码的 RSA 私钥
openssl genrsa -aes256 -out 加密私钥.key 2048

# 从私钥提取公钥
openssl rsa -in 私钥.key -pubout -out 公钥.pub

# 生成 ECC 私钥（prime256v1曲线）
openssl ecparam -genkey -name prime256v1 -out ecc私钥.key

# 检查私钥
openssl rsa -in 私钥.key -check

# 移除私钥密码
openssl rsa -in 加密私钥.key -out 无密码私钥.key

3. 证书签名请求（CSR）

bash 复制代码 
# 生成 CSR（交互式）
openssl req -new -key 私钥.key -out 请求.csr

# 生成 CSR（非交互式）
openssl req -new -key 私钥.key -out 请求.csr \
  -subj "/C=CN/ST=Beijing/L=Beijing/O=公司/CN=域名.com"

# 使用配置文件生成 CSR
openssl req -new -key 私钥.key -out 请求.csr -config 配置.cnf

# 从现有证书生成 CSR
openssl x509 -x509toreq -in 证书.crt -out 请求.csr -signkey 私钥.key

4. 自签名证书

bash 复制代码 
# 生成自签名证书（有效期365天）
openssl req -x509 -newkey rsa:2048 -keyout 私钥.key -out 证书.crt -days 365

# 使用现有私钥生成自签名证书
openssl req -x509 -key 私钥.key -in 请求.csr -out 证书.crt -days 365

# 生成自签名证书（指定主题）
openssl req -x509 -newkey rsa:2048 -nodes -keyout 私钥.key \
  -out 证书.crt -days 365 \
  -subj "/C=CN/ST=Beijing/L=Beijing/O=公司/CN=域名.com"

5. 加密和解密

bash 复制代码 
# 对称加密（AES-256-CBC）
openssl enc -aes-256-cbc -salt -in 明文.txt -out 密文.enc

# 对称解密
openssl enc -aes-256-cbc -d -in 密文.enc -out 解密.txt

# 非对称加密（使用公钥）
openssl pkeyutl -encrypt -in 明文.txt -out 密文.enc -pubin -inkey 公钥.pub

# 非对称解密（使用私钥）
openssl pkeyutl -decrypt -in 密文.enc -out 解密.txt -inkey 私钥.key

# 大文件加密（使用对称加密，然后用非对称加密密钥）
# 生成随机对称密钥
openssl rand -base64 32 > 对称密钥.key
# 用对称密钥加密文件
openssl enc -aes-256-cbc -salt -in 大文件.txt -out 加密文件.enc -pass file:对称密钥.key
# 用公钥加密对称密钥
openssl pkeyutl -encrypt -in 对称密钥.key -out 加密密钥.enc -pubin -inkey 公钥.pub

6. 摘要和哈希

bash 复制代码 
# 计算 MD5 哈希（已不安全，仅用于兼容）
openssl md5 文件.txt

# 计算 SHA256 哈希
openssl sha256 文件.txt

# 计算 SHA512 哈希
openssl sha512 文件.txt

# 计算文件哈希并输出到文件
openssl dgst -sha256 -out 哈希值.txt 文件.txt

# 计算字符串哈希
echo -n "字符串" | openssl sha256

# HMAC 计算
openssl dgst -sha256 -hmac "密钥" 文件.txt

7. 网络测试和调试

bash 复制代码 
# 测试 SSL/TLS 连接
openssl s_client -connect 域名:443 -showcerts

# 测试 SMTP over SSL
openssl s_client -connect smtp.gmail.com:465 -quiet

# 测试 IMAP over SSL
openssl s_client -connect imap.gmail.com:993 -quiet

# 查看证书链
openssl s_client -connect 域名:443 -showcerts </dev/null 2>/dev/null | \
  openssl x509 -text -noout

# 测试特定 TLS 版本
openssl s_client -connect 域名:443 -tls1_2
openssl s_client -connect 域名:443 -tls1_3

8. 随机数生成

bash 复制代码 
# 生成随机密码（16字节，base64编码）
openssl rand -base64 16

# 生成随机密钥（32字节，十六进制）
openssl rand -hex 32

# 生成随机文件（1MB）
openssl rand -out 随机文件.bin 1048576

# 生成随机数用于密码盐
openssl rand -base64 8

⚡ 实际应用示例

示例 1：完整的 HTTPS 证书生成流程

bash 复制代码 
#!/bin/bash
# 完整的自签名证书生成脚本
# 适用于开发和测试环境

DOMAIN="example.com"
DAYS=365
OUTPUT_DIR="./ssl_certs"

echo "=== 生成 SSL/TLS 证书 ==="
echo "域名: $DOMAIN"
echo "有效期: $DAYS 天"
echo "输出目录: $OUTPUT_DIR"
echo ""

# 创建输出目录
mkdir -p "$OUTPUT_DIR"
cd "$OUTPUT_DIR" || exit

# 1. 生成私钥
echo "1. 生成 RSA 私钥 (2048位)..."
openssl genrsa -out "$DOMAIN.key" 2048
echo "✅ 私钥已生成: $DOMAIN.key"
echo ""

# 2. 生成证书签名请求 (CSR)
echo "2. 生成证书签名请求 (CSR)..."
cat > "$DOMAIN.cnf" << EOF
[req]
default_bits = 2048
prompt = no
default_md = sha256
distinguished_name = dn
req_extensions = req_ext

[dn]
C = CN
ST = Beijing
L = Beijing
O = Example Company
OU = IT Department
CN = $DOMAIN
emailAddress = admin@$DOMAIN

[req_ext]
subjectAltName = @alt_names

[alt_names]
DNS.1 = $DOMAIN
DNS.2 = www.$DOMAIN
DNS.3 = mail.$DOMAIN
IP.1 = 127.0.0.1
EOF

openssl req -new -key "$DOMAIN.key" -out "$DOMAIN.csr" -config "$DOMAIN.cnf"
echo "✅ CSR 已生成: $DOMAIN.csr"
echo ""

# 3. 生成自签名证书
echo "3. 生成自签名证书..."
cat > "$DOMAIN.ext" << EOF
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names

[alt_names]
DNS.1 = $DOMAIN
DNS.2 = www.$DOMAIN
DNS.3 = mail.$DOMAIN
IP.1 = 127.0.0.1
EOF

openssl x509 -req -in "$DOMAIN.csr" \
  -signkey "$DOMAIN.key" \
  -out "$DOMAIN.crt" \
  -days "$DAYS" \
  -sha256 \
  -extfile "$DOMAIN.ext"
echo "✅ 证书已生成: $DOMAIN.crt"
echo ""

# 4. 生成 PEM 格式文件（包含证书和私钥）
echo "4. 生成 PEM 文件（用于 Nginx/Apache）..."
cat "$DOMAIN.crt" "$DOMAIN.key" > "$DOMAIN.pem"
echo "✅ PEM 文件已生成: $DOMAIN.pem"
echo ""

# 5. 验证证书
echo "5. 验证证书信息..."
echo "证书详细信息:"
openssl x509 -in "$DOMAIN.crt" -text -noout | grep -E "Subject:|Issuer:|Not Before|Not After|DNS:|IP Address:"
echo ""

echo "证书指纹:"
openssl x509 -in "$DOMAIN.crt" -fingerprint -sha256 -noout
openssl x509 -in "$DOMAIN.crt" -fingerprint -sha1 -noout
echo ""

# 6. 生成 PKCS12 格式（用于 Windows/Java）
echo "6. 生成 PKCS12 格式..."
openssl pkcs12 -export \
  -out "$DOMAIN.p12" \
  -inkey "$DOMAIN.key" \
  -in "$DOMAIN.crt" \
  -passout pass:changeit
echo "✅ PKCS12 文件已生成: $DOMAIN.p12 (密码: changeit)"
echo ""

# 7. 清理临时文件
echo "7. 清理临时文件..."
rm -f "$DOMAIN.cnf" "$DOMAIN.ext"
echo "✅ 临时文件已清理"
echo ""

# 8. 生成使用说明
cat > README.txt << EOF
=== SSL 证书生成完成 ===

生成的文件:
1. $DOMAIN.key    - 私钥文件（保密！）
2. $DOMAIN.csr    - 证书签名请求（提交给 CA）
3. $DOMAIN.crt    - 自签名证书
4. $DOMAIN.pem    - PEM 格式（证书+私钥）
5. $DOMAIN.p12    - PKCS12 格式（密码: changeit）

Nginx 配置示例:
    ssl_certificate     $PWD/$DOMAIN.crt;
    ssl_certificate_key $PWD/$DOMAIN.key;

Apache 配置示例:
    SSLCertificateFile      $PWD/$DOMAIN.crt
    SSLCertificateKeyFile   $PWD/$DOMAIN.key

有效期: $DAYS 天
生成时间: $(date)
EOF

echo "=== 生成完成 ==="
echo "请查看 $OUTPUT_DIR/README.txt 获取使用说明"
ls -la

示例 2：证书检查和验证脚本

bash 复制代码 
#!/bin/bash
# SSL 证书检查工具

check_cert() {
    local host="$1"
    local port="${2:-443}"
    
    echo "=== 检查证书: $host:$port ==="
    echo ""
    
    # 获取证书信息
    echo "1. 证书基本信息:"
    echo "----------------------------------------"
    timeout 10 openssl s_client -connect "$host:$port" -servername "$host" 2>/dev/null </dev/null | \
        openssl x509 -noout -subject -issuer -dates
    echo ""
    
    # 获取证书有效期
    echo "2. 有效期信息:"
    echo "----------------------------------------"
    cert_info=$(timeout 10 openssl s_client -connect "$host:$port" -servername "$host" 2>/dev/null </dev/null | \
        openssl x509 -noout -dates)
    
    not_before=$(echo "$cert_info" | grep "notBefore" | cut -d= -f2)
    not_after=$(echo "$cert_info" | grep "notAfter" | cut -d= -f2)
    
    echo "生效时间: $not_before"
    echo "过期时间: $not_after"
    
    # 计算剩余天数
    now_epoch=$(date +%s)
    expire_epoch=$(date -d "$not_after" +%s 2>/dev/null || date -j -f "%b %d %T %Y %Z" "$not_after" +%s 2>/dev/null)
    
    if [[ -n "$expire_epoch" ]]; then
        days_left=$(( (expire_epoch - now_epoch) / 86400 ))
        echo "剩余天数: $days_left 天"
        
        if [[ $days_left -lt 0 ]]; then
            echo "❌ 证书已过期！"
        elif [[ $days_left -lt 7 ]]; then
            echo "⚠️  证书即将过期（7天内）！"
        elif [[ $days_left -lt 30 ]]; then
            echo "⚠️  证书即将过期（30天内）"
        else
            echo "✅ 证书有效期正常"
        fi
    fi
    echo ""
    
    # 检查证书链
    echo "3. 证书链验证:"
    echo "----------------------------------------"
    timeout 10 openssl s_client -connect "$host:$port" -servername "$host" -showcerts 2>/dev/null </dev/null | \
        grep -E "^ [0-9]+ s:" | tail -1
    echo ""
    
    # 检查支持的协议
    echo "4. 支持的 TLS 协议:"
    echo "----------------------------------------"
    for protocol in ssl2 ssl3 tls1 tls1_1 tls1_2 tls1_3; do
        if timeout 5 openssl s_client -connect "$host:$port" -servername "$host" -"$protocol" 2>/dev/null </dev/null | \
           grep -q "CONNECTED"; then
            echo "✅ $protocol: 支持"
        else
            echo "❌ $protocol: 不支持"
        fi
    done
    echo ""
    
    # 检查证书指纹
    echo "5. 证书指纹:"
    echo "----------------------------------------"
    timeout 10 openssl s_client -connect "$host:$port" -servername "$host" 2>/dev/null </dev/null | \
        openssl x509 -fingerprint -sha256 -noout
    timeout 10 openssl s_client -connect "$host:$port" -servername "$host" 2>/dev/null </dev/null | \
        openssl x509 -fingerprint -sha1 -noout
    echo ""
    
    # 检查证书透明度
    echo "6. 证书透明度 (CT):"
    echo "----------------------------------------"
    timeout 10 openssl s_client -connect "$host:$port" -servername "$host" 2>/dev/null </dev/null | \
        openssl x509 -text -noout | grep -i "ct" || echo "未找到 CT 信息"
    echo ""
    
    # 检查 OCSP Stapling
    echo "7. OCSP Stapling:"
    echo "----------------------------------------"
    if timeout 10 openssl s_client -connect "$host:$port" -servername "$host" -status 2>/dev/null </dev/null | \
       grep -q "OCSP Response"; then
        echo "✅ 支持 OCSP Stapling"
    else
        echo "❌ 不支持 OCSP Stapling"
    fi
    echo ""
}

# 批量检查证书
batch_check() {
    local input_file="$1"
    
    if [[ ! -f "$input_file" ]]; then
        echo "用法: $0 batch <域名列表文件>"
        echo "文件格式: 每行一个域名，可选端口（默认443）"
        echo "示例:"
        echo "  example.com"
        echo "  example.com:8443"
        exit 1
    fi
    
    echo "=== 批量证书检查 ==="
    echo "开始时间: $(date)"
    echo ""
    
    while IFS= read -r line || [[ -n "$line" ]]; do
        # 跳过空行和注释
        [[ -z "$line" ]] && continue
        [[ "$line" =~ ^# ]] && continue
        
        # 解析域名和端口
        host=$(echo "$line" | cut -d: -f1)
        port=$(echo "$line" | cut -d: -f2)
        port=${port:-443}
        
        echo "检查: $host:$port"
        echo "----------------------------------------"
        
        # 调用检查函数
        check_cert "$host" "$port"
        
        echo "========================================"
        echo ""
        
        # 避免请求过快
        sleep 1
    done < "$input_file"
    
    echo "检查完成: $(date)"
}

# 主程序
if [[ "$1" == "batch" ]]; then
    batch_check "$2"
elif [[ -n "$1" ]]; then
    host=$(echo "$1" | cut -d: -f1)
    port=$(echo "$1" | cut -d: -f2)
    port=${port:-443}
    check_cert "$host" "$port"
else
    echo "SSL 证书检查工具"
    echo ""
    echo "用法:"
    echo "  $0 <域名>[:端口]         检查单个证书"
    echo "  $0 batch <文件>          批量检查证书"
    echo ""
    echo "示例:"
    echo "  $0 example.com"
    echo "  $0 example.com:8443"
    echo "  $0 batch domains.txt"
    echo ""
    echo "域名列表文件格式:"
    echo "  # 注释"
    echo "  example.com"
    echo "  example.com:8443"
    echo "  google.com"
fi

示例 3：文件加密和解密工具

bash 复制代码 
#!/bin/bash
# 文件加密解密工具

encrypt_file() {
    local input_file="$1"
    local output_file="$2"
    local algorithm="${3:-aes-256-cbc}"
    
    if [[ ! -f "$input_file" ]]; then
        echo "错误: 输入文件不存在: $input_file"
        return 1
    fi
    
    echo "加密文件: $input_file"
    echo "算法: $algorithm"
    echo ""
    
    # 读取密码（不显示）
    read -sp "输入加密密码: " password
    echo
    read -sp "确认加密密码: " password_confirm
    echo
    
    if [[ "$password" != "$password_confirm" ]]; then
        echo "错误: 密码不匹配"
        return 1
    fi
    
    # 加密文件
    echo "$password" | openssl enc -"$algorithm" -salt -pbkdf2 \
        -in "$input_file" -out "$output_file" -pass stdin
    
    if [[ $? -eq 0 ]]; then
        echo "✅ 加密完成: $output_file"
        
        # 计算哈希值
        echo ""
        echo "文件哈希值:"
        echo "MD5:    $(openssl md5 "$output_file" | awk '{print $2}')"
        echo "SHA256: $(openssl sha256 "$output_file" | awk '{print $2}')"
    else
        echo "❌ 加密失败"
        return 1
    fi
}

decrypt_file() {
    local input_file="$1"
    local output_file="$2"
    
    if [[ ! -f "$input_file" ]]; then
        echo "错误: 输入文件不存在: $input_file"
        return 1
    fi
    
    echo "解密文件: $input_file"
    echo ""
    
    # 尝试自动检测算法
    file_header=$(head -c 8 "$input_file" 2>/dev/null | xxd -p)
    echo "文件头部: $file_header"
    
    # 常见加密算法标识
    case "$file_header" in
        "53616c7465645f5f")
            algorithm="aes-256-cbc"
            echo "检测到算法: AES-256-CBC"
            ;;
        *)
            echo "无法自动检测算法，请手动选择:"
            echo "1) aes-256-cbc (默认)"
            echo "2) aes-192-cbc"
            echo "3) aes-128-cbc"
            echo "4) des3"
            echo "5) bf (Blowfish)"
            read -p "选择算法 [1-5]: " algo_choice
            
            case "$algo_choice" in
                2) algorithm="aes-192-cbc" ;;
                3) algorithm="aes-128-cbc" ;;
                4) algorithm="des3" ;;
                5) algorithm="bf" ;;
                *) algorithm="aes-256-cbc" ;;
            esac
            ;;
    esac
    
    echo "使用算法: $algorithm"
    echo ""
    
    # 读取密码
    read -sp "输入解密密码: " password
    echo
    
    # 解密文件
    echo "$password" | openssl enc -"$algorithm" -d -pbkdf2 \
        -in "$input_file" -out "$output_file" -pass stdin 2>/dev/null
    
    if [[ $? -eq 0 ]] && [[ -f "$output_file" ]]; then
        echo "✅ 解密完成: $output_file"
        
        # 验证解密结果
        echo ""
        echo "解密文件信息:"
        file_type=$(file -b "$output_file")
        echo "文件类型: $file_type"
        echo "文件大小: $(stat -c%s "$output_file") 字节"
    else
        echo "❌ 解密失败: 密码错误或文件损坏"
        rm -f "$output_file" 2>/dev/null
        return 1
    fi
}

encrypt_asymmetric() {
    local input_file="$1"
    local public_key="$2"
    local output_file="$3"
    
    if [[ ! -f "$input_file" ]]; then
        echo "错误: 输入文件不存在: $input_file"
        return 1
    fi
    
    if [[ ! -f "$public_key" ]]; then
        echo "错误: 公钥文件不存在: $public_key"
        return 1
    fi
    
    echo "非对称加密文件: $input_file"
    echo "使用公钥: $public_key"
    echo ""
    
    # 生成随机对称密钥
    echo "生成随机对称密钥..."
    symmetric_key=$(openssl rand -base64 32)
    symmetric_key_file="/tmp/symmetric_key.$$.tmp"
    echo "$symmetric_key" > "$symmetric_key_file"
    
    # 用对称密钥加密文件
    echo "使用对称密钥加密文件..."
    encrypted_data_file="/tmp/encrypted_data.$$.tmp"
    echo "$symmetric_key" | openssl enc -aes-256-cbc -salt -pbkdf2 \
        -in "$input_file" -out "$encrypted_data_file" -pass stdin
    
    # 用公钥加密对称密钥
    echo "使用公钥加密对称密钥..."
    encrypted_key_file="/tmp/encrypted_key.$$.tmp"
    echo "$symmetric_key" | openssl pkeyutl -encrypt \
        -pubin -inkey "$public_key" \
        -out "$encrypted_key_file"
    
    # 合并文件
    echo "创建最终加密文件..."
    {
        # 头部：加密的对称密钥长度（4字节）
        key_size=$(stat -c%s "$encrypted_key_file")
        printf "%.4d" "$key_size"
        # 加密的对称密钥
        cat "$encrypted_key_file"
        # 加密的数据
        cat "$encrypted_data_file"
    } > "$output_file"
    
    # 清理临时文件
    rm -f "$symmetric_key_file" "$encrypted_key_file" "$encrypted_data_file"
    
    echo "✅ 非对称加密完成: $output_file"
    echo "文件大小: $(stat -c%s "$output_file") 字节"
}

decrypt_asymmetric() {
    local input_file="$1"
    local private_key="$2"
    local output_file="$3"
    
    if [[ ! -f "$input_file" ]]; then
        echo "错误: 输入文件不存在: $input_file"
        return 1
    fi
    
    if [[ ! -f "$private_key" ]]; then
        echo "错误: 私钥文件不存在: $private_key"
        return 1
    fi
    
    echo "非对称解密文件: $input_file"
    echo "使用私钥: $private_key"
    echo ""
    
    # 读取密钥长度
    key_size=$(head -c 4 "$input_file" | tr -d '\0')
    
    if [[ -z "$key_size" ]] || [[ ! "$key_size" =~ ^[0-9]+$ ]]; then
        echo "错误: 无效的加密文件格式"
        return 1
    fi
    
    echo "加密密钥长度: $key_size 字节"
    
    # 提取加密的对称密钥
    encrypted_key_file="/tmp/encrypted_key.$$.tmp"
    head -c $((4 + key_size)) "$input_file" | tail -c "$key_size" > "$encrypted_key_file"
    
    # 提取加密的数据
    encrypted_data_file="/tmp/encrypted_data.$$.tmp"
    tail -c +$((5 + key_size)) "$input_file" > "$encrypted_data_file"
    
    # 用私钥解密对称密钥
    echo "解密对称密钥..."
    symmetric_key_file="/tmp/symmetric_key.$$.tmp"
    openssl pkeyutl -decrypt \
        -inkey "$private_key" \
        -in "$encrypted_key_file" \
        -out "$symmetric_key_file" 2>/dev/null
    
    if [[ $? -ne 0 ]] || [[ ! -s "$symmetric_key_file" ]]; then
        echo "错误: 解密对称密钥失败（私钥可能不匹配）"
        rm -f "$encrypted_key_file" "$encrypted_data_file" "$symmetric_key_file"
        return 1
    fi
    
    symmetric_key=$(cat "$symmetric_key_file")
    
    # 用对称密钥解密数据
    echo "解密数据..."
    echo "$symmetric_key" | openssl enc -aes-256-cbc -d -pbkdf2 \
        -in "$encrypted_data_file" -out "$output_file" -pass stdin
    
    # 清理临时文件
    rm -f "$encrypted_key_file" "$encrypted_data_file" "$symmetric_key_file"
    
    if [[ $? -eq 0 ]] && [[ -f "$output_file" ]]; then
        echo "✅ 非对称解密完成: $output_file"
        echo "文件大小: $(stat -c%s "$output_file") 字节"
    else
        echo "❌ 解密失败"
        rm -f "$output_file"
        return 1
    fi
}

# 主程序
case "$1" in
    encrypt)
        if [[ $# -lt 3 ]]; then
            echo "用法: $0 encrypt <输入文件> <输出文件> [算法]"
            echo "算法: aes-256-cbc (默认), aes-192-cbc, aes-128-cbc, des3, bf"
            exit 1
        fi
        encrypt_file "$2" "$3" "$4"
        ;;
    
    decrypt)
        if [[ $# -lt 3 ]]; then
            echo "用法: $0 decrypt <输入文件> <输出文件>"
            exit 1
        fi
        decrypt_file "$2" "$3"
        ;;
    
    encrypt-rsa)
        if [[ $# -lt 4 ]]; then
            echo "用法: $0 encrypt-rsa <输入文件> <公钥文件> <输出文件>"
            exit 1
        fi
        encrypt_asymmetric "$2" "$3" "$4"
        ;;
    
    decrypt-rsa)
        if [[ $# -lt 4 ]]; then
            echo "用法: $0 decrypt-rsa <输入文件> <私钥文件> <输出文件>"
            exit 1
        fi
        decrypt_asymmetric "$2" "$3" "$4"
        ;;
    
    genkey)
        echo "生成 RSA 密钥对..."
        openssl genrsa -out private.key 2048
        openssl rsa -in private.key -pubout -out public.key
        echo "✅ 密钥对已生成:"
        echo "   私钥: private.key (保密！)"
        echo "   公钥: public.key"
        ;;
    
    hash)
        if [[ $# -lt 2 ]]; then
            echo "用法: $0 hash <文件>"
            exit 1
        fi
        echo "文件哈希值:"
        echo "MD5:    $(openssl md5 "$2" | awk '{print $2}')"
        echo "SHA1:   $(openssl sha1 "$2" | awk '{print $2}')"
        echo "SHA256: $(openssl sha256 "$2" | awk '{print $2}')"
        echo "SHA512: $(openssl sha512 "$2" | awk '{print $2}')"
        ;;
    
    *)
        echo "文件加密解密工具"
        echo ""
        echo "用法:"
        echo "  $0 encrypt <输入文件> <输出文件> [算法]   对称加密"
        echo "  $0 decrypt <输入文件> <输出文件>         对称解密"
        echo "  $0 encrypt-rsa <输入文件> <公钥> <输出>  非对称加密"
        echo "  $0 decrypt-rsa <输入文件> <私钥> <输出>  非对称解密"
        echo "  $0 genkey                               生成RSA密钥对"
        echo "  $0 hash <文件>                         计算文件哈希"
        echo ""
        echo "示例:"
        echo "  $0 encrypt secret.txt secret.enc aes-256-cbc"
        echo "  $0 decrypt secret.enc secret.dec"
        echo "  $0 encrypt-rsa data.txt public.key data.enc"
        echo "  $0 decrypt-rsa data.enc private.key data.dec"
        echo "  $0 hash document.pdf"
        ;;
esac

📦 总结

OpenSSL是一个功能极其强大的工具，涵盖了加密、解密、证书管理、数字签名、SSL/TLS测试等多个方面。通过掌握这些常用命令和脚本，你可以：

管理SSL/TLS证书：生成、转换、验证证书

保护数据安全：加密敏感文件，确保数据机密性

验证身份：通过数字签名确认数据来源

测试网络安全：检查SSL/TLS配置的安全性

性能优化：测试加密算法的性能表现

重要提示：

在生产环境中使用加密时，请确保遵循最佳安全实践

定期更新OpenSSL版本，以修复安全漏洞

备份所有密钥和证书

使用强密码和足够长的密钥长度

考虑使用硬件安全模块（HSM）保护顶级密钥

通过合理使用OpenSSL，你可以大大增强系统和数据的安全性。

相关推荐
●VON3 小时前
AtomGit Flutter鸿蒙客户端：文件树与代码浏览
android·服务器·安全·flutter·harmonyos·鸿蒙
bush49 小时前
嵌入式linux学习记录七，中断
linux·嵌入式
RisunJan10 小时前
Linux命令-nologin（用于系统账户或需要禁止交互式登录的场景）
linux·运维
是阿建吖!10 小时前
【Linux】信号
android·linux·c语言·c++
城北徐宫10 小时前
Linux信号深度解剖：5种产生、3张表、4次切换
linux·c++·学习
倔强的石头10610 小时前
【Linux指南】Linux快捷键与系统实用技巧
linux·运维·服务器
番茄地瓜10 小时前
Linux 配置静态 IP 步骤
linux·运维·服务器
liulilittle10 小时前
论 Linux 内核态全局稳态带宽的卡尔曼估计与工程实现
linux·服务器·网络·c++·计算机网络·tcp·通信
Irissgwe11 小时前
五、应用层协议HTTP
linux·网络·网络协议·http·状态码·url
热门推荐
01GitHub 镜像站点022026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf03【AI】2026 年具身智能模型和世界模型总结04Codex 下载安装指南：Windows 和 macOS 官方版下载05Codex 桌面端更新后 Chrome 插件和 Computer Use 不可用，怎么排查和修复06CC-Switch 下载、安装与使用配置指南【2026.5.29】07【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法08CC-Switch & Claude 基于 Linux 服务器安装使用指南09Codex 接入 DeepSeek API 完整配置文档10裂开！ChatGPT 居然开始要手机号验证，附详细解决方法