Linux内核crypto子系统的调用逻辑

最新推荐文章于 2023-12-12 20:53:37 发布
最新推荐文章于 2023-12-12 20:53:37 发布
阅读量2.1k 收藏 4
点赞数
分类专栏： crypto linux_crypto 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CHYabc123456hh/article/details/122219494
版权 
struct crypto_alg {
	struct list_head cra_list;
	struct list_head cra_users;
 
	u32 cra_flags;
	unsigned int cra_blocksize;
	unsigned int cra_ctxsize;
	unsigned int cra_alignmask;
 
	int cra_priority;
	refcount_t cra_refcnt;
 
	char cra_name[CRYPTO_MAX_ALG_NAME];
	char cra_driver_name[CRYPTO_MAX_ALG_NAME];
 
	const struct crypto_type *cra_type;
 
	union {
		struct cipher_alg cipher;
		struct compress_alg compress;
	} cra_u;
 
	int (*cra_init)(struct crypto_tfm *tfm);
	void (*cra_exit)(struct crypto_tfm *tfm);
	void (*cra_destroy)(struct crypto_alg *alg);
	
	struct module *cra_module;
 
#ifdef CONFIG_CRYPTO_STATS
	union {
		struct crypto_istat_aead aead;
		struct crypto_istat_akcipher akcipher;
		struct crypto_istat_cipher cipher;
		struct crypto_istat_compress compress;
		struct crypto_istat_hash hash;
		struct crypto_istat_rng rng;
		struct crypto_istat_kpp kpp;
	} stats;
#endif /* CONFIG_CRYPTO_STATS */
 
} CRYPTO_MINALIGN_ATTR;
  • 执行一个请求的时候，还有维护一组上下文的信息， 这些信息记录在结构体: struct crypto_tfm
  • crypto_tfm类型指针tfm可以理解为指代了一个算法对象
  • 参考链接 Linux内核 crypto文件夹 密码学知识学习_CHYabc123456hh的博客-CSDN博客
  • cra_init是准备上下文的函数，比如，你用一个硬件设备压缩数据，实际的物理操作发生在这个硬件的一个队列上，那么就需要准备这个队列，准备必要的缓存等等。
  • cra_exit 是退出上下文。
  • cra_u里是具体执行算法的函数，比如可以压缩和解压缩的函数。
struct crypto_tfm {

	u32 crt_flags;

	int node;
	
	void (*exit)(struct crypto_tfm *tfm);
	
	struct crypto_alg *__crt_alg;

	void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
};
  • crypto_tfm中最后一个元素__crt_ctx是这个上下文的私有数据。
  • 上面的crypto_alg中cra_ctxsize参数就是这个私有数据的__crt_ctx的大小

例子   同步接口

/* 分配一个压缩解压缩的上下文, 可以看到这里的压缩解压缩的上下文完全就是crypto_tfm */
struct crypto_comp = crypto_alloc_comp(driver, type, mask);
    --> crypto_alloc_base(alg_name, type, mask)
            /* find algrithm: use alg_name, driver name */
        --> alg = crypto_alg_mod_lookup(alg_name, type, mask);
            /* 上下文是依据具体的算法去分配的 */
        --> tfm = __crypto_alloc_tfm(alg, type, mask);
            /* 上下文中指定相关的算法 */
            --> tfm->__crt_alg = alg;
            --> crypto_init_ops
                /* 把相应的算法中的压缩解压缩函数传递给上下文 */
                --> crypto_init_compress_ops(tfm)
                        /* ops is struct compress_tfm */
                --> ops->cot_compress = crypto_compress;
                        --> tfm->__crt_alg->cra_compress.coa_compress

                --> ops->cot_decompress = crypto_decompress;
        /*
        * 在创建上下文的最后调用下，算法里的初始化函数，如果是和一个硬件
        * 的驱动适配，那么这里就可以执行相应硬件初始化的内容。
        */
            --> if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))

第二，就是执行压缩的操作:
crypto_comp_compress(tfm, input, ilen, result, &dlen)

crypto_comp_decompress(crypto_comp, src, slen, dst, dlen)
        /* so hardware can do compress here! */
    --> compress_tfm->cot_compress;

第三，就是释放这个压缩的上下文
crypto_free_comp(comp)

  • 从设备驱动的角度讲, 设备驱动只是看到了crypto_alg这个结构。

  • 这个结构里的crypt_tfm 即一个操作执行的上下文是从哪里知道的呢？毕竟crypto_alg这个结构里的.cra_init, .cra_exit, .cra_u里的.coa_compress都需要这个执行上下文。

  • 知道这些内部的数据结构对我们理解外部的API有帮助。现在假设crypto的设备驱动已经有了，那么，其他的内核模块怎么用呢？ 其实一开头我们已经讲到crypto/testmgr.c测试程序。

  • 测试的代码里有异步的测试和同步的测试流程，我们这里先看同步的测试:

  • 主要的逻辑就三个函数, 首先需要分配一个压缩的上下文(本文用压缩的例子), 其实它就是crypto_tfm的包装，和cryto_tfm是一样的:    紫色的删去 ,我没找到这个压缩的例子 

struct crypto_comp {
	struct crypto_tfm base;
};
  • 使用testmgr.c文件中的函数进行分析 

第一步 创建对象  进行准备操作

  •  crypto_alloc_base通过crypro_alg_mod_lookup判断这个算法类型是存在的
  • 才会使用函数__crypto_alloc_tfm为其创建对象

第二步 执行具体的函数操作

 第三步 释放压缩的上下文

例子 异步接口 

static int test_acomp(struct crypto_acomp *tfm,
			      const struct comp_testvec *ctemplate,
		      const struct comp_testvec *dtemplate,
		      int ctcount, int dtcount)
{
	const char *algo = crypto_tfm_alg_driver_name(crypto_acomp_tfm(tfm));
	unsigned int i;
	char *output, *decomp_out;
	int ret;
	struct scatterlist src, dst;
	struct acomp_req *req;
	struct crypto_wait wait;

	output = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
	if (!output)
		return -ENOMEM;

	decomp_out = kmalloc(COMP_BUF_SIZE, GFP_KERNEL);
	if (!decomp_out) {
		kfree(output);
		return -ENOMEM;
	}

	for (i = 0; i < ctcount; i++) {
		unsigned int dlen = COMP_BUF_SIZE;
		int ilen = ctemplate[i].inlen;
		void *input_vec;

		input_vec = kmemdup(ctemplate[i].input, ilen, GFP_KERNEL);
		if (!input_vec) {
			ret = -ENOMEM;
			goto out;
		}

		memset(output, 0, dlen);
		crypto_init_wait(&wait);
		sg_init_one(&src, input_vec, ilen);
		sg_init_one(&dst, output, dlen);

		req = acomp_request_alloc(tfm);
		if (!req) {
			pr_err("alg: acomp: request alloc failed for %s\n",
			       algo);
			kfree(input_vec);
			ret = -ENOMEM;
			goto out;
		}

		acomp_request_set_params(req, &src, &dst, ilen, dlen);
		acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
					   crypto_req_done, &wait);

		ret = crypto_wait_req(crypto_acomp_compress(req), &wait);
		if (ret) {
			pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
			       i + 1, algo, -ret);
			kfree(input_vec);
			acomp_request_free(req);
			goto out;
		}

		ilen = req->dlen;
		dlen = COMP_BUF_SIZE;
		sg_init_one(&src, output, ilen);
		sg_init_one(&dst, decomp_out, dlen);
		crypto_init_wait(&wait);
		acomp_request_set_params(req, &src, &dst, ilen, dlen);

		ret = crypto_wait_req(crypto_acomp_decompress(req), &wait);
		if (ret) {
			pr_err("alg: acomp: compression failed on test %d for %s: ret=%d\n",
			       i + 1, algo, -ret);
			kfree(input_vec);
			acomp_request_free(req);
			goto out;
		}

		if (req->dlen != ctemplate[i].inlen) {
			pr_err("alg: acomp: Compression test %d failed for %s: output len = %d\n",
			       i + 1, algo, req->dlen);
			ret = -EINVAL;
			kfree(input_vec);
			acomp_request_free(req);
			goto out;
		}

		if (memcmp(input_vec, decomp_out, req->dlen)) {
			pr_err("alg: acomp: Compression test %d failed for %s\n",
			       i + 1, algo);
			hexdump(output, req->dlen);
			ret = -EINVAL;
			kfree(input_vec);
			acomp_request_free(req);
			goto out;
		}

		kfree(input_vec);
		acomp_request_free(req);
	}

	for (i = 0; i < dtcount; i++) {
		unsigned int dlen = COMP_BUF_SIZE;
		int ilen = dtemplate[i].inlen;
		void *input_vec;

		input_vec = kmemdup(dtemplate[i].input, ilen, GFP_KERNEL);
		if (!input_vec) {
			ret = -ENOMEM;
			goto out;
		}

		memset(output, 0, dlen);
		crypto_init_wait(&wait);
		sg_init_one(&src, input_vec, ilen);
		sg_init_one(&dst, output, dlen);

		req = acomp_request_alloc(tfm);
		if (!req) {
			pr_err("alg: acomp: request alloc failed for %s\n",
			       algo);
			kfree(input_vec);
			ret = -ENOMEM;
			goto out;
		}

		acomp_request_set_params(req, &src, &dst, ilen, dlen);
		acomp_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
					   crypto_req_done, &wait);

		ret = crypto_wait_req(crypto_acomp_decompress(req), &wait);
		if (ret) {
			pr_err("alg: acomp: decompression failed on test %d for %s: ret=%d\n",
			       i + 1, algo, -ret);
			kfree(input_vec);
			acomp_request_free(req);
			goto out;
		}

		if (req->dlen != dtemplate[i].outlen) {
			pr_err("alg: acomp: Decompression test %d failed for %s: output len = %d\n",
			       i + 1, algo, req->dlen);
			ret = -EINVAL;
			kfree(input_vec);
			acomp_request_free(req);
			goto out;
		}

		if (memcmp(output, dtemplate[i].output, req->dlen)) {
			pr_err("alg: acomp: Decompression test %d failed for %s\n",
			       i + 1, algo);
			hexdump(output, req->dlen);
			ret = -EINVAL;
			kfree(input_vec);
			acomp_request_free(req);
			goto out;
		}

		kfree(input_vec);
		acomp_request_free(req);
	}

	ret = 0;

out:
	kfree(decomp_out);
	kfree(output);
	return ret;
}

  • 这里需要说明的是，testmsg.c里的这个acomp的测试程序里加了wait的相关内容。这里应该是为了测试方便而加的，一般的异步接口里, 当硬件完成操作的时候，在中断函数里直接调用异步接口的回调函数就可以了。
  • request是为了异步而创建的，但是wait对象的存在的主要目的目前还不清楚

例外一个例子

 

总的来说，在内核态使用加密算法的过程分为以下几步：

  • 分配tranform对象   也就是具体的算法
  • 分配request对象  异步操作等待对象
  • 设置上下文 如加密密钥/验签公钥，填充数据源，给scatterlist设置缓冲区，给异步请求对象设置回调函数/初始化向量等，给密码算法对象设置密钥
  • 完成加密/解密/摘要/验签
  • 释放transform,request等对象
  • 如果是同步调用的方式，不需要创建request对象

参考链接

MY CUP OF TEA
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux4.14 加密框架——testmgr.c的分析
yangguoyu8023的博客
06-16 804
testmgr.c的分析
CP AUTOSAR标准之Crypto Driver(AUTOSAR_SWS_CryptoDriver)
最新发布
CoolBreeze的博客
05-06 310
该规范指定了AUTOSAR 基础软件模块加密驱动程序的功能、API 和配置。加密驱动程序位于微控制器抽象层，位于加密硬件抽象层（加密接口[4]）和上层服务层（加密服务管理器[5]）之下。加密驱动程序是特定设备的驱动程序，仅抽象硬件支持的功能。
使用RNGCryptoServiceProvider获得强随机数
04-07
产生介于0到9之间的随机数。
linux4.14 加密框架 —— 算法上下文（1）——tfm简介
yangguoyu8023的博客
02-17 1436
算法上下文
Linux加密框架的应用示例（一）
weixin_43916535的博客
10-18 1750
创建哈希算法实例 crypto_alloc_ahash函数 加密框架中的哈希算法可以是同步方式实现的也可以是异步方式实现的，但是算法应用不关注哈希算法的实现方式，关注的是哈希算法提供的算法接口。为实现统一管理，加密框架将哈希算法的外部接口统一定义为异步哈希算法接口。 算法实例是算法应用和加密框架之间的桥梁，算法应用通过算法实例实现算法调用。以哈希算法实例为例，在IPSEC框架的AH协议模块中，协议状态初始化（ah_init_state函数）时，将根据配置的认证算法名（x->aalg->alg
linux加密框架 crypto 算法管理 - 算法查找接口 crypto_find_alg
CHYabc123456hh的博客
01-04 434
算法查找接口crypto_find_alg 算法实例tfm是算法的一个可运行的副本，因此在创建算法实例前首先要查找确认算法是否已经注册有效，此时算法查找由函数crypto_find_alg实现。 补充： struct crypto_tfm *tfm; crypto_tfm类型指针tfm可以理解为指代了一个算法对象 crypto.h - include/linux/crypto.h - Linux source code (v5.15.12) - Bootlin crypto_alg c..
linux crypto
u014044624的博客
05-17 465
The Linux Kernel-crypto The Linux Kernel-crypto-AEAD_API Kernel Crypto框架 Linux内核crypto子系统学习笔记 Linux内核密码学API--对称密码 AES-GCM加密算法的简单介绍 CCM加密学习 CCM-AES从Linux内核(CCM-AES from Linux Kernel) Linux加解密支持模块代码总体描述 Linux加解密支持模块代码总体描述 Linux加解密支持模块代码详细分析之核心文件分析
Linux内核源码树介绍
05-23
Linux内核的主要功能有存储管理、CPU和进程管理、文件系统、设备管理和驱动、网络通信，以及系统的初始化、系统调用等。 Linux内核源码树是Linux内核的核心部分，包含了所有的源代码文件。了解Linux内核源码树目录...
Linux 内核加解密流程分析
06-21
在深入探讨Linux内核的加解密流程之前，我们需要了解一些基本概念和关键数据结构。Linux内核的加密架构是基于模块化和可扩展的设计，允许添加新的加密算法并高效地处理各种加密任务。 1. 前言 Linux内核的加解密...
Linux 加密文件系统
03-14
近年来随着嵌入式设备应用的不断推广，对个人敏感数据的保护成为人们关注的热点问题，因此对嵌入式设备文件系统的加密成为未来不可或缺的一环，用于对嵌入式设备文件和文件夹进行加密，防止其数据被其他用户或者外部...
linux内核驱动笔记-尚观
12-02
Linux内核不仅包括内存管理，还有其他多个子系统。例如，kernel子系统管理所有软件和硬件资源，进程是资源的集合。在ARM架构中，SWI（Software Interrupt）用于软件中断请求。内核子系统如input、frambuffer提供了...
AES加密算法在Linux文件系统中的设计与研究.pdf
09-06
《AES加密算法在Linux文件系统中的设计与研究》这篇论文主要探讨了如何将先进的AES（高级加密标准）加密算法应用于Linux操作系统中的文件系统，以增强文件系统的安全性，保护用户数据。文章介绍了AES加密算法的基本...
Linux内核的加密函数框架
xinyuan510214的专栏
01-26 7865
原文链接：点击打开链接 Linux内核支持很多加密算法，包括对称加密算法，如AES；摘要算法，如sha1,md5；压缩算法，如deflate。不过内核好像不支持非对称加密算法。这些算法作为加密函数框架的最底层，提供加密和解密的实际操作。这些函数可以在内核crypto文件夹下，相应的文件中找到。不过内核模块不能直接调用这些函数，因为它们并没有export。内核提供一个统一的框架，来管理这些算法。加
Linux内核异步加密接口,Linux内核加密接口分析
weixin_42489252的博客
04-30 184
一、概述Linux内核从2.5版本开始引入了强力的加密机制，主要原因有：删除冗余代码、支持IPSec协议以及通用的加密功能等。将来的应用会包括：硬件加密设备驱动、内核代码签名、硬件随机数生成器、文件系统加密等。二、如何使用加密API1、安装从2.6.6版本之后，内核源码就提供了丰富的密码学算法支持，需要配置编译选项将加密算法作为模块编入内核。如图所示，menuconfig的时候配置这部分选项 重...
chatGPT快问快答之linux crypto子系统
墨染锦年的博客
07-26 672
Linux Crypto子系统是Linux内核中的一个模块化框架，用于提供各种加密和密码学功能。它为应用程序和其他内核组件提供了一组API和接口，使它们能够利用硬件和软件加密功能来执行各种密码学操作。Linux Crypto子系统的主要目标是提供通用的密码学功能，如对称加密、非对称加密、哈希函数、消息认证码等。它支持多种算法和协议，包括AES、DES、RSA、DSA、SHA、MD5等，以及各种密码学模式和协议，如CBC、ECB、CTR、GCM等。
Linux内核 crypto文件夹 密码学知识学习
CHYabc123456hh的博客
12-27 4376
参考链接 Linux source code (v5.15.11) - Bootlin Linux内核 在线源代码 查询函数定义和使用 Linux Kernel(Android) 加密算法总结(一)（cipher、compress、digest）_万能的终端和网络-程序员宅基地 - 程序员宅基地 ...
Linux内核加解密框架介绍
李老板的移动安全杂货铺
12-12 2365
加密框架是Linux内核加密API的核心组成部分，它为内核中的加密操作提供了通用的接口和管理机制。通过使用这些加解密API，应用程序可以通过调用相应的系统调用，直接在内核中进行加解密操作。加密API还提供了范围和散列函数的接口，用于处理分散的数据和计算散列值。使用此API可以获得一个用于RSA公钥加密和解密操作的公钥对象，以便进行加密和解密操作。使用此API可以获得一个用于RSA私钥加密和解密操作的私钥对象，以便进行加密和解密操作。使用此API可以将加密的数据使用RSA私钥进行解密。
Linux加密框架 crypto 算法模板 HMAC模板举例
CHYabc123456hh的博客
12-28 221
参考链接 Linux加密框架中的主要数据结构（三）_家有一希的博客-CSDN博客 Linux加密框架 crypto 算法模板_CHYabc123456hh的博客-CSDN博客 HMAC算法模板 hmac.c - crypto/hmac.c - Linux source code (v5.15.11) - Bootlin hmac.c - crypto/hmac.c - Linux source code (v5.15.11) - Bootlin hmac_create ...
《Linux系统调用：crypt,getpass》
yexiangCSDN的专栏
12-10 585
一、介绍 crypt和getpass结合使用的目的是密码加密和用户认证。某些应用程序会要求用户对自身进行认证，通常会采用用户名+密码认证出于这一目的，应用程序可能会维护其自有的用户名和密码数据库，有时候为了方便让用户输入标准的用户名和密码(定义在/etc/passwd和/etc/shadow之中)登入到远程系统如ssh，ftp等对用户进行认证。 #include <unistd.h...
linux操作系统Crypto模块
05-31
在Linux操作系统中，Crypto模块是用于提供...在使用Crypto模块时，需要先加载Crypto模块，然后通过系统调用或者内核API进行加密和解密操作。同时，为了保证安全性，需要注意密钥的生成和管理、算法的选择和配置等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值