crypto/asymmetric_keys/verify_pefile.c

23 			       struct pefile_context *ctx)
60 		ctx->image_checksum_offset =
62 		ctx->header_size = pe32->header_size;
64 		ctx->n_data_dirents = pe32->data_dirs;
69 		ctx->image_checksum_offset =
71 		ctx->header_size = pe64->header_size;
73 		ctx->n_data_dirents = pe64->data_dirs;
81 	pr_debug("checksum @ %x\n", ctx->image_checksum_offset);
82 	pr_debug("header size = %x\n", ctx->header_size);
84 	if (cursor >= ctx->header_size || ctx->header_size >= datalen)
87 	if (ctx->n_data_dirents > (ctx->header_size - cursor) / sizeof(*dde))
91 	cursor += sizeof(*dde) * ctx->n_data_dirents;
93 	ctx->cert_dirent_offset =
95 	ctx->certs_size = ddir->certs.size;
102 	chkaddr(ctx->header_size, ddir->certs.virtual_address,
104 	ctx->sig_offset = ddir->certs.virtual_address;
105 	ctx->sig_len = ddir->certs.size;
107 		 ctx->sig_len, ctx->sig_offset,
108 		 ctx->sig_len, pebuf + ctx->sig_offset);
110 	ctx->n_sections = pe->sections;
111 	if (ctx->n_sections > (ctx->header_size - cursor) / sizeof(*sec))
113 	ctx->secs = pebuf + cursor;
123 				    struct pefile_context *ctx)
129 	if (ctx->sig_len < sizeof(wrapper)) {
134 	memcpy(&wrapper, pebuf + ctx->sig_offset, sizeof(wrapper));
144 	if (wrapper.length > ctx->sig_len) {
146 			ctx->sig_len, wrapper.length);
163 	ctx->sig_len = wrapper.length;
164 	ctx->sig_offset += sizeof(wrapper);
165 	ctx->sig_len -= sizeof(wrapper);
166 	if (ctx->sig_len < 4) {
172 	pkcs7 = pebuf + ctx->sig_offset;
195 	if (len <= ctx->sig_len) {
197 		ctx->sig_len = len;
246 				     struct pefile_context *ctx,
255 	ret = crypto_shash_update(desc, pebuf, ctx->image_checksum_offset);
259 	tmp = ctx->image_checksum_offset + sizeof(uint32_t);
261 				  ctx->cert_dirent_offset - tmp);
265 	tmp = ctx->cert_dirent_offset + sizeof(struct data_dirent);
266 	ret = crypto_shash_update(desc, pebuf + tmp, ctx->header_size - tmp);
270 	canon = kcalloc(ctx->n_sections, sizeof(unsigned), GFP_KERNEL);
278 	for (loop = 1; loop < ctx->n_sections; loop++) {
280 			if (pefile_compare_shdrs(&ctx->secs[canon[i]],
281 						 &ctx->secs[loop]) > 0) {
290 	hashed_bytes = ctx->header_size;
291 	for (loop = 0; loop < ctx->n_sections; loop++) {
293 		if (ctx->secs[i].raw_data_size == 0)
296 					  pebuf + ctx->secs[i].data_addr,
297 					  ctx->secs[i].raw_data_size);
302 		hashed_bytes += ctx->secs[i].raw_data_size;
307 		tmp = hashed_bytes + ctx->certs_size;
323 			    struct pefile_context *ctx)
331 	kenter(",%s", ctx->digest_algo);
336 	tfm = crypto_alloc_shash(ctx->digest_algo, 0, 0);
343 	if (digest_size != ctx->digest_len) {
345 			digest_size, ctx->digest_len);
361 	ret = pefile_digest_pe_contents(pebuf, pelen, ctx, desc);
370 	pr_debug("Digest calc = [%*ph]\n", ctx->digest_len, digest);
375 	if (memcmp(digest, ctx->digest, ctx->digest_len) != 0) {
424 	struct pefile_context ctx;
429 	memset(&ctx, 0, sizeof(ctx));
430 	ret = pefile_parse_binary(pebuf, pelen, &ctx);
434 	ret = pefile_strip_sig_wrapper(pebuf, &ctx);
439 				     pebuf + ctx.sig_offset, ctx.sig_len,
441 				     mscode_parse, &ctx);
446 		 ctx.digest_len, ctx.digest_len, ctx.digest);
451 	ret = pefile_digest_pe(pebuf, pelen, &ctx);
454 	kfree_sensitive(ctx.digest);