linux内核实现了crypto接口，用于类似IPSec之类要在内核中实现的与操作系统绑定的安全机制，如果不是用于这样的机制，不要使用内核中的crypto接口，总的来说，linux的crypto中最重要的结构体有两个：crypto_tfm和crypto_alg
struct crypto_tfm {
u32 crt_flags;
union {
struct cipher_tfm cipher;
struct digest_tfm digest;
struct compress_tfm compress;
} crt_u; //该联合体指出linux实现了cipher，digest和compress三类算法，每一类中有许多种算法，注意这个联合的每一个都仅仅实现了一大类算法的实现封装，并不是具体的实现。
struct crypto_alg *__crt_alg;
char __crt_ctx[] __attribute__ ((__aligned__));
};
下面这个结构体才是具体算法的实现，上面crypto_tfm中的crt_u中一系列函数都是对下面结构体中cra_u中一系列函数的封装：
struct crypto_alg {
struct list_head cra_list;
u32 cra_flags; //这个flags很重要
unsigned int cra_blocksize;
unsigned int cra_ctxsize;
unsigned int cra_alignmask;
int cra_priority;
char cra_name[CRYPTO_MAX_ALG_NAME];
char cra_driver_name[CRYPTO_MAX_ALG_NAME];
union {
struct cipher_alg cipher;
struct digest_alg digest;
struct compress_alg compress;
} cra_u;
int (*cra_init)(struct crypto_tfm *tfm);
void (*cra_exit)(struct crypto_tfm *tfm);
struct module *cra_module;
};
上面的两个结构中都有一个联合体，事实上每个联合体字段都是一个完整的算法实现，而且三个算法类型几乎没有任何共同点可言，对于摘要类算法来说，回调函数是init，update，final等，而对于cipher而言，就是encrypt和decrypt等，linux实际上是利用联合体的性质来将三类算法封装到了一个结构体中。
crt_u里面的回调函数和cra_u中的回调函数名称几乎一模一样，但是它们的层次不同，crt中的函数实现了一大类算法的运行逻辑，比如cipher中的des中的块应该怎么分割等等，虽然对于摘要算法，sha1或者别的什么的算法逻辑没有什么区别，但是对于cipher来讲就不是这样了，同一种算法可能拥有ecb，cbc，fcb等不同的模式，于是就来了个中间层，这个中间层就是上面的联合体crt_u。
最后，linux将所有的三大类算法组织成了并列的链表，在注册算法的时候要通过crypto_register_alg将一个crypto_alg结构体注册进内核，就是说摘要和加密算法不做区别，只有在crypto_alloc_tfm的时候才会根据算法的名称和flags来确定这个算法到底是做什么的，判断的依据就是crypto_alg中的cra_name字段和cra_flags字段。
从上述结构体和代码可以看出，linux对加crypto的算法的组织要远比openssl的简单，这也许是linux内核运行效率决定的吧。下面看一下重要的crypto_alloc_tfm函数，很多工作都在这个函数里面完成，比如初始化函数的执行逻辑，也就是初始化crt_u的一堆函数指针，顺便说一下，如果你把crypto_alg理解成一个静态的结构的话，那么crypto_tfm就是一个动态的容器，这种动静结合的方式在优秀的开源代码中很常见，都是用静态的结构初始化动态的结构，然后再根据一些策略逻辑完成动态结构的初始化，有时候动态结构就是一个用于解除耦合的桥梁，比如一些过程的controler，有的时候它就是一个上下文环境或者说是一个容器，比如命名为xxx_ctx的结构体，对于linux内核的cryptoAPI，crypto_tfm可以说是一个桥梁，也可以说是一个容器，一个controler，具体是什么不重要，重要的是代码灵活了：
struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
{
struct crypto_tfm *tfm = NULL;
struct crypto_alg *alg;
unsigned int tfm_size;
alg = crypto_alg_mod_lookup(name);//根据名称来查找算法实现
tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, flags);
tfm = kzalloc(tfm_size, GFP_KERNEL);
tfm->__crt_alg = alg;
crypto_init_flags(tfm, flags);
crypto_init_ops(tfm);
alg->cra_init(tfm);
...
return tfm;
}
crypto_init_ops函数完成了具体实现的封装，也就是说它初始化了crypto_tfm结构体中crt_u中的一系列函数指针：
static int crypto_init_ops(struct crypto_tfm *tfm)
{
switch (crypto_tfm_alg_type(tfm)) {
case CRYPTO_ALG_TYPE_CIPHER:
return crypto_init_cipher_ops(tfm);//初始化cipher封装函数，下面例子中以digest来说明，它在这里的调用逻辑和cipher原理是一样的，都是在crypto_init_ops实现具体实现的封装过程。
...
}
下面是使用linux内核中cryptoAPI实现的digest的一个例子的大致过程，流程和openssl的evp系列是差不多的，只是在涉及算法实现的点上有差异：
char *Kern_Digest(const void *data, size_t count,
unsigned char *md, unsigned int *size, const char *name)
{
struct crypto_tfm *tfm;
struct scatterlist sg[1];
tfm = crypto_alloc_tfm(name, 0);
sg_init_one(sg, data, count); //此往下，摘要算法的实现已经确定了，接下来只剩下回调函数的调用了
crypto_digest_init(tfm);
crypto_digest_update(tfm, sg, 1);
crypto_digest_final(tfm, md);
if (size != NULL)
*size = tfm->cra_digest.dia_digestsize;
crypto_free_tfm(tfm);
}
crypto_digest_xxx系列函数仅仅是具体实现的封装，以init为例：
static inline void crypto_digest_init(struct crypto_tfm *tfm)
{
tfm->crt_digest.dit_init(tfm);//dit_init依然是一个封装，它在crypto_init_ops中被初始化，这个dit_YYY系列的封装才是有意义的封装。
}
这种封装解除了调用者和实现者之间的耦合。下面是openssl中的digest的实现过程：
int EVP_Digest(const void *data, size_t count,
unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl)
{ //传入的type参数其实只是一个空壳，仅仅包含了nid字段是有效的，对于EVP_MD来说就是type字段，因为别的字段具体是什么还要看engine的实现，所以此处的参数type可以仅仅理解成一个算法id。
EVP_MD_CTX ctx;
EVP_MD_CTX_init(&ctx);
M_EVP_MD_CTX_set_flags(&ctx,EVP_MD_CTX_FLAG_ONESHOT);
ret=EVP_DigestInit_ex(&ctx, type, impl)
&& EVP_DigestUpdate(&ctx, data, count)
&& EVP_DigestFinal_ex(&ctx, md, size);
EVP_MD_CTX_cleanup(&ctx);
...
}
在对外呈现的接口上，openssl和linux是一致的，openssl需要一个算法的id，而linux需要一个算法的名称，所不同的是，openssl有engine的支持，这样同一个算法就可以指定不同的实现，engine作为算法名称或者id和算法实现之间的桥梁存在，解除了它们之间的耦合。而linux由于没有engine，那么只要给定了一个算法名称，比如sha1，那么只能得到唯一的实现，虽然内核可能通过增加优先级字段来影响算法实现的被选中率，但是这种做法远没有openssl的engine灵活，但是反过来想一下，内核中的机制都是比较稳定的，不经常变动的，而且linux本身就不提倡你在内核完成一些功能，除非万不得已，因此linux的crypto的设计也算是圆满了。
struct crypto_tfm {
u32 crt_flags;
union {
struct cipher_tfm cipher;
struct digest_tfm digest;
struct compress_tfm compress;
} crt_u; //该联合体指出linux实现了cipher，digest和compress三类算法，每一类中有许多种算法，注意这个联合的每一个都仅仅实现了一大类算法的实现封装，并不是具体的实现。
struct crypto_alg *__crt_alg;
char __crt_ctx[] __attribute__ ((__aligned__));
};
下面这个结构体才是具体算法的实现，上面crypto_tfm中的crt_u中一系列函数都是对下面结构体中cra_u中一系列函数的封装：
struct crypto_alg {
struct list_head cra_list;
u32 cra_flags; //这个flags很重要
unsigned int cra_blocksize;
unsigned int cra_ctxsize;
unsigned int cra_alignmask;
int cra_priority;
char cra_name[CRYPTO_MAX_ALG_NAME];
char cra_driver_name[CRYPTO_MAX_ALG_NAME];
union {
struct cipher_alg cipher;
struct digest_alg digest;
struct compress_alg compress;
} cra_u;
int (*cra_init)(struct crypto_tfm *tfm);
void (*cra_exit)(struct crypto_tfm *tfm);
struct module *cra_module;
};
上面的两个结构中都有一个联合体，事实上每个联合体字段都是一个完整的算法实现，而且三个算法类型几乎没有任何共同点可言，对于摘要类算法来说，回调函数是init，update，final等，而对于cipher而言，就是encrypt和decrypt等，linux实际上是利用联合体的性质来将三类算法封装到了一个结构体中。
crt_u里面的回调函数和cra_u中的回调函数名称几乎一模一样，但是它们的层次不同，crt中的函数实现了一大类算法的运行逻辑，比如cipher中的des中的块应该怎么分割等等，虽然对于摘要算法，sha1或者别的什么的算法逻辑没有什么区别，但是对于cipher来讲就不是这样了，同一种算法可能拥有ecb，cbc，fcb等不同的模式，于是就来了个中间层，这个中间层就是上面的联合体crt_u。
最后，linux将所有的三大类算法组织成了并列的链表，在注册算法的时候要通过crypto_register_alg将一个crypto_alg结构体注册进内核，就是说摘要和加密算法不做区别，只有在crypto_alloc_tfm的时候才会根据算法的名称和flags来确定这个算法到底是做什么的，判断的依据就是crypto_alg中的cra_name字段和cra_flags字段。
从上述结构体和代码可以看出，linux对加crypto的算法的组织要远比openssl的简单，这也许是linux内核运行效率决定的吧。下面看一下重要的crypto_alloc_tfm函数，很多工作都在这个函数里面完成，比如初始化函数的执行逻辑，也就是初始化crt_u的一堆函数指针，顺便说一下，如果你把crypto_alg理解成一个静态的结构的话，那么crypto_tfm就是一个动态的容器，这种动静结合的方式在优秀的开源代码中很常见，都是用静态的结构初始化动态的结构，然后再根据一些策略逻辑完成动态结构的初始化，有时候动态结构就是一个用于解除耦合的桥梁，比如一些过程的controler，有的时候它就是一个上下文环境或者说是一个容器，比如命名为xxx_ctx的结构体，对于linux内核的cryptoAPI，crypto_tfm可以说是一个桥梁，也可以说是一个容器，一个controler，具体是什么不重要，重要的是代码灵活了：
struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags)
{
struct crypto_tfm *tfm = NULL;
struct crypto_alg *alg;
unsigned int tfm_size;
alg = crypto_alg_mod_lookup(name);//根据名称来查找算法实现
tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, flags);
tfm = kzalloc(tfm_size, GFP_KERNEL);
tfm->__crt_alg = alg;
crypto_init_flags(tfm, flags);
crypto_init_ops(tfm);
alg->cra_init(tfm);
...
return tfm;
}
crypto_init_ops函数完成了具体实现的封装，也就是说它初始化了crypto_tfm结构体中crt_u中的一系列函数指针：
static int crypto_init_ops(struct crypto_tfm *tfm)
{
switch (crypto_tfm_alg_type(tfm)) {
case CRYPTO_ALG_TYPE_CIPHER:
return crypto_init_cipher_ops(tfm);//初始化cipher封装函数，下面例子中以digest来说明，它在这里的调用逻辑和cipher原理是一样的，都是在crypto_init_ops实现具体实现的封装过程。
...
}
下面是使用linux内核中cryptoAPI实现的digest的一个例子的大致过程，流程和openssl的evp系列是差不多的，只是在涉及算法实现的点上有差异：
char *Kern_Digest(const void *data, size_t count,
unsigned char *md, unsigned int *size, const char *name)
{
struct crypto_tfm *tfm;
struct scatterlist sg[1];
tfm = crypto_alloc_tfm(name, 0);
sg_init_one(sg, data, count); //此往下，摘要算法的实现已经确定了，接下来只剩下回调函数的调用了
crypto_digest_init(tfm);
crypto_digest_update(tfm, sg, 1);
crypto_digest_final(tfm, md);
if (size != NULL)
*size = tfm->cra_digest.dia_digestsize;
crypto_free_tfm(tfm);
}
crypto_digest_xxx系列函数仅仅是具体实现的封装，以init为例：
static inline void crypto_digest_init(struct crypto_tfm *tfm)
{
tfm->crt_digest.dit_init(tfm);//dit_init依然是一个封装，它在crypto_init_ops中被初始化，这个dit_YYY系列的封装才是有意义的封装。
}
这种封装解除了调用者和实现者之间的耦合。下面是openssl中的digest的实现过程：
int EVP_Digest(const void *data, size_t count,
unsigned char *md, unsigned int *size, const EVP_MD *type, ENGINE *impl)
{ //传入的type参数其实只是一个空壳，仅仅包含了nid字段是有效的，对于EVP_MD来说就是type字段，因为别的字段具体是什么还要看engine的实现，所以此处的参数type可以仅仅理解成一个算法id。
EVP_MD_CTX ctx;
EVP_MD_CTX_init(&ctx);
M_EVP_MD_CTX_set_flags(&ctx,EVP_MD_CTX_FLAG_ONESHOT);
ret=EVP_DigestInit_ex(&ctx, type, impl)
&& EVP_DigestUpdate(&ctx, data, count)
&& EVP_DigestFinal_ex(&ctx, md, size);
EVP_MD_CTX_cleanup(&ctx);
...
}
在对外呈现的接口上，openssl和linux是一致的，openssl需要一个算法的id，而linux需要一个算法的名称，所不同的是，openssl有engine的支持，这样同一个算法就可以指定不同的实现，engine作为算法名称或者id和算法实现之间的桥梁存在，解除了它们之间的耦合。而linux由于没有engine，那么只要给定了一个算法名称，比如sha1，那么只能得到唯一的实现，虽然内核可能通过增加优先级字段来影响算法实现的被选中率，但是这种做法远没有openssl的engine灵活，但是反过来想一下，内核中的机制都是比较稳定的，不经常变动的，而且linux本身就不提倡你在内核完成一些功能，除非万不得已，因此linux的crypto的设计也算是圆满了。