[apple/security.git] / libsecurity_apple_csp / open_ssl / opensslUtils / opensslAsn1.h

/*
 * Copyright (c) 2003 Apple Computer, Inc. All Rights Reserved.
 * 
 * The contents of this file constitute Original Code as defined in and are
 * subject to the Apple Public Source License Version 1.2 (the 'License').
 * You may not use this file except in compliance with the License. Please obtain
 * a copy of the License at http://www.apple.com/publicsource and read it before
 * using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
 * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
 * specific language governing rights and limitations under the License.
 */


/*
 * opensslAsn1.h - ANS1 encode/decode of openssl object, libssnasn1 version
 */
 
#ifndef	_OPENSSL_ASN1_H_
#define _OPENSSL_ASN1_H_


#include <openssl/rsa.h>
#include <openssl/dsa.h>
#include <openssl/dh.h>
#include <Security/osKeyTemplates.h>
#include <Security/cssmtype.h>
#include <security_cdsa_utilities/cssmdata.h>
#include <security_asn1/SecNssCoder.h>

#ifdef	__cplusplus
extern "C" {
#endif

/* CSSM_DATA --> BIGNUM */
BIGNUM *cssmDataToBn(
	const CSSM_DATA &cdata);
	
/* BIGNUM --> CSSM_DATA, mallocing from a SecNssCoder's PL_ArenaPool */
void bnToCssmData(
	const BIGNUM *bn,
	CSSM_DATA &cdata,
	SecNssCoder &coder);

/* CSSM_DATA --> unsigned int */
unsigned cssmDataToInt(
	const CSSM_DATA &cdata);

/* unsigned int --> CSSM_DATA, mallocing from an SecNssCoder */
void intToCssmData(
	unsigned num,
	CSSM_DATA &cdata,
	SecNssCoder &coder);

/*
 * DER encode/decode RSA keys in various formats. 
 */
CSSM_RETURN RSAPublicKeyDecode(
	RSA 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	void 				*p, 
	size_t				length);
CSSM_RETURN	RSAPublicKeyEncode(
	RSA 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	const CssmData		&descData,
	CssmOwnedData		&encodedKey);
CSSM_RETURN RSAPrivateKeyDecode(
	RSA 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	void 				*p, 
	size_t				length);
CSSM_RETURN	RSAPrivateKeyEncode(
	RSA 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	const CssmData		&descData,
	CssmOwnedData		&encodedKey);
CSSM_RETURN RSAOAEPPublicKeyDecode(
	RSA 				*openKey, 
	void 				*p, 
	size_t				length,
	/* mallocd and returned label */
	CSSM_DATA			*label);
CSSM_RETURN	RSAOAEPPublicKeyEncode(
	RSA 				*openKey, 
	const CSSM_DATA		*label,
	CssmOwnedData		&encodedKey);
CSSM_RETURN RSAOAEPPrivateKeyDecode(
	RSA 				*openKey, 
	void 				*p, 
	size_t				length,
	/* mallocd and returned label */
	CSSM_DATA			*label);
CSSM_RETURN	RSAOAEPPrivateKeyEncode(
	RSA 				*openKey, 
	const CSSM_DATA		*label,
	CssmOwnedData		&encodedKey);

CSSM_RETURN generateDigestInfo(
	const void		*messageDigest,
	size_t			digestLen,
	CSSM_ALGORITHMS	digestAlg,		// CSSM_ALGID_SHA1, etc.
	CssmOwnedData	&encodedInfo,
	size_t			maxEncodedSize);
CSSM_RETURN DSAPublicKeyDecode(
	DSA 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	void 				*p, 
	size_t				length);
CSSM_RETURN	DSAPublicKeyEncode(
	DSA 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	const CssmData		&descData,
	CssmOwnedData		&encodedKey);
CSSM_RETURN DSAPrivateKeyDecode(
	DSA 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	void 				*p, 
	size_t	 			length);
CSSM_RETURN	DSAPrivateKeyEncode(
	DSA 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	const CssmData		&descData,
	CssmOwnedData		&encodedKey);

CSSM_RETURN DSASigEncode(
	DSA_SIG			*openSig,
	CssmOwnedData	&encodedSig);
CSSM_RETURN DSASigDecode(
	DSA_SIG 		*openSig, 
	const void 		*p, 
	unsigned		length);

CSSM_RETURN DSAEncodeAlgParams(
	NSS_DSAAlgParams	&algParams,
	CssmOwnedData		&encodedParams);
CSSM_RETURN DSADecodeAlgParams(
	NSS_DSAAlgParams	&algParams,
	const void			*p,
	unsigned			len,
	SecNssCoder			&coder);
	
CSSM_RETURN DHPrivateKeyDecode(
	DH	 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	unsigned char 		*p, 
	unsigned 			length);
CSSM_RETURN	DHPrivateKeyEncode(
	DH	 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	CssmOwnedData		&encodedKey);
CSSM_RETURN DHPublicKeyDecode(
	DH	 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	unsigned char 		*p, 
	unsigned 			length);
CSSM_RETURN	DHPublicKeyEncode(
	DH	 				*openKey, 
	CSSM_KEYBLOB_FORMAT	format,
	CssmOwnedData		&encodedKey);
CSSM_RETURN DHParamBlockDecode(
	const CSSM_DATA &encParam,
	NSS_DHParameterBlock &paramBlock,
	SecNssCoder &coder);

CSSM_RETURN generateDigestInfo(
	const void		*msgDigest,
	size_t			digestLen,
	CSSM_ALGORITHMS	digestAlg,		// CSSM_ALGID_SHA1, etc.
	CssmOwnedData	&encodedInfo,
	size_t			maxEncodedSize);

#ifdef	__cplusplus
}
#endif

#endif	/* _OPENSSL_ASN1_H_ */
Commit	Line	Data
b1ab9ed8 A	1	/*
	2	* Copyright (c) 2003 Apple Computer, Inc. All Rights Reserved.
	3	*
	4	* The contents of this file constitute Original Code as defined in and are
	5	* subject to the Apple Public Source License Version 1.2 (the 'License').
	6	* You may not use this file except in compliance with the License. Please obtain
	7	* a copy of the License at http://www.apple.com/publicsource and read it before
	8	* using this file.
	9	*
	10	* This Original Code and all software distributed under the License are
	11	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
	12	* OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
	13	* LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
	14	* PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
	15	* specific language governing rights and limitations under the License.
	16	*/
	17
	18
	19	/*
	20	* opensslAsn1.h - ANS1 encode/decode of openssl object, libssnasn1 version
	21	*/
	22
	23	#ifndef _OPENSSL_ASN1_H_
	24	#define _OPENSSL_ASN1_H_
	25
	26
	27	#include <openssl/rsa.h>
	28	#include <openssl/dsa.h>
	29	#include <openssl/dh.h>
	30	#include <Security/osKeyTemplates.h>
	31	#include <Security/cssmtype.h>
	32	#include <security_cdsa_utilities/cssmdata.h>
	33	#include <security_asn1/SecNssCoder.h>
	34
	35	#ifdef __cplusplus
	36	extern "C" {
	37	#endif
	38
	39	/* CSSM_DATA --> BIGNUM */
	40	BIGNUM *cssmDataToBn(
	41	const CSSM_DATA &cdata);
	42
	43	/* BIGNUM --> CSSM_DATA, mallocing from a SecNssCoder's PL_ArenaPool */
	44	void bnToCssmData(
	45	const BIGNUM *bn,
	46	CSSM_DATA &cdata,
	47	SecNssCoder &coder);
	48
	49	/* CSSM_DATA --> unsigned int */
	50	unsigned cssmDataToInt(
	51	const CSSM_DATA &cdata);
	52
	53	/* unsigned int --> CSSM_DATA, mallocing from an SecNssCoder */
	54	void intToCssmData(
	55	unsigned num,
	56	CSSM_DATA &cdata,
	57	SecNssCoder &coder);
	58
	59	/*
	60	* DER encode/decode RSA keys in various formats.
	61	*/
	62	CSSM_RETURN RSAPublicKeyDecode(
	63	RSA *openKey,
	64	CSSM_KEYBLOB_FORMAT format,
65	void *p,
66	size_t length);
67	CSSM_RETURN RSAPublicKeyEncode(
68	RSA *openKey,
69	CSSM_KEYBLOB_FORMAT format,
70	const CssmData &descData,
71	CssmOwnedData &encodedKey);
72	CSSM_RETURN RSAPrivateKeyDecode(
73	RSA *openKey,
74	CSSM_KEYBLOB_FORMAT format,
75	void *p,
76	size_t length);
77	CSSM_RETURN RSAPrivateKeyEncode(
78	RSA *openKey,
79	CSSM_KEYBLOB_FORMAT format,
80	const CssmData &descData,
81	CssmOwnedData &encodedKey);
82	CSSM_RETURN RSAOAEPPublicKeyDecode(
83	RSA *openKey,
84	void *p,
85	size_t length,
86	/* mallocd and returned label */
87	CSSM_DATA *label);
88	CSSM_RETURN RSAOAEPPublicKeyEncode(
89	RSA *openKey,
90	const CSSM_DATA *label,
91	CssmOwnedData &encodedKey);
92	CSSM_RETURN RSAOAEPPrivateKeyDecode(
93	RSA *openKey,
94	void *p,
95	size_t length,
96	/* mallocd and returned label */
97	CSSM_DATA *label);
98	CSSM_RETURN RSAOAEPPrivateKeyEncode(
99	RSA *openKey,
100	const CSSM_DATA *label,
101	CssmOwnedData &encodedKey);
102
103	CSSM_RETURN generateDigestInfo(
104	const void *messageDigest,
105	size_t digestLen,
106	CSSM_ALGORITHMS digestAlg, // CSSM_ALGID_SHA1, etc.
107	CssmOwnedData &encodedInfo,
108	size_t maxEncodedSize);
109	CSSM_RETURN DSAPublicKeyDecode(
110	DSA *openKey,
111	CSSM_KEYBLOB_FORMAT format,
112	void *p,
113	size_t length);
114	CSSM_RETURN DSAPublicKeyEncode(
115	DSA *openKey,
116	CSSM_KEYBLOB_FORMAT format,
117	const CssmData &descData,
118	CssmOwnedData &encodedKey);
119	CSSM_RETURN DSAPrivateKeyDecode(
120	DSA *openKey,
121	CSSM_KEYBLOB_FORMAT format,
122	void *p,
123	size_t length);
124	CSSM_RETURN DSAPrivateKeyEncode(
125	DSA *openKey,
126	CSSM_KEYBLOB_FORMAT format,
127	const CssmData &descData,
128	CssmOwnedData &encodedKey);
129
130	CSSM_RETURN DSASigEncode(
131	DSA_SIG *openSig,
132	CssmOwnedData &encodedSig);
133	CSSM_RETURN DSASigDecode(
134	DSA_SIG *openSig,
135	const void *p,
136	unsigned length);
137
138	CSSM_RETURN DSAEncodeAlgParams(
139	NSS_DSAAlgParams &algParams,
140	CssmOwnedData &encodedParams);
141	CSSM_RETURN DSADecodeAlgParams(
142	NSS_DSAAlgParams &algParams,
143	const void *p,
144	unsigned len,
145	SecNssCoder &coder);
146
147	CSSM_RETURN DHPrivateKeyDecode(
148	DH *openKey,
149	CSSM_KEYBLOB_FORMAT format,
150	unsigned char *p,
151	unsigned length);
152	CSSM_RETURN DHPrivateKeyEncode(
153	DH *openKey,
154	CSSM_KEYBLOB_FORMAT format,
155	CssmOwnedData &encodedKey);
156	CSSM_RETURN DHPublicKeyDecode(
157	DH *openKey,
158	CSSM_KEYBLOB_FORMAT format,
159	unsigned char *p,
160	unsigned length);
161	CSSM_RETURN DHPublicKeyEncode(
162	DH *openKey,
163	CSSM_KEYBLOB_FORMAT format,
164	CssmOwnedData &encodedKey);
165	CSSM_RETURN DHParamBlockDecode(
166	const CSSM_DATA &encParam,
167	NSS_DHParameterBlock &paramBlock,
168	SecNssCoder &coder);
169
170	CSSM_RETURN generateDigestInfo(
171	const void *msgDigest,
172	size_t digestLen,
173	CSSM_ALGORITHMS digestAlg, // CSSM_ALGID_SHA1, etc.
174	CssmOwnedData &encodedInfo,
175	size_t maxEncodedSize);
176
177	#ifdef __cplusplus
178	}
179	#endif
180
181	#endif /* _OPENSSL_ASN1_H_ */