IpSecCryptIo.h@ 77664

Last change on this file since 77664 was 58466, checked in by vboxsync, 9 years ago
EFI/Firmware: Merged in the svn:eol-style, svn:mime-type and trailing whitespace cleanup that was done after the initial UDK2014.SP1 import: svn merge ^{/vendor/edk2/UDK2014.SP1}/vendor/edk2/current .
Property svn:eol-style set to `native`
File size: 24.9 KB

Line
1	/** @file
2	Definitions related to the Cryptographic Operations in IPsec.
3
4	Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
5
6	This program and the accompanying materials
7	are licensed and made available under the terms and conditions of the BSD License
8	which accompanies this distribution. The full text of the license may be found at
9	http://opensource.org/licenses/bsd-license.php.
10
11	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14	**/
15	#ifndef _EFI_IPSEC_CRYPTIO_H_
16	#define _EFI_IPSEC_CRYPTIO_H_
17
18	#include <Protocol/IpSecConfig.h>
19	#include <Library/DebugLib.h>
20	#include <Library/BaseCryptLib.h>
21	#include <Library/BaseMemoryLib.h>
22	#include <Library/MemoryAllocationLib.h>
23
24	#include "IpSecImpl.h"
25	#include "IkeCommon.h"
26
27	#define IPSEC_ENCRYPT_ALGORITHM_LIST_SIZE 4
28	#define IPSEC_AUTH_ALGORITHM_LIST_SIZE 3
29	#define IPSEC_HASH_ALGORITHM_LIST_SIZE 3
30
31	///
32	/// Authentication Algorithm Definition
33	/// The number value definition is aligned to IANA assignment
34	///
35	#define IKE_AALG_NONE 0x00
36	#define IKE_AALG_SHA1HMAC 0x02
37	#define IKE_AALG_NULL 0xFB
38
39	///
40	/// Encryption Algorithm Definition
41	/// The number value definition is aligned to IANA assignment
42	///
43	#define IKE_EALG_NONE 0x00
44	#define IKE_EALG_3DESCBC 0x03
45	#define IKE_EALG_NULL 0x0B
46	#define IKE_EALG_AESCBC 0x0C
47
48	/**
49	Prototype of HMAC GetContextSize.
50
51	Retrieves the size, in bytes, of the context buffer required.
52
53	@return The size, in bytes, of the context buffer required.
54
55	**/
56	typedef
57	UINTN
58	(EFIAPI *CRYPTO_HMAC_GETCONTEXTSIZE)(
59	VOID
60	);
61
62	/**
63	Prototype of HMAC Operation Initiating.
64
65	Initialization with a new context.
66
67	@param[out] Context Input Context.
68	@param[in] Key Pointer to the key for HMAC.
69	@param[in] KeySize The length of the Key in bytes.
70
71	@retval TRUE Initialization Successfully.
72
73	**/
74	typedef
75	BOOLEAN
76	(EFIAPI *CRYPTO_HMAC_INIT)(
77	OUT VOID *Context,
78	IN CONST UINT8 *Key,
79	IN UINTN KeySize
80	);
81
82	/**
83	Prototype of HMAC update.
84	HMAC update operation. Continue an HMAC message digest operation, processing
85	another message block, and updating the HMAC context.
86
87	If Context is NULL, then ASSERT().
88	If Data is NULL, then ASSERT().
89
90	@param[in,out] Context The Specified Context.
91	@param[in,out] Data The Input Data to be digested.
92	@param[in] DataLength The length, in bytes, of Data.
93
94	@retval TRUE Update data successfully.
95	@retval FALSE The Context has been finalized.
96
97	**/
98	typedef
99	BOOLEAN
100	(EFIAPI *CRYPTO_HMAC_UPDATE)(
101	IN OUT VOID *Context,
102	IN CONST VOID *Data,
103	IN UINTN DataLength
104	);
105
106	/**
107	Prototype of HMAC finallization.
108	Terminate a HMAC message digest operation and output the message digest.
109
110	If Context is NULL, then ASSERT().
111	If HashValue is NULL, then ASSERT().
112
113	@param[in,out] Context The specified Context.
114	@param[out] HmacValue Pointer to a 16-byte message digest output buffer.
115
116	@retval TRUE Finalized successfully.
117
118	**/
119	typedef
120	BOOLEAN
121	(EFIAPI *CRYPTO_HMAC_FINAL)(
122	IN OUT VOID *Context,
123	OUT UINT8 *HmacValue
124	);
125
126	/**
127	Prototype of Block Cipher GetContextSize.
128
129	Retrieves the size, in bytes, of the context buffer required.
130
131	@return The size, in bytes, of the context buffer required.
132
133	**/
134	typedef
135	UINTN
136	(EFIAPI *CRYPTO_CIPHER_GETCONTEXTSIZE)(
137	VOID
138	);
139
140	/**
141	Prototype of Block Cipher initiation.
142	Intializes the user-supplied key as the specifed context (key materials) for both
143	encryption and decryption operations.
144
145	If Context is NULL, then ASSERT().
146	If Key is NULL, then generate random key for usage.
147
148	@param[in,out] Context The specified Context.
149	@param[in] Key User-supplied cipher key.
150	@param[in] KeyBits Key length in bits.
151
152	@retval TRUE Block Cipher Initialization was successful.
153
154	**/
155	typedef
156	BOOLEAN
157	(EFIAPI *CRYPTO_CIPHER_INIT)(
158	IN OUT VOID *Context,
159	IN CONST UINT8 *Key,
160	IN UINTN KeyBits
161	);
162
163	/**
164	Prototype of Cipher encryption.
165	Encrypts plaintext message with the specified cipher.
166
167	If Context is NULL, then ASSERT().
168	if InData is NULL, then ASSERT().
169	If Size of input data is not multiple of Cipher algorithm related block size,
170	then ASSERT().
171
172	@param[in] Context The specified Context.
173	@param[in] InData The input plaintext data to be encrypted.
174	@param[in] InputSize The size of input data.
175	@param[in] Ivec Pointer to Initial Vector data for encryption.
176	@param[out] OutData The resultant encrypted ciphertext.
177
178	@retval TRUE Encryption successful.
179
180	**/
181	typedef
182	BOOLEAN
183	(EFIAPI *CRYPTO_CIPHER_ENCRYPT)(
184	IN VOID *Context,
185	IN CONST UINT8 *InData,
186	IN UINTN InputSize,
187	IN CONST UINT8 *Ivec,
188	OUT UINT8 *OutData
189	);
190
191	/**
192	Prototype of Cipher decryption.
193	Decrypts cipher message with specified cipher.
194
195	If Context is NULL, then ASSERT().
196	if InData is NULL, then ASSERT().
197	If Size of input data is not a multiple of a certaion block size , then ASSERT().
198
199	@param[in] Context The specified Context.
200	@param[in] InData The input ciphertext data to be decrypted.
201	@param[in] InputSize The InData size.
202	@param[in] Ivec Pointer to the Initial Vector data for decryption.
203	@param[out] OutData The resultant decrypted plaintext.
204
205	@retval TRUE Decryption successful.
206
207	**/
208	typedef
209	BOOLEAN
210	(EFIAPI *CRYPTO_CIPHER_DECRYPT)(
211	IN VOID *Context,
212	IN CONST UINT8 *InData,
213	IN UINTN InputSize,
214	IN CONST UINT8 *Ivec,
215	OUT UINT8 *OutData
216	);
217
218	/**
219	Prototype of Hash ContextSize.
220
221	Retrieves the size, in bytes, of the context buffer required for specified hash operations.
222
223	@return The size, in bytes, of the context buffer required for certain hash operations.
224
225	**/
226	typedef
227	UINTN
228	(EFIAPI *CRYPTO_HASH_GETCONTEXTSIZE)(
229	VOID
230	);
231
232	/**
233	Prototype of Hash Initiate.
234
235	Initializes user-supplied memory pointed by Context as specified hash context for
236	subsequent use.
237
238	If Context is NULL, then ASSERT().
239
240	@param[out] Context Pointer to specified context being initialized.
241
242	@retval TRUE context initialization succeeded.
243	@retval FALSE context initialization failed.
244
245	**/
246	typedef
247	BOOLEAN
248	(EFIAPI *CRYPTO_HASH_INIT)(
249	OUT VOID *Context
250	);
251
252	/**
253	Prototype of Hash Update
254
255	Digests the input data and updates hash context.
256
257	This function performs digest on a data buffer of the specified size.
258	It can be called multiple times to compute the digest of long or discontinuous data streams.
259	Context should be already correctly intialized by HashInit(), and should not be finalized
260	by HashFinal(). Behavior with invalid context is undefined.
261
262	If Context is NULL, then ASSERT().
263
264	@param[in, out] Context Pointer to the specified context.
265	@param[in] Data Pointer to the buffer containing the data to be hashed.
266	@param[in] DataSize Size of Data buffer in bytes.
267
268	@retval TRUE data digest succeeded.
269	@retval FALSE data digest failed.
270
271	**/
272	typedef
273	BOOLEAN
274	(EFIAPI *CRYPTO_HASH_UPDATE)(
275	IN OUT VOID *Context,
276	IN CONST VOID *Data,
277	IN UINTN DataSize
278	);
279
280	/**
281	Prototype of Hash Finalization.
282
283	Completes computation of the digest value.
284
285	This function completes hash computation and retrieves the digest value into
286	the specified memory. After this function has been called, the context cannot
287	be used again.
288	context should be already correctly intialized by HashInit(), and should not be
289	finalized by HashFinal(). Behavior with invalid context is undefined.
290
291	If Context is NULL, then ASSERT().
292	If HashValue is NULL, then ASSERT().
293
294	@param[in, out] Context Pointer to the specified context.
295	@param[out] HashValue Pointer to a buffer that receives the digest
296	value.
297
298	@retval TRUE digest computation succeeded.
299	@retval FALSE digest computation failed.
300
301	**/
302	typedef
303	BOOLEAN
304	(EFIAPI *CRYPTO_HASH_FINAL)(
305	IN OUT VOID *Context,
306	OUT UINT8 *HashValue
307	);
308
309	//
310	// The struct used to store the information and operation of Block Cipher algorithm.
311	//
312	typedef struct _ENCRYPT_ALGORITHM {
313	//
314	// The ID of the Algorithm
315	//
316	UINT8 AlgorithmId;
317	//
318	// The Key length of the Algorithm
319	//
320	UINTN KeyLength;
321	//
322	// Iv Size of the Algorithm
323	//
324	UINTN IvLength;
325	//
326	// The Block Size of the Algorithm
327	//
328	UINTN BlockSize;
329	//
330	// The Function pointer of GetContextSize.
331	//
332	CRYPTO_CIPHER_GETCONTEXTSIZE CipherGetContextSize;
333	//
334	// The Function pointer of Cipher initiation.
335	//
336	CRYPTO_CIPHER_INIT CipherInitiate;
337	//
338	// The Function pointer of Cipher Encryption.
339	//
340	CRYPTO_CIPHER_ENCRYPT CipherEncrypt;
341	//
342	// The Function pointer of Cipher Decrption.
343	//
344	CRYPTO_CIPHER_DECRYPT CipherDecrypt;
345	} ENCRYPT_ALGORITHM;
346
347	//
348	// The struct used to store the information and operation of Autahentication algorithm.
349	//
350	typedef struct _AUTH_ALGORITHM {
351	//
352	// ID of the Algorithm
353	//
354	UINT8 AlgorithmId;
355	//
356	// The Key length of the Algorithm
357	//
358	UINTN DigestLength;
359	//
360	// The ICV length of the Algorithm
361	//
362	UINTN IcvLength;
363	//
364	// The block size of the Algorithm
365	//
366	UINTN BlockSize;
367	//
368	// The function pointer of GetContextSize.
369	//
370	CRYPTO_HMAC_GETCONTEXTSIZE HmacGetContextSize;
371	//
372	// The function pointer of Initiation
373	//
374	CRYPTO_HMAC_INIT HmacInitiate;
375	//
376	// The function pointer of HMAC Update.
377	//
378	CRYPTO_HMAC_UPDATE HmacUpdate;
379	//
380	// The fucntion pointer of HMAC Final
381	//
382	CRYPTO_HMAC_FINAL HmacFinal;
383	} AUTH_ALGORITHM;
384
385	//
386	// The struct used to store the informatino and operation of Hash algorithm.
387	//
388	typedef struct _HASH_ALGORITHM {
389	//
390	// ID of the Algorithm
391	//
392	UINT8 AlgorithmId;
393	//
394	// The Key length of the Algorithm
395	//
396	UINTN DigestLength;
397	//
398	// The ICV length of the Algorithm
399	//
400	UINTN IcvLength;
401	//
402	// The block size of the Algorithm
403	//
404	UINTN BlockSize;
405	//
406	// The function pointer of GetContextSize
407	//
408	CRYPTO_HASH_GETCONTEXTSIZE HashGetContextSize;
409	//
410	// The function pointer of Initiation
411	//
412	CRYPTO_HASH_INIT HashInitiate;
413	//
414	// The function pointer of Hash Update
415	//
416	CRYPTO_HASH_UPDATE HashUpdate;
417	//
418	// The fucntion pointer of Hash Final
419	//
420	CRYPTO_HASH_FINAL HashFinal;
421	} HASH_ALGORITHM;
422
423	/**
424	Get the IV size of specified encryption alogrithm.
425
426	@param[in] AlgorithmId The encryption algorithm ID.
427
428	@return The value of IV size.
429
430	**/
431	UINTN
432	IpSecGetEncryptIvLength (
433	IN UINT8 AlgorithmId
434	);
435
436	/**
437	Get the block size of specified encryption alogrithm.
438
439	@param[in] AlgorithmId The encryption algorithm ID.
440
441	@return The value of block size.
442
443	**/
444	UINTN
445	IpSecGetEncryptBlockSize (
446	IN UINT8 AlgorithmId
447	);
448
449	/**
450	Get the required key length of the specified encryption alogrithm.
451
452	@param[in] AlgorithmId The encryption algorithm ID.
453
454	@return The value of key length.
455
456	**/
457	UINTN
458	IpSecGetEncryptKeyLength (
459	IN UINT8 AlgorithmId
460	);
461
462	/**
463	Get the ICV size of the specified Authenticaion alogrithm.
464
465	@param[in] AlgorithmId The Authentication algorithm ID.
466
467	@return The value of ICV size.
468
469	**/
470	UINTN
471	IpSecGetIcvLength (
472	IN UINT8 AlgorithmId
473	);
474
475	/**
476	Get the HMAC digest length by the specified Algorithm ID.
477
478	@param[in] AlgorithmId The specified Alogrithm ID.
479
480	@return The digest length of the specified Authentication Algorithm ID.
481
482	**/
483	UINTN
484	IpSecGetHmacDigestLength (
485	IN UINT8 AlgorithmId
486	);
487
488	/**
489	Generate a random data for IV. If the IvSize is zero, not needed to create
490	IV and return EFI_SUCCESS.
491
492	@param[in] IvBuffer The pointer of the IV buffer.
493	@param[in] IvSize The IV size in bytes.
494
495	@retval EFI_SUCCESS Create random data for IV.
496
497	**/
498	EFI_STATUS
499	IpSecGenerateIv (
500	IN UINT8 *IvBuffer,
501	IN UINTN IvSize
502	);
503
504	/**
505	Encrypt the buffer.
506
507	This function calls relevant encryption interface from CryptoLib according to
508	the input alogrithm ID. The InData should be multiple of block size. This function
509	doesn't perform the padding. If it has the Ivec data, the length of it should be
510	same with the block size. The block size is different from the different algorithm.
511
512	@param[in] AlgorithmId The Alogrithem identification defined in RFC.
513	@param[in] Key Pointer to the buffer containing encrypting key.
514	@param[in] KeyBits The length of the key in bits.
515	@param[in] Ivec Point to the buffer containning the Initializeion
516	Vector (IV) data.
517	@param[in] InData Point to the buffer containing the data to be
518	encrypted.
519	@param[in] InDataLength The length of InData in Bytes.
520	@param[out] OutData Point to the buffer that receives the encryption
521	output.
522
523	@retval EFI_UNSUPPORTED The input Algorithm is not supported.
524	@retval EFI_OUT_OF_RESOURCE The required resource can't be allocated.
525	@retval EFI_SUCCESS The operation completed successfully.
526
527	**/
528	EFI_STATUS
529	IpSecCryptoIoEncrypt (
530	IN CONST UINT8 AlgorithmId,
531	IN CONST UINT8 *Key,
532	IN CONST UINTN KeyBits,
533	IN CONST UINT8 *Ivec, OPTIONAL
534	IN UINT8 *InData,
535	IN UINTN InDataLength,
536	OUT UINT8 *OutData
537	);
538
539	/**
540	Decrypts the buffer.
541
542	This function calls relevant Decryption interface from CryptoLib according to
543	the input alogrithm ID. The InData should be multiple of block size. This function
544	doesn't perform the padding. If it has the Ivec data, the length of it should be
545	same with the block size. The block size is different from the different algorithm.
546
547	@param[in] AlgorithmId The Alogrithem identification defined in RFC.
548	@param[in] Key Pointer to the buffer containing encrypting key.
549	@param[in] KeyBits The length of the key in bits.
550	@param[in] Ivec Point to the buffer containning the Initializeion
551	Vector (IV) data.
552	@param[in] InData Point to the buffer containing the data to be
553	decrypted.
554	@param[in] InDataLength The length of InData in Bytes.
555	@param[out] OutData Pointer to the buffer that receives the decryption
556	output.
557
558	@retval EFI_UNSUPPORTED The input Algorithm is not supported.
559	@retval EFI_OUT_OF_RESOURCE The required resource can't be allocated.
560	@retval EFI_SUCCESS The operation completed successfully.
561
562	**/
563	EFI_STATUS
564	IpSecCryptoIoDecrypt (
565	IN CONST UINT8 AlgorithmId,
566	IN CONST UINT8 *Key,
567	IN CONST UINTN KeyBits,
568	IN CONST UINT8 *Ivec, OPTIONAL
569	IN UINT8 *InData,
570	IN UINTN InDataLength,
571	OUT UINT8 *OutData
572	);
573
574	/**
575	Digests the Payload with key and store the result into the OutData.
576
577	This function calls relevant Hmac interface from CryptoLib according to
578	the input alogrithm ID. It computes all datas from InDataFragment and output
579	the result into the OutData buffer. If the OutDataSize is larger than the related
580	HMAC alogrithm output size, return EFI_INVALID_PARAMETER.
581
582	@param[in] AlgorithmId The authentication Identification.
583	@param[in] Key Pointer of the authentication key.
584	@param[in] KeyLength The length of the Key in bytes.
585	@param[in] InDataFragment The list contains all data to be authenticated.
586	@param[in] FragmentCount The size of the InDataFragment.
587	@param[out] OutData For in, the buffer to receive the output data.
588	For out, the buffer contains the authenticated data.
589	@param[in] OutDataSize The size of the buffer of OutData.
590
591	@retval EFI_UNSUPPORTED If the AuthAlg is not in the support list.
592	@retval EFI_INVALID_PARAMETER The OutData buffer size is larger than algorithm digest size.
593	@retval EFI_SUCCESS Authenticate the payload successfully.
594	@retval otherwise Authentication of the payload fails.
595
596	**/
597	EFI_STATUS
598	IpSecCryptoIoHmac (
599	IN CONST UINT8 AlgorithmId,
600	IN CONST UINT8 *Key,
601	IN UINTN KeyLength,
602	IN HASH_DATA_FRAGMENT *InDataFragment,
603	IN UINTN FragmentCount,
604	OUT UINT8 *OutData,
605	IN UINTN OutDataSize
606	);
607
608	/**
609	Digests the Payload and store the result into the OutData.
610
611	This function calls relevant Hash interface from CryptoLib according to
612	the input alogrithm ID. It computes all datas from InDataFragment and output
613	the result into the OutData buffer. If the OutDataSize is larger than the related
614	Hash alogrithm output size, return EFI_INVALID_PARAMETER.
615
616	@param[in] AlgorithmId The authentication Identification.
617	@param[in] InDataFragment A list contains all data to be authenticated.
618	@param[in] FragmentCount The size of the InDataFragment.
619	@param[out] OutData For in, the buffer to receive the output data.
620	For out, the buffer contains the authenticated data.
621	@param[in] OutDataSize The size of the buffer of OutData.
622
623	@retval EFI_UNSUPPORTED If the AuthAlg is not in the support list.
624	@retval EFI_SUCCESS Authenticated the payload successfully.
625	@retval EFI_INVALID_PARAMETER If the OutDataSize is larger than the related Hash
626	algorithm could handle.
627	@retval otherwise Authentication of the payload failed.
628
629	**/
630	EFI_STATUS
631	IpSecCryptoIoHash (
632	IN CONST UINT8 AlgorithmId,
633	IN HASH_DATA_FRAGMENT *InDataFragment,
634	IN UINTN FragmentCount,
635	OUT UINT8 *OutData,
636	IN UINTN OutDataSize
637	);
638
639	/**
640	Generates the Diffie-Hellman public key.
641
642	This function first initiate a DHContext, then call the DhSetParameter() to set
643	the prime and primelenght, at end call the DhGenerateKey() to generates random
644	secret exponent, and computes the public key. The output returned via parameter
645	PublicKey and PublicKeySize. DH context is updated accordingly. If the PublicKey
646	buffer is too small to hold the public key, EFI_INVALID_PARAMETER is returned
647	and PublicKeySize is set to the required buffer size to obtain the public key.
648
649	@param[in, out] DhContext Pointer to the DH context.
650	@param[in] Generator Vlaue of generator.
651	@param[in] PrimeLength Length in bits of prime to be generated.
652	@param[in] Prime Pointer to the buffer to receive the generated
653	prime number.
654	@param[out] PublicKey Pointer to the buffer to receive generated public key.
655	@param[in, out] PublicKeySize For in, the size of PublicKey buffer in bytes.
656	For out, the size of data returned in PublicKey
657	buffer in bytes.
658
659	@retval EFI_SUCCESS The operation perfoms successfully.
660	@retval Otherwise The operation is failed.
661
662	**/
663	EFI_STATUS
664	IpSecCryptoIoDhGetPublicKey (
665	IN OUT UINT8 **DhContext,
666	IN UINTN Generator,
667	IN UINTN PrimeLength,
668	IN CONST UINT8 *Prime,
669	OUT UINT8 *PublicKey,
670	IN OUT UINTN *PublicKeySize
671	);
672
673	/**
674	Generates exchanged common key.
675
676	Given peer's public key, this function computes the exchanged common key, based
677	on its own context including value of prime modulus and random secret exponent.
678
679	@param[in, out] DhContext Pointer to the DH context.
680	@param[in] PeerPublicKey Pointer to the peer's Public Key.
681	@param[in] PeerPublicKeySize Size of peer's public key in bytes.
682	@param[out] Key Pointer to the buffer to receive generated key.
683	@param[in, out] KeySize For in, the size of Key buffer in bytes.
684	For out, the size of data returned in Key
685	buffer in bytes.
686
687	@retval EFI_SUCCESS The operation perfoms successfully.
688	@retval Otherwise The operation is failed.
689
690	**/
691	EFI_STATUS
692	IpSecCryptoIoDhComputeKey (
693	IN OUT UINT8 *DhContext,
694	IN CONST UINT8 *PeerPublicKey,
695	IN UINTN PeerPublicKeySize,
696	OUT UINT8 *Key,
697	IN OUT UINTN *KeySize
698	);
699
700	/**
701	Releases the DH context. If DhContext is NULL, return EFI_INVALID_PARAMETER.
702
703	@param[in, out] DhContext Pointer to the DH context to be freed.
704
705	@retval EFI_SUCCESS The operation perfoms successfully.
706	@retval EFI_INVALID_PARAMETER The DhContext is NULL.
707
708	**/
709	EFI_STATUS
710	IpSecCryptoIoFreeDh (
711	IN OUT UINT8 **DhContext
712	);
713
714	/**
715	Generates random numbers of specified size.
716
717	If the Random Generator wasn't initiated, initiate it first, then call RandomBytes.
718
719	@param[out] OutBuffer Pointer to buffer to receive random value.
720	@param[in] Bytes Size of randome bytes to generate.
721
722	@retval EFI_SUCCESS The operation perfoms successfully.
723	@retval Otherwise The operation is failed.
724
725	**/
726	EFI_STATUS
727	IpSecCryptoIoGenerateRandomBytes (
728	OUT UINT8* OutBuffer,
729	IN UINTN Bytes
730	);
731
732	/**
733	Authenticate data with the certificate.
734
735	@param[in] InData Pointer to the Data to be signed.
736	@param[in] InDataSize InData size in bytes.
737	@param[in] PrivateKey Pointer to the private key.
738	@param[in] PrivateKeySize The size of Private Key in bytes.
739	@param[in] KeyPassWord Pointer to the password for retrieving private key.
740	@param[in] KeyPwdSize The size of Key Password in bytes.
741	@param[out] OutData The pointer to the signed data.
742	@param[in, out] OutDataSize Pointer to contain the size of out data.
743
744	**/
745	VOID
746	IpSecCryptoIoAuthDataWithCertificate (
747	IN UINT8 *InData,
748	IN UINTN InDataSize,
749	IN UINT8 *PrivateKey,
750	IN UINTN PrivateKeySize,
751	IN UINT8 *KeyPassWord,
752	IN UINTN KeyPwdSize,
753	OUT UINT8 **OutData,
754	IN OUT UINTN *OutDataSize
755	);
756
757	/**
758	Verify the singed data with the public key which is contained in a certificate.
759
760	@param[in] InCert Pointer to the Certificate which contains the
761	public key.
762	@param[in] CertLen The size of Certificate in bytes.
763	@param[in] InCa Pointer to the CA certificate
764	@param[in] CaLen The size of CA certificate in bytes.
765	@param[in] InData Pointer to octect message hash to be checked.
766	@param[in] InDataSize Size of the message hash in bytes.
767	@param[in] Singnature The pointer to the RSA PKCS1-V1_5 signature to be verifed.
768	@param[in] SigSize Size of signature in bytes.
769
770	@retval TRUE Valid signature encoded in PKCS1-v1_5.
771	@retval FALSE Invalid signature or invalid RSA context.
772
773	**/
774	BOOLEAN
775	IpSecCryptoIoVerifySignDataByCertificate (
776	IN UINT8 *InCert,
777	IN UINTN CertLen,
778	IN UINT8 *InCa,
779	IN UINTN CaLen,
780	IN UINT8 *InData,
781	IN UINTN InDataSize,
782	IN UINT8 *Singnature,
783	IN UINTN SigSize
784	);
785
786	/**
787	Retrieves the RSA Public Key from one X509 certificate (DER format only).
788
789	@param[in] InCert Pointer to the certificate.
790	@param[in] CertLen The size of the certificate in bytes.
791	@param[out] PublicKey Pointer to the retrieved public key.
792	@param[out] PublicKeyLen Size of Public Key in bytes.
793
794	@retval EFI_SUCCESS Successfully get the public Key.
795	@retval EFI_INVALID_PARAMETER The CA certificate is malformed.
796
797	**/
798	EFI_STATUS
799	IpSecCryptoIoGetPublicKeyFromCert (
800	IN UINT8 *InCert,
801	IN UINTN CertLen,
802	OUT UINT8 **PublicKey,
803	OUT UINTN *PublicKeyLen
804	);
805
806	/**
807	Retrieves the subject name from one X509 certificate (DER format only).
808
809	@param[in] InCert Pointer to the X509 certificate.
810	@param[in] CertSize The size of the X509 certificate in bytes.
811	@param[out] CertSubject Pointer to the retrieved certificate subject.
812	@param[out] SubjectSize The size of Certificate Subject in bytes.
813
814	@retval EFI_SUCCESS Retrieved the certificate subject successfully.
815	@retval EFI_INVALID_PARAMETER The certificate is malformed.
816
817	**/
818	EFI_STATUS
819	IpSecCryptoIoGetSubjectFromCert (
820	IN UINT8 *InCert,
821	IN UINTN CertSize,
822	OUT UINT8 **CertSubject,
823	OUT UINTN *SubjectSize
824	);
825
826	#endif
827

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/IpSecDxe/IpSecCryptIo.h@ 77664

Download in other formats: