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

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,你可以大大增强系统和数据的安全性。

相关推荐
戊本菌8 分钟前
进程(三)进程优先级:谁先上 CPU
linux·c语言·硬件架构
aningx1 小时前
Arch 系用 greetd 实现开机自动进 Plasma Wayland,注销自动回桌面
linux
张小姐的猫2 小时前
【基于 WebSocket 的多用户网页五子棋】—— 整合封装服务器模块设计实现2️⃣
服务器·websocket·网络协议
江无行者2 小时前
Linux 服务器 top 命令详解
linux
HMS工业网络2 小时前
工业远程访问的五项安全部署原则
运维·服务器·安全
吴建旭 智宅焕3 小时前
智能家居全国交付中执行端能力评估与分级调度架构设计:从注册数量到交付确定性的系统实现
运维·智能家居·devops
嵌入式 Linux手记4 小时前
一块内存,三种解释:union 的真实用法
linux·c语言·驱动开发·嵌入式
星恒随风4 小时前
MySQL 从零入门(九):事务管理详解——ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别
linux·服务器·数据库·笔记·mysql
草莓熊Lotso5 小时前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构
IT大白鼠5 小时前
eBPF 观测入门:用 bpftrace 给服务器装上“内核摄像头“
运维·服务器·ebpf