diff options
Diffstat (limited to 'src/lib/libssl')
| -rw-r--r-- | src/lib/libssl/src/doc/crypto/ASN1_OBJECT_new.pod | 46 | ||||
| -rw-r--r-- | src/lib/libssl/src/doc/crypto/ASN1_STRING_length.pod | 83 | ||||
| -rw-r--r-- | src/lib/libssl/src/doc/crypto/ASN1_STRING_new.pod | 42 | ||||
| -rw-r--r-- | src/lib/libssl/src/doc/crypto/ASN1_STRING_print_ex.pod | 95 | ||||
| -rw-r--r-- | src/lib/libssl/src/doc/crypto/ASN1_generate_nconf.pod | 265 |
5 files changed, 0 insertions, 531 deletions
diff --git a/src/lib/libssl/src/doc/crypto/ASN1_OBJECT_new.pod b/src/lib/libssl/src/doc/crypto/ASN1_OBJECT_new.pod deleted file mode 100644 index 1c43494c7d..0000000000 --- a/src/lib/libssl/src/doc/crypto/ASN1_OBJECT_new.pod +++ /dev/null | |||
| @@ -1,46 +0,0 @@ | |||
| 1 | =pod | ||
| 2 | |||
| 3 | =head1 NAME | ||
| 4 | |||
| 5 | ASN1_OBJECT_new, ASN1_OBJECT_free - object allocation functions | ||
| 6 | |||
| 7 | =head1 SYNOPSIS | ||
| 8 | |||
| 9 | #include <openssl/asn1.h> | ||
| 10 | |||
| 11 | ASN1_OBJECT *ASN1_OBJECT_new(void); | ||
| 12 | void ASN1_OBJECT_free(ASN1_OBJECT *a); | ||
| 13 | |||
| 14 | =head1 DESCRIPTION | ||
| 15 | |||
| 16 | The ASN1_OBJECT allocation routines, allocate and free an | ||
| 17 | ASN1_OBJECT structure, which represents an ASN1 OBJECT IDENTIFIER. | ||
| 18 | |||
| 19 | ASN1_OBJECT_new() allocates and initializes a ASN1_OBJECT structure. | ||
| 20 | |||
| 21 | ASN1_OBJECT_free() frees up the B<ASN1_OBJECT> structure B<a>. | ||
| 22 | |||
| 23 | =head1 NOTES | ||
| 24 | |||
| 25 | Although ASN1_OBJECT_new() allocates a new ASN1_OBJECT structure it | ||
| 26 | is almost never used in applications. The ASN1 object utility functions | ||
| 27 | such as OBJ_nid2obj() are used instead. | ||
| 28 | |||
| 29 | =head1 RETURN VALUES | ||
| 30 | |||
| 31 | If the allocation fails, ASN1_OBJECT_new() returns B<NULL> and sets an error | ||
| 32 | code that can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>. | ||
| 33 | Otherwise it returns a pointer to the newly allocated structure. | ||
| 34 | |||
| 35 | ASN1_OBJECT_free() returns no value. | ||
| 36 | |||
| 37 | =head1 SEE ALSO | ||
| 38 | |||
| 39 | L<ERR_get_error(3)|ERR_get_error(3)>, L<d2i_ASN1_OBJECT(3)|d2i_ASN1_OBJECT(3)> | ||
| 40 | |||
| 41 | =head1 HISTORY | ||
| 42 | |||
| 43 | ASN1_OBJECT_new() and ASN1_OBJECT_free() are available in all versions of | ||
| 44 | SSLeay and OpenSSL. | ||
| 45 | |||
| 46 | =cut | ||
diff --git a/src/lib/libssl/src/doc/crypto/ASN1_STRING_length.pod b/src/lib/libssl/src/doc/crypto/ASN1_STRING_length.pod deleted file mode 100644 index f9a47a47dc..0000000000 --- a/src/lib/libssl/src/doc/crypto/ASN1_STRING_length.pod +++ /dev/null | |||
| @@ -1,83 +0,0 @@ | |||
| 1 | =pod | ||
| 2 | |||
| 3 | =head1 NAME | ||
| 4 | |||
| 5 | ASN1_STRING_dup, ASN1_STRING_cmp, ASN1_STRING_set, ASN1_STRING_length, | ||
| 6 | ASN1_STRING_length_set, ASN1_STRING_type, ASN1_STRING_data, ASN1_STRING_to_UTF8 - | ||
| 7 | ASN1_STRING utility functions | ||
| 8 | |||
| 9 | =head1 SYNOPSIS | ||
| 10 | |||
| 11 | #include <openssl/asn1.h> | ||
| 12 | |||
| 13 | int ASN1_STRING_length(ASN1_STRING *x); | ||
| 14 | unsigned char * ASN1_STRING_data(ASN1_STRING *x); | ||
| 15 | |||
| 16 | ASN1_STRING * ASN1_STRING_dup(ASN1_STRING *a); | ||
| 17 | |||
| 18 | int ASN1_STRING_cmp(ASN1_STRING *a, ASN1_STRING *b); | ||
| 19 | |||
| 20 | int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len); | ||
| 21 | |||
| 22 | int ASN1_STRING_type(ASN1_STRING *x); | ||
| 23 | |||
| 24 | int ASN1_STRING_to_UTF8(unsigned char **out, ASN1_STRING *in); | ||
| 25 | |||
| 26 | =head1 DESCRIPTION | ||
| 27 | |||
| 28 | These functions allow an B<ASN1_STRING> structure to be manipulated. | ||
| 29 | |||
| 30 | ASN1_STRING_length() returns the length of the content of B<x>. | ||
| 31 | |||
| 32 | ASN1_STRING_data() returns an internal pointer to the data of B<x>. | ||
| 33 | Since this is an internal pointer it should B<not> be freed or | ||
| 34 | modified in any way. | ||
| 35 | |||
| 36 | ASN1_STRING_dup() returns a copy of the structure B<a>. | ||
| 37 | |||
| 38 | ASN1_STRING_cmp() compares B<a> and B<b> returning 0 if the two | ||
| 39 | are identical. The string types and content are compared. | ||
| 40 | |||
| 41 | ASN1_STRING_set() sets the data of string B<str> to the buffer | ||
| 42 | B<data> or length B<len>. The supplied data is copied. If B<len> | ||
| 43 | is -1 then the length is determined by strlen(data). | ||
| 44 | |||
| 45 | ASN1_STRING_type() returns the type of B<x>, using standard constants | ||
| 46 | such as B<V_ASN1_OCTET_STRING>. | ||
| 47 | |||
| 48 | ASN1_STRING_to_UTF8() converts the string B<in> to UTF8 format, the | ||
| 49 | converted data is allocated in a buffer in B<*out>. The length of | ||
| 50 | B<out> is returned or a negative error code. The buffer B<*out> | ||
| 51 | should be free using free(). | ||
| 52 | |||
| 53 | =head1 NOTES | ||
| 54 | |||
| 55 | Almost all ASN1 types in OpenSSL are represented as an B<ASN1_STRING> | ||
| 56 | structure. Other types such as B<ASN1_OCTET_STRING> are simply typedefed | ||
| 57 | to B<ASN1_STRING> and the functions call the B<ASN1_STRING> equivalents. | ||
| 58 | B<ASN1_STRING> is also used for some B<CHOICE> types which consist | ||
| 59 | entirely of primitive string types such as B<DirectoryString> and | ||
| 60 | B<Time>. | ||
| 61 | |||
| 62 | These functions should B<not> be used to examine or modify B<ASN1_INTEGER> | ||
| 63 | or B<ASN1_ENUMERATED> types: the relevant B<INTEGER> or B<ENUMERATED> | ||
| 64 | utility functions should be used instead. | ||
| 65 | |||
| 66 | In general it cannot be assumed that the data returned by ASN1_STRING_data() | ||
| 67 | is null terminated or does not contain embedded nulls. The actual format | ||
| 68 | of the data will depend on the actual string type itself: for example | ||
| 69 | for and IA5String the data will be ASCII, for a BMPString two bytes per | ||
| 70 | character in big endian format, UTF8String will be in UTF8 format. | ||
| 71 | |||
| 72 | Similar care should be take to ensure the data is in the correct format | ||
| 73 | when calling ASN1_STRING_set(). | ||
| 74 | |||
| 75 | =head1 RETURN VALUES | ||
| 76 | |||
| 77 | =head1 SEE ALSO | ||
| 78 | |||
| 79 | L<ERR_get_error(3)|ERR_get_error(3)> | ||
| 80 | |||
| 81 | =head1 HISTORY | ||
| 82 | |||
| 83 | =cut | ||
diff --git a/src/lib/libssl/src/doc/crypto/ASN1_STRING_new.pod b/src/lib/libssl/src/doc/crypto/ASN1_STRING_new.pod deleted file mode 100644 index b5e72a8347..0000000000 --- a/src/lib/libssl/src/doc/crypto/ASN1_STRING_new.pod +++ /dev/null | |||
| @@ -1,42 +0,0 @@ | |||
| 1 | =pod | ||
| 2 | |||
| 3 | =head1 NAME | ||
| 4 | |||
| 5 | ASN1_STRING_new, ASN1_STRING_type_new, ASN1_STRING_free - | ||
| 6 | ASN1_STRING allocation functions | ||
| 7 | |||
| 8 | =head1 SYNOPSIS | ||
| 9 | |||
| 10 | #include <openssl/asn1.h> | ||
| 11 | |||
| 12 | ASN1_STRING * ASN1_STRING_new(void); | ||
| 13 | ASN1_STRING * ASN1_STRING_type_new(int type); | ||
| 14 | void ASN1_STRING_free(ASN1_STRING *a); | ||
| 15 | |||
| 16 | =head1 DESCRIPTION | ||
| 17 | |||
| 18 | ASN1_STRING_new() returns an allocated B<ASN1_STRING> structure. Its type | ||
| 19 | is undefined. | ||
| 20 | |||
| 21 | ASN1_STRING_type_new() returns an allocated B<ASN1_STRING> structure of | ||
| 22 | type B<type>. | ||
| 23 | |||
| 24 | ASN1_STRING_free() frees up B<a>. | ||
| 25 | |||
| 26 | =head1 NOTES | ||
| 27 | |||
| 28 | Other string types call the B<ASN1_STRING> functions. For example | ||
| 29 | ASN1_OCTET_STRING_new() calls ASN1_STRING_type(V_ASN1_OCTET_STRING). | ||
| 30 | |||
| 31 | =head1 RETURN VALUES | ||
| 32 | |||
| 33 | ASN1_STRING_new() and ASN1_STRING_type_new() return a valid | ||
| 34 | ASN1_STRING structure or B<NULL> if an error occurred. | ||
| 35 | |||
| 36 | ASN1_STRING_free() does not return a value. | ||
| 37 | |||
| 38 | =head1 SEE ALSO | ||
| 39 | |||
| 40 | L<ERR_get_error(3)|ERR_get_error(3)> | ||
| 41 | |||
| 42 | =cut | ||
diff --git a/src/lib/libssl/src/doc/crypto/ASN1_STRING_print_ex.pod b/src/lib/libssl/src/doc/crypto/ASN1_STRING_print_ex.pod deleted file mode 100644 index a93047a040..0000000000 --- a/src/lib/libssl/src/doc/crypto/ASN1_STRING_print_ex.pod +++ /dev/null | |||
| @@ -1,95 +0,0 @@ | |||
| 1 | =pod | ||
| 2 | |||
| 3 | =head1 NAME | ||
| 4 | |||
| 5 | ASN1_STRING_print_ex, ASN1_STRING_print_ex_fp, ASN1_STRING_print - ASN1_STRING output routines. | ||
| 6 | |||
| 7 | =head1 SYNOPSIS | ||
| 8 | |||
| 9 | #include <openssl/asn1.h> | ||
| 10 | |||
| 11 | int ASN1_STRING_print_ex(BIO *out, ASN1_STRING *str, unsigned long flags); | ||
| 12 | int ASN1_STRING_print_ex_fp(FILE *fp, ASN1_STRING *str, unsigned long flags); | ||
| 13 | int ASN1_STRING_print(BIO *out, ASN1_STRING *str); | ||
| 14 | |||
| 15 | |||
| 16 | =head1 DESCRIPTION | ||
| 17 | |||
| 18 | These functions output an B<ASN1_STRING> structure. B<ASN1_STRING> is used to | ||
| 19 | represent all the ASN1 string types. | ||
| 20 | |||
| 21 | ASN1_STRING_print_ex() outputs B<str> to B<out>, the format is determined by | ||
| 22 | the options B<flags>. ASN1_STRING_print_ex_fp() is identical except it outputs | ||
| 23 | to B<fp> instead. | ||
| 24 | |||
| 25 | ASN1_STRING_print() prints B<str> to B<out> but using a different format to | ||
| 26 | ASN1_STRING_print_ex(). It replaces unprintable characters (other than CR, LF) | ||
| 27 | with '.'. | ||
| 28 | |||
| 29 | =head1 NOTES | ||
| 30 | |||
| 31 | ASN1_STRING_print() is a legacy function which should be avoided in new | ||
| 32 | applications. | ||
| 33 | |||
| 34 | Although there are a large number of options frequently B<ASN1_STRFLGS_RFC2253> | ||
| 35 | is suitable, or on UTF8 terminals B<ASN1_STRFLGS_RFC2253 & | ||
| 36 | ~ASN1_STRFLGS_ESC_MSB>. | ||
| 37 | |||
| 38 | The complete set of supported options for B<flags> is listed below. | ||
| 39 | |||
| 40 | Various characters can be escaped. If B<ASN1_STRFLGS_ESC_2253> is set the | ||
| 41 | characters determined by RFC2253 are escaped. If B<ASN1_STRFLGS_ESC_CTRL> is | ||
| 42 | set control characters are escaped. If B<ASN1_STRFLGS_ESC_MSB> is set | ||
| 43 | characters with the MSB set are escaped: this option should B<not> be used if | ||
| 44 | the terminal correctly interprets UTF8 sequences. | ||
| 45 | |||
| 46 | Escaping takes several forms. | ||
| 47 | |||
| 48 | If the character being escaped is a 16 bit character then the form "\UXXXX" is | ||
| 49 | used using exactly four characters for the hex representation. If it is 32 bits | ||
| 50 | then "\WXXXXXXXX" is used using eight characters of its hex representation. | ||
| 51 | These forms will only be used if UTF8 conversion is not set (see below). | ||
| 52 | |||
| 53 | Printable characters are normally escaped using the backslash '\' character. If | ||
| 54 | B<ASN1_STRFLGS_ESC_QUOTE> is set then the whole string is instead surrounded by | ||
| 55 | double quote characters: this is arguably more readable than the backslash | ||
| 56 | notation. Other characters use the "\XX" using exactly two characters of the hex | ||
| 57 | representation. | ||
| 58 | |||
| 59 | If B<ASN1_STRFLGS_UTF8_CONVERT> is set then characters are converted to UTF8 | ||
| 60 | format first. If the terminal supports the display of UTF8 sequences then this | ||
| 61 | option will correctly display multi byte characters. | ||
| 62 | |||
| 63 | If B<ASN1_STRFLGS_IGNORE_TYPE> is set then the string type is not interpreted | ||
| 64 | at all: everything is assumed to be one byte per character. This is primarily | ||
| 65 | for debugging purposes and can result in confusing output in multi character | ||
| 66 | strings. | ||
| 67 | |||
| 68 | If B<ASN1_STRFLGS_SHOW_TYPE> is set then the string type itself is printed out | ||
| 69 | before its value (for example "BMPSTRING"), this actually uses ASN1_tag2str(). | ||
| 70 | |||
| 71 | The content of a string instead of being interpreted can be "dumped": this just | ||
| 72 | outputs the value of the string using the form #XXXX using hex format for each | ||
| 73 | octet. | ||
| 74 | |||
| 75 | If B<ASN1_STRFLGS_DUMP_ALL> is set then any type is dumped. | ||
| 76 | |||
| 77 | Normally non character string types (such as OCTET STRING) are assumed to be | ||
| 78 | one byte per character, if B<ASN1_STRFLGS_DUMP_UNKNOWN> is set then they will | ||
| 79 | be dumped instead. | ||
| 80 | |||
| 81 | When a type is dumped normally just the content octets are printed, if | ||
| 82 | B<ASN1_STRFLGS_DUMP_DER> is set then the complete encoding is dumped | ||
| 83 | instead (including tag and length octets). | ||
| 84 | |||
| 85 | B<ASN1_STRFLGS_RFC2253> includes all the flags required by RFC2253. It is | ||
| 86 | equivalent to: | ||
| 87 | ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | | ||
| 88 | ASN1_STRFLGS_UTF8_CONVERT | ASN1_STRFLGS_DUMP_UNKNOWN ASN1_STRFLGS_DUMP_DER | ||
| 89 | |||
| 90 | =head1 SEE ALSO | ||
| 91 | |||
| 92 | L<X509_NAME_print_ex(3)|X509_NAME_print_ex(3)>, | ||
| 93 | L<ASN1_tag2str(3)|ASN1_tag2str(3)> | ||
| 94 | |||
| 95 | =cut | ||
diff --git a/src/lib/libssl/src/doc/crypto/ASN1_generate_nconf.pod b/src/lib/libssl/src/doc/crypto/ASN1_generate_nconf.pod deleted file mode 100644 index 4b8a937a66..0000000000 --- a/src/lib/libssl/src/doc/crypto/ASN1_generate_nconf.pod +++ /dev/null | |||
| @@ -1,265 +0,0 @@ | |||
| 1 | =pod | ||
| 2 | |||
| 3 | =head1 NAME | ||
| 4 | |||
| 5 | ASN1_generate_nconf, ASN1_generate_v3 - ASN1 generation functions | ||
| 6 | |||
| 7 | =head1 SYNOPSIS | ||
| 8 | |||
| 9 | #include <openssl/asn1.h> | ||
| 10 | |||
| 11 | ASN1_TYPE *ASN1_generate_nconf(char *str, CONF *nconf); | ||
| 12 | ASN1_TYPE *ASN1_generate_v3(char *str, X509V3_CTX *cnf); | ||
| 13 | |||
| 14 | =head1 DESCRIPTION | ||
| 15 | |||
| 16 | These functions generate the ASN1 encoding of a string | ||
| 17 | in an B<ASN1_TYPE> structure. | ||
| 18 | |||
| 19 | B<str> contains the string to encode B<nconf> or B<cnf> contains | ||
| 20 | the optional configuration information where additional strings | ||
| 21 | will be read from. B<nconf> will typically come from a config | ||
| 22 | file wherease B<cnf> is obtained from an B<X509V3_CTX> structure | ||
| 23 | which will typically be used by X509 v3 certificate extension | ||
| 24 | functions. B<cnf> or B<nconf> can be set to B<NULL> if no additional | ||
| 25 | configuration will be used. | ||
| 26 | |||
| 27 | =head1 GENERATION STRING FORMAT | ||
| 28 | |||
| 29 | The actual data encoded is determined by the string B<str> and | ||
| 30 | the configuration information. The general format of the string | ||
| 31 | is: | ||
| 32 | |||
| 33 | =over 2 | ||
| 34 | |||
| 35 | =item B<[modifier,]type[:value]> | ||
| 36 | |||
| 37 | =back | ||
| 38 | |||
| 39 | That is zero or more comma separated modifiers followed by a type | ||
| 40 | followed by an optional colon and a value. The formats of B<type>, | ||
| 41 | B<value> and B<modifier> are explained below. | ||
| 42 | |||
| 43 | =head2 SUPPORTED TYPES | ||
| 44 | |||
| 45 | The supported types are listed below. Unless otherwise specified | ||
| 46 | only the B<ASCII> format is permissible. | ||
| 47 | |||
| 48 | =over 2 | ||
| 49 | |||
| 50 | =item B<BOOLEAN>, B<BOOL> | ||
| 51 | |||
| 52 | This encodes a boolean type. The B<value> string is mandatory and | ||
| 53 | should be B<TRUE> or B<FALSE>. Additionally B<TRUE>, B<true>, B<Y>, | ||
| 54 | B<y>, B<YES>, B<yes>, B<FALSE>, B<false>, B<N>, B<n>, B<NO> and B<no> | ||
| 55 | are acceptable. | ||
| 56 | |||
| 57 | =item B<NULL> | ||
| 58 | |||
| 59 | Encode the B<NULL> type, the B<value> string must not be present. | ||
| 60 | |||
| 61 | =item B<INTEGER>, B<INT> | ||
| 62 | |||
| 63 | Encodes an ASN1 B<INTEGER> type. The B<value> string represents | ||
| 64 | the value of the integer, it can be prefaced by a minus sign and | ||
| 65 | is normally interpreted as a decimal value unless the prefix B<0x> | ||
| 66 | is included. | ||
| 67 | |||
| 68 | =item B<ENUMERATED>, B<ENUM> | ||
| 69 | |||
| 70 | Encodes the ASN1 B<ENUMERATED> type, it is otherwise identical to | ||
| 71 | B<INTEGER>. | ||
| 72 | |||
| 73 | =item B<OBJECT>, B<OID> | ||
| 74 | |||
| 75 | Encodes an ASN1 B<OBJECT IDENTIFIER>, the B<value> string can be | ||
| 76 | a short name, a long name or numerical format. | ||
| 77 | |||
| 78 | =item B<UTCTIME>, B<UTC> | ||
| 79 | |||
| 80 | Encodes an ASN1 B<UTCTime> structure, the value should be in | ||
| 81 | the format B<YYMMDDHHMMSSZ>. | ||
| 82 | |||
| 83 | =item B<GENERALIZEDTIME>, B<GENTIME> | ||
| 84 | |||
| 85 | Encodes an ASN1 B<GeneralizedTime> structure, the value should be in | ||
| 86 | the format B<YYYYMMDDHHMMSSZ>. | ||
| 87 | |||
| 88 | =item B<OCTETSTRING>, B<OCT> | ||
| 89 | |||
| 90 | Encodes an ASN1 B<OCTET STRING>. B<value> represents the contents | ||
| 91 | of this structure, the format strings B<ASCII> and B<HEX> can be | ||
| 92 | used to specify the format of B<value>. | ||
| 93 | |||
| 94 | =item B<BITSTRING>, B<BITSTR> | ||
| 95 | |||
| 96 | Encodes an ASN1 B<BIT STRING>. B<value> represents the contents | ||
| 97 | of this structure, the format strings B<ASCII>, B<HEX> and B<BITLIST> | ||
| 98 | can be used to specify the format of B<value>. | ||
| 99 | |||
| 100 | If the format is anything other than B<BITLIST> the number of unused | ||
| 101 | bits is set to zero. | ||
| 102 | |||
| 103 | =item B<UNIVERSALSTRING>, B<UNIV>, B<IA5>, B<IA5STRING>, B<UTF8>, | ||
| 104 | B<UTF8String>, B<BMP>, B<BMPSTRING>, B<VISIBLESTRING>, | ||
| 105 | B<VISIBLE>, B<PRINTABLESTRING>, B<PRINTABLE>, B<T61>, | ||
| 106 | B<T61STRING>, B<TELETEXSTRING>, B<GeneralString>, B<NUMERICSTRING>, | ||
| 107 | B<NUMERIC> | ||
| 108 | |||
| 109 | These encode the corresponding string types. B<value> represents the | ||
| 110 | contents of this structure. The format can be B<ASCII> or B<UTF8>. | ||
| 111 | |||
| 112 | =item B<SEQUENCE>, B<SEQ>, B<SET> | ||
| 113 | |||
| 114 | Formats the result as an ASN1 B<SEQUENCE> or B<SET> type. B<value> | ||
| 115 | should be a section name which will contain the contents. The | ||
| 116 | field names in the section are ignored and the values are in the | ||
| 117 | generated string format. If B<value> is absent then an empty SEQUENCE | ||
| 118 | will be encoded. | ||
| 119 | |||
| 120 | =back | ||
| 121 | |||
| 122 | =head2 MODIFIERS | ||
| 123 | |||
| 124 | Modifiers affect the following structure, they can be used to | ||
| 125 | add EXPLICIT or IMPLICIT tagging, add wrappers or to change | ||
| 126 | the string format of the final type and value. The supported | ||
| 127 | formats are documented below. | ||
| 128 | |||
| 129 | =over 2 | ||
| 130 | |||
| 131 | =item B<EXPLICIT>, B<EXP> | ||
| 132 | |||
| 133 | Add an explicit tag to the following structure. This string | ||
| 134 | should be followed by a colon and the tag value to use as a | ||
| 135 | decimal value. | ||
| 136 | |||
| 137 | By following the number with B<U>, B<A>, B<P> or B<C> UNIVERSAL, | ||
| 138 | APPLICATION, PRIVATE or CONTEXT SPECIFIC tagging can be used, | ||
| 139 | the default is CONTEXT SPECIFIC. | ||
| 140 | |||
| 141 | =item B<IMPLICIT>, B<IMP> | ||
| 142 | |||
| 143 | This is the same as B<EXPLICIT> except IMPLICIT tagging is used | ||
| 144 | instead. | ||
| 145 | |||
| 146 | =item B<OCTWRAP>, B<SEQWRAP>, B<SETWRAP>, B<BITWRAP> | ||
| 147 | |||
| 148 | The following structure is surrounded by an OCTET STRING, a SEQUENCE, | ||
| 149 | a SET or a BIT STRING respectively. For a BIT STRING the number of unused | ||
| 150 | bits is set to zero. | ||
| 151 | |||
| 152 | =item B<FORMAT> | ||
| 153 | |||
| 154 | This specifies the format of the ultimate value. It should be followed | ||
| 155 | by a colon and one of the strings B<ASCII>, B<UTF8>, B<HEX> or B<BITLIST>. | ||
| 156 | |||
| 157 | If no format specifier is included then B<ASCII> is used. If B<UTF8> is | ||
| 158 | specified then the value string must be a valid B<UTF8> string. For B<HEX> the | ||
| 159 | output must be a set of hex digits. B<BITLIST> (which is only valid for a BIT | ||
| 160 | STRING) is a comma separated list of the indices of the set bits, all other | ||
| 161 | bits are zero. | ||
| 162 | |||
| 163 | =back | ||
| 164 | |||
| 165 | =head1 EXAMPLES | ||
| 166 | |||
| 167 | A simple IA5String: | ||
| 168 | |||
| 169 | IA5STRING:Hello World | ||
| 170 | |||
| 171 | An IA5String explicitly tagged: | ||
| 172 | |||
| 173 | EXPLICIT:0,IA5STRING:Hello World | ||
| 174 | |||
| 175 | An IA5String explicitly tagged using APPLICATION tagging: | ||
| 176 | |||
| 177 | EXPLICIT:0A,IA5STRING:Hello World | ||
| 178 | |||
| 179 | A BITSTRING with bits 1 and 5 set and all others zero: | ||
| 180 | |||
| 181 | FORMAT:BITLIST,BITSTRING:1,5 | ||
| 182 | |||
| 183 | A more complex example using a config file to produce a | ||
| 184 | SEQUENCE consiting of a BOOL an OID and a UTF8String: | ||
| 185 | |||
| 186 | asn1 = SEQUENCE:seq_section | ||
| 187 | |||
| 188 | [seq_section] | ||
| 189 | |||
| 190 | field1 = BOOLEAN:TRUE | ||
| 191 | field2 = OID:commonName | ||
| 192 | field3 = UTF8:Third field | ||
| 193 | |||
| 194 | This example produces an RSAPrivateKey structure, this is the | ||
| 195 | key contained in the file client.pem in all OpenSSL distributions | ||
| 196 | (note: the field names such as 'coeff' are ignored and are present just | ||
| 197 | for clarity): | ||
| 198 | |||
| 199 | asn1=SEQUENCE:private_key | ||
| 200 | [private_key] | ||
| 201 | version=INTEGER:0 | ||
| 202 | |||
| 203 | n=INTEGER:0xBB6FE79432CC6EA2D8F970675A5A87BFBE1AFF0BE63E879F2AFFB93644\ | ||
| 204 | D4D2C6D000430DEC66ABF47829E74B8C5108623A1C0EE8BE217B3AD8D36D5EB4FCA1D9 | ||
| 205 | |||
| 206 | e=INTEGER:0x010001 | ||
| 207 | |||
| 208 | d=INTEGER:0x6F05EAD2F27FFAEC84BEC360C4B928FD5F3A9865D0FCAAD291E2A52F4A\ | ||
| 209 | F810DC6373278C006A0ABBA27DC8C63BF97F7E666E27C5284D7D3B1FFFE16B7A87B51D | ||
| 210 | |||
| 211 | p=INTEGER:0xF3929B9435608F8A22C208D86795271D54EBDFB09DDEF539AB083DA912\ | ||
| 212 | D4BD57 | ||
| 213 | |||
| 214 | q=INTEGER:0xC50016F89DFF2561347ED1186A46E150E28BF2D0F539A1594BBD7FE467\ | ||
| 215 | 46EC4F | ||
| 216 | |||
| 217 | exp1=INTEGER:0x9E7D4326C924AFC1DEA40B45650134966D6F9DFA3A7F9D698CD4ABEA\ | ||
| 218 | 9C0A39B9 | ||
| 219 | |||
| 220 | exp2=INTEGER:0xBA84003BB95355AFB7C50DF140C60513D0BA51D637272E355E397779\ | ||
| 221 | E7B2458F | ||
| 222 | |||
| 223 | coeff=INTEGER:0x30B9E4F2AFA5AC679F920FC83F1F2DF1BAF1779CF989447FABC2F5\ | ||
| 224 | 628657053A | ||
| 225 | |||
| 226 | This example is the corresponding public key in a SubjectPublicKeyInfo | ||
| 227 | structure: | ||
| 228 | |||
| 229 | # Start with a SEQUENCE | ||
| 230 | asn1=SEQUENCE:pubkeyinfo | ||
| 231 | |||
| 232 | # pubkeyinfo contains an algorithm identifier and the public key wrapped | ||
| 233 | # in a BIT STRING | ||
| 234 | [pubkeyinfo] | ||
| 235 | algorithm=SEQUENCE:rsa_alg | ||
| 236 | pubkey=BITWRAP,SEQUENCE:rsapubkey | ||
| 237 | |||
| 238 | # algorithm ID for RSA is just an OID and a NULL | ||
| 239 | [rsa_alg] | ||
| 240 | algorithm=OID:rsaEncryption | ||
| 241 | parameter=NULL | ||
| 242 | |||
| 243 | # Actual public key: modulus and exponent | ||
| 244 | [rsapubkey] | ||
| 245 | n=INTEGER:0xBB6FE79432CC6EA2D8F970675A5A87BFBE1AFF0BE63E879F2AFFB93644\ | ||
| 246 | D4D2C6D000430DEC66ABF47829E74B8C5108623A1C0EE8BE217B3AD8D36D5EB4FCA1D9 | ||
| 247 | |||
| 248 | e=INTEGER:0x010001 | ||
| 249 | |||
| 250 | =head1 RETURN VALUES | ||
| 251 | |||
| 252 | ASN1_generate_nconf() and ASN1_generate_v3() return the encoded | ||
| 253 | data as an B<ASN1_TYPE> structure or B<NULL> if an error occurred. | ||
| 254 | |||
| 255 | The error codes that can be obtained by L<ERR_get_error(3)|ERR_get_error(3)>. | ||
| 256 | |||
| 257 | =head1 SEE ALSO | ||
| 258 | |||
| 259 | L<ERR_get_error(3)|ERR_get_error(3)> | ||
| 260 | |||
| 261 | =head1 HISTORY | ||
| 262 | |||
| 263 | ASN1_generate_nconf() and ASN1_generate_v3() were added to OpenSSL 0.9.8 | ||
| 264 | |||
| 265 | =cut | ||
