1 /* pkcs12.h */ 2 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL 3 * project 1999. 4 */ 5 /* ==================================================================== 6 * Copyright (c) 1999 The OpenSSL Project. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in 17 * the documentation and/or other materials provided with the 18 * distribution. 19 * 20 * 3. All advertising materials mentioning features or use of this 21 * software must display the following acknowledgment: 22 * "This product includes software developed by the OpenSSL Project 23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" 24 * 25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 26 * endorse or promote products derived from this software without 27 * prior written permission. For written permission, please contact 28 * licensing@OpenSSL.org. 29 * 30 * 5. Products derived from this software may not be called "OpenSSL" 31 * nor may "OpenSSL" appear in their names without prior written 32 * permission of the OpenSSL Project. 33 * 34 * 6. Redistributions of any form whatsoever must retain the following 35 * acknowledgment: 36 * "This product includes software developed by the OpenSSL Project 37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" 38 * 39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 50 * OF THE POSSIBILITY OF SUCH DAMAGE. 51 * ==================================================================== 52 * 53 * This product includes cryptographic software written by Eric Young 54 * (eay@cryptsoft.com). This product includes software written by Tim 55 * Hudson (tjh@cryptsoft.com). 56 * 57 */ 58 59 module deimos.openssl.pkcs12; 60 61 import deimos.openssl._d_util; 62 63 public import deimos.openssl.bio; 64 public import deimos.openssl.x509; 65 public import deimos.openssl.pkcs7; 66 67 extern (C): 68 nothrow: 69 70 enum PKCS12_KEY_ID = 1; 71 enum PKCS12_IV_ID = 2; 72 enum PKCS12_MAC_ID = 3; 73 74 /* Default iteration count */ 75 // #ifndef PKCS12_DEFAULT_ITER 76 alias PKCS5_DEFAULT_ITER PKCS12_DEFAULT_ITER; 77 // #endif 78 79 enum PKCS12_MAC_KEY_LENGTH = 20; 80 81 enum PKCS12_SALT_LEN = 8; 82 83 /* Uncomment out next line for unicode password and names, otherwise ASCII */ 84 85 /*#define PBE_UNICODE*/ 86 87 version (PBE_UNICODE) { 88 alias PKCS12_key_gen_uni PKCS12_key_gen; 89 alias PKCS12_add_friendlyname_uni PKCS12_add_friendlyname; 90 } else { 91 alias PKCS12_key_gen_asc PKCS12_key_gen; 92 alias PKCS12_add_friendlyname_asc PKCS12_add_friendlyname; 93 } 94 95 /* MS key usage constants */ 96 97 enum KEY_EX = 0x10; 98 enum KEY_SIG = 0x80; 99 100 struct PKCS12_MAC_DATA { 101 X509_SIG* dinfo; 102 ASN1_OCTET_STRING* salt; 103 ASN1_INTEGER* iter; /* defaults to 1 */ 104 } 105 106 struct PKCS12 { 107 ASN1_INTEGER* version_; 108 PKCS12_MAC_DATA* mac; 109 PKCS7* authsafes; 110 } 111 112 struct PKCS12_SAFEBAG { 113 ASN1_OBJECT* type; 114 union value_ { 115 pkcs12_bag_st* bag; /* secret, crl and certbag */ 116 pkcs8_priv_key_info_st* keybag; /* keybag */ 117 X509_SIG* shkeybag; /* shrouded key bag */ 118 STACK_OF!(PKCS12_SAFEBAG) *safes; 119 ASN1_TYPE* other; 120 } 121 value_ value; 122 STACK_OF!(X509_ATTRIBUTE) *attrib; 123 } 124 125 /+mixin DECLARE_STACK_OF!(PKCS12_SAFEBAG);+/ 126 mixin DECLARE_ASN1_SET_OF!(PKCS12_SAFEBAG); 127 mixin DECLARE_PKCS12_STACK_OF!(PKCS12_SAFEBAG); 128 129 struct pkcs12_bag_st { 130 ASN1_OBJECT* type; 131 union value_ { 132 ASN1_OCTET_STRING* x509cert; 133 ASN1_OCTET_STRING* x509crl; 134 ASN1_OCTET_STRING* octet; 135 ASN1_IA5STRING* sdsicert; 136 ASN1_TYPE* other; /* Secret or other bag */ 137 } 138 value_ value; 139 } 140 alias pkcs12_bag_st PKCS12_BAGS; 141 142 enum PKCS12_ERROR = 0; 143 enum PKCS12_OK = 1; 144 145 /* Compatibility macros */ 146 147 alias PKCS12_x5092certbag M_PKCS12_x5092certbag; 148 alias PKCS12_x509crl2certbag M_PKCS12_x509crl2certbag; 149 150 alias PKCS12_certbag2x509 M_PKCS12_certbag2x509; 151 alias PKCS12_certbag2x509crl M_PKCS12_certbag2x509crl; 152 153 alias PKCS12_unpack_p7data M_PKCS12_unpack_p7data; 154 alias PKCS12_pack_authsafes M_PKCS12_pack_authsafes; 155 alias PKCS12_unpack_authsafes M_PKCS12_unpack_authsafes; 156 alias PKCS12_unpack_p7encdata M_PKCS12_unpack_p7encdata; 157 158 alias PKCS12_decrypt_skey M_PKCS12_decrypt_skey; 159 alias PKCS8_decrypt M_PKCS8_decrypt; 160 161 auto M_PKCS12_bag_type(B)(B bg) {return OBJ_obj2nid(bg.type); } 162 auto M_PKCS12_cert_bag_type(B)(B bg) {return OBJ_obj2nid(bg.value.bag.type); } 163 alias M_PKCS12_cert_bag_type M_PKCS12_crl_bag_type; 164 165 auto PKCS12_get_attr()(PKCS12_SAFEBAG* bag, int attr_nid) { 166 return PKCS12_get_attr_gen(bag.attrib, attr_nid); } 167 168 auto PKCS8_get_attr(P)(P p8, int attr_nid) { 169 return PKCS12_get_attr_gen(p8.attributes, attr_nid);} 170 171 auto PKCS12_mac_present()(PKCS12* p12) { return p12.mac ? 1 : 0; } 172 173 174 PKCS12_SAFEBAG* PKCS12_x5092certbag(X509* x509); 175 PKCS12_SAFEBAG* PKCS12_x509crl2certbag(X509_CRL* crl); 176 X509* PKCS12_certbag2x509(PKCS12_SAFEBAG* bag); 177 X509_CRL* PKCS12_certbag2x509crl(PKCS12_SAFEBAG* bag); 178 179 PKCS12_SAFEBAG* PKCS12_item_pack_safebag(void* obj, const(ASN1_ITEM)* it, int nid1, 180 int nid2); 181 PKCS12_SAFEBAG* PKCS12_MAKE_KEYBAG(PKCS8_PRIV_KEY_INFO* p8); 182 PKCS8_PRIV_KEY_INFO* PKCS8_decrypt(X509_SIG* p8, const(char)* pass, int passlen); 183 PKCS8_PRIV_KEY_INFO* PKCS12_decrypt_skey(PKCS12_SAFEBAG* bag, const(char)* pass, 184 int passlen); 185 X509_SIG* PKCS8_encrypt(int pbe_nid, const(EVP_CIPHER)* cipher, 186 const(char)* pass, int passlen, 187 ubyte* salt, int saltlen, int iter, 188 PKCS8_PRIV_KEY_INFO* p8); 189 PKCS12_SAFEBAG* PKCS12_MAKE_SHKEYBAG(int pbe_nid, const(char)* pass, 190 int passlen, ubyte* salt, 191 int saltlen, int iter, 192 PKCS8_PRIV_KEY_INFO* p8); 193 PKCS7* PKCS12_pack_p7data(STACK_OF!(PKCS12_SAFEBAG) *sk); 194 STACK_OF!(PKCS12_SAFEBAG) *PKCS12_unpack_p7data(PKCS7* p7); 195 PKCS7* PKCS12_pack_p7encdata(int pbe_nid, const(char)* pass, int passlen, 196 ubyte* salt, int saltlen, int iter, 197 STACK_OF!(PKCS12_SAFEBAG) *bags); 198 STACK_OF!(PKCS12_SAFEBAG) *PKCS12_unpack_p7encdata(PKCS7* p7, const(char)* pass, int passlen); 199 200 int PKCS12_pack_authsafes(PKCS12* p12, STACK_OF!(PKCS7) *safes); 201 STACK_OF!(PKCS7) *PKCS12_unpack_authsafes(PKCS12* p12); 202 203 int PKCS12_add_localkeyid(PKCS12_SAFEBAG* bag, ubyte* name, int namelen); 204 int PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG* bag, const(char)* name, 205 int namelen); 206 int PKCS12_add_CSPName_asc(PKCS12_SAFEBAG* bag, const(char)* name, 207 int namelen); 208 int PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG* bag, const(ubyte)* name, 209 int namelen); 210 int PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO* p8, int usage); 211 ASN1_TYPE* PKCS12_get_attr_gen(STACK_OF!(X509_ATTRIBUTE) *attrs, int attr_nid); 212 char* PKCS12_get_friendlyname(PKCS12_SAFEBAG* bag); 213 ubyte* PKCS12_pbe_crypt(X509_ALGOR* algor, const(char)* pass, 214 int passlen, ubyte* in_, int inlen, 215 ubyte** data, int* datalen, int en_de); 216 void* PKCS12_item_decrypt_d2i(X509_ALGOR* algor, const(ASN1_ITEM)* it, 217 const(char)* pass, int passlen, ASN1_OCTET_STRING* oct, int zbuf); 218 ASN1_OCTET_STRING* PKCS12_item_i2d_encrypt(X509_ALGOR* algor, const(ASN1_ITEM)* it, 219 const(char)* pass, int passlen, 220 void* obj, int zbuf); 221 PKCS12* PKCS12_init(int mode); 222 int PKCS12_key_gen_asc(const(char)* pass, int passlen, ubyte* salt, 223 int saltlen, int id, int iter, int n, 224 ubyte* out_, const(EVP_MD)* md_type); 225 int PKCS12_key_gen_uni(ubyte* pass, int passlen, ubyte* salt, int saltlen, int id, int iter, int n, ubyte* out_, const(EVP_MD)* md_type); 226 int PKCS12_PBE_keyivgen(EVP_CIPHER_CTX* ctx, const(char)* pass, int passlen, 227 ASN1_TYPE* param, const(EVP_CIPHER)* cipher, const(EVP_MD)* md_type, 228 int en_de); 229 int PKCS12_gen_mac(PKCS12* p12, const(char)* pass, int passlen, 230 ubyte* mac, uint* maclen); 231 int PKCS12_verify_mac(PKCS12* p12, const(char)* pass, int passlen); 232 int PKCS12_set_mac(PKCS12* p12, const(char)* pass, int passlen, 233 ubyte* salt, int saltlen, int iter, 234 const(EVP_MD)* md_type); 235 int PKCS12_setup_mac(PKCS12* p12, int iter, ubyte* salt, 236 int saltlen, const(EVP_MD)* md_type); 237 ubyte* OPENSSL_asc2uni(const(char)* asc, int asclen, ubyte** uni, int* unilen); 238 char* OPENSSL_uni2asc(ubyte* uni, int unilen); 239 240 mixin(DECLARE_ASN1_FUNCTIONS!"PKCS12"); 241 mixin(DECLARE_ASN1_FUNCTIONS!"PKCS12_MAC_DATA"); 242 mixin(DECLARE_ASN1_FUNCTIONS!"PKCS12_SAFEBAG"); 243 mixin(DECLARE_ASN1_FUNCTIONS!"PKCS12_BAGS"); 244 245 mixin(DECLARE_ASN1_ITEM!"PKCS12_SAFEBAGS"); 246 mixin(DECLARE_ASN1_ITEM!"PKCS12_AUTHSAFES"); 247 248 void PKCS12_PBE_add(); 249 int PKCS12_parse(PKCS12* p12, const(char)* pass, EVP_PKEY** pkey, X509** cert, 250 STACK_OF!(X509) **ca); 251 PKCS12* PKCS12_create(char* pass, char* name, EVP_PKEY* pkey, X509* cert, 252 STACK_OF!(X509) *ca, int nid_key, int nid_cert, int iter, 253 int mac_iter, int keytype); 254 255 PKCS12_SAFEBAG* PKCS12_add_cert(STACK_OF!(PKCS12_SAFEBAG) **pbags, X509* cert); 256 PKCS12_SAFEBAG* PKCS12_add_key(STACK_OF!(PKCS12_SAFEBAG) **pbags, EVP_PKEY* key, 257 int key_usage, int iter, 258 int key_nid, char* pass); 259 int PKCS12_add_safe(STACK_OF!(PKCS7) **psafes, STACK_OF!(PKCS12_SAFEBAG) *bags, 260 int safe_nid, int iter, char* pass); 261 PKCS12* PKCS12_add_safes(STACK_OF!(PKCS7) *safes, int p7_nid); 262 263 int i2d_PKCS12_bio(BIO* bp, PKCS12* p12); 264 int i2d_PKCS12_fp(FILE* fp, PKCS12* p12); 265 PKCS12* d2i_PKCS12_bio(BIO* bp, PKCS12** p12); 266 PKCS12* d2i_PKCS12_fp(FILE* fp, PKCS12** p12); 267 int PKCS12_newpass(PKCS12* p12, char* oldpass, char* newpass); 268 269 /* BEGIN ERROR CODES */ 270 /* The following lines are auto generated by the script mkerr.pl. Any changes 271 * made after this point may be overwritten when the script is next run. 272 */ 273 void ERR_load_PKCS12_strings(); 274 275 /* Error codes for the PKCS12 functions. */ 276 277 /* Function codes. */ 278 enum PKCS12_F_PARSE_BAG = 129; 279 enum PKCS12_F_PARSE_BAGS = 103; 280 enum PKCS12_F_PKCS12_ADD_FRIENDLYNAME = 100; 281 enum PKCS12_F_PKCS12_ADD_FRIENDLYNAME_ASC = 127; 282 enum PKCS12_F_PKCS12_ADD_FRIENDLYNAME_UNI = 102; 283 enum PKCS12_F_PKCS12_ADD_LOCALKEYID = 104; 284 enum PKCS12_F_PKCS12_CREATE = 105; 285 enum PKCS12_F_PKCS12_GEN_MAC = 107; 286 enum PKCS12_F_PKCS12_INIT = 109; 287 enum PKCS12_F_PKCS12_ITEM_DECRYPT_D2I = 106; 288 enum PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT = 108; 289 enum PKCS12_F_PKCS12_ITEM_PACK_SAFEBAG = 117; 290 enum PKCS12_F_PKCS12_KEY_GEN_ASC = 110; 291 enum PKCS12_F_PKCS12_KEY_GEN_UNI = 111; 292 enum PKCS12_F_PKCS12_MAKE_KEYBAG = 112; 293 enum PKCS12_F_PKCS12_MAKE_SHKEYBAG = 113; 294 enum PKCS12_F_PKCS12_NEWPASS = 128; 295 enum PKCS12_F_PKCS12_PACK_P7DATA = 114; 296 enum PKCS12_F_PKCS12_PACK_P7ENCDATA = 115; 297 enum PKCS12_F_PKCS12_PARSE = 118; 298 enum PKCS12_F_PKCS12_PBE_CRYPT = 119; 299 enum PKCS12_F_PKCS12_PBE_KEYIVGEN = 120; 300 enum PKCS12_F_PKCS12_SETUP_MAC = 122; 301 enum PKCS12_F_PKCS12_SET_MAC = 123; 302 enum PKCS12_F_PKCS12_UNPACK_AUTHSAFES = 130; 303 enum PKCS12_F_PKCS12_UNPACK_P7DATA = 131; 304 enum PKCS12_F_PKCS12_VERIFY_MAC = 126; 305 enum PKCS12_F_PKCS8_ADD_KEYUSAGE = 124; 306 enum PKCS12_F_PKCS8_ENCRYPT = 125; 307 308 /* Reason codes. */ 309 enum PKCS12_R_CANT_PACK_STRUCTURE = 100; 310 enum PKCS12_R_CONTENT_TYPE_NOT_DATA = 121; 311 enum PKCS12_R_DECODE_ERROR = 101; 312 enum PKCS12_R_ENCODE_ERROR = 102; 313 enum PKCS12_R_ENCRYPT_ERROR = 103; 314 enum PKCS12_R_ERROR_SETTING_ENCRYPTED_DATA_TYPE = 120; 315 enum PKCS12_R_INVALID_NULL_ARGUMENT = 104; 316 enum PKCS12_R_INVALID_NULL_PKCS12_POINTER = 105; 317 enum PKCS12_R_IV_GEN_ERROR = 106; 318 enum PKCS12_R_KEY_GEN_ERROR = 107; 319 enum PKCS12_R_MAC_ABSENT = 108; 320 enum PKCS12_R_MAC_GENERATION_ERROR = 109; 321 enum PKCS12_R_MAC_SETUP_ERROR = 110; 322 enum PKCS12_R_MAC_STRING_SET_ERROR = 111; 323 enum PKCS12_R_MAC_VERIFY_ERROR = 112; 324 enum PKCS12_R_MAC_VERIFY_FAILURE = 113; 325 enum PKCS12_R_PARSE_ERROR = 114; 326 enum PKCS12_R_PKCS12_ALGOR_CIPHERINIT_ERROR = 115; 327 enum PKCS12_R_PKCS12_CIPHERFINAL_ERROR = 116; 328 enum PKCS12_R_PKCS12_PBE_CRYPT_ERROR = 117; 329 enum PKCS12_R_UNKNOWN_DIGEST_ALGORITHM = 118; 330 enum PKCS12_R_UNSUPPORTED_PKCS12_MODE = 119;