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


dcaba436797a1507a14280c783d9c085a5c131e2
[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 - 2016, 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 INT32 Length;
167 VOID *Buffer;
168
169 Status = FALSE;
170
171 if ((X509Stack == NULL) || (Cert == NULL) || (CertSize == NULL)) {
172 return Status;
173 }
174
175 CertStack = (STACK_OF(X509) *) X509Stack;
176
177 X509Cert = sk_X509_pop (CertStack);
178
179 if (X509Cert == NULL) {
180 return Status;
181 }
182
183 Buffer = NULL;
184
185 CertBio = BIO_new (BIO_s_mem ());
186 if (CertBio == NULL) {
187 return Status;
188 }
189
190 Result = i2d_X509_bio (CertBio, X509Cert);
191 if (Result == 0) {
192 goto _Exit;
193 }
194
195 Length = (INT32)(((BUF_MEM *) CertBio->ptr)->length);
196 if (Length <= 0) {
197 goto _Exit;
198 }
199
200 Buffer = malloc (Length);
201 if (Buffer == NULL) {
202 goto _Exit;
203 }
204
205 Result = BIO_read (CertBio, Buffer, Length);
206 if (Result != Length) {
207 goto _Exit;
208 }
209
210 *Cert = Buffer;
211 *CertSize = Length;
212
213 Status = TRUE;
214
215 _Exit:
216
217 BIO_free (CertBio);
218
219 if (!Status && (Buffer != NULL)) {
220 free (Buffer);
221 }
222
223 return Status;
224 }
225
226 /**
227 Get the signer's certificates from PKCS#7 signed data as described in "PKCS #7:
228 Cryptographic Message Syntax Standard". The input signed data could be wrapped
229 in a ContentInfo structure.
230
231 If P7Data, CertStack, StackLength, TrustedCert or CertLength is NULL, then
232 return FALSE. If P7Length overflow, then return FALSE.
233
234 Caution: This function may receive untrusted input.
235 UEFI Authenticated Variable is external input, so this function will do basic
236 check for PKCS#7 data structure.
237
238 @param[in] P7Data Pointer to the PKCS#7 message to verify.
239 @param[in] P7Length Length of the PKCS#7 message in bytes.
240 @param[out] CertStack Pointer to Signer's certificates retrieved from P7Data.
241 It's caller's responsibility to free the buffer.
242 @param[out] StackLength Length of signer's certificates in bytes.
243 @param[out] TrustedCert Pointer to a trusted certificate from Signer's certificates.
244 It's caller's responsibility to free the buffer.
245 @param[out] CertLength Length of the trusted certificate in bytes.
246
247 @retval TRUE The operation is finished successfully.
248 @retval FALSE Error occurs during the operation.
249
250 **/
251 BOOLEAN
252 EFIAPI
253 Pkcs7GetSigners (
254 IN CONST UINT8 *P7Data,
255 IN UINTN P7Length,
256 OUT UINT8 **CertStack,
257 OUT UINTN *StackLength,
258 OUT UINT8 **TrustedCert,
259 OUT UINTN *CertLength
260 )
261 {
262 PKCS7 *Pkcs7;
263 BOOLEAN Status;
264 UINT8 *SignedData;
265 CONST UINT8 *Temp;
266 UINTN SignedDataSize;
267 BOOLEAN Wrapped;
268 STACK_OF(X509) *Stack;
269 UINT8 Index;
270 UINT8 *CertBuf;
271 UINT8 *OldBuf;
272 UINTN BufferSize;
273 UINTN OldSize;
274 UINT8 *SingleCert;
275 UINTN SingleCertSize;
276
277 if ((P7Data == NULL) || (CertStack == NULL) || (StackLength == NULL) ||
278 (TrustedCert == NULL) || (CertLength == NULL) || (P7Length > INT_MAX)) {
279 return FALSE;
280 }
281
282 Status = WrapPkcs7Data (P7Data, P7Length, &Wrapped, &SignedData, &SignedDataSize);
283 if (!Status) {
284 return Status;
285 }
286
287 Status = FALSE;
288 Pkcs7 = NULL;
289 Stack = NULL;
290 CertBuf = NULL;
291 OldBuf = NULL;
292 SingleCert = NULL;
293
294 //
295 // Retrieve PKCS#7 Data (DER encoding)
296 //
297 if (SignedDataSize > INT_MAX) {
298 goto _Exit;
299 }
300
301 Temp = SignedData;
302 Pkcs7 = d2i_PKCS7 (NULL, (const unsigned char **) &Temp, (int) SignedDataSize);
303 if (Pkcs7 == NULL) {
304 goto _Exit;
305 }
306
307 //
308 // Check if it's PKCS#7 Signed Data (for Authenticode Scenario)
309 //
310 if (!PKCS7_type_is_signed (Pkcs7)) {
311 goto _Exit;
312 }
313
314 Stack = PKCS7_get0_signers(Pkcs7, NULL, PKCS7_BINARY);
315 if (Stack == NULL) {
316 goto _Exit;
317 }
318
319 //
320 // Convert CertStack to buffer in following format:
321 // UINT8 CertNumber;
322 // UINT32 Cert1Length;
323 // UINT8 Cert1[];
324 // UINT32 Cert2Length;
325 // UINT8 Cert2[];
326 // ...
327 // UINT32 CertnLength;
328 // UINT8 Certn[];
329 //
330 BufferSize = sizeof (UINT8);
331 OldSize = BufferSize;
332
333 for (Index = 0; ; Index++) {
334 Status = X509PopCertificate (Stack, &SingleCert, &SingleCertSize);
335 if (!Status) {
336 break;
337 }
338
339 OldSize = BufferSize;
340 OldBuf = CertBuf;
341 BufferSize = OldSize + SingleCertSize + sizeof (UINT32);
342 CertBuf = malloc (BufferSize);
343
344 if (CertBuf == NULL) {
345 goto _Exit;
346 }
347
348 if (OldBuf != NULL) {
349 CopyMem (CertBuf, OldBuf, OldSize);
350 free (OldBuf);
351 OldBuf = NULL;
352 }
353
354 WriteUnaligned32 ((UINT32 *) (CertBuf + OldSize), (UINT32) SingleCertSize);
355 CopyMem (CertBuf + OldSize + sizeof (UINT32), SingleCert, SingleCertSize);
356
357 free (SingleCert);
358 SingleCert = NULL;
359 }
360
361 if (CertBuf != NULL) {
362 //
363 // Update CertNumber.
364 //
365 CertBuf[0] = Index;
366
367 *CertLength = BufferSize - OldSize - sizeof (UINT32);
368 *TrustedCert = malloc (*CertLength);
369 if (*TrustedCert == NULL) {
370 goto _Exit;
371 }
372
373 CopyMem (*TrustedCert, CertBuf + OldSize + sizeof (UINT32), *CertLength);
374 *CertStack = CertBuf;
375 *StackLength = BufferSize;
376 Status = TRUE;
377 }
378
379 _Exit:
380 //
381 // Release Resources
382 //
383 if (!Wrapped) {
384 free (SignedData);
385 }
386
387 if (Pkcs7 != NULL) {
388 PKCS7_free (Pkcs7);
389 }
390
391 if (Stack != NULL) {
392 sk_X509_pop_free(Stack, X509_free);
393 }
394
395 if (SingleCert != NULL) {
396 free (SingleCert);
397 }
398
399 if (!Status && (CertBuf != NULL)) {
400 free (CertBuf);
401 *CertStack = NULL;
402 }
403
404 if (OldBuf != NULL) {
405 free (OldBuf);
406 }
407
408 return Status;
409 }
410
411 /**
412 Wrap function to use free() to free allocated memory for certificates.
413
414 @param[in] Certs Pointer to the certificates to be freed.
415
416 **/
417 VOID
418 EFIAPI
419 Pkcs7FreeSigners (
420 IN UINT8 *Certs
421 )
422 {
423 if (Certs == NULL) {
424 return;
425 }
426
427 free (Certs);
428 }
429
430 /**
431 Retrieves all embedded certificates from PKCS#7 signed data as described in "PKCS #7:
432 Cryptographic Message Syntax Standard", and outputs two certificate lists chained and
433 unchained to the signer's certificates.
434 The input signed data could be wrapped in a ContentInfo structure.
435
436 @param[in] P7Data Pointer to the PKCS#7 message.
437 @param[in] P7Length Length of the PKCS#7 message in bytes.
438 @param[out] SignerChainCerts Pointer to the certificates list chained to signer's
439 certificate. It's caller's responsibility to free the buffer.
440 @param[out] ChainLength Length of the chained certificates list buffer in bytes.
441 @param[out] UnchainCerts Pointer to the unchained certificates lists. It's caller's
442 responsibility to free the buffer.
443 @param[out] UnchainLength Length of the unchained certificates list buffer in bytes.
444
445 @retval TRUE The operation is finished successfully.
446 @retval FALSE Error occurs during the operation.
447
448 **/
449 BOOLEAN
450 EFIAPI
451 Pkcs7GetCertificatesList (
452 IN CONST UINT8 *P7Data,
453 IN UINTN P7Length,
454 OUT UINT8 **SignerChainCerts,
455 OUT UINTN *ChainLength,
456 OUT UINT8 **UnchainCerts,
457 OUT UINTN *UnchainLength
458 )
459 {
460 BOOLEAN Status;
461 UINT8 *NewP7Data;
462 UINTN NewP7Length;
463 BOOLEAN Wrapped;
464 UINT8 Index;
465 PKCS7 *Pkcs7;
466 X509_STORE_CTX CertCtx;
467 STACK_OF(X509) *Signers;
468 X509 *Signer;
469 X509 *Cert;
470 X509 *TempCert;
471 X509 *Issuer;
472 UINT8 *CertBuf;
473 UINT8 *OldBuf;
474 UINTN BufferSize;
475 UINTN OldSize;
476 UINT8 *SingleCert;
477 UINTN CertSize;
478
479 //
480 // Initializations
481 //
482 Status = FALSE;
483 NewP7Data = NULL;
484 Pkcs7 = NULL;
485 Cert = NULL;
486 TempCert = NULL;
487 SingleCert = NULL;
488 CertBuf = NULL;
489 OldBuf = NULL;
490 Signers = NULL;
491
492 ZeroMem (&CertCtx, sizeof (CertCtx));
493
494 //
495 // Parameter Checking
496 //
497 if ((P7Data == NULL) || (SignerChainCerts == NULL) || (ChainLength == NULL) ||
498 (UnchainCerts == NULL) || (UnchainLength == NULL) || (P7Length > INT_MAX)) {
499 return Status;
500 }
501
502 *SignerChainCerts = NULL;
503 *ChainLength = 0;
504 *UnchainCerts = NULL;
505 *UnchainLength = 0;
506
507 //
508 // Construct a new PKCS#7 data wrapping with ContentInfo structure if needed.
509 //
510 Status = WrapPkcs7Data (P7Data, P7Length, &Wrapped, &NewP7Data, &NewP7Length);
511 if (!Status || (NewP7Length > INT_MAX)) {
512 goto _Error;
513 }
514
515 //
516 // Decodes PKCS#7 SignedData
517 //
518 Pkcs7 = d2i_PKCS7 (NULL, (const unsigned char **) &NewP7Data, (int) NewP7Length);
519 if ((Pkcs7 == NULL) || (!PKCS7_type_is_signed (Pkcs7))) {
520 goto _Error;
521 }
522
523 //
524 // Obtains Signer's Certificate from PKCS#7 data
525 // NOTE: Only one signer case will be handled in this function, which means SignerInfos
526 // should include only one signer's certificate.
527 //
528 Signers = PKCS7_get0_signers (Pkcs7, NULL, PKCS7_BINARY);
529 if ((Signers == NULL) || (sk_X509_num (Signers) != 1)) {
530 goto _Error;
531 }
532 Signer = sk_X509_value (Signers, 0);
533
534 if (!X509_STORE_CTX_init (&CertCtx, NULL, Signer, Pkcs7->d.sign->cert)) {
535 goto _Error;
536 }
537 //
538 // Initialize Chained & Untrusted stack
539 //
540 if (CertCtx.chain == NULL) {
541 if (((CertCtx.chain = sk_X509_new_null ()) == NULL) ||
542 (!sk_X509_push (CertCtx.chain, CertCtx.cert))) {
543 goto _Error;
544 }
545 }
546 (VOID)sk_X509_delete_ptr (CertCtx.untrusted, Signer);
547
548 //
549 // Build certificates stack chained from Signer's certificate.
550 //
551 Cert = Signer;
552 for (; ;) {
553 //
554 // Self-Issue checking
555 //
556 if (CertCtx.check_issued (&CertCtx, Cert, Cert)) {
557 break;
558 }
559
560 //
561 // Found the issuer of the current certificate
562 //
563 if (CertCtx.untrusted != NULL) {
564 Issuer = NULL;
565 for (Index = 0; Index < sk_X509_num (CertCtx.untrusted); Index++) {
566 TempCert = sk_X509_value (CertCtx.untrusted, Index);
567 if (CertCtx.check_issued (&CertCtx, Cert, TempCert)) {
568 Issuer = TempCert;
569 break;
570 }
571 }
572 if (Issuer != NULL) {
573 if (!sk_X509_push (CertCtx.chain, Issuer)) {
574 goto _Error;
575 }
576 (VOID)sk_X509_delete_ptr (CertCtx.untrusted, Issuer);
577
578 Cert = Issuer;
579 continue;
580 }
581 }
582
583 break;
584 }
585
586 //
587 // Converts Chained and Untrusted Certificate to Certificate Buffer in following format:
588 // UINT8 CertNumber;
589 // UINT32 Cert1Length;
590 // UINT8 Cert1[];
591 // UINT32 Cert2Length;
592 // UINT8 Cert2[];
593 // ...
594 // UINT32 CertnLength;
595 // UINT8 Certn[];
596 //
597
598 if (CertCtx.chain != NULL) {
599 BufferSize = sizeof (UINT8);
600 OldSize = BufferSize;
601 CertBuf = NULL;
602
603 for (Index = 0; ; Index++) {
604 Status = X509PopCertificate (CertCtx.chain, &SingleCert, &CertSize);
605 if (!Status) {
606 break;
607 }
608
609 OldSize = BufferSize;
610 OldBuf = CertBuf;
611 BufferSize = OldSize + CertSize + sizeof (UINT32);
612 CertBuf = malloc (BufferSize);
613
614 if (CertBuf == NULL) {
615 Status = FALSE;
616 goto _Error;
617 }
618 if (OldBuf != NULL) {
619 CopyMem (CertBuf, OldBuf, OldSize);
620 free (OldBuf);
621 OldBuf = NULL;
622 }
623
624 WriteUnaligned32 ((UINT32 *) (CertBuf + OldSize), (UINT32) CertSize);
625 CopyMem (CertBuf + OldSize + sizeof (UINT32), SingleCert, CertSize);
626
627 free (SingleCert);
628 SingleCert = NULL;
629 }
630
631 if (CertBuf != NULL) {
632 //
633 // Update CertNumber.
634 //
635 CertBuf[0] = Index;
636
637 *SignerChainCerts = CertBuf;
638 *ChainLength = BufferSize;
639 }
640 }
641
642 if (CertCtx.untrusted != NULL) {
643 BufferSize = sizeof (UINT8);
644 OldSize = BufferSize;
645 CertBuf = NULL;
646
647 for (Index = 0; ; Index++) {
648 Status = X509PopCertificate (CertCtx.untrusted, &SingleCert, &CertSize);
649 if (!Status) {
650 break;
651 }
652
653 OldSize = BufferSize;
654 OldBuf = CertBuf;
655 BufferSize = OldSize + CertSize + sizeof (UINT32);
656 CertBuf = malloc (BufferSize);
657
658 if (CertBuf == NULL) {
659 Status = FALSE;
660 goto _Error;
661 }
662 if (OldBuf != NULL) {
663 CopyMem (CertBuf, OldBuf, OldSize);
664 free (OldBuf);
665 OldBuf = NULL;
666 }
667
668 WriteUnaligned32 ((UINT32 *) (CertBuf + OldSize), (UINT32) CertSize);
669 CopyMem (CertBuf + OldSize + sizeof (UINT32), SingleCert, CertSize);
670
671 free (SingleCert);
672 SingleCert = NULL;
673 }
674
675 if (CertBuf != NULL) {
676 //
677 // Update CertNumber.
678 //
679 CertBuf[0] = Index;
680
681 *UnchainCerts = CertBuf;
682 *UnchainLength = BufferSize;
683 }
684 }
685
686 Status = TRUE;
687
688 _Error:
689 //
690 // Release Resources.
691 //
692 if (!Wrapped && (NewP7Data != NULL)) {
693 free (NewP7Data);
694 }
695
696 if (Pkcs7 != NULL) {
697 PKCS7_free (Pkcs7);
698 }
699 sk_X509_free (Signers);
700
701 X509_STORE_CTX_cleanup (&CertCtx);
702
703 if (SingleCert != NULL) {
704 free (SingleCert);
705 }
706
707 if (OldBuf != NULL) {
708 free (OldBuf);
709 }
710
711 if (!Status && (CertBuf != NULL)) {
712 free (CertBuf);
713 *SignerChainCerts = NULL;
714 *UnchainCerts = NULL;
715 }
716
717 return Status;
718 }
719
720 /**
721 Verifies the validity of a PKCS#7 signed data as described in "PKCS #7:
722 Cryptographic Message Syntax Standard". The input signed data could be wrapped
723 in a ContentInfo structure.
724
725 If P7Data, TrustedCert or InData is NULL, then return FALSE.
726 If P7Length, CertLength or DataLength overflow, then return FALSE.
727
728 Caution: This function may receive untrusted input.
729 UEFI Authenticated Variable is external input, so this function will do basic
730 check for PKCS#7 data structure.
731
732 @param[in] P7Data Pointer to the PKCS#7 message to verify.
733 @param[in] P7Length Length of the PKCS#7 message in bytes.
734 @param[in] TrustedCert Pointer to a trusted/root certificate encoded in DER, which
735 is used for certificate chain verification.
736 @param[in] CertLength Length of the trusted certificate in bytes.
737 @param[in] InData Pointer to the content to be verified.
738 @param[in] DataLength Length of InData in bytes.
739
740 @retval TRUE The specified PKCS#7 signed data is valid.
741 @retval FALSE Invalid PKCS#7 signed data.
742
743 **/
744 BOOLEAN
745 EFIAPI
746 Pkcs7Verify (
747 IN CONST UINT8 *P7Data,
748 IN UINTN P7Length,
749 IN CONST UINT8 *TrustedCert,
750 IN UINTN CertLength,
751 IN CONST UINT8 *InData,
752 IN UINTN DataLength
753 )
754 {
755 PKCS7 *Pkcs7;
756 BIO *DataBio;
757 BOOLEAN Status;
758 X509 *Cert;
759 X509_STORE *CertStore;
760 UINT8 *SignedData;
761 CONST UINT8 *Temp;
762 UINTN SignedDataSize;
763 BOOLEAN Wrapped;
764
765 //
766 // Check input parameters.
767 //
768 if (P7Data == NULL || TrustedCert == NULL || InData == NULL ||
769 P7Length > INT_MAX || CertLength > INT_MAX || DataLength > INT_MAX) {
770 return FALSE;
771 }
772
773 Pkcs7 = NULL;
774 DataBio = NULL;
775 Cert = NULL;
776 CertStore = NULL;
777
778 //
779 // Register & Initialize necessary digest algorithms for PKCS#7 Handling
780 //
781 if (EVP_add_digest (EVP_md5 ()) == 0) {
782 return FALSE;
783 }
784 if (EVP_add_digest (EVP_sha1 ()) == 0) {
785 return FALSE;
786 }
787 if (EVP_add_digest (EVP_sha256 ()) == 0) {
788 return FALSE;
789 }
790 if (EVP_add_digest (EVP_sha384 ()) == 0) {
791 return FALSE;
792 }
793 if (EVP_add_digest (EVP_sha512 ()) == 0) {
794 return FALSE;
795 }
796 if (EVP_add_digest_alias (SN_sha1WithRSAEncryption, SN_sha1WithRSA) == 0) {
797 return FALSE;
798 }
799
800 Status = WrapPkcs7Data (P7Data, P7Length, &Wrapped, &SignedData, &SignedDataSize);
801 if (!Status) {
802 return Status;
803 }
804
805 Status = FALSE;
806
807 //
808 // Retrieve PKCS#7 Data (DER encoding)
809 //
810 if (SignedDataSize > INT_MAX) {
811 goto _Exit;
812 }
813
814 Temp = SignedData;
815 Pkcs7 = d2i_PKCS7 (NULL, (const unsigned char **) &Temp, (int) SignedDataSize);
816 if (Pkcs7 == NULL) {
817 goto _Exit;
818 }
819
820 //
821 // Check if it's PKCS#7 Signed Data (for Authenticode Scenario)
822 //
823 if (!PKCS7_type_is_signed (Pkcs7)) {
824 goto _Exit;
825 }
826
827 //
828 // Read DER-encoded root certificate and Construct X509 Certificate
829 //
830 Temp = TrustedCert;
831 Cert = d2i_X509 (NULL, &Temp, (long) CertLength);
832 if (Cert == NULL) {
833 goto _Exit;
834 }
835
836 //
837 // Setup X509 Store for trusted certificate
838 //
839 CertStore = X509_STORE_new ();
840 if (CertStore == NULL) {
841 goto _Exit;
842 }
843 if (!(X509_STORE_add_cert (CertStore, Cert))) {
844 goto _Exit;
845 }
846
847 //
848 // For generic PKCS#7 handling, InData may be NULL if the content is present
849 // in PKCS#7 structure. So ignore NULL checking here.
850 //
851 DataBio = BIO_new (BIO_s_mem ());
852 if (DataBio == NULL) {
853 goto _Exit;
854 }
855
856 if (BIO_write (DataBio, InData, (int) DataLength) <= 0) {
857 goto _Exit;
858 }
859
860 //
861 // Allow partial certificate chains, terminated by a non-self-signed but
862 // still trusted intermediate certificate. Also disable time checks.
863 //
864 X509_STORE_set_flags (CertStore,
865 X509_V_FLAG_PARTIAL_CHAIN | X509_V_FLAG_NO_CHECK_TIME);
866
867 //
868 // OpenSSL PKCS7 Verification by default checks for SMIME (email signing) and
869 // doesn't support the extended key usage for Authenticode Code Signing.
870 // Bypass the certificate purpose checking by enabling any purposes setting.
871 //
872 X509_STORE_set_purpose (CertStore, X509_PURPOSE_ANY);
873
874 //
875 // Verifies the PKCS#7 signedData structure
876 //
877 Status = (BOOLEAN) PKCS7_verify (Pkcs7, NULL, CertStore, DataBio, NULL, PKCS7_BINARY);
878
879 _Exit:
880 //
881 // Release Resources
882 //
883 BIO_free (DataBio);
884 X509_free (Cert);
885 X509_STORE_free (CertStore);
886 PKCS7_free (Pkcs7);
887
888 if (!Wrapped) {
889 OPENSSL_free (SignedData);
890 }
891
892 return Status;
893 }
894
895 /**
896 Extracts the attached content from a PKCS#7 signed data if existed. The input signed
897 data could be wrapped in a ContentInfo structure.
898
899 If P7Data, Content, or ContentSize is NULL, then return FALSE. If P7Length overflow,
900 then return FALSE. If the P7Data is not correctly formatted, then return FALSE.
901
902 Caution: This function may receive untrusted input. So this function will do
903 basic check for PKCS#7 data structure.
904
905 @param[in] P7Data Pointer to the PKCS#7 signed data to process.
906 @param[in] P7Length Length of the PKCS#7 signed data in bytes.
907 @param[out] Content Pointer to the extracted content from the PKCS#7 signedData.
908 It's caller's responsibility to free the buffer.
909 @param[out] ContentSize The size of the extracted content in bytes.
910
911 @retval TRUE The P7Data was correctly formatted for processing.
912 @retval FALSE The P7Data was not correctly formatted for processing.
913
914 */
915 BOOLEAN
916 EFIAPI
917 Pkcs7GetAttachedContent (
918 IN CONST UINT8 *P7Data,
919 IN UINTN P7Length,
920 OUT VOID **Content,
921 OUT UINTN *ContentSize
922 )
923 {
924 BOOLEAN Status;
925 PKCS7 *Pkcs7;
926 UINT8 *SignedData;
927 UINTN SignedDataSize;
928 BOOLEAN Wrapped;
929 CONST UINT8 *Temp;
930 ASN1_OCTET_STRING *OctStr;
931
932 //
933 // Check input parameter.
934 //
935 if ((P7Data == NULL) || (P7Length > INT_MAX) || (Content == NULL) || (ContentSize == NULL)) {
936 return FALSE;
937 }
938
939 *Content = NULL;
940 Pkcs7 = NULL;
941 SignedData = NULL;
942 OctStr = NULL;
943
944 Status = WrapPkcs7Data (P7Data, P7Length, &Wrapped, &SignedData, &SignedDataSize);
945 if (!Status || (SignedDataSize > INT_MAX)) {
946 goto _Exit;
947 }
948
949 Status = FALSE;
950
951 //
952 // Decoding PKCS#7 SignedData
953 //
954 Temp = SignedData;
955 Pkcs7 = d2i_PKCS7 (NULL, (const unsigned char **)&Temp, (int)SignedDataSize);
956 if (Pkcs7 == NULL) {
957 goto _Exit;
958 }
959
960 //
961 // The type of Pkcs7 must be signedData
962 //
963 if (!PKCS7_type_is_signed (Pkcs7)) {
964 goto _Exit;
965 }
966
967 //
968 // Check for detached or attached content
969 //
970 if (PKCS7_get_detached (Pkcs7)) {
971 //
972 // No Content supplied for PKCS7 detached signedData
973 //
974 *Content = NULL;
975 *ContentSize = 0;
976 } else {
977 //
978 // Retrieve the attached content in PKCS7 signedData
979 //
980 OctStr = Pkcs7->d.sign->contents->d.data;
981 if ((OctStr->length > 0) && (OctStr->data != NULL)) {
982 *ContentSize = OctStr->length;
983 *Content = malloc (*ContentSize);
984 if (*Content == NULL) {
985 *ContentSize = 0;
986 goto _Exit;
987 }
988 CopyMem (*Content, OctStr->data, *ContentSize);
989 }
990 }
991 Status = TRUE;
992
993 _Exit:
994 //
995 // Release Resources
996 //
997 PKCS7_free (Pkcs7);
998
999 if (!Wrapped) {
1000 OPENSSL_free (SignedData);
1001 }
1002
1003 return Status;
1004 }
EFI Development Kit II mirror for PVE