]> git.proxmox.com Git - mirror_edk2.git/blob - CryptoPkg/Library/BaseCryptLib/Pk/CryptPkcs7Verify.c
projects / mirror_edk2.git / blob
? search:


bf67a1f569a2b664ecac8d4d3ab2e1a3d3afe15d
[mirror_edk2.git] / CryptoPkg / Library / BaseCryptLib / Pk / CryptPkcs7Verify.c
1 /** @file
2 PKCS#7 SignedData Verification Wrapper Implementation over OpenSSL.
3
4 Caution: This module requires additional review when modified.
5 This library will have external input - signature (e.g. UEFI Authenticated
6 Variable). It may by input in SMM mode.
7 This external input must be validated carefully to avoid security issue like
8 buffer overflow, integer overflow.
9
10 WrapPkcs7Data(), Pkcs7GetSigners(), Pkcs7Verify() will get UEFI Authenticated
11 Variable and will do basic check for data structure.
12
13 Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
14 This program and the accompanying materials
15 are licensed and made available under the terms and conditions of the BSD License
16 which accompanies this distribution. The full text of the license may be found at
17 http://opensource.org/licenses/bsd-license.php
18
19 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
20 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
21
22 **/
23
24 #include "InternalCryptLib.h"
25
26 #include <openssl/objects.h>
27 #include <openssl/x509.h>
28 #include <openssl/x509v3.h>
29 #include <openssl/pkcs7.h>
30
31 UINT8 mOidValue[9] = { 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x02 };
32
33 /**
34 Check input P7Data is a wrapped ContentInfo structure or not. If not construct
35 a new structure to wrap P7Data.
36
37 Caution: This function may receive untrusted input.
38 UEFI Authenticated Variable is external input, so this function will do basic
39 check for PKCS#7 data structure.
40
41 @param[in] P7Data Pointer to the PKCS#7 message to verify.
42 @param[in] P7Length Length of the PKCS#7 message in bytes.
43 @param[out] WrapFlag If TRUE P7Data is a ContentInfo structure, otherwise
44 return FALSE.
45 @param[out] WrapData If return status of this function is TRUE:
46 1) when WrapFlag is TRUE, pointer to P7Data.
47 2) when WrapFlag is FALSE, pointer to a new ContentInfo
48 structure. It's caller's responsibility to free this
49 buffer.
50 @param[out] WrapDataSize Length of ContentInfo structure in bytes.
51
52 @retval TRUE The operation is finished successfully.
53 @retval FALSE The operation is failed due to lack of resources.
54
55 **/
56 BOOLEAN
57 WrapPkcs7Data (
58 IN CONST UINT8 *P7Data,
59 IN UINTN P7Length,
60 OUT BOOLEAN *WrapFlag,
61 OUT UINT8 **WrapData,
62 OUT UINTN *WrapDataSize
63 )
64 {
65 BOOLEAN Wrapped;
66 UINT8 *SignedData;
67
68 //
69 // Check whether input P7Data is a wrapped ContentInfo structure or not.
70 //
71 Wrapped = FALSE;
72 if ((P7Data[4] == 0x06) && (P7Data[5] == 0x09)) {
73 if (CompareMem (P7Data + 6, mOidValue, sizeof (mOidValue)) == 0) {
74 if ((P7Data[15] == 0xA0) && (P7Data[16] == 0x82)) {
75 Wrapped = TRUE;
76 }
77 }
78 }
79
80 if (Wrapped) {
81 *WrapData = (UINT8 *) P7Data;
82 *WrapDataSize = P7Length;
83 } else {
84 //
85 // Wrap PKCS#7 signeddata to a ContentInfo structure - add a header in 19 bytes.
86 //
87 *WrapDataSize = P7Length + 19;
88 *WrapData = malloc (*WrapDataSize);
89 if (*WrapData == NULL) {
90 *WrapFlag = Wrapped;
91 return FALSE;
92 }
93
94 SignedData = *WrapData;
95
96 //
97 // Part1: 0x30, 0x82.
98 //
99 SignedData[0] = 0x30;
100 SignedData[1] = 0x82;
101
102 //
103 // Part2: Length1 = P7Length + 19 - 4, in big endian.
104 //
105 SignedData[2] = (UINT8) (((UINT16) (*WrapDataSize - 4)) >> 8);
106 SignedData[3] = (UINT8) (((UINT16) (*WrapDataSize - 4)) & 0xff);
107
108 //
109 // Part3: 0x06, 0x09.
110 //
111 SignedData[4] = 0x06;
112 SignedData[5] = 0x09;
113
114 //
115 // Part4: OID value -- 0x2A 0x86 0x48 0x86 0xF7 0x0D 0x01 0x07 0x02.
116 //
117 CopyMem (SignedData + 6, mOidValue, sizeof (mOidValue));
118
119 //
120 // Part5: 0xA0, 0x82.
121 //
122 SignedData[15] = 0xA0;
123 SignedData[16] = 0x82;
124
125 //
126 // Part6: Length2 = P7Length, in big endian.
127 //
128 SignedData[17] = (UINT8) (((UINT16) P7Length) >> 8);
129 SignedData[18] = (UINT8) (((UINT16) P7Length) & 0xff);
130
131 //
132 // Part7: P7Data.
133 //
134 CopyMem (SignedData + 19, P7Data, P7Length);
135 }
136
137 *WrapFlag = Wrapped;
138 return TRUE;
139 }
140
141 /**
142 Pop single certificate from STACK_OF(X509).
143
144 If X509Stack, Cert, or CertSize is NULL, then return FALSE.
145
146 @param[in] X509Stack Pointer to a X509 stack object.
147 @param[out] Cert Pointer to a X509 certificate.
148 @param[out] CertSize Length of output X509 certificate in bytes.
149
150 @retval TRUE The X509 stack pop succeeded.
151 @retval FALSE The pop operation failed.
152
153 **/
154 BOOLEAN
155 X509PopCertificate (
156 IN VOID *X509Stack,
157 OUT UINT8 **Cert,
158 OUT UINTN *CertSize
159 )
160 {
161 BIO *CertBio;
162 X509 *X509Cert;
163 STACK_OF(X509) *CertStack;
164 BOOLEAN Status;
165 INT32 Result;
166 BUF_MEM *Ptr;
167 INT32 Length;
168 VOID *Buffer;
169
170 Status = FALSE;
171
172 if ((X509Stack == NULL) || (Cert == NULL) || (CertSize == NULL)) {
173 return Status;
174 }
175
176 CertStack = (STACK_OF(X509) *) X509Stack;
177
178 X509Cert = sk_X509_pop (CertStack);
179
180 if (X509Cert == NULL) {
181 return Status;
182 }
183
184 Buffer = NULL;
185
186 CertBio = BIO_new (BIO_s_mem ());
187 if (CertBio == NULL) {
188 return Status;
189 }
190
191 Result = i2d_X509_bio (CertBio, X509Cert);
192 if (Result == 0) {
193 goto _Exit;
194 }
195
196 BIO_get_mem_ptr (CertBio, &Ptr);
197 Length = (INT32)(Ptr->length);
198 if (Length <= 0) {
199 goto _Exit;
200 }
201
202 Buffer = malloc (Length);
203 if (Buffer == NULL) {
204 goto _Exit;
205 }
206
207 Result = BIO_read (CertBio, Buffer, Length);
208 if (Result != Length) {
209 goto _Exit;
210 }
211
212 *Cert = Buffer;
213 *CertSize = Length;
214
215 Status = TRUE;
216
217 _Exit:
218
219 BIO_free (CertBio);
220
221 if (!Status && (Buffer != NULL)) {
222 free (Buffer);
223 }
224
225 return Status;
226 }
227
228 /**
229 Get the signer's certificates from PKCS#7 signed data as described in "PKCS #7:
230 Cryptographic Message Syntax Standard". The input signed data could be wrapped
231 in a ContentInfo structure.
232
233 If P7Data, CertStack, StackLength, TrustedCert or CertLength is NULL, then
234 return FALSE. If P7Length overflow, then return FALSE.
235
236 Caution: This function may receive untrusted input.
237 UEFI Authenticated Variable is external input, so this function will do basic
238 check for PKCS#7 data structure.
239
240 @param[in] P7Data Pointer to the PKCS#7 message to verify.
241 @param[in] P7Length Length of the PKCS#7 message in bytes.
242 @param[out] CertStack Pointer to Signer's certificates retrieved from P7Data.
243 It's caller's responsibility to free the buffer.
244 @param[out] StackLength Length of signer's certificates in bytes.
245 @param[out] TrustedCert Pointer to a trusted certificate from Signer's certificates.
246 It's caller's responsibility to free the buffer.
247 @param[out] CertLength Length of the trusted certificate in bytes.
248
249 @retval TRUE The operation is finished successfully.
250 @retval FALSE Error occurs during the operation.
251
252 **/
253 BOOLEAN
254 EFIAPI
255 Pkcs7GetSigners (
256 IN CONST UINT8 *P7Data,
257 IN UINTN P7Length,
258 OUT UINT8 **CertStack,
259 OUT UINTN *StackLength,
260 OUT UINT8 **TrustedCert,
261 OUT UINTN *CertLength
262 )
263 {
264 PKCS7 *Pkcs7;
265 BOOLEAN Status;
266 UINT8 *SignedData;
267 CONST UINT8 *Temp;
268 UINTN SignedDataSize;
269 BOOLEAN Wrapped;
270 STACK_OF(X509) *Stack;
271 UINT8 Index;
272 UINT8 *CertBuf;
273 UINT8 *OldBuf;
274 UINTN BufferSize;
275 UINTN OldSize;
276 UINT8 *SingleCert;
277 UINTN SingleCertSize;
278
279 if ((P7Data == NULL) || (CertStack == NULL) || (StackLength == NULL) ||
280 (TrustedCert == NULL) || (CertLength == NULL) || (P7Length > INT_MAX)) {
281 return FALSE;
282 }
283
284 Status = WrapPkcs7Data (P7Data, P7Length, &Wrapped, &SignedData, &SignedDataSize);
285 if (!Status) {
286 return Status;
287 }
288
289 Status = FALSE;
290 Pkcs7 = NULL;
291 Stack = NULL;
292 CertBuf = NULL;
293 OldBuf = NULL;
294 SingleCert = NULL;
295
296 //
297 // Retrieve PKCS#7 Data (DER encoding)
298 //
299 if (SignedDataSize > INT_MAX) {
300 goto _Exit;
301 }
302
303 Temp = SignedData;
304 Pkcs7 = d2i_PKCS7 (NULL, (const unsigned char **) &Temp, (int) SignedDataSize);
305 if (Pkcs7 == NULL) {
306 goto _Exit;
307 }
308
309 //
310 // Check if it's PKCS#7 Signed Data (for Authenticode Scenario)
311 //
312 if (!PKCS7_type_is_signed (Pkcs7)) {
313 goto _Exit;
314 }
315
316 Stack = PKCS7_get0_signers(Pkcs7, NULL, PKCS7_BINARY);
317 if (Stack == NULL) {
318 goto _Exit;
319 }
320
321 //
322 // Convert CertStack to buffer in following format:
323 // UINT8 CertNumber;
324 // UINT32 Cert1Length;
325 // UINT8 Cert1[];
326 // UINT32 Cert2Length;
327 // UINT8 Cert2[];
328 // ...
329 // UINT32 CertnLength;
330 // UINT8 Certn[];
331 //
332 BufferSize = sizeof (UINT8);
333 OldSize = BufferSize;
334
335 for (Index = 0; ; Index++) {
336 Status = X509PopCertificate (Stack, &SingleCert, &SingleCertSize);
337 if (!Status) {
338 break;
339 }
340
341 OldSize = BufferSize;
342 OldBuf = CertBuf;
343 BufferSize = OldSize + SingleCertSize + sizeof (UINT32);
344 CertBuf = malloc (BufferSize);
345
346 if (CertBuf == NULL) {
347 goto _Exit;
348 }
349
350 if (OldBuf != NULL) {
351 CopyMem (CertBuf, OldBuf, OldSize);
352 free (OldBuf);
353 OldBuf = NULL;
354 }
355
356 WriteUnaligned32 ((UINT32 *) (CertBuf + OldSize), (UINT32) SingleCertSize);
357 CopyMem (CertBuf + OldSize + sizeof (UINT32), SingleCert, SingleCertSize);
358
359 free (SingleCert);
360 SingleCert = NULL;
361 }
362
363 if (CertBuf != NULL) {
364 //
365 // Update CertNumber.
366 //
367 CertBuf[0] = Index;
368
369 *CertLength = BufferSize - OldSize - sizeof (UINT32);
370 *TrustedCert = malloc (*CertLength);
371 if (*TrustedCert == NULL) {
372 goto _Exit;
373 }
374
375 CopyMem (*TrustedCert, CertBuf + OldSize + sizeof (UINT32), *CertLength);
376 *CertStack = CertBuf;
377 *StackLength = BufferSize;
378 Status = TRUE;
379 }
380
381 _Exit:
382 //
383 // Release Resources
384 //
385 if (!Wrapped) {
386 free (SignedData);
387 }
388
389 if (Pkcs7 != NULL) {
390 PKCS7_free (Pkcs7);
391 }
392
393 if (Stack != NULL) {
394 sk_X509_pop_free(Stack, X509_free);
395 }
396
397 if (SingleCert != NULL) {
398 free (SingleCert);
399 }
400
401 if (!Status && (CertBuf != NULL)) {
402 free (CertBuf);
403 *CertStack = NULL;
404 }
405
406 if (OldBuf != NULL) {
407 free (OldBuf);
408 }
409
410 return Status;
411 }
412
413 /**
414 Wrap function to use free() to free allocated memory for certificates.
415
416 @param[in] Certs Pointer to the certificates to be freed.
417
418 **/
419 VOID
420 EFIAPI
421 Pkcs7FreeSigners (
422 IN UINT8 *Certs
423 )
424 {
425 if (Certs == NULL) {
426 return;
427 }
428
429 free (Certs);
430 }
431
432 /**
433 Retrieves all embedded certificates from PKCS#7 signed data as described in "PKCS #7:
434 Cryptographic Message Syntax Standard", and outputs two certificate lists chained and
435 unchained to the signer's certificates.
436 The input signed data could be wrapped in a ContentInfo structure.
437
438 @param[in] P7Data Pointer to the PKCS#7 message.
439 @param[in] P7Length Length of the PKCS#7 message in bytes.
440 @param[out] SignerChainCerts Pointer to the certificates list chained to signer's
441 certificate. It's caller's responsibility to free the buffer.
442 @param[out] ChainLength Length of the chained certificates list buffer in bytes.
443 @param[out] UnchainCerts Pointer to the unchained certificates lists. It's caller's
444 responsibility to free the buffer.
445 @param[out] UnchainLength Length of the unchained certificates list buffer in bytes.
446
447 @retval TRUE The operation is finished successfully.
448 @retval FALSE Error occurs during the operation.
449
450 **/
451 BOOLEAN
452 EFIAPI
453 Pkcs7GetCertificatesList (
454 IN CONST UINT8 *P7Data,
455 IN UINTN P7Length,
456 OUT UINT8 **SignerChainCerts,
457 OUT UINTN *ChainLength,
458 OUT UINT8 **UnchainCerts,
459 OUT UINTN *UnchainLength
460 )
461 {
462 BOOLEAN Status;
463 UINT8 *NewP7Data;
464 UINTN NewP7Length;
465 BOOLEAN Wrapped;
466 UINT8 Index;
467 PKCS7 *Pkcs7;
468 X509_STORE_CTX *CertCtx;
469 STACK_OF(X509) *CtxChain;
470 STACK_OF(X509) *CtxUntrusted;
471 X509 *CtxCert;
472 STACK_OF(X509) *Signers;
473 X509 *Signer;
474 X509 *Cert;
475 X509 *Issuer;
476 X509_NAME *IssuerName;
477 UINT8 *CertBuf;
478 UINT8 *OldBuf;
479 UINTN BufferSize;
480 UINTN OldSize;
481 UINT8 *SingleCert;
482 UINTN CertSize;
483
484 //
485 // Initializations
486 //
487 Status = FALSE;
488 NewP7Data = NULL;
489 Pkcs7 = NULL;
490 CertCtx = NULL;
491 CtxChain = NULL;
492 CtxCert = NULL;
493 CtxUntrusted = NULL;
494 Cert = NULL;
495 SingleCert = NULL;
496 CertBuf = NULL;
497 OldBuf = NULL;
498 Signers = NULL;
499
500 ZeroMem (&CertCtx, sizeof (CertCtx));
501
502 //
503 // Parameter Checking
504 //
505 if ((P7Data == NULL) || (SignerChainCerts == NULL) || (ChainLength == NULL) ||
506 (UnchainCerts == NULL) || (UnchainLength == NULL) || (P7Length > INT_MAX)) {
507 return Status;
508 }
509
510 *SignerChainCerts = NULL;
511 *ChainLength = 0;
512 *UnchainCerts = NULL;
513 *UnchainLength = 0;
514
515 //
516 // Construct a new PKCS#7 data wrapping with ContentInfo structure if needed.
517 //
518 Status = WrapPkcs7Data (P7Data, P7Length, &Wrapped, &NewP7Data, &NewP7Length);
519 if (!Status || (NewP7Length > INT_MAX)) {
520 goto _Error;
521 }
522
523 //
524 // Decodes PKCS#7 SignedData
525 //
526 Pkcs7 = d2i_PKCS7 (NULL, (const unsigned char **) &NewP7Data, (int) NewP7Length);
527 if ((Pkcs7 == NULL) || (!PKCS7_type_is_signed (Pkcs7))) {
528 goto _Error;
529 }
530
531 //
532 // Obtains Signer's Certificate from PKCS#7 data
533 // NOTE: Only one signer case will be handled in this function, which means SignerInfos
534 // should include only one signer's certificate.
535 //
536 Signers = PKCS7_get0_signers (Pkcs7, NULL, PKCS7_BINARY);
537 if ((Signers == NULL) || (sk_X509_num (Signers) != 1)) {
538 goto _Error;
539 }
540 Signer = sk_X509_value (Signers, 0);
541
542 CertCtx = X509_STORE_CTX_new ();
543 if (CertCtx == NULL) {
544 goto _Error;
545 }
546 if (!X509_STORE_CTX_init (CertCtx, NULL, Signer, Pkcs7->d.sign->cert)) {
547 goto _Error;
548 }
549 //
550 // Initialize Chained & Untrusted stack
551 //
552 CtxChain = X509_STORE_CTX_get0_chain (CertCtx);
553 CtxCert = X509_STORE_CTX_get0_cert (CertCtx);
554 if (CtxChain == NULL) {
555 if (((CtxChain = sk_X509_new_null ()) == NULL) ||
556 (!sk_X509_push (CtxChain, CtxCert))) {
557 goto _Error;
558 }
559 }
560 CtxUntrusted = X509_STORE_CTX_get0_untrusted (CertCtx);
561 if (CtxUntrusted != NULL) {
562 (VOID)sk_X509_delete_ptr (CtxUntrusted, Signer);
563 }
564
565 //
566 // Build certificates stack chained from Signer's certificate.
567 //
568 Cert = Signer;
569 for (; ;) {
570 //
571 // Self-Issue checking
572 //
573 Issuer = NULL;
574 if (X509_STORE_CTX_get1_issuer (&Issuer, CertCtx, Cert) == 1) {
575 if (X509_cmp (Issuer, Cert) == 0) {
576 break;
577 }
578 }
579
580 //
581 // Found the issuer of the current certificate
582 //
583 if (CtxUntrusted != NULL) {
584 Issuer = NULL;
585 IssuerName = X509_get_issuer_name (Cert);
586 Issuer = X509_find_by_subject (CtxUntrusted, IssuerName);
587 if (Issuer != NULL) {
588 if (!sk_X509_push (CtxChain, Issuer)) {
589 goto _Error;
590 }
591 (VOID)sk_X509_delete_ptr (CtxUntrusted, Issuer);
592
593 Cert = Issuer;
594 continue;
595 }
596 }
597
598 break;
599 }
600
601 //
602 // Converts Chained and Untrusted Certificate to Certificate Buffer in following format:
603 // UINT8 CertNumber;
604 // UINT32 Cert1Length;
605 // UINT8 Cert1[];
606 // UINT32 Cert2Length;
607 // UINT8 Cert2[];
608 // ...
609 // UINT32 CertnLength;
610 // UINT8 Certn[];
611 //
612
613 if (CtxChain != NULL) {
614 BufferSize = sizeof (UINT8);
615 CertBuf = NULL;
616
617 for (Index = 0; ; Index++) {
618 Status = X509PopCertificate (CtxChain, &SingleCert, &CertSize);
619 if (!Status) {
620 break;
621 }
622
623 OldSize = BufferSize;
624 OldBuf = CertBuf;
625 BufferSize = OldSize + CertSize + sizeof (UINT32);
626 CertBuf = malloc (BufferSize);
627
628 if (CertBuf == NULL) {
629 Status = FALSE;
630 goto _Error;
631 }
632 if (OldBuf != NULL) {
633 CopyMem (CertBuf, OldBuf, OldSize);
634 free (OldBuf);
635 OldBuf = NULL;
636 }
637
638 WriteUnaligned32 ((UINT32 *) (CertBuf + OldSize), (UINT32) CertSize);
639 CopyMem (CertBuf + OldSize + sizeof (UINT32), SingleCert, CertSize);
640
641 free (SingleCert);
642 SingleCert = NULL;
643 }
644
645 if (CertBuf != NULL) {
646 //
647 // Update CertNumber.
648 //
649 CertBuf[0] = Index;
650
651 *SignerChainCerts = CertBuf;
652 *ChainLength = BufferSize;
653 }
654 }
655
656 if (CtxUntrusted != NULL) {
657 BufferSize = sizeof (UINT8);
658 CertBuf = NULL;
659
660 for (Index = 0; ; Index++) {
661 Status = X509PopCertificate (CtxUntrusted, &SingleCert, &CertSize);
662 if (!Status) {
663 break;
664 }
665
666 OldSize = BufferSize;
667 OldBuf = CertBuf;
668 BufferSize = OldSize + CertSize + sizeof (UINT32);
669 CertBuf = malloc (BufferSize);
670
671 if (CertBuf == NULL) {
672 Status = FALSE;
673 goto _Error;
674 }
675 if (OldBuf != NULL) {
676 CopyMem (CertBuf, OldBuf, OldSize);
677 free (OldBuf);
678 OldBuf = NULL;
679 }
680
681 WriteUnaligned32 ((UINT32 *) (CertBuf + OldSize), (UINT32) CertSize);
682 CopyMem (CertBuf + OldSize + sizeof (UINT32), SingleCert, CertSize);
683
684 free (SingleCert);
685 SingleCert = NULL;
686 }
687
688 if (CertBuf != NULL) {
689 //
690 // Update CertNumber.
691 //
692 CertBuf[0] = Index;
693
694 *UnchainCerts = CertBuf;
695 *UnchainLength = BufferSize;
696 }
697 }
698
699 Status = TRUE;
700
701 _Error:
702 //
703 // Release Resources.
704 //
705 if (!Wrapped && (NewP7Data != NULL)) {
706 free (NewP7Data);
707 }
708
709 if (Pkcs7 != NULL) {
710 PKCS7_free (Pkcs7);
711 }
712 sk_X509_free (Signers);
713
714 if (CertCtx != NULL) {
715 X509_STORE_CTX_cleanup (CertCtx);
716 X509_STORE_CTX_free (CertCtx);
717 }
718
719 if (SingleCert != NULL) {
720 free (SingleCert);
721 }
722
723 if (OldBuf != NULL) {
724 free (OldBuf);
725 }
726
727 if (!Status && (CertBuf != NULL)) {
728 free (CertBuf);
729 *SignerChainCerts = NULL;
730 *UnchainCerts = NULL;
731 }
732
733 return Status;
734 }
735
736 /**
737 Verifies the validity of a PKCS#7 signed data as described in "PKCS #7:
738 Cryptographic Message Syntax Standard". The input signed data could be wrapped
739 in a ContentInfo structure.
740
741 If P7Data, TrustedCert or InData is NULL, then return FALSE.
742 If P7Length, CertLength or DataLength overflow, then return FALSE.
743
744 Caution: This function may receive untrusted input.
745 UEFI Authenticated Variable is external input, so this function will do basic
746 check for PKCS#7 data structure.
747
748 @param[in] P7Data Pointer to the PKCS#7 message to verify.
749 @param[in] P7Length Length of the PKCS#7 message in bytes.
750 @param[in] TrustedCert Pointer to a trusted/root certificate encoded in DER, which
751 is used for certificate chain verification.
752 @param[in] CertLength Length of the trusted certificate in bytes.
753 @param[in] InData Pointer to the content to be verified.
754 @param[in] DataLength Length of InData in bytes.
755
756 @retval TRUE The specified PKCS#7 signed data is valid.
757 @retval FALSE Invalid PKCS#7 signed data.
758
759 **/
760 BOOLEAN
761 EFIAPI
762 Pkcs7Verify (
763 IN CONST UINT8 *P7Data,
764 IN UINTN P7Length,
765 IN CONST UINT8 *TrustedCert,
766 IN UINTN CertLength,
767 IN CONST UINT8 *InData,
768 IN UINTN DataLength
769 )
770 {
771 PKCS7 *Pkcs7;
772 BIO *DataBio;
773 BOOLEAN Status;
774 X509 *Cert;
775 X509_STORE *CertStore;
776 UINT8 *SignedData;
777 CONST UINT8 *Temp;
778 UINTN SignedDataSize;
779 BOOLEAN Wrapped;
780
781 //
782 // Check input parameters.
783 //
784 if (P7Data == NULL || TrustedCert == NULL || InData == NULL ||
785 P7Length > INT_MAX || CertLength > INT_MAX || DataLength > INT_MAX) {
786 return FALSE;
787 }
788
789 Pkcs7 = NULL;
790 DataBio = NULL;
791 Cert = NULL;
792 CertStore = NULL;
793
794 //
795 // Register & Initialize necessary digest algorithms for PKCS#7 Handling
796 //
797 if (EVP_add_digest (EVP_md5 ()) == 0) {
798 return FALSE;
799 }
800 if (EVP_add_digest (EVP_sha1 ()) == 0) {
801 return FALSE;
802 }
803 if (EVP_add_digest (EVP_sha256 ()) == 0) {
804 return FALSE;
805 }
806 if (EVP_add_digest (EVP_sha384 ()) == 0) {
807 return FALSE;
808 }
809 if (EVP_add_digest (EVP_sha512 ()) == 0) {
810 return FALSE;
811 }
812 if (EVP_add_digest_alias (SN_sha1WithRSAEncryption, SN_sha1WithRSA) == 0) {
813 return FALSE;
814 }
815
816 Status = WrapPkcs7Data (P7Data, P7Length, &Wrapped, &SignedData, &SignedDataSize);
817 if (!Status) {
818 return Status;
819 }
820
821 Status = FALSE;
822
823 //
824 // Retrieve PKCS#7 Data (DER encoding)
825 //
826 if (SignedDataSize > INT_MAX) {
827 goto _Exit;
828 }
829
830 Temp = SignedData;
831 Pkcs7 = d2i_PKCS7 (NULL, (const unsigned char **) &Temp, (int) SignedDataSize);
832 if (Pkcs7 == NULL) {
833 goto _Exit;
834 }
835
836 //
837 // Check if it's PKCS#7 Signed Data (for Authenticode Scenario)
838 //
839 if (!PKCS7_type_is_signed (Pkcs7)) {
840 goto _Exit;
841 }
842
843 //
844 // Read DER-encoded root certificate and Construct X509 Certificate
845 //
846 Temp = TrustedCert;
847 Cert = d2i_X509 (NULL, &Temp, (long) CertLength);
848 if (Cert == NULL) {
849 goto _Exit;
850 }
851
852 //
853 // Setup X509 Store for trusted certificate
854 //
855 CertStore = X509_STORE_new ();
856 if (CertStore == NULL) {
857 goto _Exit;
858 }
859 if (!(X509_STORE_add_cert (CertStore, Cert))) {
860 goto _Exit;
861 }
862
863 //
864 // For generic PKCS#7 handling, InData may be NULL if the content is present
865 // in PKCS#7 structure. So ignore NULL checking here.
866 //
867 DataBio = BIO_new (BIO_s_mem ());
868 if (DataBio == NULL) {
869 goto _Exit;
870 }
871
872 if (BIO_write (DataBio, InData, (int) DataLength) <= 0) {
873 goto _Exit;
874 }
875
876 //
877 // Allow partial certificate chains, terminated by a non-self-signed but
878 // still trusted intermediate certificate. Also disable time checks.
879 //
880 X509_STORE_set_flags (CertStore,
881 X509_V_FLAG_PARTIAL_CHAIN | X509_V_FLAG_NO_CHECK_TIME);
882
883 //
884 // OpenSSL PKCS7 Verification by default checks for SMIME (email signing) and
885 // doesn't support the extended key usage for Authenticode Code Signing.
886 // Bypass the certificate purpose checking by enabling any purposes setting.
887 //
888 X509_STORE_set_purpose (CertStore, X509_PURPOSE_ANY);
889
890 //
891 // Verifies the PKCS#7 signedData structure
892 //
893 Status = (BOOLEAN) PKCS7_verify (Pkcs7, NULL, CertStore, DataBio, NULL, PKCS7_BINARY);
894
895 _Exit:
896 //
897 // Release Resources
898 //
899 BIO_free (DataBio);
900 X509_free (Cert);
901 X509_STORE_free (CertStore);
902 PKCS7_free (Pkcs7);
903
904 if (!Wrapped) {
905 OPENSSL_free (SignedData);
906 }
907
908 return Status;
909 }
910
911 /**
912 Extracts the attached content from a PKCS#7 signed data if existed. The input signed
913 data could be wrapped in a ContentInfo structure.
914
915 If P7Data, Content, or ContentSize is NULL, then return FALSE. If P7Length overflow,
916 then return FALSE. If the P7Data is not correctly formatted, then return FALSE.
917
918 Caution: This function may receive untrusted input. So this function will do
919 basic check for PKCS#7 data structure.
920
921 @param[in] P7Data Pointer to the PKCS#7 signed data to process.
922 @param[in] P7Length Length of the PKCS#7 signed data in bytes.
923 @param[out] Content Pointer to the extracted content from the PKCS#7 signedData.
924 It's caller's responsibility to free the buffer.
925 @param[out] ContentSize The size of the extracted content in bytes.
926
927 @retval TRUE The P7Data was correctly formatted for processing.
928 @retval FALSE The P7Data was not correctly formatted for processing.
929
930 **/
931 BOOLEAN
932 EFIAPI
933 Pkcs7GetAttachedContent (
934 IN CONST UINT8 *P7Data,
935 IN UINTN P7Length,
936 OUT VOID **Content,
937 OUT UINTN *ContentSize
938 )
939 {
940 BOOLEAN Status;
941 PKCS7 *Pkcs7;
942 UINT8 *SignedData;
943 UINTN SignedDataSize;
944 BOOLEAN Wrapped;
945 CONST UINT8 *Temp;
946 ASN1_OCTET_STRING *OctStr;
947
948 //
949 // Check input parameter.
950 //
951 if ((P7Data == NULL) || (P7Length > INT_MAX) || (Content == NULL) || (ContentSize == NULL)) {
952 return FALSE;
953 }
954
955 *Content = NULL;
956 Pkcs7 = NULL;
957 SignedData = NULL;
958 OctStr = NULL;
959
960 Status = WrapPkcs7Data (P7Data, P7Length, &Wrapped, &SignedData, &SignedDataSize);
961 if (!Status || (SignedDataSize > INT_MAX)) {
962 goto _Exit;
963 }
964
965 Status = FALSE;
966
967 //
968 // Decoding PKCS#7 SignedData
969 //
970 Temp = SignedData;
971 Pkcs7 = d2i_PKCS7 (NULL, (const unsigned char **)&Temp, (int)SignedDataSize);
972 if (Pkcs7 == NULL) {
973 goto _Exit;
974 }
975
976 //
977 // The type of Pkcs7 must be signedData
978 //
979 if (!PKCS7_type_is_signed (Pkcs7)) {
980 goto _Exit;
981 }
982
983 //
984 // Check for detached or attached content
985 //
986 if (PKCS7_get_detached (Pkcs7)) {
987 //
988 // No Content supplied for PKCS7 detached signedData
989 //
990 *Content = NULL;
991 *ContentSize = 0;
992 } else {
993 //
994 // Retrieve the attached content in PKCS7 signedData
995 //
996 OctStr = Pkcs7->d.sign->contents->d.data;
997 if ((OctStr->length > 0) && (OctStr->data != NULL)) {
998 *ContentSize = OctStr->length;
999 *Content = malloc (*ContentSize);
1000 if (*Content == NULL) {
1001 *ContentSize = 0;
1002 goto _Exit;
1003 }
1004 CopyMem (*Content, OctStr->data, *ContentSize);
1005 }
1006 }
1007 Status = TRUE;
1008
1009 _Exit:
1010 //
1011 // Release Resources
1012 //
1013 PKCS7_free (Pkcs7);
1014
1015 if (!Wrapped) {
1016 OPENSSL_free (SignedData);
1017 }
1018
1019 return Status;
1020 }
EFI Development Kit II mirror for PVE