Linux Crypto(8)：hash以及sha256

Linux Crypto：hash

1 哈希算法基础

哈希算法（Hash Algorithm）将任意长度输入（消息）映射为固定长度输出（哈希值），具有以下特性：
1. 确定性：相同输入产生相同输出
2. 高效性：快速计算哈希值
3. 抗碰撞性：难以找到不同输入产生相同输出
4. 单向性：难以从哈希值反推原始输入

Linux内核支持的哈希算法包括：SHA-1、SHA-256、SHA-512、MD5等，广泛应用于文件校验、数字签名、安全启动等场景。

2 数据结构

struct crypto_shash表示同步哈希算法实例（单核操作）。

struct crypto_shash {
    struct crypto_tfm base;      // 基础转换对象
    unsigned int descsize;       // 描述符大小
};

struct shash_alg表示同步哈希算法实现。

struct shash_alg {
        int (*init)(struct shash_desc *desc);           // -- 同步初始化函数指针
        int (*update)(struct shash_desc *desc, const u8 *data,
                      unsigned int len);                // -- 同步数据更新函数指针
        int (*final)(struct shash_desc *desc, u8 *out); // -- 同步最终计算函数指针
        int (*finup)(struct shash_desc *desc, const u8 *data,
                     unsigned int len, u8 *out);        // -- 同步最后块处理+完成函数指针
        int (*digest)(struct shash_desc *desc, const u8 *data,
                      unsigned int len, u8 *out);       // -- 同步单次完整计算函数指针
        int (*export)(struct shash_desc *desc, void *out); // -- 同步状态导出函数指针
        int (*import)(struct shash_desc *desc, const void *in); // -- 同步状态导入函数指针
        int (*setkey)(struct crypto_shash *tfm, const u8 *key,
                      unsigned int keylen);             // -- 同步密钥设置函数指针
        int (*init_tfm)(struct crypto_shash *tfm);      // -- 同步算法实例初始化
        void (*exit_tfm)(struct crypto_shash *tfm);     // -- 同步算法实例清理
        int (*clone_tfm)(struct crypto_shash *dst, struct crypto_shash *src); // -- 同步实例克隆

        unsigned int descsize;                          // -- shash_desc上下文大小

        union {
                struct HASH_ALG_COMMON;                 // -- 旧版哈希通用属性
                struct hash_alg_common halg;            // -- 哈希算法通用属性
        };
};

struct shash_desc表示同步操作描述符。

struct shash_desc {
    struct crypto_shash *tfm;    // 关联的算法实例
    void *__ctx[] __aligned(8); // 算法私有上下文
};

struct crypto_ahash表示异步哈希算法实例（支持中断/DMA）。

struct crypto_ahash {
        int (*init)(struct ahash_request *req);          // -- 异步哈希初始化函数指针
        int (*update)(struct ahash_request *req);        // -- 异步数据更新函数指针
        int (*final)(struct ahash_request *req);         // -- 异步最终计算函数指针
        int (*finup)(struct ahash_request *req);         // -- 异步最后块处理+完成函数指针
        int (*digest)(struct ahash_request *req);        // -- 异步单次完整计算函数指针
        int (*export)(struct ahash_request *req, void *out); // -- 异步状态导出函数指针
        int (*import)(struct ahash_request *req, const void *in); // -- 异步状态导入函数指针
        int (*setkey)(struct crypto_ahash *tfm, const u8 *key,
                      unsigned int keylen);              // -- 异步密钥设置函数指针

        unsigned int statesize;                         // -- 算法状态大小（字节）
        unsigned int reqsize;                           // -- ahash_request上下文大小（字节）
        struct crypto_tfm base;                         // -- 基础加密变换对象
};

struct ahash_request表示异步操作请求。

struct ahash_request {
        struct crypto_async_request base;               // -- 基础异步请求结构

        unsigned int nbytes;                            // -- 待处理数据长度（字节）
        struct scatterlist *src;                        // -- 分散/聚集列表数据源
        u8 *result;                                     // -- 摘要输出缓冲区

        /* This field may only be used by the ahash API code. */
        void *priv;                                     // -- 私有数据（内部使用）

        void *__ctx[] CRYPTO_MINALIGN_ATTR;             // -- 算法私有上下文（内存对齐）
};

struct ahash_alg表示异步哈希算法实现。

struct ahash_alg {
        int (*init)(struct ahash_request *req);             // -- 初始化哈希上下文（设置初始状态）
        int (*update)(struct ahash_request *req);           // -- 更新哈希状态（处理新数据块）
        int (*final)(struct ahash_request *req);            // -- 完成哈希计算（填充+输出摘要）
        int (*finup)(struct ahash_request *req);            // -- 最后数据块处理+完成计算（update+final组合优化）
        int (*digest)(struct ahash_request *req);           // -- 单次完整哈希操作（init+update+final三合一）
        int (*export)(struct ahash_request *req, void *out); // -- 导出当前哈希中间状态（用于保存计算进度）
        int (*import)(struct ahash_request *req, const void *in); // -- 导入先前保存的状态（恢复计算进度）
        int (*setkey)(struct crypto_ahash *tfm, const u8 *key, unsigned int keylen); // -- 设置算法密钥（用于HMAC等带密钥算法）
        
        // 以下为算法实例生命周期管理函数
        int (*init_tfm)(struct crypto_ahash *tfm);          // -- 初始化算法实例（分配资源/硬件初始化）
        void (*exit_tfm)(struct crypto_ahash *tfm);         // -- 清理算法实例（释放资源/硬件关闭）
        int (*clone_tfm)(struct crypto_ahash *dst, struct crypto_ahash *src); // -- 克隆算法实例状态（用于创建相同配置的新实例）

        // 通用哈希算法属性
        struct hash_alg_common halg;                        // -- 包含算法名称/摘要大小/状态大小等通用属性
};

3 hash同步和异步API

shash同步API：

// 算法分配/释放
struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type, u32 mask);
void crypto_free_shash(struct crypto_shash *tfm);

// 描述符操作
struct shash_desc *crypto_shash_desc_ctx(struct shash_desc *desc); // 获取上下文
unsigned int crypto_shash_descsize(struct crypto_shash *tfm); // 描述符大小

// 哈希计算
int crypto_shash_init(struct shash_desc *desc);
int crypto_shash_update(struct shash_desc *desc, const u8 *data, unsigned int len);
int crypto_shash_final(struct shash_desc *desc, u8 *out);
int crypto_shash_finup(struct shash_desc *desc, const u8 *data, unsigned int len, u8 *out);
int crypto_shash_digest(struct shash_desc *desc, const u8 *data, unsigned int len, u8 *out);

// 状态管理
int crypto_shash_export(struct shash_desc *desc, void *out);
int crypto_shash_import(struct shash_desc *desc, const void *in);

// 工具函数
unsigned int crypto_shash_digestsize(struct crypto_shash *tfm);
unsigned int crypto_shash_alignmask(struct crypto_shash *tfm);

ahash异步API：

// 算法分配/释放
struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type, u32 mask);
void crypto_free_ahash(struct crypto_ahash *tfm);

// 请求管理
struct ahash_request *ahash_request_alloc(struct crypto_ahash *tfm, gfp_t gfp);
void ahash_request_free(struct ahash_request *req);
void ahash_request_set_callback(struct ahash_request *req, u32 flags,
                               crypto_completion_t compl, void *data);
void ahash_request_set_crypt(struct ahash_request *req, struct scatterlist *src,
                            u8 *result, unsigned int nbytes);

// 哈希计算
int crypto_ahash_init(struct ahash_request *req);
int crypto_ahash_update(struct ahash_request *req);
int crypto_ahash_final(struct ahash_request *req);
int crypto_ahash_finup(struct ahash_request *req);
int crypto_ahash_digest(struct ahash_request *req);

// 密钥管理
int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key, unsigned int keylen);

// 工具函数
unsigned int crypto_ahash_digestsize(struct crypto_ahash *tfm);
unsigned int crypto_ahash_reqsize(struct crypto_ahash *tfm);

4 hash算法sha256

sha256_generic_mod_init注册类sha256同步hash算法到Crypto核心框架。

sha256_generic_mod_init
    ->crypto_register_shashes--注册多个同步hash算法到Crypto核心框架。
　　　　->crypto_register_shash

sha256系列hash算法实例：

static struct shash_alg sha256_algs[2] = { {
        .digestsize     =       SHA256_DIGEST_SIZE,
        .init           =       sha256_base_init,
        .update         =       crypto_sha256_update,
        .final          =       crypto_sha256_final,
        .finup          =       crypto_sha256_finup,
        .descsize       =       sizeof(struct sha256_state),
        .base           =       {
                .cra_name       =       "sha256",
                .cra_driver_name=       "sha256-generic",
                .cra_priority   =       100,
                .cra_blocksize  =       SHA256_BLOCK_SIZE,
                .cra_module     =       THIS_MODULE,
        }
}, {
        .digestsize     =       SHA224_DIGEST_SIZE,
        .init           =       sha224_base_init,
        .update         =       crypto_sha256_update,
        .final          =       crypto_sha256_final,
        .finup          =       crypto_sha256_finup,
        .descsize       =       sizeof(struct sha256_state),
        .base           =       {
                .cra_name       =       "sha224",
                .cra_driver_name=       "sha224-generic",
                .cra_priority   =       100,
                .cra_blocksize  =       SHA224_BLOCK_SIZE,
                .cra_module     =       THIS_MODULE,
        }
} };