5 Any keypair function here that gets deprecated should be moved to
12 d2i_ACCESS_DESCRIPTION,
16 d2i_ASIdentifierChoice,
21 d2i_ASN1_GENERALIZEDTIME,
22 d2i_ASN1_GENERALSTRING,
27 d2i_ASN1_OCTET_STRING,
29 d2i_ASN1_PRINTABLESTRING,
30 d2i_ASN1_SEQUENCE_ANY,
36 d2i_ASN1_UNIVERSALSTRING,
39 d2i_ASN1_VISIBLESTRING,
41 d2i_AUTHORITY_INFO_ACCESS,
43 d2i_BASIC_CONSTRAINTS,
44 d2i_CERTIFICATEPOLICIES,
46 d2i_CMS_ReceiptRequest,
59 d2i_ESS_ISSUER_SERIAL,
61 d2i_ESS_SIGNING_CERT_V2,
62 d2i_EXTENDED_KEY_USAGE,
70 d2i_ISSUING_DIST_POINT,
72 d2i_NETSCAPE_CERT_SEQUENCE,
92 d2i_OSSL_CMP_PKIHEADER,
95 d2i_OSSL_CRMF_CERTTEMPLATE,
96 d2i_OSSL_CRMF_ENCRYPTEDVALUE,
99 d2i_OSSL_CRMF_PBMPARAMETER,
100 d2i_OSSL_CRMF_PKIPUBLICATIONINFO,
101 d2i_OSSL_CRMF_SINGLEPUBINFO,
115 d2i_PKCS7_ENC_CONTENT,
117 d2i_PKCS7_ISSUER_AND_SERIAL,
118 d2i_PKCS7_RECIP_INFO,
120 d2i_PKCS7_SIGNER_INFO,
121 d2i_PKCS7_SIGN_ENVELOPE,
124 d2i_PKCS8_PRIV_KEY_INFO,
125 d2i_PKCS8_PRIV_KEY_INFO_bio,
126 d2i_PKCS8_PRIV_KEY_INFO_fp,
129 d2i_PKEY_USAGE_PERIOD,
133 d2i_PROXY_CERT_INFO_EXTENSION,
143 d2i_TS_MSG_IMPRINT_bio,
144 d2i_TS_MSG_IMPRINT_fp,
182 i2d_ACCESS_DESCRIPTION,
184 i2d_ADMISSION_SYNTAX,
186 i2d_ASIdentifierChoice,
191 i2d_ASN1_GENERALIZEDTIME,
192 i2d_ASN1_GENERALSTRING,
197 i2d_ASN1_OCTET_STRING,
199 i2d_ASN1_PRINTABLESTRING,
200 i2d_ASN1_SEQUENCE_ANY,
205 i2d_ASN1_UNIVERSALSTRING,
208 i2d_ASN1_VISIBLESTRING,
211 i2d_AUTHORITY_INFO_ACCESS,
213 i2d_BASIC_CONSTRAINTS,
214 i2d_CERTIFICATEPOLICIES,
216 i2d_CMS_ReceiptRequest,
229 i2d_ESS_ISSUER_SERIAL,
230 i2d_ESS_SIGNING_CERT,
231 i2d_ESS_SIGNING_CERT_V2,
232 i2d_EXTENDED_KEY_USAGE,
237 i2d_IPAddressOrRange,
239 i2d_ISSUER_SIGN_TOOL,
240 i2d_ISSUING_DIST_POINT,
241 i2d_NAMING_AUTHORITY,
242 i2d_NETSCAPE_CERT_SEQUENCE,
257 i2d_OCSP_REVOKEDINFO,
262 i2d_OSSL_CMP_PKIHEADER,
264 i2d_OSSL_CRMF_CERTID,
265 i2d_OSSL_CRMF_CERTTEMPLATE,
266 i2d_OSSL_CRMF_ENCRYPTEDVALUE,
269 i2d_OSSL_CRMF_PBMPARAMETER,
270 i2d_OSSL_CRMF_PKIPUBLICATIONINFO,
271 i2d_OSSL_CRMF_SINGLEPUBINFO,
285 i2d_PKCS7_ENC_CONTENT,
287 i2d_PKCS7_ISSUER_AND_SERIAL,
289 i2d_PKCS7_RECIP_INFO,
291 i2d_PKCS7_SIGNER_INFO,
292 i2d_PKCS7_SIGN_ENVELOPE,
295 i2d_PKCS8PrivateKeyInfo_bio,
296 i2d_PKCS8PrivateKeyInfo_fp,
297 i2d_PKCS8_PRIV_KEY_INFO,
298 i2d_PKCS8_PRIV_KEY_INFO_bio,
299 i2d_PKCS8_PRIV_KEY_INFO_fp,
302 i2d_PKEY_USAGE_PERIOD,
306 i2d_PROXY_CERT_INFO_EXTENSION,
316 i2d_TS_MSG_IMPRINT_bio,
317 i2d_TS_MSG_IMPRINT_fp,
355 - convert objects from/to ASN.1/DER representation
361 TYPE *d2i_TYPE(TYPE **a, const unsigned char **ppin, long length);
362 TYPE *d2i_TYPE_bio(BIO *bp, TYPE **a);
363 TYPE *d2i_TYPE_fp(FILE *fp, TYPE **a);
365 int i2d_TYPE(const TYPE *a, unsigned char **ppout);
366 int i2d_TYPE(TYPE *a, unsigned char **ppout);
367 int i2d_TYPE_fp(FILE *fp, const TYPE *a);
368 int i2d_TYPE_fp(FILE *fp, TYPE *a);
369 int i2d_TYPE_bio(BIO *bp, const TYPE *a);
370 int i2d_TYPE_bio(BIO *bp, TYPE *a);
374 In the description here, B<I<TYPE>> is used a placeholder
375 for any of the OpenSSL datatypes, such as B<X509_CRL>.
376 The function parameters I<ppin> and I<ppout> are generally
377 either both named I<pp> in the headers, or I<in> and I<out>.
379 These functions convert OpenSSL objects to and from their ASN.1/DER
380 encoding. Unlike the C structures which can have pointers to sub-objects
381 within, the DER is a serialized encoding, suitable for sending over the
382 network, writing to a file, and so on.
384 B<d2i_I<TYPE>>() attempts to decode I<len> bytes at I<*ppin>. If successful a
385 pointer to the B<I<TYPE>> structure is returned and I<*ppin> is incremented to
386 the byte following the parsed data. If I<a> is not NULL then a pointer
387 to the returned structure is also written to I<*a>. If an error occurred
388 then NULL is returned.
390 On a successful return, if I<*a> is not NULL then it is assumed that I<*a>
391 contains a valid B<I<TYPE>> structure and an attempt is made to reuse it. This
392 "reuse" capability is present for historical compatibility but its use is
393 B<strongly discouraged> (see BUGS below, and the discussion in the RETURN
396 B<d2i_I<TYPE>_bio>() is similar to B<d2i_I<TYPE>>() except it attempts
397 to parse data from BIO I<bp>.
399 B<d2i_I<TYPE>_fp>() is similar to B<d2i_I<TYPE>>() except it attempts
400 to parse data from FILE pointer I<fp>.
402 B<i2d_I<TYPE>>() encodes the structure pointed to by I<a> into DER format.
403 If I<ppout> is not NULL, it writes the DER encoded data to the buffer
404 at I<*ppout>, and increments it to point after the data just written.
405 If the return value is negative an error occurred, otherwise it
406 returns the length of the encoded data.
408 If I<*ppout> is NULL memory will be allocated for a buffer and the encoded
409 data written to it. In this case I<*ppout> is not incremented and it points
410 to the start of the data just written.
412 B<i2d_I<TYPE>_bio>() is similar to B<i2d_I<TYPE>>() except it writes
413 the encoding of the structure I<a> to BIO I<bp> and it
414 returns 1 for success and 0 for failure.
416 B<i2d_I<TYPE>_fp>() is similar to B<i2d_I<TYPE>>() except it writes
417 the encoding of the structure I<a> to FILE pointer I<fp> and it
418 returns 1 for success and 0 for failure.
420 These routines do not encrypt private keys and therefore offer no
421 security; use L<PEM_write_PrivateKey(3)> or similar for writing to files.
425 The letters B<i> and B<d> in B<i2d_I<TYPE>>() stand for
426 "internal" (that is, an internal C structure) and "DER" respectively.
427 So B<i2d_I<TYPE>>() converts from internal to DER.
429 The functions can also understand B<BER> forms.
431 The actual TYPE structure passed to B<i2d_I<TYPE>>() must be a valid
432 populated B<I<TYPE>> structure -- it B<cannot> simply be fed with an
433 empty structure such as that returned by TYPE_new().
435 The encoded data is in binary form and may contain embedded zeros.
436 Therefore, any FILE pointers or BIOs should be opened in binary mode.
437 Functions such as strlen() will B<not> return the correct length
438 of the encoded structure.
440 The ways that I<*ppin> and I<*ppout> are incremented after the operation
441 can trap the unwary. See the B<WARNINGS> section for some common
443 The reason for this-auto increment behaviour is to reflect a typical
444 usage of ASN1 functions: after one structure is encoded or decoded
445 another will be processed after it.
447 The following points about the data types might be useful:
453 Represents an ASN1 OBJECT IDENTIFIER.
457 Represents a PKCS#3 DH parameters structure.
461 Represents an ANSI X9.42 DH parameters structure.
465 Represents an ECDSA signature.
469 Represents an B<AlgorithmIdentifier> structure as used in IETF RFC 6960 and
474 Represents a B<Name> type as used for subject and issuer names in
475 IETF RFC 6960 and elsewhere.
479 Represents a PKCS#10 certificate request.
483 Represents the B<DigestInfo> structure defined in PKCS#1 and PKCS#7.
489 B<d2i_I<TYPE>>(), B<d2i_I<TYPE>_bio>() and B<d2i_I<TYPE>_fp>() return a valid
490 B<I<TYPE>> structure or NULL if an error occurs. If the "reuse" capability has
491 been used with a valid structure being passed in via I<a>, then the object is
492 freed in the event of error and I<*a> is set to NULL.
494 B<i2d_I<TYPE>>() returns the number of bytes successfully encoded or a negative
495 value if an error occurs.
497 B<i2d_I<TYPE>_bio>() and B<i2d_I<TYPE>_fp>() return 1 for success and 0 if an
502 Allocate and encode the DER encoding of an X509 structure:
508 len = i2d_X509(x, &buf);
512 Attempt to decode a buffer:
516 const unsigned char *p;
519 /* Set up buf and len to point to the input buffer. */
521 x = d2i_X509(NULL, &p, len);
525 Alternative technique:
529 const unsigned char *p;
532 /* Set up buf and len to point to the input buffer. */
536 if (d2i_X509(&x, &p, len) == NULL)
541 Using a temporary variable is mandatory. A common
542 mistake is to attempt to use a buffer directly as follows:
547 len = i2d_X509(x, NULL);
548 buf = OPENSSL_malloc(len);
554 This code will result in I<buf> apparently containing garbage because
555 it was incremented after the call to point after the data just written.
556 Also I<buf> will no longer contain the pointer allocated by OPENSSL_malloc()
557 and the subsequent call to OPENSSL_free() is likely to crash.
559 Another trap to avoid is misuse of the I<a> argument to B<d2i_I<TYPE>>():
563 if (d2i_X509(&x, &p, len) == NULL)
566 This will probably crash somewhere in d2i_X509(). The reason for this
567 is that the variable I<x> is uninitialized and an attempt will be made to
568 interpret its (invalid) value as an B<X509> structure, typically causing
569 a segmentation violation. If I<x> is set to NULL first then this will not
574 In some versions of OpenSSL the "reuse" behaviour of B<d2i_I<TYPE>>() when
575 I<*a> is valid is broken and some parts of the reused structure may
576 persist if they are not present in the new one. Additionally, in versions of
577 OpenSSL prior to 1.1.0, when the "reuse" behaviour is used and an error occurs
578 the behaviour is inconsistent. Some functions behaved as described here, while
579 some did not free I<*a> on error and did not set I<*a> to NULL.
581 As a result of the above issues the "reuse" behaviour is strongly discouraged.
583 B<i2d_I<TYPE>>() will not return an error in many versions of OpenSSL,
584 if mandatory fields are not initialized due to a programming error
585 then the encoded structure may contain invalid data or omit the
586 fields entirely and will not be parsed by B<d2i_I<TYPE>>(). This may be
587 fixed in future so code should not assume that B<i2d_I<TYPE>>() will
590 Any function which encodes a structure (B<i2d_I<TYPE>>(),
591 B<i2d_I<TYPE>>() or B<i2d_I<TYPE>>()) may return a stale encoding if the
592 structure has been modified after deserialization or previous
593 serialization. This is because some objects cache the encoding for
598 Copyright 1998-2021 The OpenSSL Project Authors. All Rights Reserved.
600 Licensed under the Apache License 2.0 (the "License"). You may not use
601 this file except in compliance with the License. You can obtain a copy
602 in the file LICENSE in the source distribution or at
603 L<https://www.openssl.org/source/license.html>.