一、? ? ? ? 前言

Linux加密框架是內核安全子系統的重要組成部份，同時，它又一個的獨立子系統形式出現，從它出現在內核根目錄下的crypto/就可以看出其地位了。
Crypto實現較為復雜，其主要體現在其OOP的設計思路和高度的對像抽像與封裝模型，作者展現了其出色的架構設計水準和面向對像的抽像能力。本文力圖從加密框架的重要應用，即IPSec(xfrm)的兩個重要協議AH和ESP對加密框架的使用，展現其設計與實現。
內核版本：2.6.31.13

二、? ? ? ? 算法模版
1.? ? ? ? 模版的基本概念
算法模版是加密框架的第一個重要概念。內核中有很多算法是動態生成的，例如cbc(des)算法。內核并不存在這樣的算法，它事實上是cbc和des的組合，但是內核加密框架從統一抽像管理的角度。將cbc(des)看做一個算法，在實際使用時動態分配并向內核注冊該算法。這樣，可以將cbc抽像為一個模版，它可以同任意的加密算法進行組合。算法模版使用結構crypto_template來描述，其結構原型：

點擊(此處)折疊或打開

struct crypto_template?{

struct list_head list;?//模版鏈表成員，用于注冊

struct hlist_head instances;?//算法實例鏈表首部

struct module?*module;?//模塊指針

struct crypto_instance?*(*alloc)(struct rtattr?**tb);?//算法實例分配

void?(*free)(struct crypto_instance?*inst);?//算法實例釋放

char name[CRYPTO_MAX_ALG_NAME];?//模版名稱

};

例如，一個名為cbc的算法模版，可以用它來動態分配cbc(des),cbc(twofish)……諸如此類。

crypto/algapi.c下包含了模版的一些常用操作。最為常見的就是模版的注冊與注銷，其實質是對以crypto_template_list為首的鏈表的操作過程：

點擊(此處)折疊或打開

static LIST_HEAD(crypto_template_list);

int?crypto_register_template(struct crypto_template?*tmpl)

{

struct crypto_template?*q;

int?err?=?-EEXIST;

down_write(&crypto_alg_sem);

//遍歷crypto_template_list，看當前模板是否被注冊

list_for_each_entry(q,?&crypto_template_list,?list)?{

if?(q?==?tmpl)

goto out;

}

//注冊之

list_add(&tmpl->list,?&crypto_template_list);

//事件通告

crypto_notify(CRYPTO_MSG_TMPL_REGISTER,?tmpl);

err?=?0;

out:

up_write(&crypto_alg_sem);

return?err;

}

EXPORT_SYMBOL_GPL(crypto_register_template);

注銷算法模版，除了模版本身，還有一個重要的內容是處理算法模版產生的算法實例，關于算法實例，后文詳述。

點擊(此處)折疊或打開

void crypto_unregister_template(struct crypto_template?*tmpl)

{

struct crypto_instance?*inst;

struct hlist_node?*p,?*n;

struct hlist_head?*list;

LIST_HEAD(users);

down_write(&crypto_alg_sem);

BUG_ON(list_empty(&tmpl->list));

//注銷算法模版，并重新初始化模版的list成員

list_del_init(&tmpl->list);

//首先移除模版上的所有算法實例

list?=?&tmpl->instances;

hlist_for_each_entry(inst,?p,?list,?list)?{

int?err?=?crypto_remove_alg(&inst->alg,?&users);

BUG_ON(err);

}

crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER,?tmpl);

up_write(&crypto_alg_sem);

//釋放模版的所有算法實例分配的內存

hlist_for_each_entry_safe(inst,?p,?n,?list,?list)?{

BUG_ON(atomic_read(&inst->alg.cra_refcnt)?!=?1);

tmpl->free(inst);

}

crypto_remove_final(&users);

}

EXPORT_SYMBOL_GPL(crypto_unregister_template);

2.? ? ? ? 算法模版的查找

點擊(此處)折疊或打開

crypto_lookup_template函數根據名稱，查找相應的模版：

struct crypto_template?*crypto_lookup_template(const?char?*name)

{

return try_then_request_module(__crypto_lookup_template(name),?name);

}

__crypto_lookup_template完成實質的模版模找工作，而try_then_request_module則嘗試動態插入相應的內核模塊，如果需要的話：

點擊(此處)折疊或打開

static struct crypto_template?*__crypto_lookup_template(const?char?*name)

{

struct crypto_template?*q,?*tmpl?=?NULL;

down_read(&crypto_alg_sem);

//遍歷crypto_template_list鏈，匹備模版名稱

list_for_each_entry(q,?&crypto_template_list,?list)?{

if?(strcmp(q->name,?name))

continue;

//查找命中，需要對其增加引用，以防止其正在使用時，模塊被卸載。完成該操作后返回查找到的模版

if?(unlikely(!crypto_tmpl_get(q)))

continue;

tmpl?=?q;

break;

}

up_read(&crypto_alg_sem);

return tmpl;

}

3.? ? ? ? 模版的算法實例分配時機
模版可以看做一個靜態的概念，其只有被動態創建后才具有生命力，本文將模版通過alloc分配創建的算法（對像）稱為“實例(instance)”。
算法模版的核心作用是，上層調用者構造一個完整合法的算法名稱，如hmac(md5)，觸發模版的alloc動作，為該名稱分配一個算法實例，類似于為類實例化一個對像，最終的目的還是使用算法本身。對于xfrm來說，一個典型的算法模版的實例分配觸發流程如下所述:
xfrm包裹了一層加密框架支持，參后文“ xfrm加密框架”一節，其算法查找函數為xfrm_find_algo，它調用crypto_has_alg函數進行算法的查找，以驗證自己支持的算法是否被內核支持，如xfrm支持cbc(des)，但此時并不知道內核是否有這個算法(如果該算法首次被使用，則還沒有分配算法實例)。crypto_has_alg會調用crypto_alg_mod_lookup完成查找工作，crypto_alg_mod_lookup函數查找不命中，會調用crypto_probing_notify函數進行請求探測：

點擊(此處)折疊或打開

struct crypto_alg?*crypto_alg_mod_lookup(const?char?*name,?u32 type,?u32 mask)

{

……

ok?=?crypto_probing_notify(CRYPTO_MSG_ALG_REQUEST,?larval);

……

}

請求是通過通知鏈表來通告的：

點擊(此處)折疊或打開

int?crypto_probing_notify(unsigned long val,?void?*v)

{

int?ok;

ok?=?blocking_notifier_call_chain(&crypto_chain,?val,?v);

if?(ok?==?NOTIFY_DONE)?{

request_module("cryptomgr");

ok?=?blocking_notifier_call_chain(&crypto_chain,?val,?v);

}

return ok;

}

在algboss.c中注冊了一個名為cryptomgr_notifier的通告塊結構，其通告處理函數為cryptomgr_notify

點擊(此處)折疊或打開

static struct notifier_block cryptomgr_notifier?=?{

.notifier_call?=?cryptomgr_notify,

};

static?int?__init cryptomgr_init(void)

{

return crypto_register_notifier(&cryptomgr_notifier);

}

static void __exit cryptomgr_exit(void)

{

int?err?=?crypto_unregister_notifier(&cryptomgr_notifier);

BUG_ON(err);

}

這樣，當有算法被使用的時候，會調用通告塊的處理函數cryptomgr_notify，因為此時的消息是CRYPTO_MSG_ALG_REQUEST，所以cryptomgr_schedule_probe進行算法的探測：

點擊(此處)折疊或打開

static?int?cryptomgr_notify(struct notifier_block?*this,?unsigned long msg,

void?*data)

{

switch?(msg)?{

case?CRYPTO_MSG_ALG_REQUEST:

return cryptomgr_schedule_probe(data);

……

return NOTIFY_DONE;

}

cryptomgr_schedule_probe啟動一個名為cryptomgr_probe的內核線程來進行算法模版的探測：

點擊(此處)折疊或打開

static?int?cryptomgr_schedule_probe(struct crypto_larval?*larval)

{

……

//構造param，以供后面使用

……

thread?=?kthread_run(cryptomgr_probe,?param,?"cryptomgr_probe");

……

}

cryptomgr_probe完成具體的算法探測過程：

點擊(此處)折疊或打開

static?int?cryptomgr_probe(void?*data)

{

struct cryptomgr_param?*param?=?data;

struct crypto_template?*tmpl;

struct crypto_instance?*inst;

int?err;

//查找算法模版

tmpl?=?crypto_lookup_template(param->template);

if?(!tmpl)

goto?err;

//循環調用模版的alloc函數分配算法實列，并將模版注冊之

//這里值得注意的是循環的條件，當返回碼為-EAGAIN時，會循環再次嘗試

//這樣使用的一個場景后面會分析到

do?{

inst?=?tmpl->alloc(param->tb);

if?(IS_ERR(inst))

err?=?PTR_ERR(inst);

else?if?((err?=?crypto_register_instance(tmpl,?inst)))

tmpl->free(inst);

}?while?(err?==?-EAGAIN?&&?!signal_pending(current));

//查找中會增加引用，這里已經用完了釋放之

crypto_tmpl_put(tmpl);

if?(err)

goto?err;

out:

kfree(param);

module_put_and_exit(0);

err:

crypto_larval_error(param->larval,?param->otype,?param->omask);

goto out;

}

理解了算法的注冊與查找后，再來理解這個函數就非常容易了，其核心在do{}while循環中，包含了算法實例的分配和注冊動作。針對每一種算法模版，其alloc動作不盡一致。后文會對xfrm使用的算法模版一一闡述。

為什么不把“算法實例”直接稱之為“算法”，這是因為實例包含了更多的內容，其由結構struct crypto_instance可以看出：

點擊(此處)折疊或打開

struct crypto_instance?{

struct crypto_alg alg;?//對應的算法名稱

struct crypto_template?*tmpl;?//所屬的算法模版

struct hlist_node list;?//鏈表成員

void?*__ctx[]?CRYPTO_MINALIGN_ATTR;?//上下文信息指針

};

內核使用struct crypto_alg描述一個算法（該結構在后文使用時再來分析），可見一個算法實例除了包含其對應的算法，還包含更多的內容。

當分配成功后，cryptomgr_probe會調用crypto_register_instance將其注冊，以期將來可以順利地找到并使用它：

點擊(此處)折疊或打開

int?crypto_register_instance(struct crypto_template?*tmpl,

struct crypto_instance?*inst)

{

struct crypto_larval?*larval;

int?err;

//對算法進行合法性檢查，并構造完整的驅動名稱

err?=?crypto_check_alg(&inst->alg);

if?(err)

goto?err;

//設置算法內核模塊指針指向所屬模版

inst->alg.cra_module?=?tmpl->module;

down_write(&crypto_alg_sem);

//注冊算法實例對應的算法

larval?=?__crypto_register_alg(&inst->alg);

if?(IS_ERR(larval))

goto unlock;

//成功后，將算法再注冊到所屬的模版上面

hlist_add_head(&inst->list,?&tmpl->instances);

//設置模版指針

inst->tmpl?=?tmpl;

unlock:

up_write(&crypto_alg_sem);

err?=?PTR_ERR(larval);

if?(IS_ERR(larval))

goto?err;

crypto_wait_for_test(larval);

err?=?0;

err:

return?err;

}

注冊的一個重要工作，就是調用__crypto_register_alg將實例所對應的算法注冊到加密框架子系統中。算法注冊成功后，上層調用者就可以調用crypto_alg_mod_lookup等函數進行查找，并使用該算法了。

三、? ? ? ? HMAC
MAC（消息認證碼）與hash函數非常相似，只是生成固定長度的消息摘要時需要秘密的密鑰而已。
HAMC是密鑰相關的哈希運算消息認證碼（keyed-Hash Message Authentication Code）,HMAC運算利用哈希算法，以一個密鑰和一個消息為輸入，生成一個消息摘要作為輸出。具體的算法描述詳見：http://baike.baidu.com/view/1136366.htm?fr=ala0_1。
根據HMAC的特點(可以和類似md5、sha等hash算法組合，構造出hmac(md5)這樣的算法)，Linux 加密框架將其抽像為一個算法模版。本章將假設上層調用者使用了名為hmac(md5)的算法，展示這一算法是如何被構造、初始化及調用以實現數據驗證的。

1.? ? ? ? 算法模版的注冊與注銷

點擊(此處)折疊或打開

static struct crypto_template hmac_tmpl?=?{

.name?=?"hmac",

.alloc?=?hmac_alloc,

.free?=?hmac_free,

.module?=?THIS_MODULE,

};

點擊(此處)折疊或打開

static?int?__init hmac_module_init(void)

{

return crypto_register_template(&hmac_tmpl);

}

點擊(此處)折疊或打開

static void __exit hmac_module_exit(void)

{

crypto_unregister_template(&hmac_tmpl);

}

模版的注冊與注銷前文已經描述過了。

2.? ? ? ? 算法實例的分配
當一個算法需要被使用卻查找不到的時候，會嘗試調用其模版對應分配相應的算法實列，這也適用于hmac，其alloc函數指針指向hmac_alloc：

點擊(此處)折疊或打開

static struct crypto_instance?*?hmac_alloc?(struct rtattr?**tb)

{

struct crypto_instance?*inst;

struct crypto_alg?*alg;

int?err;

int?ds;

//類型檢查，所屬算法必需為hash類型

err?=?crypto_check_attr_type(tb,?CRYPTO_ALG_TYPE_HASH);

if?(err)

return ERR_PTR(err);

//根據參數名稱，查找相應的子算法，如md5,shax等

alg?=?crypto_get_attr_alg(tb,?CRYPTO_ALG_TYPE_HASH,

CRYPTO_ALG_TYPE_HASH_MASK);

//查找失敗

if?(IS_ERR(alg))

return ERR_CAST(alg);

//初始化算法實例

inst?=?ERR_PTR(-EINVAL);

//計算算法實列的消息摘要大小(輸出大小)

ds?=?alg->cra_type?==?&crypto_hash_type??

alg->cra_hash.digestsize?:

alg->cra_type??

__crypto_shash_alg(alg)->digestsize?:

alg->cra_digest.dia_digestsize;

if?(ds?>?alg->cra_blocksize)

goto out_put_alg;

//分配一個算法實列，這樣，一個新的算法，如hmac(md5)就橫空出世了

inst?=?crypto_alloc_instance("hmac",?alg);

//分配失敗

if?(IS_ERR(inst))

goto out_put_alg;

//初始化算法實例，其相應的成員等于其子算法中的對應成員

//類型

inst->alg.cra_flags?=?CRYPTO_ALG_TYPE_HASH;

//優先級

inst->alg.cra_priority?=?alg->cra_priority;

//計算消息摘要的塊長度(輸入大小)

inst->alg.cra_blocksize?=?alg->cra_blocksize;

//對齊掩碼

inst->alg.cra_alignmask?=?alg->cra_alignmask;

//類型指針指向crypto_hash_type

inst->alg.cra_type?=?&crypto_hash_type;

//消息摘要大小

inst->alg.cra_hash.digestsize?=?ds;

//計算算法所需的上下文空間大小

inst->alg.cra_ctxsize?=?sizeof(struct hmac_ctx)?+

ALIGN(inst->alg.cra_blocksize?*?2?+?ds,

sizeof(void?*));

//初始化和退出函數

inst->alg.cra_init?=?hmac_init_tfm;

inst->alg.cra_exit?=?hmac_exit_tfm;

//置相應hash算法的操作函數，包含hash函數標準的init/update/final和digest/setkey

inst->alg.cra_hash.init?=?hmac_init;

inst->alg.cra_hash.update?=?hmac_update;

inst->alg.cra_hash.final?=?hmac_final;

//消息摘要函數

inst->alg.cra_hash.digest?=?hmac_digest;

//setkey(密鑰設置函數)

inst->alg.cra_hash.setkey?=?hmac_setkey;

out_put_alg:

crypto_mod_put(alg);

return inst;

}

每個模版的alloc動作雖不同，但是它們基本上遵循一些共性的操作：
1、? ? ? ? 合法性檢驗，如類型檢查；
2、? ? ? ? 取得其子算法（即被模版所包裹的算法，如hmac(md5)中，就是md5）的算法指針;?
3、? ? ? ? 調用crypto_alloc_instance分配一個相應的算法實列；
4、? ? ? ? 對分配成功的算法實例進行實始化，這也是理解該算法實例最核心的部份，因為它初始化算法運行所需的一些必要參數和虛函數指針；

crypto_alloc_instance(algapi.c) 函數用于分配一個算法實例，這個函數有兩個重要功能，一個是分配內存空間，另一個是初始化spawn。

點擊(此處)折疊或打開

//name:?模版名稱?

//alg:模版的子算法

struct crypto_instance?*crypto_alloc_instance(const?char?*name,

struct crypto_alg?*alg)

{

struct crypto_instance?*inst;

struct crypto_spawn?*spawn;

int?err;

//分配一個算法實例，crypto_instance結構的最后一個成員ctx是一個指針變量，所以，在分配空間的時候，在其尾部追加相應的空間，可以使用ctx訪問之。

//另一個重要的概念是，算法實例中包含了算法，這個分配，同時也完成了算法實例對應的算法的分配工作。

inst?=?kzalloc(sizeof(*inst)?+?sizeof(*spawn),?GFP_KERNEL);

if?(!inst)

return ERR_PTR(-ENOMEM);

err?=?-ENAMETOOLONG;

//構造完成的算法名稱

if?(snprintf(inst->alg.cra_name,?CRYPTO_MAX_ALG_NAME,?"%s(%s)",?name,

alg->cra_name)?>=?CRYPTO_MAX_ALG_NAME)

goto err_free_inst;

//構造完整的算法驅動名稱

if?(snprintf(inst->alg.cra_driver_name,?CRYPTO_MAX_ALG_NAME,?"%s(%s)",

name,?alg->cra_driver_name)?>=?CRYPTO_MAX_ALG_NAME)

goto err_free_inst;

//spawn指向算法實例的上下文成員，可以這樣做是因為__ctx是一個可變長的成員，在分配實例的時候，

//在尾部增加了一個spawn的空間

spawn?=?crypto_instance_ctx(inst);

//初始化spawn

err?=?crypto_init_spawn(spawn,?alg,?inst,

CRYPTO_ALG_TYPE_MASK?|?CRYPTO_ALG_ASYNC);

if?(err)

goto err_free_inst;

return inst;

err_free_inst:

kfree(inst);

return ERR_PTR(err);

}

crypto_instance_ctx取出算法實例的ctx指針，返回值是void *，這意味著可以根具不同的需要，將其轉換為所需的類型：

點擊(此處)折疊或打開

static inline void?*crypto_instance_ctx(struct crypto_instance?*inst)

{

return inst->__ctx;

}

一個算法實例被分配成員后，其會被注冊至加密子系統，這樣，一個算法，例如，hmac(md5)就可以直接被使用了。

3.? ? ? ? 待孵化的卵
? ? ? ? 已經看到了從模版到算法實例的第一層抽像，每個算法在每一次被使用時，它們的運行環境不盡相同，例如，可能會擁有不同的密鑰。將算法看成一個類，則在每一次運行調用時，需要為它產生一個“對像”，這在內核中被稱為transform，簡稱為tfm。后文會詳細看到分配一個tfm的過程，現在引入這一概念，主要是為了分析spawn。
加密或認證算法，在調用時，都需要分配其算法對應的tfm，在分配算法實例的同時，并沒有為之分配相應的tfm結構，這是因為真正的算法還沒有被調用，這并不是進行tfm結構分配的最佳地點。在初始化算法實例的時候，加密框架使用了XXX_spawn_XXX函數簇來解決這一問題。這樣的算法對像，被稱為spawn(卵)。也就是說，在算法實例分配的時候，只是下了一個蛋（設置好spawn），等到合適的時候來對其進行孵化，這個“合適的時候”，通常指為調用算法實際使用的時候。

在crypto_alloc_instance分配算法實例的時候，就順便分配了spawn，然后調用crypto_init_spawn對其進行初始化：

點擊(此處)折疊或打開

int?crypto_init_spawn(struct crypto_spawn?*spawn,?struct crypto_alg?*alg,

struct crypto_instance?*inst,?u32 mask)

{

int?err?=?-EAGAIN;

//初始化其成員

spawn->inst?=?inst;

spawn->mask?=?mask;

down_write(&crypto_alg_sem);

if?(!crypto_is_moribund(alg))?{

//加入鏈表，每個spawn，都被加入到算法的cra_users鏈，即算做算法的一個用戶

list_add(&spawn->list,?&alg->cra_users);

//spawn的alg成員指針指向當前成員，這就方便引用了

spawn->alg?=?alg;

err?=?0;

}

up_write(&crypto_alg_sem);

return?err;

}

所以，所謂算法的spawn的初始化，就是初始化crypto_spawn結構，核心的操作是設置其對應的算法實例、算法，以及一個加入算法的鏈表的過程。

4.? ? ? ? 算法的初始化
有了算法實例，僅表示內核擁有這一種“算法”——加引號的意思是說，它可能并不以類似md5.c這樣的源代碼形式存現，而是通過模版動態創建的。實際要使用該算法，需要為算法分配“運行的對像”，即tfm。

4.1? ? ? ? tfm
內核加密框架中，使用結構crypto_alg來描述一個算法，每一個算法(實例)相當于一個類，在實際的使用環境中，需要為它分配一個對像，在內核加密框架中，這個“對像”被稱為transform（簡稱tfm）。transform意味“變換”，可能譯為“蛻變”更為合適。作者對它的注釋是：
/*
* Transforms: user-instantiated objects which encapsulate algorithms
* and core processing logic.??Managed via crypto_alloc_*() and
* crypto_free_*(), as well as the various helpers below.
……
*/

tfm是加密框架中一個極為重要的概念，它由結構crypto_tfm描述：

點擊(此處)折疊或打開

struct crypto_tfm?{

u32 crt_flags;

union?{

struct ablkcipher_tfm ablkcipher;

struct aead_tfm aead;

struct blkcipher_tfm blkcipher;

struct cipher_tfm cipher;

struct hash_tfm hash;

struct ahash_tfm ahash;

struct compress_tfm compress;

struct rng_tfm rng;

}?crt_u;

void?(*exit)(struct crypto_tfm?*tfm);

struct crypto_alg?*__crt_alg;

void?*__crt_ctx[]?CRYPTO_MINALIGN_ATTR;

};

這些成員的作用，將在后面一一看到，值得注意的是，針對每種算法不同，結構定義了一個名為crt_u的聯合體，以對應每種算法的tfm的具體操作，例如加密/解密，求hash，壓縮/解壓等，加密框架引入了一組名為xxx_tfm的結構封裝，xxx表示算法類型，也就是crt_u成員。其定義如下：

點擊(此處)折疊或打開

struct ablkcipher_tfm?{

int?(*setkey)(struct crypto_ablkcipher?*tfm,?const?u8?*key,

unsigned?int?keylen);

int?(*encrypt)(struct ablkcipher_request?*req);

int?(*decrypt)(struct ablkcipher_request?*req);

int?(*givencrypt)(struct skcipher_givcrypt_request?*req);

int?(*givdecrypt)(struct skcipher_givcrypt_request?*req);

struct crypto_ablkcipher?*base;

unsigned?int?ivsize;

unsigned?int?reqsize;

};

struct aead_tfm?{

int?(*setkey)(struct crypto_aead?*tfm,?const?u8?*key,

unsigned?int?keylen);

int?(*encrypt)(struct aead_request?*req);

int?(*decrypt)(struct aead_request?*req);

int?(*givencrypt)(struct aead_givcrypt_request?*req);

int?(*givdecrypt)(struct aead_givcrypt_request?*req);

struct crypto_aead?*base;

unsigned?int?ivsize;

unsigned?int?authsize;

unsigned?int?reqsize;

};

struct blkcipher_tfm?{

void?*iv;

int?(*setkey)(struct crypto_tfm?*tfm,?const?u8?*key,

unsigned?int?keylen);

int?(*encrypt)(struct blkcipher_desc?*desc,?struct scatterlist?*dst,

struct scatterlist?*src,?unsigned?int?nbytes);

int?(*decrypt)(struct blkcipher_desc?*desc,?struct scatterlist?*dst,

struct scatterlist?*src,?unsigned?int?nbytes);

};

struct cipher_tfm?{

int?(*cit_setkey)(struct crypto_tfm?*tfm,

const?u8?*key,?unsigned?int?keylen);

void?(*cit_encrypt_one)(struct crypto_tfm?*tfm,?u8?*dst,?const?u8?*src);

void?(*cit_decrypt_one)(struct crypto_tfm?*tfm,?u8?*dst,?const?u8?*src);

};

struct hash_tfm?{

int?(*init)(struct hash_desc?*desc);

int?(*update)(struct hash_desc?*desc,

struct scatterlist?*sg,?unsigned?int?nsg);

int?(*final)(struct hash_desc?*desc,?u8?*out);

int?(*digest)(struct hash_desc?*desc,?struct scatterlist?*sg,

unsigned?int?nsg,?u8?*out);

int?(*setkey)(struct crypto_hash?*tfm,?const?u8?*key,

unsigned?int?keylen);

unsigned?int?digestsize;

};

struct ahash_tfm?{

int?(*init)(struct ahash_request?*req);

int?(*update)(struct ahash_request?*req);

int?(*final)(struct ahash_request?*req);

int?(*digest)(struct ahash_request?*req);

int?(*setkey)(struct crypto_ahash?*tfm,?const?u8?*key,

unsigned?int?keylen);

unsigned?int?digestsize;

unsigned?int?reqsize;

};

struct compress_tfm?{

int?(*cot_compress)(struct crypto_tfm?*tfm,

const?u8?*src,?unsigned?int?slen,

u8?*dst,?unsigned?int?*dlen);

int?(*cot_decompress)(struct crypto_tfm?*tfm,

const?u8?*src,?unsigned?int?slen,

u8?*dst,?unsigned?int?*dlen);

};

struct rng_tfm?{

int?(*rng_gen_random)(struct crypto_rng?*tfm,?u8?*rdata,

unsigned?int?dlen);

int?(*rng_reset)(struct crypto_rng?*tfm,?u8?*seed,?unsigned?int?slen);

};

為了直接訪問這些成員，定義了如下宏：

點擊(此處)折疊或打開

#define crt_ablkcipher crt_u.ablkcipher

#define crt_aead crt_u.aead

#define crt_blkcipher crt_u.blkcipher

#define crt_cipher crt_u.cipher

#define crt_hash crt_u.hash

#define crt_ahash crt_u.ahash

#define crt_compress crt_u.compress

#define crt_rng crt_u.rng

這樣，要訪問hash算法的hash成員，就可以直接使用crt_hash，而不是crt_u.hash。

每種算法訪問tfm都使用了二次封裝，例如：

點擊(此處)折疊或打開

struct crypto_ablkcipher?{

struct crypto_tfm base;

};

struct crypto_aead?{

struct crypto_tfm base;

};

struct crypto_blkcipher?{

struct crypto_tfm base;

};

struct crypto_cipher?{

struct crypto_tfm base;

};

struct crypto_comp?{

struct crypto_tfm base;

};

struct crypto_hash?{

struct crypto_tfm base;

};

struct crypto_rng?{

struct crypto_tfm base;

};

其base成員就是相應算法的tfm。因為它們擁有相應的起始地址，可以很方便地強制類型轉換來操作，內核為此專門定義了一組函數，以hash為例，完成這一工作的是crypto_hash_cast：

點擊(此處)折疊或打開

static inline struct crypto_hash?*__crypto_hash_cast(struct crypto_tfm?*tfm)

{

return?(struct crypto_hash?*)tfm;

}

static inline struct crypto_hash?*crypto_hash_cast(struct crypto_tfm?*tfm)

{

BUG_ON((crypto_tfm_alg_type(tfm)?^ CRYPTO_ALG_TYPE_HASH)?&

CRYPTO_ALG_TYPE_HASH_MASK);

return __crypto_hash_cast(tfm);

}

當然，針對各種不同的算法，還有許多不同的XXX_cast函數。這些cast函數，將tfm強制轉換為其所屬的算法類型的封裝結構。

4.2 tfm的分配
對于算法的實始化，其核心功能就是分配一個tfm，并設置其上下文環境，例如密鑰等參數，然后初始化上述struct xxx_tfm結構。對于hash類的算法來講，分配tfm是由crypto_alloc_hash(crypt.h) 這個API來完成的，以AH為例，在其初始化過程中有：

點擊(此處)折疊或打開

static?int?ah_init_state(struct xfrm_state?*x)

{

struct crypto_hash?*tfm;

……

tfm?=?crypto_alloc_hash(x->aalg->alg_name,?0,?CRYPTO_ALG_ASYNC);

if?(IS_ERR(tfm))

goto?error;

……

}

AH調用crypto_alloc_hash為SA中指定的算法（如hmac(md5)）分配一個tfm，第二個參數為0，第三個參數指明了AH使用異步模式。

點擊(此處)折疊或打開

static inline struct crypto_hash?*crypto_alloc_hash(const?char?*alg_name,

u32 type,?u32 mask)

{

//初始化相應的類型的掩碼

type?&=?~CRYPTO_ALG_TYPE_MASK;?//清除類型的CRYPTO_ALG_TYPE_MASK位

mask?&=?~CRYPTO_ALG_TYPE_MASK;?//清除掩碼的CRYPTO_ALG_TYPE_MASK位

type?|=?CRYPTO_ALG_TYPE_HASH;?//置類型CRYPTO_ALG_TYPE_HASH位

mask?|=?CRYPTO_ALG_TYPE_HASH_MASK;?//置掩碼CRYPTO_ALG_TYPE_HASH_MASK位

//最終的分配函數是crypto_alloc_base，它分配一個base(每個算法的tfm)，再將其強制類型轉換為所需要結構類型

return __crypto_hash_cast(crypto_alloc_base(alg_name,?type,?mask));

}

crypto_alloc_base首先檢查相應的算法是否存在，對于hmac(md5)這個例子，xfrm在SA的增加中，會觸發相應的算法查找，最終會調用hmac模版的alloc分配算法實例（當然也包括算法本身），然后向內核注冊算法及算法實例，所以，查找會命中。接下來的工作，是調用tfm的核心分配函數__crypto_alloc_tfm進行分配，其實現如下：

點擊(此處)折疊或打開

struct crypto_tfm?*crypto_alloc_base(const?char?*alg_name,?u32 type,?u32 mask)

{

struct crypto_tfm?*tfm;

int?err;

for?(;;)?{

struct crypto_alg?*alg;

//根據算法名稱，查找相應的算法,它會首先嘗試已經加載的算法，如果失敗，也會嘗試

//動態插入內核模塊

alg?=?crypto_alg_mod_lookup(alg_name,?type,?mask);

//查找失敗，返回退出循環

if?(IS_ERR(alg))?{

err?=?PTR_ERR(alg);

goto?err;

}

//查找成功，為算法分配tfm

tfm?=?__crypto_alloc_tfm(alg,?type,?mask);

//分配成功，返回之

if?(!IS_ERR(tfm))

return tfm;

//釋放引用計算，因為查找會增加引用

crypto_mod_put(alg);

//獲取返回錯誤值，根據其值，決定是否要繼續嘗試

err?=?PTR_ERR(tfm);

err:

if?(err?!=?-EAGAIN)

break;

if?(signal_pending(current))?{

err?=?-EINTR;

break;

}

}

return ERR_PTR(err);

}

__crypto_alloc_tfm是內核加密框架中又一重要的函數，它完成了對算法tfm的分配和初始化的工作：

點擊(此處)折疊或打開

struct crypto_tfm?*__crypto_alloc_tfm(struct crypto_alg?*alg,?u32 type,

u32 mask)

{

struct crypto_tfm?*tfm?=?NULL;

unsigned?int?tfm_size;

int?err?=?-ENOMEM;

//計算tfm所需的空間大小，它包括了tfm結構本身和算法上下文大小

tfm_size?=?sizeof(*tfm)?+?crypto_ctxsize(alg,?type,?mask);

//分配tfm

tfm?=?kzalloc(tfm_size,?GFP_KERNEL);

if?(tfm?==?NULL)

goto out_err;

//__crt_alg成員指向其所屬的算法，對于hmac而言，它就是hmac(xxx)，例如hmac(md5)

tfm->__crt_alg?=?alg;

//初始化tfm選項

err?=?crypto_init_ops(tfm,?type,?mask);

if?(err)

goto out_free_tfm;

//調用算法的初始化函數，初始化tfm，這有個先決條件是tfm本身沒有exit函數的實現

if?(!tfm->exit?&&?alg->cra_init?&&?(err?=?alg->cra_init(tfm)))

goto cra_init_failed;

goto out;

cra_init_failed:

crypto_exit_ops(tfm);

out_free_tfm:

if?(err?==?-EAGAIN)

crypto_shoot_alg(alg);

kfree(tfm);

out_err:

tfm?=?ERR_PTR(err);

out:

return tfm;

}

crypto_init_ops負責初始化tfm的選項，對于一個真正的算法（例如md5、dst）和一個偽算法（我說的“偽”，是指由模版動態分配的，如hmac(xxx), authenc(xxx,xxx)），因為并不存在這樣的算法，只是內核的一個抽像，故稱為"偽"，它們的初始化過程是截然不同的。一個偽算法，它都設置了其所屬的類型cra_type，例如，對于hmac(xxx)而言，它指向了crypto_hash_type。這樣，初始化時，實質上調用的是其所屬類型的init函數：

點擊(此處)折疊或打開

static?int?crypto_init_ops(struct crypto_tfm?*tfm,?u32 type,?u32 mask)

{

//獲取tfm所屬算法的所屬類型

const?struct crypto_type?*type_obj?=?tfm->__crt_alg->cra_type;

//如果設置了類型，調用類型的init

if?(type_obj)

return type_obj->init(tfm,?type,?mask);

//否則，判斷算法的類型，調用相應的初始化函數，這些在不同的算法實現中分析

switch?(crypto_tfm_alg_type(tfm))?{

case?CRYPTO_ALG_TYPE_CIPHER:

return crypto_init_cipher_ops(tfm);

case?CRYPTO_ALG_TYPE_DIGEST:

if?((mask?&?CRYPTO_ALG_TYPE_HASH_MASK)?!=

CRYPTO_ALG_TYPE_HASH_MASK)

return crypto_init_digest_ops_async(tfm);

else

return crypto_init_digest_ops(tfm);

case?CRYPTO_ALG_TYPE_COMPRESS:

return crypto_init_compress_ops(tfm);

default:

break;

}

BUG();

return?-EINVAL;

}

算法類型的概念很好理解，因為若干個hmac(xxx)都擁有一此相同的類型屬性（其它偽算法同樣如此），所以可以將它們抽像管理。
對于hash類型的算法而言，它們擁有一個共同的類型crypto_hash_type，其定義在hash.c中：

點擊(此處)折疊或打開

const?struct crypto_type crypto_hash_type?=?{

.ctxsize?=?crypto_hash_ctxsize,

.init?=?crypto_init_hash_ops,

#ifdef CONFIG_PROC_FS

.show?=?crypto_hash_show,

#endif

};

它的init函數指針指向crypto_init_hash_ops：

點擊(此處)折疊或打開

static?int?crypto_init_hash_ops(struct crypto_tfm?*tfm,?u32 type,?u32 mask)

{

struct hash_alg?*alg?=?&tfm->__crt_alg->cra_hash;

//其消息摘要大小不同超過1/8個頁面

if?(alg->digestsize?>?PAGE_SIZE?/?8)

return?-EINVAL;

//根據掩碼位，判斷是同步初始化還是異步，對于crypto_alloc_hash調用下來的而言，它

//設置了CRYPTO_ALG_TYPE_HASH_MASK位，所以是同步初始化

if?((mask?&?CRYPTO_ALG_TYPE_HASH_MASK)?!=?CRYPTO_ALG_TYPE_HASH_MASK)

return crypto_init_hash_ops_async?(tfm);

else

return crypto_init_hash_ops_sync(tfm);

}

在我們AH的例子中，AH使用了異步模式，所以crypto_init_hash_ops_async會被調用。

前述hash_tfm結構封裝了hash類型的算法的通用的操作：

點擊(此處)折疊或打開

struct hash_tfm?{

int?(*init)(struct hash_desc?*desc);

int?(*update)(struct hash_desc?*desc,

struct scatterlist?*sg,?unsigned?int?nsg);

int?(*final)(struct hash_desc?*desc,?u8?*out);

int?(*digest)(struct hash_desc?*desc,?struct scatterlist?*sg,

unsigned?int?nsg,?u8?*out);

int?(*setkey)(struct crypto_hash?*tfm,?const?u8?*key,

unsigned?int?keylen);

unsigned?int?digestsize;

};

先來看同步模式的初始化操作，crypto_init_hash_ops_sync函數負責初始化這一結構：

點擊(此處)折疊或打開

static?int?crypto_init_hash_ops_sync(struct crypto_tfm?*tfm)

{

struct hash_tfm?*crt?=?&tfm->crt_hash;

struct hash_alg?*alg?=?&tfm->__crt_alg->cra_hash;

//置tfm相應操作為算法本身的對應操作，

//對于hmac(xxx)算法而言，這些東東在hmac_alloc中已經初始化過了，也就是hmac_init等函數

crt->init?=?alg->init;

crt->update?=?alg->update;

crt->final?=?alg->final;

crt->digest?=?alg->digest;

crt->setkey?=?hash_setkey;

crt->digestsize?=?alg->digestsize;

return 0;

}

異步模式則稍有不同，它使用了hash類型算法的通用函數：

點擊(此處)折疊或打開

static?int?crypto_init_hash_ops_async(struct crypto_tfm?*tfm)

{

struct ahash_tfm?*crt?=?&tfm->crt_ahash;

struct hash_alg?*alg?=?&tfm->__crt_alg->cra_hash;

crt->init?=?hash_async_init;

crt->update?=?hash_async_update;

crt->final?=?hash_async_final;

crt->digest?=?hash_async_digest;

crt->setkey?=?hash_async_setkey;

crt->digestsize?=?alg->digestsize;

return 0;

}

不論是同步還是異步，算法的tfm都得到的相應的初始化。回到__crypto_alloc_tfm中來，__crypto_alloc_tfm函數的最后一步是調用算法的cra_init函數(如果它存在的話)，對于hmac(xxx)而言，它在分配的時候指向hmac_init_tfm。hmac_init_tfm的主要工作就是對hmac(xxx)的spawn進行孵化操作。還記得“待孵化的卵”嗎？前面講了只是初始化它，現在到了孵化的時候了

點擊(此處)折疊或打開

static?int?hmac_init_tfm(struct crypto_tfm?*tfm)

{

struct crypto_hash?*hash;

//因為算法實例的第一個成員就是alg，在注冊算法時，就是注冊的它，所以可以很方便地通過tfm的__crt_alg強制類型轉換得到對應的算法實例

struct crypto_instance?*inst?=?(void?*)tfm->__crt_alg;

//取得算法實例的__ctx域，也就是spawn

struct crypto_spawn?*spawn?=?crypto_instance_ctx(inst);

//取得tfm的上下文指針

struct hmac_ctx?*ctx?=?hmac_ctx(__crypto_hash_cast(tfm));

//對hmac(xxx)進行孵化，以hmac(md5)為例，這將得到一個md5算法的tfm，當然，通過強制類型轉換，它被封裝在結構crypto_hash中

hash?=?crypto_spawn_hash(spawn);

if?(IS_ERR(hash))

return PTR_ERR(hash);

//設置子算法指向孵化的tfm

ctx->child?=?hash;

return 0;

}

crypto_spawn_hash展示了如何對hash算法簇進行spawn的孵化操作：

點擊(此處)折疊或打開

static inline struct crypto_hash?*crypto_spawn_hash(struct crypto_spawn?*spawn)

{

//初始化孵化所需的類型和掩碼

u32 type?=?CRYPTO_ALG_TYPE_HASH;

u32 mask?=?CRYPTO_ALG_TYPE_HASH_MASK;

//調用crypto_spawn_tfm孵化一個tfm，并強制類型轉換

return __crypto_hash_cast(crypto_spawn_tfm(spawn,?type,?mask));

}

最后的任務交給了crypto_spawn_tfm函數，它為算法孵化一個tfm，因為spawn的alg成員指向了所要孵化的算法，使得這一操作很容易實現

點擊(此處)折疊或打開

struct crypto_tfm?*crypto_spawn_tfm(struct crypto_spawn?*spawn,?u32 type,

u32 mask)

{

struct crypto_alg?*alg;

struct crypto_alg?*alg2;

struct crypto_tfm?*tfm;

down_read(&crypto_alg_sem);

//要孵化的spawn所屬的算法

alg?=?spawn->alg;

alg2?=?alg;

//查找算法所屬模塊

if?(alg2)

alg2?=?crypto_mod_get(alg2);

up_read(&crypto_alg_sem);

//如果其所屬模塊沒了，則標注算法為DYING，出錯退回

if?(!alg2)?{

if?(alg)

crypto_shoot_alg(alg);

return ERR_PTR(-EAGAIN);

}

//初始化tfm

tfm?=?ERR_PTR(-EINVAL);

//驗證掩碼標志位

if?(unlikely((alg->cra_flags ^ type)?&?mask))

goto out_put_alg;

//為算法分配相應的tfm，這樣，一個算法的spawn就孵化完成了

tfm?=?__crypto_alloc_tfm(alg,?type,?mask);

if?(IS_ERR(tfm))

goto out_put_alg;

return tfm;

out_put_alg:

crypto_mod_put(alg);

return tfm;

}

又繞回了__crypto_alloc_tfm函數，其實現之前已經分析過了，對于一個普通的算法(非模版產生的算法，如md5)，其初始化工作略有不同，在了解其初始化工作之前，需要對一個實際的算法作了解。

順例說一句，內核的這種抽像管理方式，功能異常地強大，可以想像，它可以抽像更多層的嵌套。所以hmac(xxx)中，xxx不一定就是一個md5之類，可能還是一層形如xxx(xxx)的抽像，理論上，它可以像變形金剛一樣。

4.3 小結一下
本節分析了一個算法的tfm是如何生成的，因為算法可以是多層的組裝，在生成上層算法的同時，它也要為其所包含的算法分配tfm，這一過程稱之為spawn。

?