diff options
author | schwarze <> | 2015-02-14 13:54:59 +0000 |
---|---|---|
committer | schwarze <> | 2015-02-14 13:54:59 +0000 |
commit | 948b14a55ded39aea589e34e23c19085fd99cac5 (patch) | |
tree | 1405d05559e07c92604d649882549c9d103f1bae /src/lib/libssl | |
parent | b8d9c2ac1e0d5ebc096503ffa770326846a8fb7c (diff) | |
download | openbsd-948b14a55ded39aea589e34e23c19085fd99cac5.tar.gz openbsd-948b14a55ded39aea589e34e23c19085fd99cac5.tar.bz2 openbsd-948b14a55ded39aea589e34e23c19085fd99cac5.zip |
While doing development work on pod2mdoc(1),
profit of the occasion to start the conversion of
LibreSSL libcrypto manuals from perlpod(1) to mdoc(7).
miod@ jmc@ bentley@ agreed to the process when shown this patch.
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 | ||