5 d2i_ACCESS_DESCRIPTION,
9 d2i_ASIdentifierChoice,
14 d2i_ASN1_GENERALIZEDTIME,
15 d2i_ASN1_GENERALSTRING,
20 d2i_ASN1_OCTET_STRING,
22 d2i_ASN1_PRINTABLESTRING,
23 d2i_ASN1_SEQUENCE_ANY,
29 d2i_ASN1_UNIVERSALSTRING,
32 d2i_ASN1_VISIBLESTRING,
34 d2i_AUTHORITY_INFO_ACCESS,
36 d2i_BASIC_CONSTRAINTS,
37 d2i_CERTIFICATEPOLICIES,
39 d2i_CMS_ReceiptRequest,
48 d2i_DSAPrivateKey_bio,
67 d2i_ESS_ISSUER_SERIAL,
69 d2i_EXTENDED_KEY_USAGE,
76 d2i_ISSUING_DIST_POINT,
78 d2i_NETSCAPE_CERT_SEQUENCE,
110 d2i_PKCS7_ENC_CONTENT,
112 d2i_PKCS7_ISSUER_AND_SERIAL,
113 d2i_PKCS7_RECIP_INFO,
115 d2i_PKCS7_SIGNER_INFO,
116 d2i_PKCS7_SIGN_ENVELOPE,
119 d2i_PKCS8_PRIV_KEY_INFO,
120 d2i_PKCS8_PRIV_KEY_INFO_bio,
121 d2i_PKCS8_PRIV_KEY_INFO_fp,
124 d2i_PKEY_USAGE_PERIOD,
128 d2i_PROXY_CERT_INFO_EXTENSION,
131 d2i_RSAPrivateKey_bio,
132 d2i_RSAPrivateKey_fp,
134 d2i_RSAPublicKey_bio,
147 d2i_TS_MSG_IMPRINT_bio,
148 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,
225 i2d_DSAPrivateKey_bio,
226 i2d_DSAPrivateKey_fp,
237 i2d_ECPrivateKey_bio,
244 i2d_ESS_ISSUER_SERIAL,
245 i2d_ESS_SIGNING_CERT,
246 i2d_EXTENDED_KEY_USAGE,
251 i2d_IPAddressOrRange,
253 i2d_ISSUING_DIST_POINT,
254 i2d_NAMING_AUTHORITY,
255 i2d_NETSCAPE_CERT_SEQUENCE,
270 i2d_OCSP_REVOKEDINFO,
287 i2d_PKCS7_ENC_CONTENT,
289 i2d_PKCS7_ISSUER_AND_SERIAL,
291 i2d_PKCS7_RECIP_INFO,
293 i2d_PKCS7_SIGNER_INFO,
294 i2d_PKCS7_SIGN_ENVELOPE,
297 i2d_PKCS8PrivateKeyInfo_bio,
298 i2d_PKCS8PrivateKeyInfo_fp,
299 i2d_PKCS8_PRIV_KEY_INFO,
300 i2d_PKCS8_PRIV_KEY_INFO_bio,
301 i2d_PKCS8_PRIV_KEY_INFO_fp,
304 i2d_PKEY_USAGE_PERIOD,
308 i2d_PROXY_CERT_INFO_EXTENSION,
312 i2d_RSAPrivateKey_bio,
313 i2d_RSAPrivateKey_fp,
315 i2d_RSAPublicKey_bio,
328 i2d_TS_MSG_IMPRINT_bio,
329 i2d_TS_MSG_IMPRINT_fp,
363 - convert objects from/to ASN.1/DER representation
369 TYPE *d2i_TYPE(TYPE **a, unsigned char **ppin, long length);
370 TYPE *d2i_TYPE_bio(BIO *bp, TYPE **a);
371 TYPE *d2i_TYPE_fp(FILE *fp, TYPE **a);
373 int i2d_TYPE(TYPE *a, unsigned char **ppout);
374 int i2d_TYPE_fp(FILE *fp, TYPE *a);
375 int i2d_TYPE_bio(BIO *bp, TYPE *a);
379 In the description here, I<TYPE> is used a placeholder
380 for any of the OpenSSL datatypes, such as I<X509_CRL>.
381 The function parameters I<ppin> and I<ppout> are generally
382 either both named I<pp> in the headers, or I<in> and I<out>.
384 These functions convert OpenSSL objects to and from their ASN.1/DER
385 encoding. Unlike the C structures which can have pointers to sub-objects
386 within, the DER is a serialized encoding, suitable for sending over the
387 network, writing to a file, and so on.
389 d2i_TYPE() attempts to decode B<len> bytes at B<*ppin>. If successful a
390 pointer to the B<TYPE> structure is returned and B<*ppin> is incremented to
391 the byte following the parsed data. If B<a> is not B<NULL> then a pointer
392 to the returned structure is also written to B<*a>. If an error occurred
393 then B<NULL> is returned.
395 On a successful return, if B<*a> is not B<NULL> then it is assumed that B<*a>
396 contains a valid B<TYPE> structure and an attempt is made to reuse it. This
397 "reuse" capability is present for historical compatibility but its use is
398 B<strongly discouraged> (see BUGS below, and the discussion in the RETURN
401 d2i_TYPE_bio() is similar to d2i_TYPE() except it attempts
402 to parse data from BIO B<bp>.
404 d2i_TYPE_fp() is similar to d2i_TYPE() except it attempts
405 to parse data from FILE pointer B<fp>.
407 i2d_TYPE() encodes the structure pointed to by B<a> into DER format.
408 If B<ppout> is not B<NULL>, it writes the DER encoded data to the buffer
409 at B<*ppout>, and increments it to point after the data just written.
410 If the return value is negative an error occurred, otherwise it
411 returns the length of the encoded data.
413 If B<*ppout> is B<NULL> memory will be allocated for a buffer and the encoded
414 data written to it. In this case B<*ppout> is not incremented and it points
415 to the start of the data just written.
417 i2d_TYPE_bio() is similar to i2d_TYPE() except it writes
418 the encoding of the structure B<a> to BIO B<bp> and it
419 returns 1 for success and 0 for failure.
421 i2d_TYPE_fp() is similar to i2d_TYPE() except it writes
422 the encoding of the structure B<a> to BIO B<bp> and it
423 returns 1 for success and 0 for failure.
425 These routines do not encrypt private keys and therefore offer no
426 security; use L<PEM_write_PrivateKey(3)> or similar for writing to files.
430 The letters B<i> and B<d> in B<i2d_TYPE> stand for
431 "internal" (that is, an internal C structure) and "DER" respectively.
432 So B<i2d_TYPE> converts from internal to DER.
434 The functions can also understand B<BER> forms.
436 The actual TYPE structure passed to i2d_TYPE() must be a valid
437 populated B<TYPE> structure -- it B<cannot> simply be fed with an
438 empty structure such as that returned by TYPE_new().
440 The encoded data is in binary form and may contain embedded zeroes.
441 Therefore any FILE pointers or BIOs should be opened in binary mode.
442 Functions such as strlen() will B<not> return the correct length
443 of the encoded structure.
445 The ways that B<*ppin> and B<*ppout> are incremented after the operation
446 can trap the unwary. See the B<WARNINGS> section for some common
448 The reason for this-auto increment behaviour is to reflect a typical
449 usage of ASN1 functions: after one structure is encoded or decoded
450 another will be processed after it.
452 The following points about the data types might be useful:
458 Represents an ASN1 OBJECT IDENTIFIER.
462 Represents a PKCS#3 DH parameters structure.
466 Represents an ANSI X9.42 DH parameters structure.
470 Represents a DSA public key using a B<SubjectPublicKeyInfo> structure.
472 =item B<DSAPublicKey, DSAPrivateKey>
474 Use a non-standard OpenSSL format and should be avoided; use B<DSA_PUBKEY>,
475 B<PEM_write_PrivateKey(3)>, or similar instead.
479 Represents an ECDSA signature.
481 =item B<RSAPublicKey>
483 Represents a PKCS#1 RSA public key structure.
487 Represents an B<AlgorithmIdentifier> structure as used in IETF RFC 6960 and
492 Represents a B<Name> type as used for subject and issuer names in
493 IETF RFC 6960 and elsewhere.
497 Represents a PKCS#10 certificate request.
501 Represents the B<DigestInfo> structure defined in PKCS#1 and PKCS#7.
507 d2i_TYPE(), d2i_TYPE_bio() and d2i_TYPE_fp() return a valid B<TYPE> structure
508 or B<NULL> if an error occurs. If the "reuse" capability has been used with
509 a valid structure being passed in via B<a>, then the object is freed in
510 the event of error and B<*a> is set to NULL.
512 i2d_TYPE() returns the number of bytes successfully encoded or a negative
513 value if an error occurs.
515 i2d_TYPE_bio() and i2d_TYPE_fp() return 1 for success and 0 if an error
520 Allocate and encode the DER encoding of an X509 structure:
526 len = i2d_X509(x, &buf);
530 Attempt to decode a buffer:
533 unsigned char *buf, *p;
536 /* Set up buf and len to point to the input buffer. */
538 x = d2i_X509(NULL, &p, len);
542 Alternative technique:
545 unsigned char *buf, *p;
548 /* Set up buf and len to point to the input buffer. */
552 if (d2i_X509(&x, &p, len) == NULL)
557 Using a temporary variable is mandatory. A common
558 mistake is to attempt to use a buffer directly as follows:
563 len = i2d_X509(x, NULL);
564 buf = OPENSSL_malloc(len);
570 This code will result in B<buf> apparently containing garbage because
571 it was incremented after the call to point after the data just written.
572 Also B<buf> will no longer contain the pointer allocated by OPENSSL_malloc()
573 and the subsequent call to OPENSSL_free() is likely to crash.
575 Another trap to avoid is misuse of the B<a> argument to d2i_TYPE():
579 if (d2i_X509(&x, &p, len) == NULL)
582 This will probably crash somewhere in d2i_X509(). The reason for this
583 is that the variable B<x> is uninitialized and an attempt will be made to
584 interpret its (invalid) value as an B<X509> structure, typically causing
585 a segmentation violation. If B<x> is set to NULL first then this will not
590 In some versions of OpenSSL the "reuse" behaviour of d2i_TYPE() when
591 B<*a> is valid is broken and some parts of the reused structure may
592 persist if they are not present in the new one. Additionally, in versions of
593 OpenSSL prior to 1.1.0, when the "reuse" behaviour is used and an error occurs
594 the behaviour is inconsistent. Some functions behaved as described here, while
595 some did not free B<*a> on error and did not set B<*a> to NULL.
597 As a result of the above issues the "reuse" behaviour is strongly discouraged.
599 i2d_TYPE() will not return an error in many versions of OpenSSL,
600 if mandatory fields are not initialized due to a programming error
601 then the encoded structure may contain invalid data or omit the
602 fields entirely and will not be parsed by d2i_TYPE(). This may be
603 fixed in future so code should not assume that i2d_TYPE() will
606 Any function which encodes a structure (i2d_TYPE(),
607 i2d_TYPE() or i2d_TYPE()) may return a stale encoding if the
608 structure has been modified after deserialization or previous
609 serialization. This is because some objects cache the encoding for
614 Copyright 1998-2019 The OpenSSL Project Authors. All Rights Reserved.
616 Licensed under the OpenSSL license (the "License"). You may not use
617 this file except in compliance with the License. You can obtain a copy
618 in the file LICENSE in the source distribution or at
619 L<https://www.openssl.org/source/license.html>.