好问题！针对100GB以上的大型视频文件哈希计算，OpenSSL确实能实现中断后恢复的操作，但要注意：OpenSSL命令行工具本身不提供这个功能——你得用它的编程接口（比如C语言的EVP库）来实现。下面一步步拆解具体做法：

核心原理：哈希上下文的序列化与恢复 #

哈希算法（比如SHA-256、MD5）的计算过程依赖一个内部状态上下文，它记录了当前计算到哪一步的中间值。只要能把这个上下文序列化保存下来，之后再反序列化恢复，就能从中断的位置继续计算，完全不需要从头开始处理整个文件。

具体实现步骤（以C语言为例） #

1. 初始化哈希上下文并处理部分数据（模拟中断） #

首先用OpenSSL的EVP接口初始化目标哈希算法，分块读取文件内容更新哈希上下文；当需要暂停时，停止读取，转而保存上下文和当前文件的偏移量（这个偏移量是恢复的关键）。

#include <openssl/evp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#define CHUNK_SIZE 1024 * 1024 // 1MB分块，可根据内存情况调整

int main() {
    // 初始化哈希上下文（这里用SHA-256，可替换为其他算法）
    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
    if (!ctx) {
        fprintf(stderr, "Failed to create MD context\n");
        return 1;
    }
    if (EVP_DigestInit_ex(ctx, EVP_sha256(), NULL) != 1) {
        fprintf(stderr, "Failed to init digest\n");
        EVP_MD_CTX_free(ctx);
        return 1;
    }

    // 打开目标大文件
    FILE *fp = fopen("large_video.mp4", "rb");
    if (!fp) {
        perror("Failed to open file");
        EVP_MD_CTX_free(ctx);
        return 1;
    }

    // 分块处理文件，模拟中途中断（比如先处理100个1MB块）
    unsigned char buf[CHUNK_SIZE];
    size_t bytes_read;
    int chunks_processed = 0;
    while (chunks_processed < 100) {
        bytes_read = fread(buf, 1, CHUNK_SIZE, fp);
        if (bytes_read == 0) break;
        if (EVP_DigestUpdate(ctx, buf, bytes_read) != 1) {
            fprintf(stderr, "Failed to update digest\n");
            fclose(fp);
            EVP_MD_CTX_free(ctx);
            return 1;
        }
        chunks_processed++;
    }

    // 记录当前文件偏移量（恢复时要从这里继续读）
    off_t current_offset = ftello(fp);
    fclose(fp);

    // 序列化哈希上下文到二进制文件
    size_t ctx_len = i2d_EVP_MD_CTX(ctx, NULL);
    unsigned char *ctx_buf = malloc(ctx_len);
    if (!ctx_buf) {
        fprintf(stderr, "Out of memory\n");
        EVP_MD_CTX_free(ctx);
        return 1;
    }
    unsigned char *p = ctx_buf;
    i2d_EVP_MD_CTX(ctx, &p);

    FILE *ctx_fp = fopen("hash_state.bin", "wb");
    if (!ctx_fp) {
        perror("Failed to save hash state");
        free(ctx_buf);
        EVP_MD_CTX_free(ctx);
        return 1;
    }
    fwrite(ctx_buf, 1, ctx_len, ctx_fp);
    fclose(ctx_fp);
    free(ctx_buf);
    EVP_MD_CTX_free(ctx);

    // 保存文件偏移量到文本文件
    FILE *offset_fp = fopen("file_offset.txt", "w");
    if (!offset_fp) {
        perror("Failed to save file offset");
        return 1;
    }
    fprintf(offset_fp, "%lld", (long long)current_offset);
    fclose(offset_fp);

    printf("已暂停哈希计算，状态已保存\n");
    return 0;
}

2. 从保存的状态恢复哈希计算 #

当需要继续计算时，先读取保存的哈希上下文和文件偏移量，跳转到文件的对应位置，继续分块处理剩余内容，最终输出完整哈希值。

#include <openssl/evp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#define CHUNK_SIZE 1024 * 1024

int main() {
    // 读取保存的文件偏移量
    FILE *offset_fp = fopen("file_offset.txt", "r");
    if (!offset_fp) {
        perror("Failed to read file offset");
        return 1;
    }
    long long offset;
    fscanf(offset_fp, "%lld", &offset);
    fclose(offset_fp);

    // 反序列化哈希上下文
    FILE *ctx_fp = fopen("hash_state.bin", "rb");
    if (!ctx_fp) {
        perror("Failed to read hash state");
        return 1;
    }
    fseek(ctx_fp, 0, SEEK_END);
    size_t ctx_len = ftell(ctx_fp);
    fseek(ctx_fp, 0, SEEK_SET);
    unsigned char *ctx_buf = malloc(ctx_len);
    if (!ctx_buf) {
        fprintf(stderr, "Out of memory\n");
        fclose(ctx_fp);
        return 1;
    }
    fread(ctx_buf, 1, ctx_len, ctx_fp);
    fclose(ctx_fp);

    EVP_MD_CTX *ctx = d2i_EVP_MD_CTX(NULL, (const unsigned char **)&ctx_buf, ctx_len);
    if (!ctx) {
        fprintf(stderr, "Failed to restore MD context\n");
        free(ctx_buf);
        return 1;
    }
    free(ctx_buf);

    // 打开文件并跳转到中断位置
    FILE *fp = fopen("large_video.mp4", "rb");
    if (!fp) {
        perror("Failed to open file");
        EVP_MD_CTX_free(ctx);
        return 1;
    }
    if (fseeko(fp, offset, SEEK_SET) != 0) {
        perror("Failed to seek file");
        fclose(fp);
        EVP_MD_CTX_free(ctx);
        return 1;
    }

    // 继续处理剩余文件内容
    unsigned char buf[CHUNK_SIZE];
    size_t bytes_read;
    while ((bytes_read = fread(buf, 1, CHUNK_SIZE, fp)) > 0) {
        if (EVP_DigestUpdate(ctx, buf, bytes_read) != 1) {
            fprintf(stderr, "Failed to update digest\n");
            fclose(fp);
            EVP_MD_CTX_free(ctx);
            return 1;
        }
    }
    fclose(fp);

    // 计算并输出最终哈希值
    unsigned char hash[EVP_MAX_MD_SIZE];
    unsigned int hash_len;
    if (EVP_DigestFinal_ex(ctx, hash, &hash_len) != 1) {
        fprintf(stderr, "Failed to finalize digest\n");
        EVP_MD_CTX_free(ctx);
        return 1;
    }
    EVP_MD_CTX_free(ctx);

    printf("最终SHA-256哈希值：");
    for (int i = 0; i < hash_len; i++) {
        printf("%02x", hash[i]);
    }
    printf("\n");

    return 0;
}

关键注意事项 #

• 算法一致性：恢复时必须使用和中断时完全相同的哈希算法，否则上下文无法正确解析。
• 版本兼容性：OpenSSL的上下文序列化格式可能随版本变化，尽量用同一版本的OpenSSL编译和运行中断/恢复代码，避免版本不兼容导致状态失效。
• 文件完整性：恢复操作前必须确保原文件没有被修改，否则计算出的哈希值会和从头计算的结果不一致。
• 分块大小调整：分块大小可根据内存情况调整，1MB-10MB是比较平衡的选择，太小会增加IO次数，太大则占用过多内存。
• 错误处理：示例代码简化了部分错误处理逻辑，实际生产环境中一定要补充完整，避免意外崩溃导致状态丢失。

命令行替代方案？ #

如果不想写代码，目前OpenSSL命令行工具没有原生支持中断恢复的功能——因为命令行是封装好的黑盒，不会暴露哈希的内部上下文状态。所以必须通过编程接口才能实现需求。

内容的提问来源于stack exchange，提问作者Overlook Motel