diff options
| author | cvs2svn <admin@example.com> | 2015-08-02 21:54:22 +0000 |
|---|---|---|
| committer | cvs2svn <admin@example.com> | 2015-08-02 21:54:22 +0000 |
| commit | 92262c9818409ff436c41f1e51c2cea5b227f152 (patch) | |
| tree | 5609c82060f75c53af0a7641d9b33a88574876cd /src/lib/libcrypto/asn1 | |
| parent | ed40f444ba01bcae1d8540f9c26d79537ab5baf2 (diff) | |
| download | openbsd-OPENBSD_5_8_BASE.tar.gz openbsd-OPENBSD_5_8_BASE.tar.bz2 openbsd-OPENBSD_5_8_BASE.zip | |
This commit was manufactured by cvs2git to create tag 'OPENBSD_5_8_BASE'.OPENBSD_5_8_BASE
Diffstat (limited to 'src/lib/libcrypto/asn1')
81 files changed, 0 insertions, 25197 deletions
diff --git a/src/lib/libcrypto/asn1/a_bitstr.c b/src/lib/libcrypto/asn1/a_bitstr.c deleted file mode 100644 index c0259ad815..0000000000 --- a/src/lib/libcrypto/asn1/a_bitstr.c +++ /dev/null | |||
| @@ -1,259 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_bitstr.c,v 1.22 2015/07/29 14:58:34 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | |||
| 65 | int | ||
| 66 | ASN1_BIT_STRING_set(ASN1_BIT_STRING *x, unsigned char *d, int len) | ||
| 67 | { | ||
| 68 | return ASN1_STRING_set(x, d, len); | ||
| 69 | } | ||
| 70 | |||
| 71 | int | ||
| 72 | i2c_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **pp) | ||
| 73 | { | ||
| 74 | int ret, j, bits, len; | ||
| 75 | unsigned char *p, *d; | ||
| 76 | |||
| 77 | if (a == NULL) | ||
| 78 | return (0); | ||
| 79 | |||
| 80 | len = a->length; | ||
| 81 | |||
| 82 | if (len > 0) { | ||
| 83 | if (a->flags & ASN1_STRING_FLAG_BITS_LEFT) { | ||
| 84 | bits = (int)a->flags & 0x07; | ||
| 85 | } else { | ||
| 86 | for (; len > 0; len--) { | ||
| 87 | if (a->data[len - 1]) | ||
| 88 | break; | ||
| 89 | } | ||
| 90 | j = a->data[len - 1]; | ||
| 91 | if (j & 0x01) | ||
| 92 | bits = 0; | ||
| 93 | else if (j & 0x02) | ||
| 94 | bits = 1; | ||
| 95 | else if (j & 0x04) | ||
| 96 | bits = 2; | ||
| 97 | else if (j & 0x08) | ||
| 98 | bits = 3; | ||
| 99 | else if (j & 0x10) | ||
| 100 | bits = 4; | ||
| 101 | else if (j & 0x20) | ||
| 102 | bits = 5; | ||
| 103 | else if (j & 0x40) | ||
| 104 | bits = 6; | ||
| 105 | else if (j & 0x80) | ||
| 106 | bits = 7; | ||
| 107 | else | ||
| 108 | bits = 0; /* should not happen */ | ||
| 109 | } | ||
| 110 | } else | ||
| 111 | bits = 0; | ||
| 112 | |||
| 113 | ret = 1 + len; | ||
| 114 | if (pp == NULL) | ||
| 115 | return (ret); | ||
| 116 | |||
| 117 | p= *pp; | ||
| 118 | |||
| 119 | *(p++) = (unsigned char)bits; | ||
| 120 | d = a->data; | ||
| 121 | memcpy(p, d, len); | ||
| 122 | p += len; | ||
| 123 | if (len > 0) | ||
| 124 | p[-1]&=(0xff << bits); | ||
| 125 | *pp = p; | ||
| 126 | return (ret); | ||
| 127 | } | ||
| 128 | |||
| 129 | ASN1_BIT_STRING * | ||
| 130 | c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, const unsigned char **pp, long len) | ||
| 131 | { | ||
| 132 | ASN1_BIT_STRING *ret = NULL; | ||
| 133 | const unsigned char *p; | ||
| 134 | unsigned char *s; | ||
| 135 | int i; | ||
| 136 | |||
| 137 | if (len < 1) { | ||
| 138 | i = ASN1_R_STRING_TOO_SHORT; | ||
| 139 | goto err; | ||
| 140 | } | ||
| 141 | |||
| 142 | if ((a == NULL) || ((*a) == NULL)) { | ||
| 143 | if ((ret = M_ASN1_BIT_STRING_new()) == NULL) | ||
| 144 | return (NULL); | ||
| 145 | } else | ||
| 146 | ret = (*a); | ||
| 147 | |||
| 148 | p = *pp; | ||
| 149 | i = *(p++); | ||
| 150 | /* We do this to preserve the settings. If we modify | ||
| 151 | * the settings, via the _set_bit function, we will recalculate | ||
| 152 | * on output */ | ||
| 153 | ret->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07); /* clear */ | ||
| 154 | ret->flags|=(ASN1_STRING_FLAG_BITS_LEFT|(i&0x07)); /* set */ | ||
| 155 | |||
| 156 | if (len-- > 1) /* using one because of the bits left byte */ | ||
| 157 | { | ||
| 158 | s = malloc(len); | ||
| 159 | if (s == NULL) { | ||
| 160 | i = ERR_R_MALLOC_FAILURE; | ||
| 161 | goto err; | ||
| 162 | } | ||
| 163 | memcpy(s, p, len); | ||
| 164 | s[len - 1] &= (0xff << i); | ||
| 165 | p += len; | ||
| 166 | } else | ||
| 167 | s = NULL; | ||
| 168 | |||
| 169 | ret->length = (int)len; | ||
| 170 | free(ret->data); | ||
| 171 | ret->data = s; | ||
| 172 | ret->type = V_ASN1_BIT_STRING; | ||
| 173 | if (a != NULL) | ||
| 174 | (*a) = ret; | ||
| 175 | *pp = p; | ||
| 176 | return (ret); | ||
| 177 | |||
| 178 | err: | ||
| 179 | ASN1err(ASN1_F_C2I_ASN1_BIT_STRING, i); | ||
| 180 | if ((ret != NULL) && ((a == NULL) || (*a != ret))) | ||
| 181 | M_ASN1_BIT_STRING_free(ret); | ||
| 182 | return (NULL); | ||
| 183 | } | ||
| 184 | |||
| 185 | /* These next 2 functions from Goetz Babin-Ebell <babinebell@trustcenter.de> | ||
| 186 | */ | ||
| 187 | int | ||
| 188 | ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value) | ||
| 189 | { | ||
| 190 | int w, v, iv; | ||
| 191 | unsigned char *c; | ||
| 192 | |||
| 193 | w = n/8; | ||
| 194 | v = 1 << (7 - (n & 0x07)); | ||
| 195 | iv = ~v; | ||
| 196 | if (!value) | ||
| 197 | v = 0; | ||
| 198 | |||
| 199 | if (a == NULL) | ||
| 200 | return 0; | ||
| 201 | |||
| 202 | a->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); /* clear, set on write */ | ||
| 203 | |||
| 204 | if ((a->length < (w + 1)) || (a->data == NULL)) { | ||
| 205 | if (!value) | ||
| 206 | return(1); /* Don't need to set */ | ||
| 207 | c = OPENSSL_realloc_clean(a->data, a->length, w + 1); | ||
| 208 | if (c == NULL) { | ||
| 209 | ASN1err(ASN1_F_ASN1_BIT_STRING_SET_BIT, ERR_R_MALLOC_FAILURE); | ||
| 210 | return 0; | ||
| 211 | } | ||
| 212 | if (w + 1 - a->length > 0) | ||
| 213 | memset(c + a->length, 0, w + 1 - a->length); | ||
| 214 | a->data = c; | ||
| 215 | a->length = w + 1; | ||
| 216 | } | ||
| 217 | a->data[w] = ((a->data[w]) & iv) | v; | ||
| 218 | while ((a->length > 0) && (a->data[a->length - 1] == 0)) | ||
| 219 | a->length--; | ||
| 220 | |||
| 221 | return (1); | ||
| 222 | } | ||
| 223 | |||
| 224 | int | ||
| 225 | ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a, int n) | ||
| 226 | { | ||
| 227 | int w, v; | ||
| 228 | |||
| 229 | w = n / 8; | ||
| 230 | v = 1 << (7 - (n & 0x07)); | ||
| 231 | if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL)) | ||
| 232 | return (0); | ||
| 233 | return ((a->data[w] & v) != 0); | ||
| 234 | } | ||
| 235 | |||
| 236 | /* | ||
| 237 | * Checks if the given bit string contains only bits specified by | ||
| 238 | * the flags vector. Returns 0 if there is at least one bit set in 'a' | ||
| 239 | * which is not specified in 'flags', 1 otherwise. | ||
| 240 | * 'len' is the length of 'flags'. | ||
| 241 | */ | ||
| 242 | int | ||
| 243 | ASN1_BIT_STRING_check(ASN1_BIT_STRING *a, unsigned char *flags, int flags_len) | ||
| 244 | { | ||
| 245 | int i, ok; | ||
| 246 | |||
| 247 | /* Check if there is one bit set at all. */ | ||
| 248 | if (!a || !a->data) | ||
| 249 | return 1; | ||
| 250 | |||
| 251 | /* Check each byte of the internal representation of the bit string. */ | ||
| 252 | ok = 1; | ||
| 253 | for (i = 0; i < a->length && ok; ++i) { | ||
| 254 | unsigned char mask = i < flags_len ? ~flags[i] : 0xff; | ||
| 255 | /* We are done if there is an unneeded bit set. */ | ||
| 256 | ok = (a->data[i] & mask) == 0; | ||
| 257 | } | ||
| 258 | return ok; | ||
| 259 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_bool.c b/src/lib/libcrypto/asn1/a_bool.c deleted file mode 100644 index d5a0c0c8a4..0000000000 --- a/src/lib/libcrypto/asn1/a_bool.c +++ /dev/null | |||
| @@ -1,115 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_bool.c,v 1.7 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | |||
| 64 | int | ||
| 65 | i2d_ASN1_BOOLEAN(int a, unsigned char **pp) | ||
| 66 | { | ||
| 67 | int r; | ||
| 68 | unsigned char *p; | ||
| 69 | |||
| 70 | r = ASN1_object_size(0, 1, V_ASN1_BOOLEAN); | ||
| 71 | if (pp == NULL) | ||
| 72 | return (r); | ||
| 73 | p = *pp; | ||
| 74 | |||
| 75 | ASN1_put_object(&p, 0, 1, V_ASN1_BOOLEAN, V_ASN1_UNIVERSAL); | ||
| 76 | *(p++) = (unsigned char)a; | ||
| 77 | *pp = p; | ||
| 78 | return (r); | ||
| 79 | } | ||
| 80 | |||
| 81 | int | ||
| 82 | d2i_ASN1_BOOLEAN(int *a, const unsigned char **pp, long length) | ||
| 83 | { | ||
| 84 | int ret = -1; | ||
| 85 | const unsigned char *p; | ||
| 86 | long len; | ||
| 87 | int inf, tag, xclass; | ||
| 88 | int i = 0; | ||
| 89 | |||
| 90 | p = *pp; | ||
| 91 | inf = ASN1_get_object(&p, &len, &tag, &xclass, length); | ||
| 92 | if (inf & 0x80) { | ||
| 93 | i = ASN1_R_BAD_OBJECT_HEADER; | ||
| 94 | goto err; | ||
| 95 | } | ||
| 96 | |||
| 97 | if (tag != V_ASN1_BOOLEAN) { | ||
| 98 | i = ASN1_R_EXPECTING_A_BOOLEAN; | ||
| 99 | goto err; | ||
| 100 | } | ||
| 101 | |||
| 102 | if (len != 1) { | ||
| 103 | i = ASN1_R_BOOLEAN_IS_WRONG_LENGTH; | ||
| 104 | goto err; | ||
| 105 | } | ||
| 106 | ret = (int)*(p++); | ||
| 107 | if (a != NULL) | ||
| 108 | (*a) = ret; | ||
| 109 | *pp = p; | ||
| 110 | return (ret); | ||
| 111 | |||
| 112 | err: | ||
| 113 | ASN1err(ASN1_F_D2I_ASN1_BOOLEAN, i); | ||
| 114 | return (ret); | ||
| 115 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_bytes.c b/src/lib/libcrypto/asn1/a_bytes.c deleted file mode 100644 index 727ad3ed9b..0000000000 --- a/src/lib/libcrypto/asn1/a_bytes.c +++ /dev/null | |||
| @@ -1,306 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_bytes.c,v 1.18 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1.h> | ||
| 63 | #include <openssl/buffer.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | |||
| 66 | static int asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c); | ||
| 67 | /* type is a 'bitmap' of acceptable string types. | ||
| 68 | */ | ||
| 69 | ASN1_STRING * | ||
| 70 | d2i_ASN1_type_bytes(ASN1_STRING **a, const unsigned char **pp, | ||
| 71 | long length, int type) | ||
| 72 | { | ||
| 73 | ASN1_STRING *ret = NULL; | ||
| 74 | const unsigned char *p; | ||
| 75 | unsigned char *s; | ||
| 76 | long len; | ||
| 77 | int inf, tag, xclass; | ||
| 78 | int i = 0; | ||
| 79 | |||
| 80 | p = *pp; | ||
| 81 | inf = ASN1_get_object(&p, &len, &tag, &xclass, length); | ||
| 82 | if (inf & 0x80) | ||
| 83 | goto err; | ||
| 84 | |||
| 85 | if (tag >= 32) { | ||
| 86 | i = ASN1_R_TAG_VALUE_TOO_HIGH; | ||
| 87 | goto err; | ||
| 88 | } | ||
| 89 | if (!(ASN1_tag2bit(tag) & type)) { | ||
| 90 | i = ASN1_R_WRONG_TYPE; | ||
| 91 | goto err; | ||
| 92 | } | ||
| 93 | |||
| 94 | /* If a bit-string, exit early */ | ||
| 95 | if (tag == V_ASN1_BIT_STRING) | ||
| 96 | return (d2i_ASN1_BIT_STRING(a, pp, length)); | ||
| 97 | |||
| 98 | if ((a == NULL) || ((*a) == NULL)) { | ||
| 99 | if ((ret = ASN1_STRING_new()) == NULL) | ||
| 100 | return (NULL); | ||
| 101 | } else | ||
| 102 | ret = (*a); | ||
| 103 | |||
| 104 | if (len != 0) { | ||
| 105 | s = malloc(len + 1); | ||
| 106 | if (s == NULL) { | ||
| 107 | i = ERR_R_MALLOC_FAILURE; | ||
| 108 | goto err; | ||
| 109 | } | ||
| 110 | memcpy(s, p, len); | ||
| 111 | s[len]='\0'; | ||
| 112 | p += len; | ||
| 113 | } else | ||
| 114 | s = NULL; | ||
| 115 | |||
| 116 | free(ret->data); | ||
| 117 | ret->length = (int)len; | ||
| 118 | ret->data = s; | ||
| 119 | ret->type = tag; | ||
| 120 | if (a != NULL) | ||
| 121 | (*a) = ret; | ||
| 122 | *pp = p; | ||
| 123 | return (ret); | ||
| 124 | |||
| 125 | err: | ||
| 126 | ASN1err(ASN1_F_D2I_ASN1_TYPE_BYTES, i); | ||
| 127 | if (a == NULL || *a != ret) | ||
| 128 | ASN1_STRING_free(ret); | ||
| 129 | return (NULL); | ||
| 130 | } | ||
| 131 | |||
| 132 | int | ||
| 133 | i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass) | ||
| 134 | { | ||
| 135 | int ret, r, constructed; | ||
| 136 | unsigned char *p; | ||
| 137 | |||
| 138 | if (a == NULL) | ||
| 139 | return (0); | ||
| 140 | |||
| 141 | if (tag == V_ASN1_BIT_STRING) | ||
| 142 | return (i2d_ASN1_BIT_STRING(a, pp)); | ||
| 143 | |||
| 144 | ret = a->length; | ||
| 145 | r = ASN1_object_size(0, ret, tag); | ||
| 146 | if (pp == NULL) | ||
| 147 | return (r); | ||
| 148 | p = *pp; | ||
| 149 | |||
| 150 | if ((tag == V_ASN1_SEQUENCE) || (tag == V_ASN1_SET)) | ||
| 151 | constructed = 1; | ||
| 152 | else | ||
| 153 | constructed = 0; | ||
| 154 | ASN1_put_object(&p, constructed, ret, tag, xclass); | ||
| 155 | memcpy(p, a->data, a->length); | ||
| 156 | p += a->length; | ||
| 157 | *pp = p; | ||
| 158 | return (r); | ||
| 159 | } | ||
| 160 | |||
| 161 | ASN1_STRING * | ||
| 162 | d2i_ASN1_bytes(ASN1_STRING **a, const unsigned char **pp, | ||
| 163 | long length, int Ptag, int Pclass) | ||
| 164 | { | ||
| 165 | ASN1_STRING *ret = NULL; | ||
| 166 | const unsigned char *p; | ||
| 167 | unsigned char *s; | ||
| 168 | long len; | ||
| 169 | int inf, tag, xclass; | ||
| 170 | int i = 0; | ||
| 171 | |||
| 172 | if ((a == NULL) || ((*a) == NULL)) { | ||
| 173 | if ((ret = ASN1_STRING_new()) == NULL) | ||
| 174 | return (NULL); | ||
| 175 | } else | ||
| 176 | ret = (*a); | ||
| 177 | |||
| 178 | p= *pp; | ||
| 179 | inf = ASN1_get_object(&p, &len, &tag, &xclass, length); | ||
| 180 | if (inf & 0x80) { | ||
| 181 | i = ASN1_R_BAD_OBJECT_HEADER; | ||
| 182 | goto err; | ||
| 183 | } | ||
| 184 | |||
| 185 | if (tag != Ptag) { | ||
| 186 | i = ASN1_R_WRONG_TAG; | ||
| 187 | goto err; | ||
| 188 | } | ||
| 189 | |||
| 190 | if (inf & V_ASN1_CONSTRUCTED) { | ||
| 191 | ASN1_const_CTX c; | ||
| 192 | |||
| 193 | c.pp = pp; | ||
| 194 | c.p = p; | ||
| 195 | c.inf = inf; | ||
| 196 | c.slen = len; | ||
| 197 | c.tag = Ptag; | ||
| 198 | c.xclass = Pclass; | ||
| 199 | c.max = (length == 0) ? 0 : (p + length); | ||
| 200 | if (!asn1_collate_primitive(ret, &c)) | ||
| 201 | goto err; | ||
| 202 | else { | ||
| 203 | p = c.p; | ||
| 204 | } | ||
| 205 | } else { | ||
| 206 | if (len != 0) { | ||
| 207 | if ((ret->length < len) || (ret->data == NULL)) { | ||
| 208 | free(ret->data); | ||
| 209 | ret->data = NULL; | ||
| 210 | s = malloc(len + 1); | ||
| 211 | if (s == NULL) { | ||
| 212 | i = ERR_R_MALLOC_FAILURE; | ||
| 213 | goto err; | ||
| 214 | } | ||
| 215 | } else | ||
| 216 | s = ret->data; | ||
| 217 | memcpy(s, p, len); | ||
| 218 | s[len] = '\0'; | ||
| 219 | p += len; | ||
| 220 | } else { | ||
| 221 | s = NULL; | ||
| 222 | free(ret->data); | ||
| 223 | } | ||
| 224 | |||
| 225 | ret->length = (int)len; | ||
| 226 | ret->data = s; | ||
| 227 | ret->type = Ptag; | ||
| 228 | } | ||
| 229 | |||
| 230 | if (a != NULL) | ||
| 231 | (*a) = ret; | ||
| 232 | *pp = p; | ||
| 233 | return (ret); | ||
| 234 | |||
| 235 | err: | ||
| 236 | if (a == NULL || *a != ret) | ||
| 237 | ASN1_STRING_free(ret); | ||
| 238 | ASN1err(ASN1_F_D2I_ASN1_BYTES, i); | ||
| 239 | return (NULL); | ||
| 240 | } | ||
| 241 | |||
| 242 | |||
| 243 | /* We are about to parse 0..n d2i_ASN1_bytes objects, we are to collapse | ||
| 244 | * them into the one structure that is then returned */ | ||
| 245 | /* There have been a few bug fixes for this function from | ||
| 246 | * Paul Keogh <paul.keogh@sse.ie>, many thanks to him */ | ||
| 247 | static int | ||
| 248 | asn1_collate_primitive(ASN1_STRING *a, ASN1_const_CTX *c) | ||
| 249 | { | ||
| 250 | ASN1_STRING *os = NULL; | ||
| 251 | BUF_MEM b; | ||
| 252 | int num; | ||
| 253 | |||
| 254 | b.length = 0; | ||
| 255 | b.max = 0; | ||
| 256 | b.data = NULL; | ||
| 257 | |||
| 258 | if (a == NULL) { | ||
| 259 | c->error = ERR_R_PASSED_NULL_PARAMETER; | ||
| 260 | goto err; | ||
| 261 | } | ||
| 262 | |||
| 263 | num = 0; | ||
| 264 | for (;;) { | ||
| 265 | if (c->inf & 1) { | ||
| 266 | c->eos = ASN1_const_check_infinite_end(&c->p, | ||
| 267 | (long)(c->max - c->p)); | ||
| 268 | if (c->eos) | ||
| 269 | break; | ||
| 270 | } else { | ||
| 271 | if (c->slen <= 0) | ||
| 272 | break; | ||
| 273 | } | ||
| 274 | |||
| 275 | c->q = c->p; | ||
| 276 | if (d2i_ASN1_bytes(&os, &c->p, c->max - c->p, c->tag, | ||
| 277 | c->xclass) == NULL) { | ||
| 278 | c->error = ERR_R_ASN1_LIB; | ||
| 279 | goto err; | ||
| 280 | } | ||
| 281 | |||
| 282 | if (!BUF_MEM_grow_clean(&b, num + os->length)) { | ||
| 283 | c->error = ERR_R_BUF_LIB; | ||
| 284 | goto err; | ||
| 285 | } | ||
| 286 | memcpy(&(b.data[num]), os->data, os->length); | ||
| 287 | if (!(c->inf & 1)) | ||
| 288 | c->slen -= (c->p - c->q); | ||
| 289 | num += os->length; | ||
| 290 | } | ||
| 291 | |||
| 292 | if (!asn1_const_Finish(c)) | ||
| 293 | goto err; | ||
| 294 | |||
| 295 | a->length = num; | ||
| 296 | free(a->data); | ||
| 297 | a->data = (unsigned char *)b.data; | ||
| 298 | ASN1_STRING_free(os); | ||
| 299 | return (1); | ||
| 300 | |||
| 301 | err: | ||
| 302 | ASN1err(ASN1_F_ASN1_COLLATE_PRIMITIVE, c->error); | ||
| 303 | ASN1_STRING_free(os); | ||
| 304 | free(b.data); | ||
| 305 | return (0); | ||
| 306 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_d2i_fp.c b/src/lib/libcrypto/asn1/a_d2i_fp.c deleted file mode 100644 index c0fb0a3802..0000000000 --- a/src/lib/libcrypto/asn1/a_d2i_fp.c +++ /dev/null | |||
| @@ -1,271 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_d2i_fp.c,v 1.11 2014/07/13 11:10:20 miod Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <limits.h> | ||
| 60 | #include <stdio.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1.h> | ||
| 63 | #include <openssl/buffer.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | |||
| 66 | static int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb); | ||
| 67 | |||
| 68 | #ifndef NO_OLD_ASN1 | ||
| 69 | |||
| 70 | void * | ||
| 71 | ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x) | ||
| 72 | { | ||
| 73 | BIO *b; | ||
| 74 | void *ret; | ||
| 75 | |||
| 76 | if ((b = BIO_new(BIO_s_file())) == NULL) { | ||
| 77 | ASN1err(ASN1_F_ASN1_D2I_FP, ERR_R_BUF_LIB); | ||
| 78 | return (NULL); | ||
| 79 | } | ||
| 80 | BIO_set_fp(b, in, BIO_NOCLOSE); | ||
| 81 | ret = ASN1_d2i_bio(xnew, d2i, b, x); | ||
| 82 | BIO_free(b); | ||
| 83 | return (ret); | ||
| 84 | } | ||
| 85 | |||
| 86 | void * | ||
| 87 | ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x) | ||
| 88 | { | ||
| 89 | BUF_MEM *b = NULL; | ||
| 90 | const unsigned char *p; | ||
| 91 | void *ret = NULL; | ||
| 92 | int len; | ||
| 93 | |||
| 94 | len = asn1_d2i_read_bio(in, &b); | ||
| 95 | if (len < 0) | ||
| 96 | goto err; | ||
| 97 | |||
| 98 | p = (unsigned char *)b->data; | ||
| 99 | ret = d2i(x, &p, len); | ||
| 100 | |||
| 101 | err: | ||
| 102 | if (b != NULL) | ||
| 103 | BUF_MEM_free(b); | ||
| 104 | return (ret); | ||
| 105 | } | ||
| 106 | |||
| 107 | #endif | ||
| 108 | |||
| 109 | void * | ||
| 110 | ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x) | ||
| 111 | { | ||
| 112 | BUF_MEM *b = NULL; | ||
| 113 | const unsigned char *p; | ||
| 114 | void *ret = NULL; | ||
| 115 | int len; | ||
| 116 | |||
| 117 | len = asn1_d2i_read_bio(in, &b); | ||
| 118 | if (len < 0) | ||
| 119 | goto err; | ||
| 120 | |||
| 121 | p = (const unsigned char *)b->data; | ||
| 122 | ret = ASN1_item_d2i(x, &p, len, it); | ||
| 123 | |||
| 124 | err: | ||
| 125 | if (b != NULL) | ||
| 126 | BUF_MEM_free(b); | ||
| 127 | return (ret); | ||
| 128 | } | ||
| 129 | |||
| 130 | void * | ||
| 131 | ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x) | ||
| 132 | { | ||
| 133 | BIO *b; | ||
| 134 | char *ret; | ||
| 135 | |||
| 136 | if ((b = BIO_new(BIO_s_file())) == NULL) { | ||
| 137 | ASN1err(ASN1_F_ASN1_ITEM_D2I_FP, ERR_R_BUF_LIB); | ||
| 138 | return (NULL); | ||
| 139 | } | ||
| 140 | BIO_set_fp(b, in, BIO_NOCLOSE); | ||
| 141 | ret = ASN1_item_d2i_bio(it, b, x); | ||
| 142 | BIO_free(b); | ||
| 143 | return (ret); | ||
| 144 | } | ||
| 145 | |||
| 146 | #define HEADER_SIZE 8 | ||
| 147 | static int | ||
| 148 | asn1_d2i_read_bio(BIO *in, BUF_MEM **pb) | ||
| 149 | { | ||
| 150 | BUF_MEM *b; | ||
| 151 | unsigned char *p; | ||
| 152 | int i; | ||
| 153 | ASN1_const_CTX c; | ||
| 154 | size_t want = HEADER_SIZE; | ||
| 155 | int eos = 0; | ||
| 156 | size_t off = 0; | ||
| 157 | size_t len = 0; | ||
| 158 | |||
| 159 | b = BUF_MEM_new(); | ||
| 160 | if (b == NULL) { | ||
| 161 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE); | ||
| 162 | return -1; | ||
| 163 | } | ||
| 164 | |||
| 165 | ERR_clear_error(); | ||
| 166 | for (;;) { | ||
| 167 | if (want >= (len - off)) { | ||
| 168 | want -= (len - off); | ||
| 169 | |||
| 170 | if (len + want < len || !BUF_MEM_grow_clean(b, len + want)) { | ||
| 171 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE); | ||
| 172 | goto err; | ||
| 173 | } | ||
| 174 | i = BIO_read(in, &(b->data[len]), want); | ||
| 175 | if ((i < 0) && ((len - off) == 0)) { | ||
| 176 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_NOT_ENOUGH_DATA); | ||
| 177 | goto err; | ||
| 178 | } | ||
| 179 | if (i > 0) { | ||
| 180 | if (len + i < len) { | ||
| 181 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG); | ||
| 182 | goto err; | ||
| 183 | } | ||
| 184 | len += i; | ||
| 185 | } | ||
| 186 | } | ||
| 187 | /* else data already loaded */ | ||
| 188 | |||
| 189 | p = (unsigned char *) & (b->data[off]); | ||
| 190 | c.p = p; | ||
| 191 | c.inf = ASN1_get_object(&(c.p), &(c.slen), &(c.tag), | ||
| 192 | &(c.xclass), len - off); | ||
| 193 | if (c.inf & 0x80) { | ||
| 194 | unsigned long e; | ||
| 195 | |||
| 196 | e = ERR_GET_REASON(ERR_peek_error()); | ||
| 197 | if (e != ASN1_R_TOO_LONG) | ||
| 198 | goto err; | ||
| 199 | else | ||
| 200 | ERR_clear_error(); /* clear error */ | ||
| 201 | } | ||
| 202 | i = c.p - p; /* header length */ | ||
| 203 | off += i; /* end of data */ | ||
| 204 | |||
| 205 | if (c.inf & 1) { | ||
| 206 | /* no data body so go round again */ | ||
| 207 | eos++; | ||
| 208 | if (eos < 0) { | ||
| 209 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_HEADER_TOO_LONG); | ||
| 210 | goto err; | ||
| 211 | } | ||
| 212 | want = HEADER_SIZE; | ||
| 213 | } else if (eos && (c.slen == 0) && (c.tag == V_ASN1_EOC)) { | ||
| 214 | /* eos value, so go back and read another header */ | ||
| 215 | eos--; | ||
| 216 | if (eos <= 0) | ||
| 217 | break; | ||
| 218 | else | ||
| 219 | want = HEADER_SIZE; | ||
| 220 | } else { | ||
| 221 | /* suck in c.slen bytes of data */ | ||
| 222 | want = c.slen; | ||
| 223 | if (want > (len - off)) { | ||
| 224 | want -= (len - off); | ||
| 225 | if (want > INT_MAX /* BIO_read takes an int length */ || | ||
| 226 | len+want < len) { | ||
| 227 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG); | ||
| 228 | goto err; | ||
| 229 | } | ||
| 230 | if (!BUF_MEM_grow_clean(b, len + want)) { | ||
| 231 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE); | ||
| 232 | goto err; | ||
| 233 | } | ||
| 234 | while (want > 0) { | ||
| 235 | i = BIO_read(in, &(b->data[len]), want); | ||
| 236 | if (i <= 0) { | ||
| 237 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, | ||
| 238 | ASN1_R_NOT_ENOUGH_DATA); | ||
| 239 | goto err; | ||
| 240 | } | ||
| 241 | /* This can't overflow because | ||
| 242 | * |len+want| didn't overflow. */ | ||
| 243 | len += i; | ||
| 244 | want -= i; | ||
| 245 | } | ||
| 246 | } | ||
| 247 | if (off + c.slen < off) { | ||
| 248 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG); | ||
| 249 | goto err; | ||
| 250 | } | ||
| 251 | off += c.slen; | ||
| 252 | if (eos <= 0) { | ||
| 253 | break; | ||
| 254 | } else | ||
| 255 | want = HEADER_SIZE; | ||
| 256 | } | ||
| 257 | } | ||
| 258 | |||
| 259 | if (off > INT_MAX) { | ||
| 260 | ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG); | ||
| 261 | goto err; | ||
| 262 | } | ||
| 263 | |||
| 264 | *pb = b; | ||
| 265 | return off; | ||
| 266 | |||
| 267 | err: | ||
| 268 | if (b != NULL) | ||
| 269 | BUF_MEM_free(b); | ||
| 270 | return -1; | ||
| 271 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_digest.c b/src/lib/libcrypto/asn1/a_digest.c deleted file mode 100644 index 085a57d811..0000000000 --- a/src/lib/libcrypto/asn1/a_digest.c +++ /dev/null | |||
| @@ -1,84 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_digest.c,v 1.15 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <sys/types.h> | ||
| 60 | |||
| 61 | #include <stdio.h> | ||
| 62 | #include <time.h> | ||
| 63 | |||
| 64 | #include <openssl/buffer.h> | ||
| 65 | #include <openssl/err.h> | ||
| 66 | #include <openssl/evp.h> | ||
| 67 | #include <openssl/x509.h> | ||
| 68 | |||
| 69 | int | ||
| 70 | ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *asn, | ||
| 71 | unsigned char *md, unsigned int *len) | ||
| 72 | { | ||
| 73 | int i; | ||
| 74 | unsigned char *str = NULL; | ||
| 75 | |||
| 76 | i = ASN1_item_i2d(asn, &str, it); | ||
| 77 | if (!str) | ||
| 78 | return (0); | ||
| 79 | |||
| 80 | if (!EVP_Digest(str, i, md, len, type, NULL)) | ||
| 81 | return 0; | ||
| 82 | free(str); | ||
| 83 | return (1); | ||
| 84 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_dup.c b/src/lib/libcrypto/asn1/a_dup.c deleted file mode 100644 index 79cd1d4586..0000000000 --- a/src/lib/libcrypto/asn1/a_dup.c +++ /dev/null | |||
| @@ -1,118 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_dup.c,v 1.13 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | |||
| 64 | #ifndef NO_OLD_ASN1 | ||
| 65 | |||
| 66 | void * | ||
| 67 | ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x) | ||
| 68 | { | ||
| 69 | unsigned char *b, *p; | ||
| 70 | const unsigned char *p2; | ||
| 71 | int i; | ||
| 72 | char *ret; | ||
| 73 | |||
| 74 | if (x == NULL) | ||
| 75 | return (NULL); | ||
| 76 | |||
| 77 | i = i2d(x, NULL); | ||
| 78 | b = malloc(i + 10); | ||
| 79 | if (b == NULL) { | ||
| 80 | ASN1err(ASN1_F_ASN1_DUP, ERR_R_MALLOC_FAILURE); | ||
| 81 | return (NULL); | ||
| 82 | } | ||
| 83 | p = b; | ||
| 84 | i = i2d(x, &p); | ||
| 85 | p2 = b; | ||
| 86 | ret = d2i(NULL, &p2, i); | ||
| 87 | free(b); | ||
| 88 | return (ret); | ||
| 89 | } | ||
| 90 | |||
| 91 | #endif | ||
| 92 | |||
| 93 | /* ASN1_ITEM version of dup: this follows the model above except we don't need | ||
| 94 | * to allocate the buffer. At some point this could be rewritten to directly dup | ||
| 95 | * the underlying structure instead of doing and encode and decode. | ||
| 96 | */ | ||
| 97 | |||
| 98 | void * | ||
| 99 | ASN1_item_dup(const ASN1_ITEM *it, void *x) | ||
| 100 | { | ||
| 101 | unsigned char *b = NULL; | ||
| 102 | const unsigned char *p; | ||
| 103 | long i; | ||
| 104 | void *ret; | ||
| 105 | |||
| 106 | if (x == NULL) | ||
| 107 | return (NULL); | ||
| 108 | |||
| 109 | i = ASN1_item_i2d(x, &b, it); | ||
| 110 | if (b == NULL) { | ||
| 111 | ASN1err(ASN1_F_ASN1_ITEM_DUP, ERR_R_MALLOC_FAILURE); | ||
| 112 | return (NULL); | ||
| 113 | } | ||
| 114 | p = b; | ||
| 115 | ret = ASN1_item_d2i(NULL, &p, i, it); | ||
| 116 | free(b); | ||
| 117 | return (ret); | ||
| 118 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_enum.c b/src/lib/libcrypto/asn1/a_enum.c deleted file mode 100644 index 3c059266be..0000000000 --- a/src/lib/libcrypto/asn1/a_enum.c +++ /dev/null | |||
| @@ -1,189 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_enum.c,v 1.16 2014/09/21 12:17:42 miod Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/bn.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | |||
| 65 | /* | ||
| 66 | * Code for ENUMERATED type: identical to INTEGER apart from a different tag. | ||
| 67 | * for comments on encoding see a_int.c | ||
| 68 | */ | ||
| 69 | |||
| 70 | int | ||
| 71 | ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v) | ||
| 72 | { | ||
| 73 | int j, k; | ||
| 74 | unsigned int i; | ||
| 75 | unsigned char buf[sizeof(long) + 1]; | ||
| 76 | long d; | ||
| 77 | |||
| 78 | a->type = V_ASN1_ENUMERATED; | ||
| 79 | if (a->length < (int)(sizeof(long) + 1)) { | ||
| 80 | free(a->data); | ||
| 81 | a->data = calloc(1, sizeof(long) + 1); | ||
| 82 | } | ||
| 83 | if (a->data == NULL) { | ||
| 84 | ASN1err(ASN1_F_ASN1_ENUMERATED_SET, ERR_R_MALLOC_FAILURE); | ||
| 85 | return (0); | ||
| 86 | } | ||
| 87 | d = v; | ||
| 88 | if (d < 0) { | ||
| 89 | d = -d; | ||
| 90 | a->type = V_ASN1_NEG_ENUMERATED; | ||
| 91 | } | ||
| 92 | |||
| 93 | for (i = 0; i < sizeof(long); i++) { | ||
| 94 | if (d == 0) | ||
| 95 | break; | ||
| 96 | buf[i] = (int)d & 0xff; | ||
| 97 | d >>= 8; | ||
| 98 | } | ||
| 99 | j = 0; | ||
| 100 | for (k = i - 1; k >= 0; k--) | ||
| 101 | a->data[j++] = buf[k]; | ||
| 102 | a->length = j; | ||
| 103 | return (1); | ||
| 104 | } | ||
| 105 | |||
| 106 | long | ||
| 107 | ASN1_ENUMERATED_get(ASN1_ENUMERATED *a) | ||
| 108 | { | ||
| 109 | int neg = 0, i; | ||
| 110 | long r = 0; | ||
| 111 | |||
| 112 | if (a == NULL) | ||
| 113 | return (0L); | ||
| 114 | i = a->type; | ||
| 115 | if (i == V_ASN1_NEG_ENUMERATED) | ||
| 116 | neg = 1; | ||
| 117 | else if (i != V_ASN1_ENUMERATED) | ||
| 118 | return -1; | ||
| 119 | |||
| 120 | if (a->length > (int)sizeof(long)) { | ||
| 121 | /* hmm... a bit ugly */ | ||
| 122 | return -1; | ||
| 123 | } | ||
| 124 | if (a->data == NULL) | ||
| 125 | return 0; | ||
| 126 | |||
| 127 | for (i = 0; i < a->length; i++) { | ||
| 128 | r <<= 8; | ||
| 129 | r |= (unsigned char)a->data[i]; | ||
| 130 | } | ||
| 131 | if (neg) | ||
| 132 | r = -r; | ||
| 133 | return (r); | ||
| 134 | } | ||
| 135 | |||
| 136 | ASN1_ENUMERATED * | ||
| 137 | BN_to_ASN1_ENUMERATED(BIGNUM *bn, ASN1_ENUMERATED *ai) | ||
| 138 | { | ||
| 139 | ASN1_ENUMERATED *ret; | ||
| 140 | int len, j; | ||
| 141 | |||
| 142 | if (ai == NULL) | ||
| 143 | ret = M_ASN1_ENUMERATED_new(); | ||
| 144 | else | ||
| 145 | ret = ai; | ||
| 146 | if (ret == NULL) { | ||
| 147 | ASN1err(ASN1_F_BN_TO_ASN1_ENUMERATED, ERR_R_NESTED_ASN1_ERROR); | ||
| 148 | goto err; | ||
| 149 | } | ||
| 150 | if (BN_is_negative(bn)) | ||
| 151 | ret->type = V_ASN1_NEG_ENUMERATED; | ||
| 152 | else | ||
| 153 | ret->type = V_ASN1_ENUMERATED; | ||
| 154 | j = BN_num_bits(bn); | ||
| 155 | len = ((j == 0) ? 0 : ((j / 8) + 1)); | ||
| 156 | if (ret->length < len + 4) { | ||
| 157 | unsigned char *new_data = realloc(ret->data, len + 4); | ||
| 158 | if (!new_data) { | ||
| 159 | ASN1err(ASN1_F_BN_TO_ASN1_ENUMERATED, ERR_R_MALLOC_FAILURE); | ||
| 160 | goto err; | ||
| 161 | } | ||
| 162 | ret->data = new_data; | ||
| 163 | } | ||
| 164 | ret->length = BN_bn2bin(bn, ret->data); | ||
| 165 | |||
| 166 | /* Correct zero case */ | ||
| 167 | if (!ret->length) { | ||
| 168 | ret->data[0] = 0; | ||
| 169 | ret->length = 1; | ||
| 170 | } | ||
| 171 | return (ret); | ||
| 172 | |||
| 173 | err: | ||
| 174 | if (ret != ai) | ||
| 175 | M_ASN1_ENUMERATED_free(ret); | ||
| 176 | return (NULL); | ||
| 177 | } | ||
| 178 | |||
| 179 | BIGNUM * | ||
| 180 | ASN1_ENUMERATED_to_BN(ASN1_ENUMERATED *ai, BIGNUM *bn) | ||
| 181 | { | ||
| 182 | BIGNUM *ret; | ||
| 183 | |||
| 184 | if ((ret = BN_bin2bn(ai->data, ai->length, bn)) == NULL) | ||
| 185 | ASN1err(ASN1_F_ASN1_ENUMERATED_TO_BN, ASN1_R_BN_LIB); | ||
| 186 | else if (ai->type == V_ASN1_NEG_ENUMERATED) | ||
| 187 | BN_set_negative(ret, 1); | ||
| 188 | return (ret); | ||
| 189 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_i2d_fp.c b/src/lib/libcrypto/asn1/a_i2d_fp.c deleted file mode 100644 index 424068d784..0000000000 --- a/src/lib/libcrypto/asn1/a_i2d_fp.c +++ /dev/null | |||
| @@ -1,158 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_i2d_fp.c,v 1.14 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/buffer.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | |||
| 65 | #ifndef NO_OLD_ASN1 | ||
| 66 | |||
| 67 | int | ||
| 68 | ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x) | ||
| 69 | { | ||
| 70 | BIO *b; | ||
| 71 | int ret; | ||
| 72 | |||
| 73 | if ((b = BIO_new(BIO_s_file())) == NULL) { | ||
| 74 | ASN1err(ASN1_F_ASN1_I2D_FP, ERR_R_BUF_LIB); | ||
| 75 | return (0); | ||
| 76 | } | ||
| 77 | BIO_set_fp(b, out, BIO_NOCLOSE); | ||
| 78 | ret = ASN1_i2d_bio(i2d, b, x); | ||
| 79 | BIO_free(b); | ||
| 80 | return (ret); | ||
| 81 | } | ||
| 82 | |||
| 83 | int | ||
| 84 | ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x) | ||
| 85 | { | ||
| 86 | char *b; | ||
| 87 | unsigned char *p; | ||
| 88 | int i, j = 0, n, ret = 1; | ||
| 89 | |||
| 90 | n = i2d(x, NULL); | ||
| 91 | b = malloc(n); | ||
| 92 | if (b == NULL) { | ||
| 93 | ASN1err(ASN1_F_ASN1_I2D_BIO, ERR_R_MALLOC_FAILURE); | ||
| 94 | return (0); | ||
| 95 | } | ||
| 96 | |||
| 97 | p = (unsigned char *)b; | ||
| 98 | i2d(x, &p); | ||
| 99 | |||
| 100 | for (;;) { | ||
| 101 | i = BIO_write(out, &(b[j]), n); | ||
| 102 | if (i == n) | ||
| 103 | break; | ||
| 104 | if (i <= 0) { | ||
| 105 | ret = 0; | ||
| 106 | break; | ||
| 107 | } | ||
| 108 | j += i; | ||
| 109 | n -= i; | ||
| 110 | } | ||
| 111 | free(b); | ||
| 112 | return (ret); | ||
| 113 | } | ||
| 114 | |||
| 115 | #endif | ||
| 116 | |||
| 117 | int | ||
| 118 | ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x) | ||
| 119 | { | ||
| 120 | BIO *b; | ||
| 121 | int ret; | ||
| 122 | |||
| 123 | if ((b = BIO_new(BIO_s_file())) == NULL) { | ||
| 124 | ASN1err(ASN1_F_ASN1_ITEM_I2D_FP, ERR_R_BUF_LIB); | ||
| 125 | return (0); | ||
| 126 | } | ||
| 127 | BIO_set_fp(b, out, BIO_NOCLOSE); | ||
| 128 | ret = ASN1_item_i2d_bio(it, b, x); | ||
| 129 | BIO_free(b); | ||
| 130 | return (ret); | ||
| 131 | } | ||
| 132 | |||
| 133 | int | ||
| 134 | ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x) | ||
| 135 | { | ||
| 136 | unsigned char *b = NULL; | ||
| 137 | int i, j = 0, n, ret = 1; | ||
| 138 | |||
| 139 | n = ASN1_item_i2d(x, &b, it); | ||
| 140 | if (b == NULL) { | ||
| 141 | ASN1err(ASN1_F_ASN1_ITEM_I2D_BIO, ERR_R_MALLOC_FAILURE); | ||
| 142 | return (0); | ||
| 143 | } | ||
| 144 | |||
| 145 | for (;;) { | ||
| 146 | i = BIO_write(out, &(b[j]), n); | ||
| 147 | if (i == n) | ||
| 148 | break; | ||
| 149 | if (i <= 0) { | ||
| 150 | ret = 0; | ||
| 151 | break; | ||
| 152 | } | ||
| 153 | j += i; | ||
| 154 | n -= i; | ||
| 155 | } | ||
| 156 | free(b); | ||
| 157 | return (ret); | ||
| 158 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_int.c b/src/lib/libcrypto/asn1/a_int.c deleted file mode 100644 index 6a378c0884..0000000000 --- a/src/lib/libcrypto/asn1/a_int.c +++ /dev/null | |||
| @@ -1,463 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_int.c,v 1.28 2015/07/29 14:58:34 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1.h> | ||
| 63 | #include <openssl/bn.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | |||
| 66 | ASN1_INTEGER * | ||
| 67 | ASN1_INTEGER_dup(const ASN1_INTEGER *x) | ||
| 68 | { | ||
| 69 | return ASN1_STRING_dup(x); | ||
| 70 | } | ||
| 71 | |||
| 72 | int | ||
| 73 | ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y) | ||
| 74 | { | ||
| 75 | int neg, ret; | ||
| 76 | |||
| 77 | /* Compare signs */ | ||
| 78 | neg = x->type & V_ASN1_NEG; | ||
| 79 | if (neg != (y->type & V_ASN1_NEG)) { | ||
| 80 | if (neg) | ||
| 81 | return -1; | ||
| 82 | else | ||
| 83 | return 1; | ||
| 84 | } | ||
| 85 | |||
| 86 | ret = ASN1_STRING_cmp(x, y); | ||
| 87 | |||
| 88 | if (neg) | ||
| 89 | return -ret; | ||
| 90 | else | ||
| 91 | return ret; | ||
| 92 | } | ||
| 93 | |||
| 94 | |||
| 95 | /* | ||
| 96 | * This converts an ASN1 INTEGER into its content encoding. | ||
| 97 | * The internal representation is an ASN1_STRING whose data is a big endian | ||
| 98 | * representation of the value, ignoring the sign. The sign is determined by | ||
| 99 | * the type: V_ASN1_INTEGER for positive and V_ASN1_NEG_INTEGER for negative. | ||
| 100 | * | ||
| 101 | * Positive integers are no problem: they are almost the same as the DER | ||
| 102 | * encoding, except if the first byte is >= 0x80 we need to add a zero pad. | ||
| 103 | * | ||
| 104 | * Negative integers are a bit trickier... | ||
| 105 | * The DER representation of negative integers is in 2s complement form. | ||
| 106 | * The internal form is converted by complementing each octet and finally | ||
| 107 | * adding one to the result. This can be done less messily with a little trick. | ||
| 108 | * If the internal form has trailing zeroes then they will become FF by the | ||
| 109 | * complement and 0 by the add one (due to carry) so just copy as many trailing | ||
| 110 | * zeros to the destination as there are in the source. The carry will add one | ||
| 111 | * to the last none zero octet: so complement this octet and add one and finally | ||
| 112 | * complement any left over until you get to the start of the string. | ||
| 113 | * | ||
| 114 | * Padding is a little trickier too. If the first bytes is > 0x80 then we pad | ||
| 115 | * with 0xff. However if the first byte is 0x80 and one of the following bytes | ||
| 116 | * is non-zero we pad with 0xff. The reason for this distinction is that 0x80 | ||
| 117 | * followed by optional zeros isn't padded. | ||
| 118 | */ | ||
| 119 | |||
| 120 | int | ||
| 121 | i2c_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp) | ||
| 122 | { | ||
| 123 | int pad = 0, ret, i, neg; | ||
| 124 | unsigned char *p, *n, pb = 0; | ||
| 125 | |||
| 126 | if (a == NULL) | ||
| 127 | return (0); | ||
| 128 | neg = a->type & V_ASN1_NEG; | ||
| 129 | if (a->length == 0) | ||
| 130 | ret = 1; | ||
| 131 | else { | ||
| 132 | ret = a->length; | ||
| 133 | i = a->data[0]; | ||
| 134 | if (!neg && (i > 127)) { | ||
| 135 | pad = 1; | ||
| 136 | pb = 0; | ||
| 137 | } else if (neg) { | ||
| 138 | if (i > 128) { | ||
| 139 | pad = 1; | ||
| 140 | pb = 0xFF; | ||
| 141 | } else if (i == 128) { | ||
| 142 | /* | ||
| 143 | * Special case: if any other bytes non zero we pad: | ||
| 144 | * otherwise we don't. | ||
| 145 | */ | ||
| 146 | for (i = 1; i < a->length; i++) if (a->data[i]) { | ||
| 147 | pad = 1; | ||
| 148 | pb = 0xFF; | ||
| 149 | break; | ||
| 150 | } | ||
| 151 | } | ||
| 152 | } | ||
| 153 | ret += pad; | ||
| 154 | } | ||
| 155 | if (pp == NULL) | ||
| 156 | return (ret); | ||
| 157 | p= *pp; | ||
| 158 | |||
| 159 | if (pad) | ||
| 160 | *(p++) = pb; | ||
| 161 | if (a->length == 0) | ||
| 162 | *(p++) = 0; | ||
| 163 | else if (!neg) | ||
| 164 | memcpy(p, a->data, a->length); | ||
| 165 | else { | ||
| 166 | /* Begin at the end of the encoding */ | ||
| 167 | n = a->data + a->length - 1; | ||
| 168 | p += a->length - 1; | ||
| 169 | i = a->length; | ||
| 170 | /* Copy zeros to destination as long as source is zero */ | ||
| 171 | while (!*n) { | ||
| 172 | *(p--) = 0; | ||
| 173 | n--; | ||
| 174 | i--; | ||
| 175 | } | ||
| 176 | /* Complement and increment next octet */ | ||
| 177 | *(p--) = ((*(n--)) ^ 0xff) + 1; | ||
| 178 | i--; | ||
| 179 | /* Complement any octets left */ | ||
| 180 | for (; i > 0; i--) | ||
| 181 | *(p--) = *(n--) ^ 0xff; | ||
| 182 | } | ||
| 183 | |||
| 184 | *pp += ret; | ||
| 185 | return (ret); | ||
| 186 | } | ||
| 187 | |||
| 188 | /* Convert just ASN1 INTEGER content octets to ASN1_INTEGER structure */ | ||
| 189 | |||
| 190 | ASN1_INTEGER * | ||
| 191 | c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp, long len) | ||
| 192 | { | ||
| 193 | ASN1_INTEGER *ret = NULL; | ||
| 194 | const unsigned char *p, *pend; | ||
| 195 | unsigned char *to, *s; | ||
| 196 | int i; | ||
| 197 | |||
| 198 | if ((a == NULL) || ((*a) == NULL)) { | ||
| 199 | if ((ret = M_ASN1_INTEGER_new()) == NULL) | ||
| 200 | return (NULL); | ||
| 201 | ret->type = V_ASN1_INTEGER; | ||
| 202 | } else | ||
| 203 | ret = (*a); | ||
| 204 | |||
| 205 | p = *pp; | ||
| 206 | pend = p + len; | ||
| 207 | |||
| 208 | /* We must malloc stuff, even for 0 bytes otherwise it | ||
| 209 | * signifies a missing NULL parameter. */ | ||
| 210 | s = malloc(len + 1); | ||
| 211 | if (s == NULL) { | ||
| 212 | i = ERR_R_MALLOC_FAILURE; | ||
| 213 | goto err; | ||
| 214 | } | ||
| 215 | to = s; | ||
| 216 | if (!len) { | ||
| 217 | /* Strictly speaking this is an illegal INTEGER but we | ||
| 218 | * tolerate it. | ||
| 219 | */ | ||
| 220 | ret->type = V_ASN1_INTEGER; | ||
| 221 | } else if (*p & 0x80) /* a negative number */ { | ||
| 222 | ret->type = V_ASN1_NEG_INTEGER; | ||
| 223 | if ((*p == 0xff) && (len != 1)) { | ||
| 224 | p++; | ||
| 225 | len--; | ||
| 226 | } | ||
| 227 | i = len; | ||
| 228 | p += i - 1; | ||
| 229 | to += i - 1; | ||
| 230 | while((!*p) && i) { | ||
| 231 | *(to--) = 0; | ||
| 232 | i--; | ||
| 233 | p--; | ||
| 234 | } | ||
| 235 | /* Special case: if all zeros then the number will be of | ||
| 236 | * the form FF followed by n zero bytes: this corresponds to | ||
| 237 | * 1 followed by n zero bytes. We've already written n zeros | ||
| 238 | * so we just append an extra one and set the first byte to | ||
| 239 | * a 1. This is treated separately because it is the only case | ||
| 240 | * where the number of bytes is larger than len. | ||
| 241 | */ | ||
| 242 | if (!i) { | ||
| 243 | *s = 1; | ||
| 244 | s[len] = 0; | ||
| 245 | len++; | ||
| 246 | } else { | ||
| 247 | *(to--) = (*(p--) ^ 0xff) + 1; | ||
| 248 | i--; | ||
| 249 | for (; i > 0; i--) | ||
| 250 | *(to--) = *(p--) ^ 0xff; | ||
| 251 | } | ||
| 252 | } else { | ||
| 253 | ret->type = V_ASN1_INTEGER; | ||
| 254 | if ((*p == 0) && (len != 1)) { | ||
| 255 | p++; | ||
| 256 | len--; | ||
| 257 | } | ||
| 258 | memcpy(s, p, len); | ||
| 259 | } | ||
| 260 | |||
| 261 | free(ret->data); | ||
| 262 | ret->data = s; | ||
| 263 | ret->length = (int)len; | ||
| 264 | if (a != NULL) | ||
| 265 | (*a) = ret; | ||
| 266 | *pp = pend; | ||
| 267 | return (ret); | ||
| 268 | |||
| 269 | err: | ||
| 270 | ASN1err(ASN1_F_C2I_ASN1_INTEGER, i); | ||
| 271 | if (a == NULL || *a != ret) | ||
| 272 | M_ASN1_INTEGER_free(ret); | ||
| 273 | return (NULL); | ||
| 274 | } | ||
| 275 | |||
| 276 | |||
| 277 | /* This is a version of d2i_ASN1_INTEGER that ignores the sign bit of | ||
| 278 | * ASN1 integers: some broken software can encode a positive INTEGER | ||
| 279 | * with its MSB set as negative (it doesn't add a padding zero). | ||
| 280 | */ | ||
| 281 | |||
| 282 | ASN1_INTEGER * | ||
| 283 | d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp, long length) | ||
| 284 | { | ||
| 285 | ASN1_INTEGER *ret = NULL; | ||
| 286 | const unsigned char *p; | ||
| 287 | unsigned char *s; | ||
| 288 | long len; | ||
| 289 | int inf, tag, xclass; | ||
| 290 | int i; | ||
| 291 | |||
| 292 | if ((a == NULL) || ((*a) == NULL)) { | ||
| 293 | if ((ret = M_ASN1_INTEGER_new()) == NULL) | ||
| 294 | return (NULL); | ||
| 295 | ret->type = V_ASN1_INTEGER; | ||
| 296 | } else | ||
| 297 | ret = (*a); | ||
| 298 | |||
| 299 | p = *pp; | ||
| 300 | inf = ASN1_get_object(&p, &len, &tag, &xclass, length); | ||
| 301 | if (inf & 0x80) { | ||
| 302 | i = ASN1_R_BAD_OBJECT_HEADER; | ||
| 303 | goto err; | ||
| 304 | } | ||
| 305 | |||
| 306 | if (tag != V_ASN1_INTEGER) { | ||
| 307 | i = ASN1_R_EXPECTING_AN_INTEGER; | ||
| 308 | goto err; | ||
| 309 | } | ||
| 310 | |||
| 311 | /* We must malloc stuff, even for 0 bytes otherwise it | ||
| 312 | * signifies a missing NULL parameter. */ | ||
| 313 | s = malloc(len + 1); | ||
| 314 | if (s == NULL) { | ||
| 315 | i = ERR_R_MALLOC_FAILURE; | ||
| 316 | goto err; | ||
| 317 | } | ||
| 318 | ret->type = V_ASN1_INTEGER; | ||
| 319 | if (len) { | ||
| 320 | if ((*p == 0) && (len != 1)) { | ||
| 321 | p++; | ||
| 322 | len--; | ||
| 323 | } | ||
| 324 | memcpy(s, p, len); | ||
| 325 | p += len; | ||
| 326 | } | ||
| 327 | |||
| 328 | free(ret->data); | ||
| 329 | ret->data = s; | ||
| 330 | ret->length = (int)len; | ||
| 331 | if (a != NULL) | ||
| 332 | (*a) = ret; | ||
| 333 | *pp = p; | ||
| 334 | return (ret); | ||
| 335 | |||
| 336 | err: | ||
| 337 | ASN1err(ASN1_F_D2I_ASN1_UINTEGER, i); | ||
| 338 | if (a == NULL || *a != ret) | ||
| 339 | M_ASN1_INTEGER_free(ret); | ||
| 340 | return (NULL); | ||
| 341 | } | ||
| 342 | |||
| 343 | int | ||
| 344 | ASN1_INTEGER_set(ASN1_INTEGER *a, long v) | ||
| 345 | { | ||
| 346 | int j, k; | ||
| 347 | unsigned int i; | ||
| 348 | unsigned char buf[sizeof(long) + 1]; | ||
| 349 | long d; | ||
| 350 | |||
| 351 | a->type = V_ASN1_INTEGER; | ||
| 352 | /* XXX ssl/ssl_asn1.c:i2d_SSL_SESSION() depends upon this bound vae */ | ||
| 353 | if (a->length < (int)(sizeof(long) + 1)) { | ||
| 354 | free(a->data); | ||
| 355 | a->data = calloc(1, sizeof(long) + 1); | ||
| 356 | } | ||
| 357 | if (a->data == NULL) { | ||
| 358 | ASN1err(ASN1_F_ASN1_INTEGER_SET, ERR_R_MALLOC_FAILURE); | ||
| 359 | return (0); | ||
| 360 | } | ||
| 361 | d = v; | ||
| 362 | if (d < 0) { | ||
| 363 | d = -d; | ||
| 364 | a->type = V_ASN1_NEG_INTEGER; | ||
| 365 | } | ||
| 366 | |||
| 367 | for (i = 0; i < sizeof(long); i++) { | ||
| 368 | if (d == 0) | ||
| 369 | break; | ||
| 370 | buf[i] = (int)d & 0xff; | ||
| 371 | d >>= 8; | ||
| 372 | } | ||
| 373 | j = 0; | ||
| 374 | for (k = i - 1; k >= 0; k--) | ||
| 375 | a->data[j++] = buf[k]; | ||
| 376 | a->length = j; | ||
| 377 | return (1); | ||
| 378 | } | ||
| 379 | |||
| 380 | long | ||
| 381 | ASN1_INTEGER_get(const ASN1_INTEGER *a) | ||
| 382 | { | ||
| 383 | int neg = 0, i; | ||
| 384 | long r = 0; | ||
| 385 | |||
| 386 | if (a == NULL) | ||
| 387 | return (0L); | ||
| 388 | i = a->type; | ||
| 389 | if (i == V_ASN1_NEG_INTEGER) | ||
| 390 | neg = 1; | ||
| 391 | else if (i != V_ASN1_INTEGER) | ||
| 392 | return -1; | ||
| 393 | |||
| 394 | if (a->length > (int)sizeof(long)) { | ||
| 395 | /* hmm... a bit ugly, return all ones */ | ||
| 396 | return -1; | ||
| 397 | } | ||
| 398 | if (a->data == NULL) | ||
| 399 | return 0; | ||
| 400 | |||
| 401 | for (i = 0; i < a->length; i++) { | ||
| 402 | r <<= 8; | ||
| 403 | r |= (unsigned char)a->data[i]; | ||
| 404 | } | ||
| 405 | if (neg) | ||
| 406 | r = -r; | ||
| 407 | return (r); | ||
| 408 | } | ||
| 409 | |||
| 410 | ASN1_INTEGER * | ||
| 411 | BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai) | ||
| 412 | { | ||
| 413 | ASN1_INTEGER *ret; | ||
| 414 | int len, j; | ||
| 415 | |||
| 416 | if (ai == NULL) | ||
| 417 | ret = M_ASN1_INTEGER_new(); | ||
| 418 | else | ||
| 419 | ret = ai; | ||
| 420 | if (ret == NULL) { | ||
| 421 | ASN1err(ASN1_F_BN_TO_ASN1_INTEGER, ERR_R_NESTED_ASN1_ERROR); | ||
| 422 | goto err; | ||
| 423 | } | ||
| 424 | if (BN_is_negative(bn)) | ||
| 425 | ret->type = V_ASN1_NEG_INTEGER; | ||
| 426 | else | ||
| 427 | ret->type = V_ASN1_INTEGER; | ||
| 428 | j = BN_num_bits(bn); | ||
| 429 | len = ((j == 0) ? 0 : ((j / 8) + 1)); | ||
| 430 | if (ret->length < len + 4) { | ||
| 431 | unsigned char *new_data = realloc(ret->data, len + 4); | ||
| 432 | if (!new_data) { | ||
| 433 | ASN1err(ASN1_F_BN_TO_ASN1_INTEGER, ERR_R_MALLOC_FAILURE); | ||
| 434 | goto err; | ||
| 435 | } | ||
| 436 | ret->data = new_data; | ||
| 437 | } | ||
| 438 | ret->length = BN_bn2bin(bn, ret->data); | ||
| 439 | |||
| 440 | /* Correct zero case */ | ||
| 441 | if (!ret->length) { | ||
| 442 | ret->data[0] = 0; | ||
| 443 | ret->length = 1; | ||
| 444 | } | ||
| 445 | return (ret); | ||
| 446 | |||
| 447 | err: | ||
| 448 | if (ret != ai) | ||
| 449 | M_ASN1_INTEGER_free(ret); | ||
| 450 | return (NULL); | ||
| 451 | } | ||
| 452 | |||
| 453 | BIGNUM * | ||
| 454 | ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn) | ||
| 455 | { | ||
| 456 | BIGNUM *ret; | ||
| 457 | |||
| 458 | if ((ret = BN_bin2bn(ai->data, ai->length, bn)) == NULL) | ||
| 459 | ASN1err(ASN1_F_ASN1_INTEGER_TO_BN, ASN1_R_BN_LIB); | ||
| 460 | else if (ai->type == V_ASN1_NEG_INTEGER) | ||
| 461 | BN_set_negative(ret, 1); | ||
| 462 | return (ret); | ||
| 463 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_mbstr.c b/src/lib/libcrypto/asn1/a_mbstr.c deleted file mode 100644 index e715fe7348..0000000000 --- a/src/lib/libcrypto/asn1/a_mbstr.c +++ /dev/null | |||
| @@ -1,453 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_mbstr.c,v 1.22 2015/07/16 02:18:58 miod Exp $ */ | ||
| 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 | #include <ctype.h> | ||
| 60 | #include <stdio.h> | ||
| 61 | #include <string.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | |||
| 66 | #include "asn1_locl.h" | ||
| 67 | |||
| 68 | static int traverse_string(const unsigned char *p, int len, int inform, | ||
| 69 | int (*rfunc)(unsigned long value, void *in), void *arg); | ||
| 70 | static int in_utf8(unsigned long value, void *arg); | ||
| 71 | static int out_utf8(unsigned long value, void *arg); | ||
| 72 | static int type_str(unsigned long value, void *arg); | ||
| 73 | static int cpy_asc(unsigned long value, void *arg); | ||
| 74 | static int cpy_bmp(unsigned long value, void *arg); | ||
| 75 | static int cpy_univ(unsigned long value, void *arg); | ||
| 76 | static int cpy_utf8(unsigned long value, void *arg); | ||
| 77 | static int is_printable(unsigned long value); | ||
| 78 | |||
| 79 | /* These functions take a string in UTF8, ASCII or multibyte form and | ||
| 80 | * a mask of permissible ASN1 string types. It then works out the minimal | ||
| 81 | * type (using the order Printable < IA5 < T61 < BMP < Universal < UTF8) | ||
| 82 | * and creates a string of the correct type with the supplied data. | ||
| 83 | * Yes this is horrible: it has to be :-( | ||
| 84 | * The 'ncopy' form checks minimum and maximum size limits too. | ||
| 85 | */ | ||
| 86 | |||
| 87 | int | ||
| 88 | ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, | ||
| 89 | int inform, unsigned long mask) | ||
| 90 | { | ||
| 91 | return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0); | ||
| 92 | } | ||
| 93 | |||
| 94 | int | ||
| 95 | ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, | ||
| 96 | int inform, unsigned long mask, long minsize, long maxsize) | ||
| 97 | { | ||
| 98 | int str_type; | ||
| 99 | int ret; | ||
| 100 | char free_out; | ||
| 101 | int outform, outlen = 0; | ||
| 102 | ASN1_STRING *dest; | ||
| 103 | unsigned char *p; | ||
| 104 | int nchar; | ||
| 105 | int (*cpyfunc)(unsigned long, void *) = NULL; | ||
| 106 | |||
| 107 | if (len < 0) | ||
| 108 | len = strlen((const char *)in); | ||
| 109 | if (!mask) | ||
| 110 | mask = DIRSTRING_TYPE; | ||
| 111 | |||
| 112 | /* First do a string check and work out the number of characters */ | ||
| 113 | switch (inform) { | ||
| 114 | case MBSTRING_BMP: | ||
| 115 | if (len & 1) { | ||
| 116 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, | ||
| 117 | ASN1_R_INVALID_BMPSTRING_LENGTH); | ||
| 118 | return -1; | ||
| 119 | } | ||
| 120 | nchar = len >> 1; | ||
| 121 | break; | ||
| 122 | |||
| 123 | case MBSTRING_UNIV: | ||
| 124 | if (len & 3) { | ||
| 125 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, | ||
| 126 | ASN1_R_INVALID_UNIVERSALSTRING_LENGTH); | ||
| 127 | return -1; | ||
| 128 | } | ||
| 129 | nchar = len >> 2; | ||
| 130 | break; | ||
| 131 | |||
| 132 | case MBSTRING_UTF8: | ||
| 133 | nchar = 0; | ||
| 134 | /* This counts the characters and does utf8 syntax checking */ | ||
| 135 | ret = traverse_string(in, len, MBSTRING_UTF8, in_utf8, &nchar); | ||
| 136 | if (ret < 0) { | ||
| 137 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, | ||
| 138 | ASN1_R_INVALID_UTF8STRING); | ||
| 139 | return -1; | ||
| 140 | } | ||
| 141 | break; | ||
| 142 | |||
| 143 | case MBSTRING_ASC: | ||
| 144 | nchar = len; | ||
| 145 | break; | ||
| 146 | |||
| 147 | default: | ||
| 148 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_UNKNOWN_FORMAT); | ||
| 149 | return -1; | ||
| 150 | } | ||
| 151 | |||
| 152 | if ((minsize > 0) && (nchar < minsize)) { | ||
| 153 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_SHORT); | ||
| 154 | ERR_asprintf_error_data("minsize=%ld", minsize); | ||
| 155 | return -1; | ||
| 156 | } | ||
| 157 | |||
| 158 | if ((maxsize > 0) && (nchar > maxsize)) { | ||
| 159 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_STRING_TOO_LONG); | ||
| 160 | ERR_asprintf_error_data("maxsize=%ld", maxsize); | ||
| 161 | return -1; | ||
| 162 | } | ||
| 163 | |||
| 164 | /* Now work out minimal type (if any) */ | ||
| 165 | if (traverse_string(in, len, inform, type_str, &mask) < 0) { | ||
| 166 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ASN1_R_ILLEGAL_CHARACTERS); | ||
| 167 | return -1; | ||
| 168 | } | ||
| 169 | |||
| 170 | |||
| 171 | /* Now work out output format and string type */ | ||
| 172 | outform = MBSTRING_ASC; | ||
| 173 | if (mask & B_ASN1_PRINTABLESTRING) | ||
| 174 | str_type = V_ASN1_PRINTABLESTRING; | ||
| 175 | else if (mask & B_ASN1_IA5STRING) | ||
| 176 | str_type = V_ASN1_IA5STRING; | ||
| 177 | else if (mask & B_ASN1_T61STRING) | ||
| 178 | str_type = V_ASN1_T61STRING; | ||
| 179 | else if (mask & B_ASN1_BMPSTRING) { | ||
| 180 | str_type = V_ASN1_BMPSTRING; | ||
| 181 | outform = MBSTRING_BMP; | ||
| 182 | } else if (mask & B_ASN1_UNIVERSALSTRING) { | ||
| 183 | str_type = V_ASN1_UNIVERSALSTRING; | ||
| 184 | outform = MBSTRING_UNIV; | ||
| 185 | } else { | ||
| 186 | str_type = V_ASN1_UTF8STRING; | ||
| 187 | outform = MBSTRING_UTF8; | ||
| 188 | } | ||
| 189 | if (!out) | ||
| 190 | return str_type; | ||
| 191 | if (*out) { | ||
| 192 | free_out = 0; | ||
| 193 | dest = *out; | ||
| 194 | if (dest->data) { | ||
| 195 | dest->length = 0; | ||
| 196 | free(dest->data); | ||
| 197 | dest->data = NULL; | ||
| 198 | } | ||
| 199 | dest->type = str_type; | ||
| 200 | } else { | ||
| 201 | free_out = 1; | ||
| 202 | dest = ASN1_STRING_type_new(str_type); | ||
| 203 | if (!dest) { | ||
| 204 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, | ||
| 205 | ERR_R_MALLOC_FAILURE); | ||
| 206 | return -1; | ||
| 207 | } | ||
| 208 | *out = dest; | ||
| 209 | } | ||
| 210 | /* If both the same type just copy across */ | ||
| 211 | if (inform == outform) { | ||
| 212 | if (!ASN1_STRING_set(dest, in, len)) { | ||
| 213 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, | ||
| 214 | ERR_R_MALLOC_FAILURE); | ||
| 215 | goto err; | ||
| 216 | } | ||
| 217 | return str_type; | ||
| 218 | } | ||
| 219 | |||
| 220 | /* Work out how much space the destination will need */ | ||
| 221 | switch (outform) { | ||
| 222 | case MBSTRING_ASC: | ||
| 223 | outlen = nchar; | ||
| 224 | cpyfunc = cpy_asc; | ||
| 225 | break; | ||
| 226 | |||
| 227 | case MBSTRING_BMP: | ||
| 228 | outlen = nchar << 1; | ||
| 229 | cpyfunc = cpy_bmp; | ||
| 230 | break; | ||
| 231 | |||
| 232 | case MBSTRING_UNIV: | ||
| 233 | outlen = nchar << 2; | ||
| 234 | cpyfunc = cpy_univ; | ||
| 235 | break; | ||
| 236 | |||
| 237 | case MBSTRING_UTF8: | ||
| 238 | outlen = 0; | ||
| 239 | if (traverse_string(in, len, inform, out_utf8, &outlen) < 0) { | ||
| 240 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, | ||
| 241 | ASN1_R_ILLEGAL_CHARACTERS); | ||
| 242 | goto err; | ||
| 243 | } | ||
| 244 | cpyfunc = cpy_utf8; | ||
| 245 | break; | ||
| 246 | } | ||
| 247 | if (!(p = malloc(outlen + 1))) { | ||
| 248 | ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE); | ||
| 249 | goto err; | ||
| 250 | } | ||
| 251 | dest->length = outlen; | ||
| 252 | dest->data = p; | ||
| 253 | p[outlen] = 0; | ||
| 254 | traverse_string(in, len, inform, cpyfunc, &p); | ||
| 255 | return str_type; | ||
| 256 | |||
| 257 | err: | ||
| 258 | if (free_out) { | ||
| 259 | ASN1_STRING_free(dest); | ||
| 260 | *out = NULL; | ||
| 261 | } | ||
| 262 | return -1; | ||
| 263 | } | ||
| 264 | |||
| 265 | /* This function traverses a string and passes the value of each character | ||
| 266 | * to an optional function along with a void * argument. | ||
| 267 | */ | ||
| 268 | |||
| 269 | static int | ||
| 270 | traverse_string(const unsigned char *p, int len, int inform, | ||
| 271 | int (*rfunc)(unsigned long value, void *in), void *arg) | ||
| 272 | { | ||
| 273 | unsigned long value; | ||
| 274 | int ret; | ||
| 275 | |||
| 276 | while (len) { | ||
| 277 | switch (inform) { | ||
| 278 | case MBSTRING_ASC: | ||
| 279 | value = *p++; | ||
| 280 | len--; | ||
| 281 | break; | ||
| 282 | case MBSTRING_BMP: | ||
| 283 | value = *p++ << 8; | ||
| 284 | value |= *p++; | ||
| 285 | /* BMP is explictly defined to not support surrogates */ | ||
| 286 | if (UNICODE_IS_SURROGATE(value)) | ||
| 287 | return -1; | ||
| 288 | len -= 2; | ||
| 289 | break; | ||
| 290 | case MBSTRING_UNIV: | ||
| 291 | value = (unsigned long)*p++ << 24; | ||
| 292 | value |= *p++ << 16; | ||
| 293 | value |= *p++ << 8; | ||
| 294 | value |= *p++; | ||
| 295 | if (value > UNICODE_MAX || UNICODE_IS_SURROGATE(value)) | ||
| 296 | return -1; | ||
| 297 | len -= 4; | ||
| 298 | break; | ||
| 299 | default: | ||
| 300 | ret = UTF8_getc(p, len, &value); | ||
| 301 | if (ret < 0) | ||
| 302 | return -1; | ||
| 303 | len -= ret; | ||
| 304 | p += ret; | ||
| 305 | break; | ||
| 306 | } | ||
| 307 | if (rfunc) { | ||
| 308 | ret = rfunc(value, arg); | ||
| 309 | if (ret <= 0) | ||
| 310 | return ret; | ||
| 311 | } | ||
| 312 | } | ||
| 313 | return 1; | ||
| 314 | } | ||
| 315 | |||
| 316 | /* Various utility functions for traverse_string */ | ||
| 317 | |||
| 318 | /* Just count number of characters */ | ||
| 319 | |||
| 320 | static int | ||
| 321 | in_utf8(unsigned long value, void *arg) | ||
| 322 | { | ||
| 323 | int *nchar; | ||
| 324 | |||
| 325 | nchar = arg; | ||
| 326 | (*nchar)++; | ||
| 327 | return 1; | ||
| 328 | } | ||
| 329 | |||
| 330 | /* Determine size of output as a UTF8 String */ | ||
| 331 | |||
| 332 | static int | ||
| 333 | out_utf8(unsigned long value, void *arg) | ||
| 334 | { | ||
| 335 | int *outlen; | ||
| 336 | int ret; | ||
| 337 | |||
| 338 | outlen = arg; | ||
| 339 | ret = UTF8_putc(NULL, -1, value); | ||
| 340 | if (ret < 0) | ||
| 341 | return ret; | ||
| 342 | *outlen += ret; | ||
| 343 | return 1; | ||
| 344 | } | ||
| 345 | |||
| 346 | /* Determine the "type" of a string: check each character against a | ||
| 347 | * supplied "mask". | ||
| 348 | */ | ||
| 349 | |||
| 350 | static int | ||
| 351 | type_str(unsigned long value, void *arg) | ||
| 352 | { | ||
| 353 | unsigned long types; | ||
| 354 | |||
| 355 | types = *((unsigned long *)arg); | ||
| 356 | if ((types & B_ASN1_PRINTABLESTRING) && !is_printable(value)) | ||
| 357 | types &= ~B_ASN1_PRINTABLESTRING; | ||
| 358 | if ((types & B_ASN1_IA5STRING) && (value > 127)) | ||
| 359 | types &= ~B_ASN1_IA5STRING; | ||
| 360 | if ((types & B_ASN1_T61STRING) && (value > 0xff)) | ||
| 361 | types &= ~B_ASN1_T61STRING; | ||
| 362 | if ((types & B_ASN1_BMPSTRING) && (value > 0xffff)) | ||
| 363 | types &= ~B_ASN1_BMPSTRING; | ||
| 364 | if (!types) | ||
| 365 | return -1; | ||
| 366 | *((unsigned long *)arg) = types; | ||
| 367 | return 1; | ||
| 368 | } | ||
| 369 | |||
| 370 | /* Copy one byte per character ASCII like strings */ | ||
| 371 | |||
| 372 | static int | ||
| 373 | cpy_asc(unsigned long value, void *arg) | ||
| 374 | { | ||
| 375 | unsigned char **p, *q; | ||
| 376 | |||
| 377 | p = arg; | ||
| 378 | q = *p; | ||
| 379 | *q = value; | ||
| 380 | (*p)++; | ||
| 381 | return 1; | ||
| 382 | } | ||
| 383 | |||
| 384 | /* Copy two byte per character BMPStrings */ | ||
| 385 | |||
| 386 | static int | ||
| 387 | cpy_bmp(unsigned long value, void *arg) | ||
| 388 | { | ||
| 389 | unsigned char **p, *q; | ||
| 390 | |||
| 391 | p = arg; | ||
| 392 | q = *p; | ||
| 393 | *q++ = (value >> 8) & 0xff; | ||
| 394 | *q = value & 0xff; | ||
| 395 | *p += 2; | ||
| 396 | return 1; | ||
| 397 | } | ||
| 398 | |||
| 399 | /* Copy four byte per character UniversalStrings */ | ||
| 400 | |||
| 401 | static int | ||
| 402 | cpy_univ(unsigned long value, void *arg) | ||
| 403 | { | ||
| 404 | unsigned char **p, *q; | ||
| 405 | |||
| 406 | p = arg; | ||
| 407 | q = *p; | ||
| 408 | *q++ = (value >> 24) & 0xff; | ||
| 409 | *q++ = (value >> 16) & 0xff; | ||
| 410 | *q++ = (value >> 8) & 0xff; | ||
| 411 | *q = value & 0xff; | ||
| 412 | *p += 4; | ||
| 413 | return 1; | ||
| 414 | } | ||
| 415 | |||
| 416 | /* Copy to a UTF8String */ | ||
| 417 | |||
| 418 | static int | ||
| 419 | cpy_utf8(unsigned long value, void *arg) | ||
| 420 | { | ||
| 421 | unsigned char **p; | ||
| 422 | |||
| 423 | int ret; | ||
| 424 | p = arg; | ||
| 425 | /* We already know there is enough room so pass 0xff as the length */ | ||
| 426 | ret = UTF8_putc(*p, 0xff, value); | ||
| 427 | *p += ret; | ||
| 428 | return 1; | ||
| 429 | } | ||
| 430 | |||
| 431 | /* Return 1 if the character is permitted in a PrintableString */ | ||
| 432 | static int | ||
| 433 | is_printable(unsigned long value) | ||
| 434 | { | ||
| 435 | int ch; | ||
| 436 | |||
| 437 | if (value > 0x7f) | ||
| 438 | return 0; | ||
| 439 | ch = (int)value; | ||
| 440 | |||
| 441 | /* Note: we can't use 'isalnum' because certain accented | ||
| 442 | * characters may count as alphanumeric in some environments. | ||
| 443 | */ | ||
| 444 | if ((ch >= 'a') && (ch <= 'z')) | ||
| 445 | return 1; | ||
| 446 | if ((ch >= 'A') && (ch <= 'Z')) | ||
| 447 | return 1; | ||
| 448 | if ((ch >= '0') && (ch <= '9')) | ||
| 449 | return 1; | ||
| 450 | if ((ch == ' ') || strchr("'()+,-./:=?", ch)) | ||
| 451 | return 1; | ||
| 452 | return 0; | ||
| 453 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_object.c b/src/lib/libcrypto/asn1/a_object.c deleted file mode 100644 index 7bcabec034..0000000000 --- a/src/lib/libcrypto/asn1/a_object.c +++ /dev/null | |||
| @@ -1,405 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_object.c,v 1.24 2015/02/10 08:33:10 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <limits.h> | ||
| 60 | #include <stdio.h> | ||
| 61 | #include <string.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1.h> | ||
| 64 | #include <openssl/bn.h> | ||
| 65 | #include <openssl/err.h> | ||
| 66 | #include <openssl/buffer.h> | ||
| 67 | #include <openssl/objects.h> | ||
| 68 | |||
| 69 | int | ||
| 70 | i2d_ASN1_OBJECT(ASN1_OBJECT *a, unsigned char **pp) | ||
| 71 | { | ||
| 72 | unsigned char *p; | ||
| 73 | int objsize; | ||
| 74 | |||
| 75 | if ((a == NULL) || (a->data == NULL)) | ||
| 76 | return (0); | ||
| 77 | |||
| 78 | objsize = ASN1_object_size(0, a->length, V_ASN1_OBJECT); | ||
| 79 | if (pp == NULL) | ||
| 80 | return objsize; | ||
| 81 | |||
| 82 | p = *pp; | ||
| 83 | ASN1_put_object(&p, 0, a->length, V_ASN1_OBJECT, V_ASN1_UNIVERSAL); | ||
| 84 | memcpy(p, a->data, a->length); | ||
| 85 | p += a->length; | ||
| 86 | |||
| 87 | *pp = p; | ||
| 88 | return (objsize); | ||
| 89 | } | ||
| 90 | |||
| 91 | int | ||
| 92 | a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num) | ||
| 93 | { | ||
| 94 | int i, first, len = 0, c, use_bn; | ||
| 95 | char ftmp[24], *tmp = ftmp; | ||
| 96 | int tmpsize = sizeof ftmp; | ||
| 97 | const char *p; | ||
| 98 | unsigned long l; | ||
| 99 | BIGNUM *bl = NULL; | ||
| 100 | |||
| 101 | if (num == 0) | ||
| 102 | return (0); | ||
| 103 | else if (num == -1) | ||
| 104 | num = strlen(buf); | ||
| 105 | |||
| 106 | p = buf; | ||
| 107 | c = *(p++); | ||
| 108 | num--; | ||
| 109 | if ((c >= '0') && (c <= '2')) { | ||
| 110 | first= c-'0'; | ||
| 111 | } else { | ||
| 112 | ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_FIRST_NUM_TOO_LARGE); | ||
| 113 | goto err; | ||
| 114 | } | ||
| 115 | |||
| 116 | if (num <= 0) { | ||
| 117 | ASN1err(ASN1_F_A2D_ASN1_OBJECT, ASN1_R_MISSING_SECOND_NUMBER); | ||
| 118 | goto err; | ||
| 119 | } | ||
| 120 | c = *(p++); | ||
| 121 | num--; | ||
| 122 | for (;;) { | ||
| 123 | if (num <= 0) | ||
| 124 | break; | ||
| 125 | if ((c != '.') && (c != ' ')) { | ||
| 126 | ASN1err(ASN1_F_A2D_ASN1_OBJECT, | ||
| 127 | ASN1_R_INVALID_SEPARATOR); | ||
| 128 | goto err; | ||
| 129 | } | ||
| 130 | l = 0; | ||
| 131 | use_bn = 0; | ||
| 132 | for (;;) { | ||
| 133 | if (num <= 0) | ||
| 134 | break; | ||
| 135 | num--; | ||
| 136 | c = *(p++); | ||
| 137 | if ((c == ' ') || (c == '.')) | ||
| 138 | break; | ||
| 139 | if ((c < '0') || (c > '9')) { | ||
| 140 | ASN1err(ASN1_F_A2D_ASN1_OBJECT, | ||
| 141 | ASN1_R_INVALID_DIGIT); | ||
| 142 | goto err; | ||
| 143 | } | ||
| 144 | if (!use_bn && l >= ((ULONG_MAX - 80) / 10L)) { | ||
| 145 | use_bn = 1; | ||
| 146 | if (!bl) | ||
| 147 | bl = BN_new(); | ||
| 148 | if (!bl || !BN_set_word(bl, l)) | ||
| 149 | goto err; | ||
| 150 | } | ||
| 151 | if (use_bn) { | ||
| 152 | if (!BN_mul_word(bl, 10L) || | ||
| 153 | !BN_add_word(bl, c-'0')) | ||
| 154 | goto err; | ||
| 155 | } else | ||
| 156 | l = l * 10L + (long)(c - '0'); | ||
| 157 | } | ||
| 158 | if (len == 0) { | ||
| 159 | if ((first < 2) && (l >= 40)) { | ||
| 160 | ASN1err(ASN1_F_A2D_ASN1_OBJECT, | ||
| 161 | ASN1_R_SECOND_NUMBER_TOO_LARGE); | ||
| 162 | goto err; | ||
| 163 | } | ||
| 164 | if (use_bn) { | ||
| 165 | if (!BN_add_word(bl, first * 40)) | ||
| 166 | goto err; | ||
| 167 | } else | ||
| 168 | l += (long)first * 40; | ||
| 169 | } | ||
| 170 | i = 0; | ||
| 171 | if (use_bn) { | ||
| 172 | int blsize; | ||
| 173 | blsize = BN_num_bits(bl); | ||
| 174 | blsize = (blsize + 6) / 7; | ||
| 175 | if (blsize > tmpsize) { | ||
| 176 | if (tmp != ftmp) | ||
| 177 | free(tmp); | ||
| 178 | tmpsize = blsize + 32; | ||
| 179 | tmp = malloc(tmpsize); | ||
| 180 | if (!tmp) | ||
| 181 | goto err; | ||
| 182 | } | ||
| 183 | while (blsize--) | ||
| 184 | tmp[i++] = (unsigned char)BN_div_word(bl, 0x80L); | ||
| 185 | } else { | ||
| 186 | |||
| 187 | for (;;) { | ||
| 188 | tmp[i++] = (unsigned char)l & 0x7f; | ||
| 189 | l >>= 7L; | ||
| 190 | if (l == 0L) | ||
| 191 | break; | ||
| 192 | } | ||
| 193 | |||
| 194 | } | ||
| 195 | if (out != NULL) { | ||
| 196 | if (len + i > olen) { | ||
| 197 | ASN1err(ASN1_F_A2D_ASN1_OBJECT, | ||
| 198 | ASN1_R_BUFFER_TOO_SMALL); | ||
| 199 | goto err; | ||
| 200 | } | ||
| 201 | while (--i > 0) | ||
| 202 | out[len++] = tmp[i]|0x80; | ||
| 203 | out[len++] = tmp[0]; | ||
| 204 | } else | ||
| 205 | len += i; | ||
| 206 | } | ||
| 207 | if (tmp != ftmp) | ||
| 208 | free(tmp); | ||
| 209 | BN_free(bl); | ||
| 210 | return (len); | ||
| 211 | |||
| 212 | err: | ||
| 213 | if (tmp != ftmp) | ||
| 214 | free(tmp); | ||
| 215 | BN_free(bl); | ||
| 216 | return (0); | ||
| 217 | } | ||
| 218 | |||
| 219 | int | ||
| 220 | i2t_ASN1_OBJECT(char *buf, int buf_len, ASN1_OBJECT *a) | ||
| 221 | { | ||
| 222 | return OBJ_obj2txt(buf, buf_len, a, 0); | ||
| 223 | } | ||
| 224 | |||
| 225 | int | ||
| 226 | i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a) | ||
| 227 | { | ||
| 228 | char buf[80], *p = buf; | ||
| 229 | int i; | ||
| 230 | |||
| 231 | if ((a == NULL) || (a->data == NULL)) | ||
| 232 | return(BIO_write(bp, "NULL",4)); | ||
| 233 | i = i2t_ASN1_OBJECT(buf, sizeof buf, a); | ||
| 234 | if (i > (int)(sizeof(buf) - 1)) { | ||
| 235 | p = malloc(i + 1); | ||
| 236 | if (!p) | ||
| 237 | return -1; | ||
| 238 | i2t_ASN1_OBJECT(p, i + 1, a); | ||
| 239 | } | ||
| 240 | if (i <= 0) | ||
| 241 | return BIO_write(bp, "<INVALID>", 9); | ||
| 242 | BIO_write(bp, p, i); | ||
| 243 | if (p != buf) | ||
| 244 | free(p); | ||
| 245 | return (i); | ||
| 246 | } | ||
| 247 | |||
| 248 | ASN1_OBJECT * | ||
| 249 | d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, long length) | ||
| 250 | { | ||
| 251 | const unsigned char *p; | ||
| 252 | long len; | ||
| 253 | int tag, xclass; | ||
| 254 | int inf, i; | ||
| 255 | ASN1_OBJECT *ret = NULL; | ||
| 256 | |||
| 257 | p = *pp; | ||
| 258 | inf = ASN1_get_object(&p, &len, &tag, &xclass, length); | ||
| 259 | if (inf & 0x80) { | ||
| 260 | i = ASN1_R_BAD_OBJECT_HEADER; | ||
| 261 | goto err; | ||
| 262 | } | ||
| 263 | |||
| 264 | if (tag != V_ASN1_OBJECT) { | ||
| 265 | i = ASN1_R_EXPECTING_AN_OBJECT; | ||
| 266 | goto err; | ||
| 267 | } | ||
| 268 | ret = c2i_ASN1_OBJECT(a, &p, len); | ||
| 269 | if (ret) | ||
| 270 | *pp = p; | ||
| 271 | return ret; | ||
| 272 | |||
| 273 | err: | ||
| 274 | ASN1err(ASN1_F_D2I_ASN1_OBJECT, i); | ||
| 275 | return (NULL); | ||
| 276 | } | ||
| 277 | |||
| 278 | ASN1_OBJECT * | ||
| 279 | c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, long len) | ||
| 280 | { | ||
| 281 | ASN1_OBJECT *ret = NULL; | ||
| 282 | const unsigned char *p; | ||
| 283 | unsigned char *data; | ||
| 284 | int i, length; | ||
| 285 | |||
| 286 | /* | ||
| 287 | * Sanity check OID encoding: | ||
| 288 | * - need at least one content octet | ||
| 289 | * - MSB must be clear in the last octet | ||
| 290 | * - can't have leading 0x80 in subidentifiers, see: X.690 8.19.2 | ||
| 291 | */ | ||
| 292 | if (len <= 0 || len > INT_MAX || pp == NULL || (p = *pp) == NULL || | ||
| 293 | p[len - 1] & 0x80) { | ||
| 294 | ASN1err(ASN1_F_C2I_ASN1_OBJECT, ASN1_R_INVALID_OBJECT_ENCODING); | ||
| 295 | return (NULL); | ||
| 296 | } | ||
| 297 | |||
| 298 | /* Now 0 < len <= INT_MAX, so the cast is safe. */ | ||
| 299 | length = (int)len; | ||
| 300 | for (i = 0; i < length; i++, p++) { | ||
| 301 | if (*p == 0x80 && (!i || !(p[-1] & 0x80))) { | ||
| 302 | ASN1err(ASN1_F_C2I_ASN1_OBJECT, | ||
| 303 | ASN1_R_INVALID_OBJECT_ENCODING); | ||
| 304 | return NULL; | ||
| 305 | } | ||
| 306 | } | ||
| 307 | |||
| 308 | /* only the ASN1_OBJECTs from the 'table' will have values | ||
| 309 | * for ->sn or ->ln */ | ||
| 310 | if ((a == NULL) || ((*a) == NULL) || | ||
| 311 | !((*a)->flags & ASN1_OBJECT_FLAG_DYNAMIC)) { | ||
| 312 | if ((ret = ASN1_OBJECT_new()) == NULL) | ||
| 313 | return (NULL); | ||
| 314 | } else | ||
| 315 | ret = (*a); | ||
| 316 | |||
| 317 | p = *pp; | ||
| 318 | /* detach data from object */ | ||
| 319 | data = (unsigned char *)ret->data; | ||
| 320 | ret->data = NULL; | ||
| 321 | /* once detached we can change it */ | ||
| 322 | if ((data == NULL) || (ret->length < length)) { | ||
| 323 | ret->length = 0; | ||
| 324 | free(data); | ||
| 325 | data = malloc(length); | ||
| 326 | if (data == NULL) { | ||
| 327 | i = ERR_R_MALLOC_FAILURE; | ||
| 328 | goto err; | ||
| 329 | } | ||
| 330 | ret->flags |= ASN1_OBJECT_FLAG_DYNAMIC_DATA; | ||
| 331 | } | ||
| 332 | memcpy(data, p, length); | ||
| 333 | /* reattach data to object, after which it remains const */ | ||
| 334 | ret->data = data; | ||
| 335 | ret->length = length; | ||
| 336 | ret->sn = NULL; | ||
| 337 | ret->ln = NULL; | ||
| 338 | /* ret->flags=ASN1_OBJECT_FLAG_DYNAMIC; we know it is dynamic */ | ||
| 339 | p += length; | ||
| 340 | |||
| 341 | if (a != NULL) | ||
| 342 | (*a) = ret; | ||
| 343 | *pp = p; | ||
| 344 | return (ret); | ||
| 345 | |||
| 346 | err: | ||
| 347 | ASN1err(ASN1_F_C2I_ASN1_OBJECT, i); | ||
| 348 | if ((ret != NULL) && ((a == NULL) || (*a != ret))) | ||
| 349 | ASN1_OBJECT_free(ret); | ||
| 350 | return (NULL); | ||
| 351 | } | ||
| 352 | |||
| 353 | ASN1_OBJECT * | ||
| 354 | ASN1_OBJECT_new(void) | ||
| 355 | { | ||
| 356 | ASN1_OBJECT *ret; | ||
| 357 | |||
| 358 | ret = malloc(sizeof(ASN1_OBJECT)); | ||
| 359 | if (ret == NULL) { | ||
| 360 | ASN1err(ASN1_F_ASN1_OBJECT_NEW, ERR_R_MALLOC_FAILURE); | ||
| 361 | return (NULL); | ||
| 362 | } | ||
| 363 | ret->length = 0; | ||
| 364 | ret->data = NULL; | ||
| 365 | ret->nid = 0; | ||
| 366 | ret->sn = NULL; | ||
| 367 | ret->ln = NULL; | ||
| 368 | ret->flags = ASN1_OBJECT_FLAG_DYNAMIC; | ||
| 369 | return (ret); | ||
| 370 | } | ||
| 371 | |||
| 372 | void | ||
| 373 | ASN1_OBJECT_free(ASN1_OBJECT *a) | ||
| 374 | { | ||
| 375 | if (a == NULL) | ||
| 376 | return; | ||
| 377 | if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_STRINGS) { | ||
| 378 | free((void *)a->sn); | ||
| 379 | free((void *)a->ln); | ||
| 380 | a->sn = a->ln = NULL; | ||
| 381 | } | ||
| 382 | if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA) { | ||
| 383 | free((void *)a->data); | ||
| 384 | a->data = NULL; | ||
| 385 | a->length = 0; | ||
| 386 | } | ||
| 387 | if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC) | ||
| 388 | free(a); | ||
| 389 | } | ||
| 390 | |||
| 391 | ASN1_OBJECT * | ||
| 392 | ASN1_OBJECT_create(int nid, unsigned char *data, int len, | ||
| 393 | const char *sn, const char *ln) | ||
| 394 | { | ||
| 395 | ASN1_OBJECT o; | ||
| 396 | |||
| 397 | o.sn = sn; | ||
| 398 | o.ln = ln; | ||
| 399 | o.data = data; | ||
| 400 | o.nid = nid; | ||
| 401 | o.length = len; | ||
| 402 | o.flags = ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS | | ||
| 403 | ASN1_OBJECT_FLAG_DYNAMIC_DATA; | ||
| 404 | return (OBJ_dup(&o)); | ||
| 405 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_octet.c b/src/lib/libcrypto/asn1/a_octet.c deleted file mode 100644 index d998675d3f..0000000000 --- a/src/lib/libcrypto/asn1/a_octet.c +++ /dev/null | |||
| @@ -1,79 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_octet.c,v 1.10 2015/07/29 14:58:34 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | |||
| 63 | ASN1_OCTET_STRING * | ||
| 64 | ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *x) | ||
| 65 | { | ||
| 66 | return ASN1_STRING_dup(x); | ||
| 67 | } | ||
| 68 | |||
| 69 | int | ||
| 70 | ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a, const ASN1_OCTET_STRING *b) | ||
| 71 | { | ||
| 72 | return ASN1_STRING_cmp(a, b); | ||
| 73 | } | ||
| 74 | |||
| 75 | int | ||
| 76 | ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *x, const unsigned char *d, int len) | ||
| 77 | { | ||
| 78 | return ASN1_STRING_set(x, d, len); | ||
| 79 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_print.c b/src/lib/libcrypto/asn1/a_print.c deleted file mode 100644 index ddcee54c7d..0000000000 --- a/src/lib/libcrypto/asn1/a_print.c +++ /dev/null | |||
| @@ -1,125 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_print.c,v 1.11 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | |||
| 63 | int | ||
| 64 | ASN1_PRINTABLE_type(const unsigned char *s, int len) | ||
| 65 | { | ||
| 66 | int c; | ||
| 67 | int ia5 = 0; | ||
| 68 | int t61 = 0; | ||
| 69 | |||
| 70 | if (len <= 0) | ||
| 71 | len = -1; | ||
| 72 | if (s == NULL) | ||
| 73 | return (V_ASN1_PRINTABLESTRING); | ||
| 74 | |||
| 75 | while ((*s) && (len-- != 0)) { | ||
| 76 | c= *(s++); | ||
| 77 | if (!(((c >= 'a') && (c <= 'z')) || | ||
| 78 | ((c >= 'A') && (c <= 'Z')) || | ||
| 79 | (c == ' ') || | ||
| 80 | ((c >= '0') && (c <= '9')) || | ||
| 81 | (c == ' ') || (c == '\'') || | ||
| 82 | (c == '(') || (c == ')') || | ||
| 83 | (c == '+') || (c == ',') || | ||
| 84 | (c == '-') || (c == '.') || | ||
| 85 | (c == '/') || (c == ':') || | ||
| 86 | (c == '=') || (c == '?'))) | ||
| 87 | ia5 = 1; | ||
| 88 | if (c & 0x80) | ||
| 89 | t61 = 1; | ||
| 90 | } | ||
| 91 | if (t61) | ||
| 92 | return (V_ASN1_T61STRING); | ||
| 93 | if (ia5) | ||
| 94 | return (V_ASN1_IA5STRING); | ||
| 95 | return (V_ASN1_PRINTABLESTRING); | ||
| 96 | } | ||
| 97 | |||
| 98 | int | ||
| 99 | ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s) | ||
| 100 | { | ||
| 101 | int i; | ||
| 102 | unsigned char *p; | ||
| 103 | |||
| 104 | if (s->type != V_ASN1_UNIVERSALSTRING) | ||
| 105 | return (0); | ||
| 106 | if ((s->length % 4) != 0) | ||
| 107 | return (0); | ||
| 108 | p = s->data; | ||
| 109 | for (i = 0; i < s->length; i += 4) { | ||
| 110 | if ((p[0] != '\0') || (p[1] != '\0') || (p[2] != '\0')) | ||
| 111 | break; | ||
| 112 | else | ||
| 113 | p += 4; | ||
| 114 | } | ||
| 115 | if (i < s->length) | ||
| 116 | return (0); | ||
| 117 | p = s->data; | ||
| 118 | for (i = 3; i < s->length; i += 4) { | ||
| 119 | *(p++) = s->data[i]; | ||
| 120 | } | ||
| 121 | *(p) = '\0'; | ||
| 122 | s->length /= 4; | ||
| 123 | s->type = ASN1_PRINTABLE_type(s->data, s->length); | ||
| 124 | return (1); | ||
| 125 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_set.c b/src/lib/libcrypto/asn1/a_set.c deleted file mode 100644 index 63d55c3714..0000000000 --- a/src/lib/libcrypto/asn1/a_set.c +++ /dev/null | |||
| @@ -1,237 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_set.c,v 1.17 2015/03/19 14:00:22 tedu Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1_mac.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | |||
| 65 | #ifndef NO_ASN1_OLD | ||
| 66 | |||
| 67 | typedef struct { | ||
| 68 | unsigned char *pbData; | ||
| 69 | int cbData; | ||
| 70 | } MYBLOB; | ||
| 71 | |||
| 72 | /* SetBlobCmp | ||
| 73 | * This function compares two elements of SET_OF block | ||
| 74 | */ | ||
| 75 | static int | ||
| 76 | SetBlobCmp(const void *elem1, const void *elem2) | ||
| 77 | { | ||
| 78 | const MYBLOB *b1 = (const MYBLOB *)elem1; | ||
| 79 | const MYBLOB *b2 = (const MYBLOB *)elem2; | ||
| 80 | int r; | ||
| 81 | |||
| 82 | r = memcmp(b1->pbData, b2->pbData, | ||
| 83 | b1->cbData < b2->cbData ? b1->cbData : b2->cbData); | ||
| 84 | if (r != 0) | ||
| 85 | return r; | ||
| 86 | return b1->cbData - b2->cbData; | ||
| 87 | } | ||
| 88 | |||
| 89 | /* int is_set: if TRUE, then sort the contents (i.e. it isn't a SEQUENCE) */ | ||
| 90 | int | ||
| 91 | i2d_ASN1_SET(STACK_OF(OPENSSL_BLOCK) *a, unsigned char **pp, i2d_of_void *i2d, | ||
| 92 | int ex_tag, int ex_class, int is_set) | ||
| 93 | { | ||
| 94 | int ret = 0, r; | ||
| 95 | int i; | ||
| 96 | unsigned char *p; | ||
| 97 | unsigned char *pStart, *pTempMem; | ||
| 98 | MYBLOB *rgSetBlob; | ||
| 99 | int totSize; | ||
| 100 | |||
| 101 | if (a == NULL) | ||
| 102 | return 0; | ||
| 103 | for (i = sk_OPENSSL_BLOCK_num(a) - 1; i >= 0; i--) | ||
| 104 | ret += i2d(sk_OPENSSL_BLOCK_value(a, i), NULL); | ||
| 105 | r = ASN1_object_size(1, ret, ex_tag); | ||
| 106 | if (pp == NULL) | ||
| 107 | return r; | ||
| 108 | |||
| 109 | p = *pp; | ||
| 110 | ASN1_put_object(&p, 1, ret, ex_tag, ex_class); | ||
| 111 | |||
| 112 | /* Modified by gp@nsj.co.jp */ | ||
| 113 | /* And then again by Ben */ | ||
| 114 | /* And again by Steve */ | ||
| 115 | |||
| 116 | if (!is_set || (sk_OPENSSL_BLOCK_num(a) < 2)) { | ||
| 117 | for (i = 0; i < sk_OPENSSL_BLOCK_num(a); i++) | ||
| 118 | i2d(sk_OPENSSL_BLOCK_value(a, i), &p); | ||
| 119 | |||
| 120 | *pp = p; | ||
| 121 | return r; | ||
| 122 | } | ||
| 123 | |||
| 124 | pStart = p; /* Catch the beg of Setblobs*/ | ||
| 125 | /* In this array we will store the SET blobs */ | ||
| 126 | rgSetBlob = reallocarray(NULL, sk_OPENSSL_BLOCK_num(a), sizeof(MYBLOB)); | ||
| 127 | if (rgSetBlob == NULL) { | ||
| 128 | ASN1err(ASN1_F_I2D_ASN1_SET, ERR_R_MALLOC_FAILURE); | ||
| 129 | return 0; | ||
| 130 | } | ||
| 131 | |||
| 132 | for (i = 0; i < sk_OPENSSL_BLOCK_num(a); i++) { | ||
| 133 | rgSetBlob[i].pbData = p; /* catch each set encode blob */ | ||
| 134 | i2d(sk_OPENSSL_BLOCK_value(a, i), &p); | ||
| 135 | /* Length of this SetBlob */ | ||
| 136 | rgSetBlob[i].cbData = p - rgSetBlob[i].pbData; | ||
| 137 | } | ||
| 138 | *pp = p; | ||
| 139 | totSize = p - pStart; /* This is the total size of all set blobs */ | ||
| 140 | |||
| 141 | /* Now we have to sort the blobs. I am using a simple algo. | ||
| 142 | * Sort ptrs | ||
| 143 | * Copy to temp-mem | ||
| 144 | * Copy from temp-mem to user-mem | ||
| 145 | */ | ||
| 146 | qsort(rgSetBlob, sk_OPENSSL_BLOCK_num(a), sizeof(MYBLOB), SetBlobCmp); | ||
| 147 | if ((pTempMem = malloc(totSize)) == NULL) { | ||
| 148 | free(rgSetBlob); | ||
| 149 | ASN1err(ASN1_F_I2D_ASN1_SET, ERR_R_MALLOC_FAILURE); | ||
| 150 | return 0; | ||
| 151 | } | ||
| 152 | |||
| 153 | /* Copy to temp mem */ | ||
| 154 | p = pTempMem; | ||
| 155 | for (i = 0; i < sk_OPENSSL_BLOCK_num(a); ++i) { | ||
| 156 | memcpy(p, rgSetBlob[i].pbData, rgSetBlob[i].cbData); | ||
| 157 | p += rgSetBlob[i].cbData; | ||
| 158 | } | ||
| 159 | |||
| 160 | /* Copy back to user mem*/ | ||
| 161 | memcpy(pStart, pTempMem, totSize); | ||
| 162 | free(pTempMem); | ||
| 163 | free(rgSetBlob); | ||
| 164 | |||
| 165 | return r; | ||
| 166 | } | ||
| 167 | |||
| 168 | STACK_OF(OPENSSL_BLOCK) * | ||
| 169 | d2i_ASN1_SET(STACK_OF(OPENSSL_BLOCK) **a, const unsigned char **pp, long length, | ||
| 170 | d2i_of_void *d2i, void (*free_func)(OPENSSL_BLOCK), int ex_tag, | ||
| 171 | int ex_class) | ||
| 172 | { | ||
| 173 | ASN1_const_CTX c; | ||
| 174 | STACK_OF(OPENSSL_BLOCK) *ret = NULL; | ||
| 175 | |||
| 176 | if (a == NULL || (*a) == NULL) { | ||
| 177 | if ((ret = sk_OPENSSL_BLOCK_new_null()) == NULL) { | ||
| 178 | ASN1err(ASN1_F_D2I_ASN1_SET, ERR_R_MALLOC_FAILURE); | ||
| 179 | goto err; | ||
| 180 | } | ||
| 181 | } else | ||
| 182 | ret = *a; | ||
| 183 | |||
| 184 | c.p = *pp; | ||
| 185 | c.max = (length == 0) ? 0 : (c.p + length); | ||
| 186 | |||
| 187 | c.inf = ASN1_get_object(&c.p, &c.slen, &c.tag, &c.xclass, c.max - c.p); | ||
| 188 | if (c.inf & 0x80) | ||
| 189 | goto err; | ||
| 190 | if (ex_class != c.xclass) { | ||
| 191 | ASN1err(ASN1_F_D2I_ASN1_SET, ASN1_R_BAD_CLASS); | ||
| 192 | goto err; | ||
| 193 | } | ||
| 194 | if (ex_tag != c.tag) { | ||
| 195 | ASN1err(ASN1_F_D2I_ASN1_SET, ASN1_R_BAD_TAG); | ||
| 196 | goto err; | ||
| 197 | } | ||
| 198 | if (c.slen + c.p > c.max) { | ||
| 199 | ASN1err(ASN1_F_D2I_ASN1_SET, ASN1_R_LENGTH_ERROR); | ||
| 200 | goto err; | ||
| 201 | } | ||
| 202 | /* check for infinite constructed - it can be as long | ||
| 203 | * as the amount of data passed to us */ | ||
| 204 | if (c.inf == (V_ASN1_CONSTRUCTED + 1)) | ||
| 205 | c.slen = length + *pp - c.p; | ||
| 206 | c.max = c.p + c.slen; | ||
| 207 | |||
| 208 | while (c.p < c.max) { | ||
| 209 | char *s; | ||
| 210 | |||
| 211 | if (M_ASN1_D2I_end_sequence()) | ||
| 212 | break; | ||
| 213 | if ((s = d2i(NULL, &c.p, c.slen)) == NULL) { | ||
| 214 | ASN1err(ASN1_F_D2I_ASN1_SET, | ||
| 215 | ASN1_R_ERROR_PARSING_SET_ELEMENT); | ||
| 216 | asn1_add_error(*pp, (int)(c.p - *pp)); | ||
| 217 | goto err; | ||
| 218 | } | ||
| 219 | if (!sk_OPENSSL_BLOCK_push(ret, s)) | ||
| 220 | goto err; | ||
| 221 | } | ||
| 222 | if (a != NULL) | ||
| 223 | *a = ret; | ||
| 224 | *pp = c.p; | ||
| 225 | return ret; | ||
| 226 | |||
| 227 | err: | ||
| 228 | if (a == NULL || *a != ret) { | ||
| 229 | if (free_func != NULL) | ||
| 230 | sk_OPENSSL_BLOCK_pop_free(ret, free_func); | ||
| 231 | else | ||
| 232 | sk_OPENSSL_BLOCK_free(ret); | ||
| 233 | } | ||
| 234 | return NULL; | ||
| 235 | } | ||
| 236 | |||
| 237 | #endif | ||
diff --git a/src/lib/libcrypto/asn1/a_sign.c b/src/lib/libcrypto/asn1/a_sign.c deleted file mode 100644 index d9385312a7..0000000000 --- a/src/lib/libcrypto/asn1/a_sign.c +++ /dev/null | |||
| @@ -1,240 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_sign.c,v 1.20 2015/07/19 18:29:31 miod Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | /* ==================================================================== | ||
| 59 | * Copyright (c) 1998-2003 The OpenSSL Project. All rights reserved. | ||
| 60 | * | ||
| 61 | * Redistribution and use in source and binary forms, with or without | ||
| 62 | * modification, are permitted provided that the following conditions | ||
| 63 | * are met: | ||
| 64 | * | ||
| 65 | * 1. Redistributions of source code must retain the above copyright | ||
| 66 | * notice, this list of conditions and the following disclaimer. | ||
| 67 | * | ||
| 68 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 69 | * notice, this list of conditions and the following disclaimer in | ||
| 70 | * the documentation and/or other materials provided with the | ||
| 71 | * distribution. | ||
| 72 | * | ||
| 73 | * 3. All advertising materials mentioning features or use of this | ||
| 74 | * software must display the following acknowledgment: | ||
| 75 | * "This product includes software developed by the OpenSSL Project | ||
| 76 | * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" | ||
| 77 | * | ||
| 78 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 79 | * endorse or promote products derived from this software without | ||
| 80 | * prior written permission. For written permission, please contact | ||
| 81 | * openssl-core@openssl.org. | ||
| 82 | * | ||
| 83 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 84 | * nor may "OpenSSL" appear in their names without prior written | ||
| 85 | * permission of the OpenSSL Project. | ||
| 86 | * | ||
| 87 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 88 | * acknowledgment: | ||
| 89 | * "This product includes software developed by the OpenSSL Project | ||
| 90 | * for use in the OpenSSL Toolkit (http://www.openssl.org/)" | ||
| 91 | * | ||
| 92 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 93 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 94 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 95 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 96 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 97 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 98 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 99 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 100 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 101 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 102 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 103 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 104 | * ==================================================================== | ||
| 105 | * | ||
| 106 | * This product includes cryptographic software written by Eric Young | ||
| 107 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 108 | * Hudson (tjh@cryptsoft.com). | ||
| 109 | * | ||
| 110 | */ | ||
| 111 | |||
| 112 | #include <sys/types.h> | ||
| 113 | |||
| 114 | #include <stdio.h> | ||
| 115 | #include <time.h> | ||
| 116 | |||
| 117 | #include <openssl/bn.h> | ||
| 118 | #include <openssl/buffer.h> | ||
| 119 | #include <openssl/err.h> | ||
| 120 | #include <openssl/evp.h> | ||
| 121 | #include <openssl/objects.h> | ||
| 122 | #include <openssl/x509.h> | ||
| 123 | |||
| 124 | #include "asn1_locl.h" | ||
| 125 | |||
| 126 | int | ||
| 127 | ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2, | ||
| 128 | ASN1_BIT_STRING *signature, void *asn, EVP_PKEY *pkey, const EVP_MD *type) | ||
| 129 | { | ||
| 130 | EVP_MD_CTX ctx; | ||
| 131 | EVP_MD_CTX_init(&ctx); | ||
| 132 | if (!EVP_DigestSignInit(&ctx, NULL, type, NULL, pkey)) { | ||
| 133 | EVP_MD_CTX_cleanup(&ctx); | ||
| 134 | return 0; | ||
| 135 | } | ||
| 136 | return ASN1_item_sign_ctx(it, algor1, algor2, signature, asn, &ctx); | ||
| 137 | } | ||
| 138 | |||
| 139 | |||
| 140 | int | ||
| 141 | ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, X509_ALGOR *algor2, | ||
| 142 | ASN1_BIT_STRING *signature, void *asn, EVP_MD_CTX *ctx) | ||
| 143 | { | ||
| 144 | const EVP_MD *type; | ||
| 145 | EVP_PKEY *pkey; | ||
| 146 | unsigned char *buf_in = NULL, *buf_out = NULL; | ||
| 147 | size_t inl = 0, outl = 0, outll = 0; | ||
| 148 | int signid, paramtype; | ||
| 149 | int rv; | ||
| 150 | |||
| 151 | type = EVP_MD_CTX_md(ctx); | ||
| 152 | pkey = EVP_PKEY_CTX_get0_pkey(ctx->pctx); | ||
| 153 | |||
| 154 | if (!type || !pkey) { | ||
| 155 | ASN1err(ASN1_F_ASN1_ITEM_SIGN_CTX, | ||
| 156 | ASN1_R_CONTEXT_NOT_INITIALISED); | ||
| 157 | return 0; | ||
| 158 | } | ||
| 159 | |||
| 160 | if (pkey->ameth->item_sign) { | ||
| 161 | rv = pkey->ameth->item_sign(ctx, it, asn, algor1, algor2, | ||
| 162 | signature); | ||
| 163 | if (rv == 1) | ||
| 164 | outl = signature->length; | ||
| 165 | /* Return value meanings: | ||
| 166 | * <=0: error. | ||
| 167 | * 1: method does everything. | ||
| 168 | * 2: carry on as normal. | ||
| 169 | * 3: ASN1 method sets algorithm identifiers: just sign. | ||
| 170 | */ | ||
| 171 | if (rv <= 0) | ||
| 172 | ASN1err(ASN1_F_ASN1_ITEM_SIGN_CTX, ERR_R_EVP_LIB); | ||
| 173 | if (rv <= 1) | ||
| 174 | goto err; | ||
| 175 | } else | ||
| 176 | rv = 2; | ||
| 177 | |||
| 178 | if (rv == 2) { | ||
| 179 | if (type->flags & EVP_MD_FLAG_PKEY_METHOD_SIGNATURE) { | ||
| 180 | if (!pkey->ameth || | ||
| 181 | !OBJ_find_sigid_by_algs(&signid, | ||
| 182 | EVP_MD_nid(type), pkey->ameth->pkey_id)) { | ||
| 183 | ASN1err(ASN1_F_ASN1_ITEM_SIGN_CTX, | ||
| 184 | ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED); | ||
| 185 | return 0; | ||
| 186 | } | ||
| 187 | } else | ||
| 188 | signid = type->pkey_type; | ||
| 189 | |||
| 190 | if (pkey->ameth->pkey_flags & ASN1_PKEY_SIGPARAM_NULL) | ||
| 191 | paramtype = V_ASN1_NULL; | ||
| 192 | else | ||
| 193 | paramtype = V_ASN1_UNDEF; | ||
| 194 | |||
| 195 | if (algor1) | ||
| 196 | X509_ALGOR_set0(algor1, | ||
| 197 | OBJ_nid2obj(signid), paramtype, NULL); | ||
| 198 | if (algor2) | ||
| 199 | X509_ALGOR_set0(algor2, | ||
| 200 | OBJ_nid2obj(signid), paramtype, NULL); | ||
| 201 | |||
| 202 | } | ||
| 203 | |||
| 204 | inl = ASN1_item_i2d(asn, &buf_in, it); | ||
| 205 | outll = outl = EVP_PKEY_size(pkey); | ||
| 206 | buf_out = malloc(outl); | ||
| 207 | if ((buf_in == NULL) || (buf_out == NULL)) { | ||
| 208 | outl = 0; | ||
| 209 | ASN1err(ASN1_F_ASN1_ITEM_SIGN_CTX, ERR_R_MALLOC_FAILURE); | ||
| 210 | goto err; | ||
| 211 | } | ||
| 212 | |||
| 213 | if (!EVP_DigestSignUpdate(ctx, buf_in, inl) || | ||
| 214 | !EVP_DigestSignFinal(ctx, buf_out, &outl)) { | ||
| 215 | outl = 0; | ||
| 216 | ASN1err(ASN1_F_ASN1_ITEM_SIGN_CTX, ERR_R_EVP_LIB); | ||
| 217 | goto err; | ||
| 218 | } | ||
| 219 | free(signature->data); | ||
| 220 | signature->data = buf_out; | ||
| 221 | buf_out = NULL; | ||
| 222 | signature->length = outl; | ||
| 223 | /* In the interests of compatibility, I'll make sure that | ||
| 224 | * the bit string has a 'not-used bits' value of 0 | ||
| 225 | */ | ||
| 226 | signature->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07); | ||
| 227 | signature->flags |= ASN1_STRING_FLAG_BITS_LEFT; | ||
| 228 | |||
| 229 | err: | ||
| 230 | EVP_MD_CTX_cleanup(ctx); | ||
| 231 | if (buf_in != NULL) { | ||
| 232 | OPENSSL_cleanse((char *)buf_in, inl); | ||
| 233 | free(buf_in); | ||
| 234 | } | ||
| 235 | if (buf_out != NULL) { | ||
| 236 | OPENSSL_cleanse((char *)buf_out, outll); | ||
| 237 | free(buf_out); | ||
| 238 | } | ||
| 239 | return (outl); | ||
| 240 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_strex.c b/src/lib/libcrypto/asn1/a_strex.c deleted file mode 100644 index f60a70d94d..0000000000 --- a/src/lib/libcrypto/asn1/a_strex.c +++ /dev/null | |||
| @@ -1,646 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_strex.c,v 1.25 2015/02/07 13:19:15 doug Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000 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 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1.h> | ||
| 63 | #include <openssl/crypto.h> | ||
| 64 | #include <openssl/x509.h> | ||
| 65 | |||
| 66 | #include "asn1_locl.h" | ||
| 67 | |||
| 68 | #include "charmap.h" | ||
| 69 | |||
| 70 | /* ASN1_STRING_print_ex() and X509_NAME_print_ex(). | ||
| 71 | * Enhanced string and name printing routines handling | ||
| 72 | * multibyte characters, RFC2253 and a host of other | ||
| 73 | * options. | ||
| 74 | */ | ||
| 75 | |||
| 76 | #define CHARTYPE_BS_ESC (ASN1_STRFLGS_ESC_2253 | CHARTYPE_FIRST_ESC_2253 | CHARTYPE_LAST_ESC_2253) | ||
| 77 | |||
| 78 | #define ESC_FLAGS (ASN1_STRFLGS_ESC_2253 | \ | ||
| 79 | ASN1_STRFLGS_ESC_QUOTE | \ | ||
| 80 | ASN1_STRFLGS_ESC_CTRL | \ | ||
| 81 | ASN1_STRFLGS_ESC_MSB) | ||
| 82 | |||
| 83 | |||
| 84 | /* Three IO functions for sending data to memory, a BIO and | ||
| 85 | * and a FILE pointer. | ||
| 86 | */ | ||
| 87 | static int | ||
| 88 | send_bio_chars(void *arg, const void *buf, int len) | ||
| 89 | { | ||
| 90 | if (!arg) | ||
| 91 | return 1; | ||
| 92 | if (BIO_write(arg, buf, len) != len) | ||
| 93 | return 0; | ||
| 94 | return 1; | ||
| 95 | } | ||
| 96 | |||
| 97 | static int | ||
| 98 | send_fp_chars(void *arg, const void *buf, int len) | ||
| 99 | { | ||
| 100 | if (!arg) | ||
| 101 | return 1; | ||
| 102 | if (fwrite(buf, 1, (size_t)len, arg) != (size_t)len) | ||
| 103 | return 0; | ||
| 104 | return 1; | ||
| 105 | } | ||
| 106 | |||
| 107 | typedef int char_io(void *arg, const void *buf, int len); | ||
| 108 | |||
| 109 | /* This function handles display of | ||
| 110 | * strings, one character at a time. | ||
| 111 | * It is passed an unsigned long for each | ||
| 112 | * character because it could come from 2 or even | ||
| 113 | * 4 byte forms. | ||
| 114 | */ | ||
| 115 | |||
| 116 | static int | ||
| 117 | do_esc_char(unsigned long c, unsigned char flags, char *do_quotes, | ||
| 118 | char_io *io_ch, void *arg) | ||
| 119 | { | ||
| 120 | unsigned char chflgs, chtmp; | ||
| 121 | char tmphex[sizeof(long) * 2 + 3]; | ||
| 122 | |||
| 123 | if (c > 0xffffffffL) | ||
| 124 | return -1; | ||
| 125 | if (c > 0xffff) { | ||
| 126 | snprintf(tmphex, sizeof tmphex, "\\W%08lX", c); | ||
| 127 | if (!io_ch(arg, tmphex, 10)) | ||
| 128 | return -1; | ||
| 129 | return 10; | ||
| 130 | } | ||
| 131 | if (c > 0xff) { | ||
| 132 | snprintf(tmphex, sizeof tmphex, "\\U%04lX", c); | ||
| 133 | if (!io_ch(arg, tmphex, 6)) | ||
| 134 | return -1; | ||
| 135 | return 6; | ||
| 136 | } | ||
| 137 | chtmp = (unsigned char)c; | ||
| 138 | if (chtmp > 0x7f) | ||
| 139 | chflgs = flags & ASN1_STRFLGS_ESC_MSB; | ||
| 140 | else | ||
| 141 | chflgs = char_type[chtmp] & flags; | ||
| 142 | if (chflgs & CHARTYPE_BS_ESC) { | ||
| 143 | /* If we don't escape with quotes, signal we need quotes */ | ||
| 144 | if (chflgs & ASN1_STRFLGS_ESC_QUOTE) { | ||
| 145 | if (do_quotes) | ||
| 146 | *do_quotes = 1; | ||
| 147 | if (!io_ch(arg, &chtmp, 1)) | ||
| 148 | return -1; | ||
| 149 | return 1; | ||
| 150 | } | ||
| 151 | if (!io_ch(arg, "\\", 1)) | ||
| 152 | return -1; | ||
| 153 | if (!io_ch(arg, &chtmp, 1)) | ||
| 154 | return -1; | ||
| 155 | return 2; | ||
| 156 | } | ||
| 157 | if (chflgs & (ASN1_STRFLGS_ESC_CTRL|ASN1_STRFLGS_ESC_MSB)) { | ||
| 158 | snprintf(tmphex, sizeof tmphex, "\\%02X", chtmp); | ||
| 159 | if (!io_ch(arg, tmphex, 3)) | ||
| 160 | return -1; | ||
| 161 | return 3; | ||
| 162 | } | ||
| 163 | /* If we get this far and do any escaping at all must escape | ||
| 164 | * the escape character itself: backslash. | ||
| 165 | */ | ||
| 166 | if (chtmp == '\\' && flags & ESC_FLAGS) { | ||
| 167 | if (!io_ch(arg, "\\\\", 2)) | ||
| 168 | return -1; | ||
| 169 | return 2; | ||
| 170 | } | ||
| 171 | if (!io_ch(arg, &chtmp, 1)) | ||
| 172 | return -1; | ||
| 173 | return 1; | ||
| 174 | } | ||
| 175 | |||
| 176 | #define BUF_TYPE_WIDTH_MASK 0x7 | ||
| 177 | #define BUF_TYPE_CONVUTF8 0x8 | ||
| 178 | |||
| 179 | /* This function sends each character in a buffer to | ||
| 180 | * do_esc_char(). It interprets the content formats | ||
| 181 | * and converts to or from UTF8 as appropriate. | ||
| 182 | */ | ||
| 183 | |||
| 184 | static int | ||
| 185 | do_buf(unsigned char *buf, int buflen, int type, unsigned char flags, | ||
| 186 | char *quotes, char_io *io_ch, void *arg) | ||
| 187 | { | ||
| 188 | int i, outlen, len; | ||
| 189 | unsigned char orflags, *p, *q; | ||
| 190 | unsigned long c; | ||
| 191 | |||
| 192 | p = buf; | ||
| 193 | q = buf + buflen; | ||
| 194 | outlen = 0; | ||
| 195 | while (p != q) { | ||
| 196 | if (p == buf && flags & ASN1_STRFLGS_ESC_2253) | ||
| 197 | orflags = CHARTYPE_FIRST_ESC_2253; | ||
| 198 | else | ||
| 199 | orflags = 0; | ||
| 200 | switch (type & BUF_TYPE_WIDTH_MASK) { | ||
| 201 | case 4: | ||
| 202 | c = ((unsigned long)*p++) << 24; | ||
| 203 | c |= ((unsigned long)*p++) << 16; | ||
| 204 | c |= ((unsigned long)*p++) << 8; | ||
| 205 | c |= *p++; | ||
| 206 | if (c > UNICODE_MAX || UNICODE_IS_SURROGATE(c)) | ||
| 207 | return -1; | ||
| 208 | break; | ||
| 209 | |||
| 210 | case 2: | ||
| 211 | c = ((unsigned long)*p++) << 8; | ||
| 212 | c |= *p++; | ||
| 213 | if (UNICODE_IS_SURROGATE(c)) | ||
| 214 | return -1; | ||
| 215 | break; | ||
| 216 | |||
| 217 | case 1: | ||
| 218 | c = *p++; | ||
| 219 | break; | ||
| 220 | |||
| 221 | case 0: | ||
| 222 | i = UTF8_getc(p, q - p, &c); | ||
| 223 | if (i < 0) | ||
| 224 | return -1; /* Invalid UTF8String */ | ||
| 225 | p += i; | ||
| 226 | break; | ||
| 227 | default: | ||
| 228 | return -1; /* invalid width */ | ||
| 229 | } | ||
| 230 | if (p == q && flags & ASN1_STRFLGS_ESC_2253) | ||
| 231 | orflags = CHARTYPE_LAST_ESC_2253; | ||
| 232 | if (type & BUF_TYPE_CONVUTF8) { | ||
| 233 | unsigned char utfbuf[6]; | ||
| 234 | int utflen; | ||
| 235 | |||
| 236 | utflen = UTF8_putc(utfbuf, sizeof utfbuf, c); | ||
| 237 | if (utflen < 0) | ||
| 238 | return -1; | ||
| 239 | for (i = 0; i < utflen; i++) { | ||
| 240 | /* We don't need to worry about setting orflags correctly | ||
| 241 | * because if utflen==1 its value will be correct anyway | ||
| 242 | * otherwise each character will be > 0x7f and so the | ||
| 243 | * character will never be escaped on first and last. | ||
| 244 | */ | ||
| 245 | len = do_esc_char(utfbuf[i], | ||
| 246 | (unsigned char)(flags | orflags), quotes, | ||
| 247 | io_ch, arg); | ||
| 248 | if (len < 0) | ||
| 249 | return -1; | ||
| 250 | outlen += len; | ||
| 251 | } | ||
| 252 | } else { | ||
| 253 | len = do_esc_char(c, (unsigned char)(flags | orflags), | ||
| 254 | quotes, io_ch, arg); | ||
| 255 | if (len < 0) | ||
| 256 | return -1; | ||
| 257 | outlen += len; | ||
| 258 | } | ||
| 259 | } | ||
| 260 | return outlen; | ||
| 261 | } | ||
| 262 | |||
| 263 | /* This function hex dumps a buffer of characters */ | ||
| 264 | |||
| 265 | static int | ||
| 266 | do_hex_dump(char_io *io_ch, void *arg, unsigned char *buf, int buflen) | ||
| 267 | { | ||
| 268 | static const char hexdig[] = "0123456789ABCDEF"; | ||
| 269 | unsigned char *p, *q; | ||
| 270 | char hextmp[2]; | ||
| 271 | if (arg) { | ||
| 272 | p = buf; | ||
| 273 | q = buf + buflen; | ||
| 274 | while (p != q) { | ||
| 275 | hextmp[0] = hexdig[*p >> 4]; | ||
| 276 | hextmp[1] = hexdig[*p & 0xf]; | ||
| 277 | if (!io_ch(arg, hextmp, 2)) | ||
| 278 | return -1; | ||
| 279 | p++; | ||
| 280 | } | ||
| 281 | } | ||
| 282 | return buflen << 1; | ||
| 283 | } | ||
| 284 | |||
| 285 | /* "dump" a string. This is done when the type is unknown, | ||
| 286 | * or the flags request it. We can either dump the content | ||
| 287 | * octets or the entire DER encoding. This uses the RFC2253 | ||
| 288 | * #01234 format. | ||
| 289 | */ | ||
| 290 | |||
| 291 | static int | ||
| 292 | do_dump(unsigned long lflags, char_io *io_ch, void *arg, ASN1_STRING *str) | ||
| 293 | { | ||
| 294 | /* Placing the ASN1_STRING in a temp ASN1_TYPE allows | ||
| 295 | * the DER encoding to readily obtained | ||
| 296 | */ | ||
| 297 | ASN1_TYPE t; | ||
| 298 | unsigned char *der_buf, *p; | ||
| 299 | int outlen, der_len; | ||
| 300 | |||
| 301 | if (!io_ch(arg, "#", 1)) | ||
| 302 | return -1; | ||
| 303 | /* If we don't dump DER encoding just dump content octets */ | ||
| 304 | if (!(lflags & ASN1_STRFLGS_DUMP_DER)) { | ||
| 305 | outlen = do_hex_dump(io_ch, arg, str->data, str->length); | ||
| 306 | if (outlen < 0) | ||
| 307 | return -1; | ||
| 308 | return outlen + 1; | ||
| 309 | } | ||
| 310 | t.type = str->type; | ||
| 311 | t.value.ptr = (char *)str; | ||
| 312 | der_len = i2d_ASN1_TYPE(&t, NULL); | ||
| 313 | der_buf = malloc(der_len); | ||
| 314 | if (!der_buf) | ||
| 315 | return -1; | ||
| 316 | p = der_buf; | ||
| 317 | i2d_ASN1_TYPE(&t, &p); | ||
| 318 | outlen = do_hex_dump(io_ch, arg, der_buf, der_len); | ||
| 319 | free(der_buf); | ||
| 320 | if (outlen < 0) | ||
| 321 | return -1; | ||
| 322 | return outlen + 1; | ||
| 323 | } | ||
| 324 | |||
| 325 | /* Lookup table to convert tags to character widths, | ||
| 326 | * 0 = UTF8 encoded, -1 is used for non string types | ||
| 327 | * otherwise it is the number of bytes per character | ||
| 328 | */ | ||
| 329 | |||
| 330 | static const signed char tag2nbyte[] = { | ||
| 331 | -1, -1, -1, -1, -1, /* 0-4 */ | ||
| 332 | -1, -1, -1, -1, -1, /* 5-9 */ | ||
| 333 | -1, -1, 0, -1, /* 10-13 */ | ||
| 334 | -1, -1, -1, -1, /* 15-17 */ | ||
| 335 | -1, 1, 1, /* 18-20 */ | ||
| 336 | -1, 1, 1, 1, /* 21-24 */ | ||
| 337 | -1, 1, -1, /* 25-27 */ | ||
| 338 | 4, -1, 2 /* 28-30 */ | ||
| 339 | }; | ||
| 340 | |||
| 341 | /* This is the main function, print out an | ||
| 342 | * ASN1_STRING taking note of various escape | ||
| 343 | * and display options. Returns number of | ||
| 344 | * characters written or -1 if an error | ||
| 345 | * occurred. | ||
| 346 | */ | ||
| 347 | |||
| 348 | static int | ||
| 349 | do_print_ex(char_io *io_ch, void *arg, unsigned long lflags, ASN1_STRING *str) | ||
| 350 | { | ||
| 351 | int outlen, len; | ||
| 352 | int type; | ||
| 353 | char quotes; | ||
| 354 | unsigned char flags; | ||
| 355 | |||
| 356 | quotes = 0; | ||
| 357 | /* Keep a copy of escape flags */ | ||
| 358 | flags = (unsigned char)(lflags & ESC_FLAGS); | ||
| 359 | type = str->type; | ||
| 360 | outlen = 0; | ||
| 361 | |||
| 362 | if (lflags & ASN1_STRFLGS_SHOW_TYPE) { | ||
| 363 | const char *tagname; | ||
| 364 | tagname = ASN1_tag2str(type); | ||
| 365 | outlen += strlen(tagname); | ||
| 366 | if (!io_ch(arg, tagname, outlen) || !io_ch(arg, ":", 1)) | ||
| 367 | return -1; | ||
| 368 | outlen++; | ||
| 369 | } | ||
| 370 | |||
| 371 | /* Decide what to do with type, either dump content or display it */ | ||
| 372 | |||
| 373 | /* Dump everything */ | ||
| 374 | if (lflags & ASN1_STRFLGS_DUMP_ALL) | ||
| 375 | type = -1; | ||
| 376 | /* Ignore the string type */ | ||
| 377 | else if (lflags & ASN1_STRFLGS_IGNORE_TYPE) | ||
| 378 | type = 1; | ||
| 379 | else { | ||
| 380 | /* Else determine width based on type */ | ||
| 381 | if ((type > 0) && (type < 31)) | ||
| 382 | type = tag2nbyte[type]; | ||
| 383 | else | ||
| 384 | type = -1; | ||
| 385 | if ((type == -1) && !(lflags & ASN1_STRFLGS_DUMP_UNKNOWN)) | ||
| 386 | type = 1; | ||
| 387 | } | ||
| 388 | |||
| 389 | if (type == -1) { | ||
| 390 | len = do_dump(lflags, io_ch, arg, str); | ||
| 391 | if (len < 0) | ||
| 392 | return -1; | ||
| 393 | outlen += len; | ||
| 394 | return outlen; | ||
| 395 | } | ||
| 396 | |||
| 397 | if (lflags & ASN1_STRFLGS_UTF8_CONVERT) { | ||
| 398 | /* Note: if string is UTF8 and we want | ||
| 399 | * to convert to UTF8 then we just interpret | ||
| 400 | * it as 1 byte per character to avoid converting | ||
| 401 | * twice. | ||
| 402 | */ | ||
| 403 | if (!type) | ||
| 404 | type = 1; | ||
| 405 | else | ||
| 406 | type |= BUF_TYPE_CONVUTF8; | ||
| 407 | } | ||
| 408 | |||
| 409 | len = do_buf(str->data, str->length, type, flags, "es, io_ch, NULL); | ||
| 410 | if (len < 0) | ||
| 411 | return -1; | ||
| 412 | outlen += len; | ||
| 413 | if (quotes) | ||
| 414 | outlen += 2; | ||
| 415 | if (!arg) | ||
| 416 | return outlen; | ||
| 417 | if (quotes && !io_ch(arg, "\"", 1)) | ||
| 418 | return -1; | ||
| 419 | if (do_buf(str->data, str->length, type, flags, NULL, io_ch, arg) < 0) | ||
| 420 | return -1; | ||
| 421 | if (quotes && !io_ch(arg, "\"", 1)) | ||
| 422 | return -1; | ||
| 423 | return outlen; | ||
| 424 | } | ||
| 425 | |||
| 426 | /* Used for line indenting: print 'indent' spaces */ | ||
| 427 | |||
| 428 | static int | ||
| 429 | do_indent(char_io *io_ch, void *arg, int indent) | ||
| 430 | { | ||
| 431 | int i; | ||
| 432 | for (i = 0; i < indent; i++) | ||
| 433 | if (!io_ch(arg, " ", 1)) | ||
| 434 | return 0; | ||
| 435 | return 1; | ||
| 436 | } | ||
| 437 | |||
| 438 | #define FN_WIDTH_LN 25 | ||
| 439 | #define FN_WIDTH_SN 10 | ||
| 440 | |||
| 441 | static int | ||
| 442 | do_name_ex(char_io *io_ch, void *arg, X509_NAME *n, int indent, | ||
| 443 | unsigned long flags) | ||
| 444 | { | ||
| 445 | int i, prev = -1, orflags, cnt; | ||
| 446 | int fn_opt, fn_nid; | ||
| 447 | ASN1_OBJECT *fn; | ||
| 448 | ASN1_STRING *val; | ||
| 449 | X509_NAME_ENTRY *ent; | ||
| 450 | char objtmp[80]; | ||
| 451 | const char *objbuf; | ||
| 452 | int outlen, len; | ||
| 453 | char *sep_dn, *sep_mv, *sep_eq; | ||
| 454 | int sep_dn_len, sep_mv_len, sep_eq_len; | ||
| 455 | |||
| 456 | if (indent < 0) | ||
| 457 | indent = 0; | ||
| 458 | outlen = indent; | ||
| 459 | if (!do_indent(io_ch, arg, indent)) | ||
| 460 | return -1; | ||
| 461 | |||
| 462 | switch (flags & XN_FLAG_SEP_MASK) { | ||
| 463 | case XN_FLAG_SEP_MULTILINE: | ||
| 464 | sep_dn = "\n"; | ||
| 465 | sep_dn_len = 1; | ||
| 466 | sep_mv = " + "; | ||
| 467 | sep_mv_len = 3; | ||
| 468 | break; | ||
| 469 | |||
| 470 | case XN_FLAG_SEP_COMMA_PLUS: | ||
| 471 | sep_dn = ","; | ||
| 472 | sep_dn_len = 1; | ||
| 473 | sep_mv = "+"; | ||
| 474 | sep_mv_len = 1; | ||
| 475 | indent = 0; | ||
| 476 | break; | ||
| 477 | |||
| 478 | case XN_FLAG_SEP_CPLUS_SPC: | ||
| 479 | sep_dn = ", "; | ||
| 480 | sep_dn_len = 2; | ||
| 481 | sep_mv = " + "; | ||
| 482 | sep_mv_len = 3; | ||
| 483 | indent = 0; | ||
| 484 | break; | ||
| 485 | |||
| 486 | case XN_FLAG_SEP_SPLUS_SPC: | ||
| 487 | sep_dn = "; "; | ||
| 488 | sep_dn_len = 2; | ||
| 489 | sep_mv = " + "; | ||
| 490 | sep_mv_len = 3; | ||
| 491 | indent = 0; | ||
| 492 | break; | ||
| 493 | |||
| 494 | default: | ||
| 495 | return -1; | ||
| 496 | } | ||
| 497 | |||
| 498 | if (flags & XN_FLAG_SPC_EQ) { | ||
| 499 | sep_eq = " = "; | ||
| 500 | sep_eq_len = 3; | ||
| 501 | } else { | ||
| 502 | sep_eq = "="; | ||
| 503 | sep_eq_len = 1; | ||
| 504 | } | ||
| 505 | |||
| 506 | fn_opt = flags & XN_FLAG_FN_MASK; | ||
| 507 | |||
| 508 | cnt = X509_NAME_entry_count(n); | ||
| 509 | for (i = 0; i < cnt; i++) { | ||
| 510 | if (flags & XN_FLAG_DN_REV) | ||
| 511 | ent = X509_NAME_get_entry(n, cnt - i - 1); | ||
| 512 | else | ||
| 513 | ent = X509_NAME_get_entry(n, i); | ||
| 514 | if (prev != -1) { | ||
| 515 | if (prev == ent->set) { | ||
| 516 | if (!io_ch(arg, sep_mv, sep_mv_len)) | ||
| 517 | return -1; | ||
| 518 | outlen += sep_mv_len; | ||
| 519 | } else { | ||
| 520 | if (!io_ch(arg, sep_dn, sep_dn_len)) | ||
| 521 | return -1; | ||
| 522 | outlen += sep_dn_len; | ||
| 523 | if (!do_indent(io_ch, arg, indent)) | ||
| 524 | return -1; | ||
| 525 | outlen += indent; | ||
| 526 | } | ||
| 527 | } | ||
| 528 | prev = ent->set; | ||
| 529 | fn = X509_NAME_ENTRY_get_object(ent); | ||
| 530 | val = X509_NAME_ENTRY_get_data(ent); | ||
| 531 | fn_nid = OBJ_obj2nid(fn); | ||
| 532 | if (fn_opt != XN_FLAG_FN_NONE) { | ||
| 533 | int objlen, fld_len; | ||
| 534 | if ((fn_opt == XN_FLAG_FN_OID) || | ||
| 535 | (fn_nid == NID_undef)) { | ||
| 536 | OBJ_obj2txt(objtmp, sizeof objtmp, fn, 1); | ||
| 537 | fld_len = 0; /* XXX: what should this be? */ | ||
| 538 | objbuf = objtmp; | ||
| 539 | } else { | ||
| 540 | if (fn_opt == XN_FLAG_FN_SN) { | ||
| 541 | fld_len = FN_WIDTH_SN; | ||
| 542 | objbuf = OBJ_nid2sn(fn_nid); | ||
| 543 | } else if (fn_opt == XN_FLAG_FN_LN) { | ||
| 544 | fld_len = FN_WIDTH_LN; | ||
| 545 | objbuf = OBJ_nid2ln(fn_nid); | ||
| 546 | } else { | ||
| 547 | fld_len = 0; /* XXX: what should this be? */ | ||
| 548 | objbuf = ""; | ||
| 549 | } | ||
| 550 | } | ||
| 551 | objlen = strlen(objbuf); | ||
| 552 | if (!io_ch(arg, objbuf, objlen)) | ||
| 553 | return -1; | ||
| 554 | if ((objlen < fld_len) && (flags & XN_FLAG_FN_ALIGN)) { | ||
| 555 | if (!do_indent(io_ch, arg, fld_len - objlen)) | ||
| 556 | return -1; | ||
| 557 | outlen += fld_len - objlen; | ||
| 558 | } | ||
| 559 | if (!io_ch(arg, sep_eq, sep_eq_len)) | ||
| 560 | return -1; | ||
| 561 | outlen += objlen + sep_eq_len; | ||
| 562 | } | ||
| 563 | /* If the field name is unknown then fix up the DER dump | ||
| 564 | * flag. We might want to limit this further so it will | ||
| 565 | * DER dump on anything other than a few 'standard' fields. | ||
| 566 | */ | ||
| 567 | if ((fn_nid == NID_undef) && | ||
| 568 | (flags & XN_FLAG_DUMP_UNKNOWN_FIELDS)) | ||
| 569 | orflags = ASN1_STRFLGS_DUMP_ALL; | ||
| 570 | else | ||
| 571 | orflags = 0; | ||
| 572 | |||
| 573 | len = do_print_ex(io_ch, arg, flags | orflags, val); | ||
| 574 | if (len < 0) | ||
| 575 | return -1; | ||
| 576 | outlen += len; | ||
| 577 | } | ||
| 578 | return outlen; | ||
| 579 | } | ||
| 580 | |||
| 581 | /* Wrappers round the main functions */ | ||
| 582 | |||
| 583 | int | ||
| 584 | X509_NAME_print_ex(BIO *out, X509_NAME *nm, int indent, unsigned long flags) | ||
| 585 | { | ||
| 586 | if (flags == XN_FLAG_COMPAT) | ||
| 587 | return X509_NAME_print(out, nm, indent); | ||
| 588 | return do_name_ex(send_bio_chars, out, nm, indent, flags); | ||
| 589 | } | ||
| 590 | |||
| 591 | int | ||
| 592 | X509_NAME_print_ex_fp(FILE *fp, X509_NAME *nm, int indent, unsigned long flags) | ||
| 593 | { | ||
| 594 | if (flags == XN_FLAG_COMPAT) { | ||
| 595 | BIO *btmp; | ||
| 596 | int ret; | ||
| 597 | btmp = BIO_new_fp(fp, BIO_NOCLOSE); | ||
| 598 | if (!btmp) | ||
| 599 | return -1; | ||
| 600 | ret = X509_NAME_print(btmp, nm, indent); | ||
| 601 | BIO_free(btmp); | ||
| 602 | return ret; | ||
| 603 | } | ||
| 604 | return do_name_ex(send_fp_chars, fp, nm, indent, flags); | ||
| 605 | } | ||
| 606 | |||
| 607 | int | ||
| 608 | ASN1_STRING_print_ex(BIO *out, ASN1_STRING *str, unsigned long flags) | ||
| 609 | { | ||
| 610 | return do_print_ex(send_bio_chars, out, flags, str); | ||
| 611 | } | ||
| 612 | |||
| 613 | int | ||
| 614 | ASN1_STRING_print_ex_fp(FILE *fp, ASN1_STRING *str, unsigned long flags) | ||
| 615 | { | ||
| 616 | return do_print_ex(send_fp_chars, fp, flags, str); | ||
| 617 | } | ||
| 618 | |||
| 619 | /* Utility function: convert any string type to UTF8, returns number of bytes | ||
| 620 | * in output string or a negative error code | ||
| 621 | */ | ||
| 622 | |||
| 623 | int | ||
| 624 | ASN1_STRING_to_UTF8(unsigned char **out, ASN1_STRING *in) | ||
| 625 | { | ||
| 626 | ASN1_STRING stmp, *str = &stmp; | ||
| 627 | int mbflag, type, ret; | ||
| 628 | |||
| 629 | if (!in) | ||
| 630 | return -1; | ||
| 631 | type = in->type; | ||
| 632 | if ((type < 0) || (type > 30)) | ||
| 633 | return -1; | ||
| 634 | mbflag = tag2nbyte[type]; | ||
| 635 | if (mbflag == -1) | ||
| 636 | return -1; | ||
| 637 | mbflag |= MBSTRING_FLAG; | ||
| 638 | stmp.data = NULL; | ||
| 639 | stmp.length = 0; | ||
| 640 | ret = ASN1_mbstring_copy(&str, in->data, in->length, mbflag, | ||
| 641 | B_ASN1_UTF8STRING); | ||
| 642 | if (ret < 0) | ||
| 643 | return ret; | ||
| 644 | *out = stmp.data; | ||
| 645 | return stmp.length; | ||
| 646 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_strnid.c b/src/lib/libcrypto/asn1/a_strnid.c deleted file mode 100644 index 0744ffb228..0000000000 --- a/src/lib/libcrypto/asn1/a_strnid.c +++ /dev/null | |||
| @@ -1,292 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_strnid.c,v 1.19 2015/02/10 11:22:21 jsing Exp $ */ | ||
| 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 | #include <ctype.h> | ||
| 60 | #include <stdio.h> | ||
| 61 | #include <string.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/objects.h> | ||
| 66 | |||
| 67 | static STACK_OF(ASN1_STRING_TABLE) *stable = NULL; | ||
| 68 | static void st_free(ASN1_STRING_TABLE *tbl); | ||
| 69 | static int sk_table_cmp(const ASN1_STRING_TABLE * const *a, | ||
| 70 | const ASN1_STRING_TABLE * const *b); | ||
| 71 | |||
| 72 | |||
| 73 | /* This is the global mask for the mbstring functions: this is use to | ||
| 74 | * mask out certain types (such as BMPString and UTF8String) because | ||
| 75 | * certain software (e.g. Netscape) has problems with them. | ||
| 76 | */ | ||
| 77 | |||
| 78 | static unsigned long global_mask = B_ASN1_UTF8STRING; | ||
| 79 | |||
| 80 | void | ||
| 81 | ASN1_STRING_set_default_mask(unsigned long mask) | ||
| 82 | { | ||
| 83 | global_mask = mask; | ||
| 84 | } | ||
| 85 | |||
| 86 | unsigned long | ||
| 87 | ASN1_STRING_get_default_mask(void) | ||
| 88 | { | ||
| 89 | return global_mask; | ||
| 90 | } | ||
| 91 | |||
| 92 | /* This function sets the default to various "flavours" of configuration. | ||
| 93 | * based on an ASCII string. Currently this is: | ||
| 94 | * MASK:XXXX : a numerical mask value. | ||
| 95 | * nobmp : Don't use BMPStrings (just Printable, T61). | ||
| 96 | * pkix : PKIX recommendation in RFC2459. | ||
| 97 | * utf8only : only use UTF8Strings (RFC2459 recommendation for 2004). | ||
| 98 | * default: the default value, Printable, T61, BMP. | ||
| 99 | */ | ||
| 100 | |||
| 101 | int | ||
| 102 | ASN1_STRING_set_default_mask_asc(const char *p) | ||
| 103 | { | ||
| 104 | unsigned long mask; | ||
| 105 | char *end; | ||
| 106 | |||
| 107 | if (!strncmp(p, "MASK:", 5)) { | ||
| 108 | if (!p[5]) | ||
| 109 | return 0; | ||
| 110 | mask = strtoul(p + 5, &end, 0); | ||
| 111 | if (*end) | ||
| 112 | return 0; | ||
| 113 | } else if (!strcmp(p, "nombstr")) | ||
| 114 | mask = ~((unsigned long)(B_ASN1_BMPSTRING|B_ASN1_UTF8STRING)); | ||
| 115 | else if (!strcmp(p, "pkix")) | ||
| 116 | mask = ~((unsigned long)B_ASN1_T61STRING); | ||
| 117 | else if (!strcmp(p, "utf8only")) | ||
| 118 | mask = B_ASN1_UTF8STRING; | ||
| 119 | else if (!strcmp(p, "default")) | ||
| 120 | mask = 0xFFFFFFFFL; | ||
| 121 | else | ||
| 122 | return 0; | ||
| 123 | ASN1_STRING_set_default_mask(mask); | ||
| 124 | return 1; | ||
| 125 | } | ||
| 126 | |||
| 127 | /* The following function generates an ASN1_STRING based on limits in a table. | ||
| 128 | * Frequently the types and length of an ASN1_STRING are restricted by a | ||
| 129 | * corresponding OID. For example certificates and certificate requests. | ||
| 130 | */ | ||
| 131 | |||
| 132 | ASN1_STRING * | ||
| 133 | ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in, int inlen, | ||
| 134 | int inform, int nid) | ||
| 135 | { | ||
| 136 | ASN1_STRING_TABLE *tbl; | ||
| 137 | ASN1_STRING *str = NULL; | ||
| 138 | unsigned long mask; | ||
| 139 | int ret; | ||
| 140 | if (!out) | ||
| 141 | out = &str; | ||
| 142 | tbl = ASN1_STRING_TABLE_get(nid); | ||
| 143 | if (tbl) { | ||
| 144 | mask = tbl->mask; | ||
| 145 | if (!(tbl->flags & STABLE_NO_MASK)) | ||
| 146 | mask &= global_mask; | ||
| 147 | ret = ASN1_mbstring_ncopy(out, in, inlen, inform, mask, | ||
| 148 | tbl->minsize, tbl->maxsize); | ||
| 149 | } else | ||
| 150 | ret = ASN1_mbstring_copy(out, in, inlen, inform, | ||
| 151 | DIRSTRING_TYPE & global_mask); | ||
| 152 | if (ret <= 0) | ||
| 153 | return NULL; | ||
| 154 | return *out; | ||
| 155 | } | ||
| 156 | |||
| 157 | /* Now the tables and helper functions for the string table: | ||
| 158 | */ | ||
| 159 | |||
| 160 | /* size limits: this stuff is taken straight from RFC3280 */ | ||
| 161 | |||
| 162 | #define ub_name 32768 | ||
| 163 | #define ub_common_name 64 | ||
| 164 | #define ub_locality_name 128 | ||
| 165 | #define ub_state_name 128 | ||
| 166 | #define ub_organization_name 64 | ||
| 167 | #define ub_organization_unit_name 64 | ||
| 168 | #define ub_title 64 | ||
| 169 | #define ub_email_address 128 | ||
| 170 | #define ub_serial_number 64 | ||
| 171 | |||
| 172 | |||
| 173 | /* This table must be kept in NID order */ | ||
| 174 | |||
| 175 | static const ASN1_STRING_TABLE tbl_standard[] = { | ||
| 176 | {NID_commonName, 1, ub_common_name, DIRSTRING_TYPE, 0}, | ||
| 177 | {NID_countryName, 2, 2, B_ASN1_PRINTABLESTRING, STABLE_NO_MASK}, | ||
| 178 | {NID_localityName, 1, ub_locality_name, DIRSTRING_TYPE, 0}, | ||
| 179 | {NID_stateOrProvinceName, 1, ub_state_name, DIRSTRING_TYPE, 0}, | ||
| 180 | {NID_organizationName, 1, ub_organization_name, DIRSTRING_TYPE, 0}, | ||
| 181 | {NID_organizationalUnitName, 1, ub_organization_unit_name, DIRSTRING_TYPE, 0}, | ||
| 182 | {NID_pkcs9_emailAddress, 1, ub_email_address, B_ASN1_IA5STRING, STABLE_NO_MASK}, | ||
| 183 | {NID_pkcs9_unstructuredName, 1, -1, PKCS9STRING_TYPE, 0}, | ||
| 184 | {NID_pkcs9_challengePassword, 1, -1, PKCS9STRING_TYPE, 0}, | ||
| 185 | {NID_pkcs9_unstructuredAddress, 1, -1, DIRSTRING_TYPE, 0}, | ||
| 186 | {NID_givenName, 1, ub_name, DIRSTRING_TYPE, 0}, | ||
| 187 | {NID_surname, 1, ub_name, DIRSTRING_TYPE, 0}, | ||
| 188 | {NID_initials, 1, ub_name, DIRSTRING_TYPE, 0}, | ||
| 189 | {NID_serialNumber, 1, ub_serial_number, B_ASN1_PRINTABLESTRING, STABLE_NO_MASK}, | ||
| 190 | {NID_friendlyName, -1, -1, B_ASN1_BMPSTRING, STABLE_NO_MASK}, | ||
| 191 | {NID_name, 1, ub_name, DIRSTRING_TYPE, 0}, | ||
| 192 | {NID_dnQualifier, -1, -1, B_ASN1_PRINTABLESTRING, STABLE_NO_MASK}, | ||
| 193 | {NID_domainComponent, 1, -1, B_ASN1_IA5STRING, STABLE_NO_MASK}, | ||
| 194 | {NID_ms_csp_name, -1, -1, B_ASN1_BMPSTRING, STABLE_NO_MASK} | ||
| 195 | }; | ||
| 196 | |||
| 197 | static int | ||
| 198 | sk_table_cmp(const ASN1_STRING_TABLE * const *a, | ||
| 199 | const ASN1_STRING_TABLE * const *b) | ||
| 200 | { | ||
| 201 | return (*a)->nid - (*b)->nid; | ||
| 202 | } | ||
| 203 | |||
| 204 | DECLARE_OBJ_BSEARCH_CMP_FN(ASN1_STRING_TABLE, ASN1_STRING_TABLE, table); | ||
| 205 | |||
| 206 | static int | ||
| 207 | table_cmp(const ASN1_STRING_TABLE *a, const ASN1_STRING_TABLE *b) | ||
| 208 | { | ||
| 209 | return a->nid - b->nid; | ||
| 210 | } | ||
| 211 | |||
| 212 | IMPLEMENT_OBJ_BSEARCH_CMP_FN(ASN1_STRING_TABLE, ASN1_STRING_TABLE, table); | ||
| 213 | |||
| 214 | ASN1_STRING_TABLE * | ||
| 215 | ASN1_STRING_TABLE_get(int nid) | ||
| 216 | { | ||
| 217 | int idx; | ||
| 218 | ASN1_STRING_TABLE *ttmp; | ||
| 219 | ASN1_STRING_TABLE fnd; | ||
| 220 | |||
| 221 | fnd.nid = nid; | ||
| 222 | ttmp = OBJ_bsearch_table(&fnd, tbl_standard, | ||
| 223 | sizeof(tbl_standard)/sizeof(ASN1_STRING_TABLE)); | ||
| 224 | if (ttmp) | ||
| 225 | return ttmp; | ||
| 226 | if (!stable) | ||
| 227 | return NULL; | ||
| 228 | idx = sk_ASN1_STRING_TABLE_find(stable, &fnd); | ||
| 229 | if (idx < 0) | ||
| 230 | return NULL; | ||
| 231 | return sk_ASN1_STRING_TABLE_value(stable, idx); | ||
| 232 | } | ||
| 233 | |||
| 234 | int | ||
| 235 | ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize, unsigned long mask, | ||
| 236 | unsigned long flags) | ||
| 237 | { | ||
| 238 | ASN1_STRING_TABLE *tmp; | ||
| 239 | char new_nid = 0; | ||
| 240 | |||
| 241 | flags &= ~STABLE_FLAGS_MALLOC; | ||
| 242 | if (!stable) | ||
| 243 | stable = sk_ASN1_STRING_TABLE_new(sk_table_cmp); | ||
| 244 | if (!stable) { | ||
| 245 | ASN1err(ASN1_F_ASN1_STRING_TABLE_ADD, ERR_R_MALLOC_FAILURE); | ||
| 246 | return 0; | ||
| 247 | } | ||
| 248 | if (!(tmp = ASN1_STRING_TABLE_get(nid))) { | ||
| 249 | tmp = malloc(sizeof(ASN1_STRING_TABLE)); | ||
| 250 | if (!tmp) { | ||
| 251 | ASN1err(ASN1_F_ASN1_STRING_TABLE_ADD, | ||
| 252 | ERR_R_MALLOC_FAILURE); | ||
| 253 | return 0; | ||
| 254 | } | ||
| 255 | tmp->flags = flags | STABLE_FLAGS_MALLOC; | ||
| 256 | tmp->nid = nid; | ||
| 257 | new_nid = 1; | ||
| 258 | } else tmp->flags = (tmp->flags & STABLE_FLAGS_MALLOC) | flags; | ||
| 259 | if (minsize != -1) | ||
| 260 | tmp->minsize = minsize; | ||
| 261 | if (maxsize != -1) | ||
| 262 | tmp->maxsize = maxsize; | ||
| 263 | tmp->mask = mask; | ||
| 264 | if (new_nid) { | ||
| 265 | if (sk_ASN1_STRING_TABLE_push(stable, tmp) == 0) { | ||
| 266 | free(tmp); | ||
| 267 | ASN1err(ASN1_F_ASN1_STRING_TABLE_ADD, | ||
| 268 | ERR_R_MALLOC_FAILURE); | ||
| 269 | return 0; | ||
| 270 | } | ||
| 271 | } | ||
| 272 | return 1; | ||
| 273 | } | ||
| 274 | |||
| 275 | void | ||
| 276 | ASN1_STRING_TABLE_cleanup(void) | ||
| 277 | { | ||
| 278 | STACK_OF(ASN1_STRING_TABLE) *tmp; | ||
| 279 | |||
| 280 | tmp = stable; | ||
| 281 | if (!tmp) | ||
| 282 | return; | ||
| 283 | stable = NULL; | ||
| 284 | sk_ASN1_STRING_TABLE_pop_free(tmp, st_free); | ||
| 285 | } | ||
| 286 | |||
| 287 | static void | ||
| 288 | st_free(ASN1_STRING_TABLE *tbl) | ||
| 289 | { | ||
| 290 | if (tbl->flags & STABLE_FLAGS_MALLOC) | ||
| 291 | free(tbl); | ||
| 292 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_time.c b/src/lib/libcrypto/asn1/a_time.c deleted file mode 100644 index f51a8b1fbe..0000000000 --- a/src/lib/libcrypto/asn1/a_time.c +++ /dev/null | |||
| @@ -1,225 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_time.c,v 1.24 2015/07/24 13:49:58 jsing Exp $ */ | ||
| 2 | /* ==================================================================== | ||
| 3 | * Copyright (c) 1999 The OpenSSL Project. All rights reserved. | ||
| 4 | * | ||
| 5 | * Redistribution and use in source and binary forms, with or without | ||
| 6 | * modification, are permitted provided that the following conditions | ||
| 7 | * are met: | ||
| 8 | * | ||
| 9 | * 1. Redistributions of source code must retain the above copyright | ||
| 10 | * notice, this list of conditions and the following disclaimer. | ||
| 11 | * | ||
| 12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer in | ||
| 14 | * the documentation and/or other materials provided with the | ||
| 15 | * distribution. | ||
| 16 | * | ||
| 17 | * 3. All advertising materials mentioning features or use of this | ||
| 18 | * software must display the following acknowledgment: | ||
| 19 | * "This product includes software developed by the OpenSSL Project | ||
| 20 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 21 | * | ||
| 22 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 23 | * endorse or promote products derived from this software without | ||
| 24 | * prior written permission. For written permission, please contact | ||
| 25 | * licensing@OpenSSL.org. | ||
| 26 | * | ||
| 27 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 28 | * nor may "OpenSSL" appear in their names without prior written | ||
| 29 | * permission of the OpenSSL Project. | ||
| 30 | * | ||
| 31 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 32 | * acknowledgment: | ||
| 33 | * "This product includes software developed by the OpenSSL Project | ||
| 34 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 35 | * | ||
| 36 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 37 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 38 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 39 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 40 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 41 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 42 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 43 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 44 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 45 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 46 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 47 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 48 | * ==================================================================== | ||
| 49 | * | ||
| 50 | * This product includes cryptographic software written by Eric Young | ||
| 51 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 52 | * Hudson (tjh@cryptsoft.com). | ||
| 53 | * | ||
| 54 | */ | ||
| 55 | |||
| 56 | /* This is an implementation of the ASN1 Time structure which is: | ||
| 57 | * Time ::= CHOICE { | ||
| 58 | * utcTime UTCTime, | ||
| 59 | * generalTime GeneralizedTime } | ||
| 60 | * written by Steve Henson. | ||
| 61 | */ | ||
| 62 | |||
| 63 | #include <stdio.h> | ||
| 64 | #include <string.h> | ||
| 65 | #include <time.h> | ||
| 66 | |||
| 67 | #include <openssl/asn1t.h> | ||
| 68 | #include <openssl/err.h> | ||
| 69 | |||
| 70 | #include "o_time.h" | ||
| 71 | |||
| 72 | |||
| 73 | const ASN1_ITEM ASN1_TIME_it = { | ||
| 74 | .itype = ASN1_ITYPE_MSTRING, | ||
| 75 | .utype = B_ASN1_TIME, | ||
| 76 | .templates = NULL, | ||
| 77 | .tcount = 0, | ||
| 78 | .funcs = NULL, | ||
| 79 | .size = sizeof(ASN1_STRING), | ||
| 80 | .sname = "ASN1_TIME", | ||
| 81 | }; | ||
| 82 | |||
| 83 | |||
| 84 | ASN1_TIME * | ||
| 85 | d2i_ASN1_TIME(ASN1_TIME **a, const unsigned char **in, long len) | ||
| 86 | { | ||
| 87 | return (ASN1_TIME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 88 | &ASN1_TIME_it); | ||
| 89 | } | ||
| 90 | |||
| 91 | int | ||
| 92 | i2d_ASN1_TIME(ASN1_TIME *a, unsigned char **out) | ||
| 93 | { | ||
| 94 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_TIME_it); | ||
| 95 | } | ||
| 96 | |||
| 97 | ASN1_TIME * | ||
| 98 | ASN1_TIME_new(void) | ||
| 99 | { | ||
| 100 | return (ASN1_TIME *)ASN1_item_new(&ASN1_TIME_it); | ||
| 101 | } | ||
| 102 | |||
| 103 | void | ||
| 104 | ASN1_TIME_free(ASN1_TIME *a) | ||
| 105 | { | ||
| 106 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_TIME_it); | ||
| 107 | } | ||
| 108 | |||
| 109 | ASN1_TIME * | ||
| 110 | ASN1_TIME_set(ASN1_TIME *s, time_t t) | ||
| 111 | { | ||
| 112 | return ASN1_TIME_adj(s, t, 0, 0); | ||
| 113 | } | ||
| 114 | |||
| 115 | ASN1_TIME * | ||
| 116 | ASN1_TIME_adj(ASN1_TIME *s, time_t t, int offset_day, long offset_sec) | ||
| 117 | { | ||
| 118 | struct tm *ts; | ||
| 119 | struct tm data; | ||
| 120 | |||
| 121 | ts = gmtime_r(&t, &data); | ||
| 122 | if (ts == NULL) { | ||
| 123 | ASN1err(ASN1_F_ASN1_TIME_ADJ, ASN1_R_ERROR_GETTING_TIME); | ||
| 124 | return NULL; | ||
| 125 | } | ||
| 126 | if (offset_day || offset_sec) { | ||
| 127 | if (!OPENSSL_gmtime_adj(ts, offset_day, offset_sec)) | ||
| 128 | return NULL; | ||
| 129 | } | ||
| 130 | if ((ts->tm_year >= 50) && (ts->tm_year < 150)) | ||
| 131 | return ASN1_UTCTIME_adj(s, t, offset_day, offset_sec); | ||
| 132 | return ASN1_GENERALIZEDTIME_adj(s, t, offset_day, offset_sec); | ||
| 133 | } | ||
| 134 | |||
| 135 | int | ||
| 136 | ASN1_TIME_check(ASN1_TIME *t) | ||
| 137 | { | ||
| 138 | if (t->type == V_ASN1_GENERALIZEDTIME) | ||
| 139 | return ASN1_GENERALIZEDTIME_check(t); | ||
| 140 | else if (t->type == V_ASN1_UTCTIME) | ||
| 141 | return ASN1_UTCTIME_check(t); | ||
| 142 | return 0; | ||
| 143 | } | ||
| 144 | |||
| 145 | /* Convert an ASN1_TIME structure to GeneralizedTime */ | ||
| 146 | static ASN1_GENERALIZEDTIME * | ||
| 147 | ASN1_TIME_to_generalizedtime_internal(ASN1_TIME *t, ASN1_GENERALIZEDTIME **out) | ||
| 148 | { | ||
| 149 | ASN1_GENERALIZEDTIME *ret; | ||
| 150 | char *str; | ||
| 151 | int newlen; | ||
| 152 | int i; | ||
| 153 | |||
| 154 | if (!ASN1_TIME_check(t)) | ||
| 155 | return NULL; | ||
| 156 | |||
| 157 | ret = *out; | ||
| 158 | |||
| 159 | /* If already GeneralizedTime just copy across */ | ||
| 160 | if (t->type == V_ASN1_GENERALIZEDTIME) { | ||
| 161 | if (!ASN1_STRING_set(ret, t->data, t->length)) | ||
| 162 | return NULL; | ||
| 163 | return ret; | ||
| 164 | } | ||
| 165 | |||
| 166 | /* grow the string */ | ||
| 167 | if (!ASN1_STRING_set(ret, NULL, t->length + 2)) | ||
| 168 | return NULL; | ||
| 169 | /* ASN1_STRING_set() allocated 'len + 1' bytes. */ | ||
| 170 | newlen = t->length + 2 + 1; | ||
| 171 | str = (char *)ret->data; | ||
| 172 | /* XXX ASN1_TIME is not Y2050 compatible */ | ||
| 173 | i = snprintf(str, newlen, "%s%s", (t->data[0] >= '5') ? "19" : "20", | ||
| 174 | (char *) t->data); | ||
| 175 | if (i == -1 || i >= newlen) { | ||
| 176 | M_ASN1_GENERALIZEDTIME_free(ret); | ||
| 177 | *out = NULL; | ||
| 178 | return NULL; | ||
| 179 | } | ||
| 180 | return ret; | ||
| 181 | } | ||
| 182 | |||
| 183 | ASN1_GENERALIZEDTIME * | ||
| 184 | ASN1_TIME_to_generalizedtime(ASN1_TIME *t, ASN1_GENERALIZEDTIME **out) | ||
| 185 | { | ||
| 186 | ASN1_GENERALIZEDTIME *tmp = NULL, *ret; | ||
| 187 | |||
| 188 | if (!out || !*out) { | ||
| 189 | if (!(tmp = ASN1_GENERALIZEDTIME_new())) | ||
| 190 | return NULL; | ||
| 191 | if (out != NULL) | ||
| 192 | *out = tmp; | ||
| 193 | else | ||
| 194 | out = &tmp; | ||
| 195 | } | ||
| 196 | |||
| 197 | ret = ASN1_TIME_to_generalizedtime_internal(t, out); | ||
| 198 | if (ret == NULL && tmp != NULL) | ||
| 199 | ASN1_GENERALIZEDTIME_free(tmp); | ||
| 200 | |||
| 201 | return ret; | ||
| 202 | } | ||
| 203 | |||
| 204 | int | ||
| 205 | ASN1_TIME_set_string(ASN1_TIME *s, const char *str) | ||
| 206 | { | ||
| 207 | ASN1_TIME t; | ||
| 208 | |||
| 209 | t.length = strlen(str); | ||
| 210 | t.data = (unsigned char *)str; | ||
| 211 | t.flags = 0; | ||
| 212 | |||
| 213 | t.type = V_ASN1_UTCTIME; | ||
| 214 | |||
| 215 | if (!ASN1_TIME_check(&t)) { | ||
| 216 | t.type = V_ASN1_GENERALIZEDTIME; | ||
| 217 | if (!ASN1_TIME_check(&t)) | ||
| 218 | return 0; | ||
| 219 | } | ||
| 220 | |||
| 221 | if (s && !ASN1_STRING_copy((ASN1_STRING *)s, (ASN1_STRING *)&t)) | ||
| 222 | return 0; | ||
| 223 | |||
| 224 | return 1; | ||
| 225 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_type.c b/src/lib/libcrypto/asn1/a_type.c deleted file mode 100644 index 38b3c65beb..0000000000 --- a/src/lib/libcrypto/asn1/a_type.c +++ /dev/null | |||
| @@ -1,158 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_type.c,v 1.16 2015/03/19 14:00:22 tedu Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/objects.h> | ||
| 63 | |||
| 64 | int | ||
| 65 | ASN1_TYPE_get(ASN1_TYPE *a) | ||
| 66 | { | ||
| 67 | if ((a->value.ptr != NULL) || (a->type == V_ASN1_NULL)) | ||
| 68 | return (a->type); | ||
| 69 | else | ||
| 70 | return (0); | ||
| 71 | } | ||
| 72 | |||
| 73 | void | ||
| 74 | ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value) | ||
| 75 | { | ||
| 76 | if (a->value.ptr != NULL) { | ||
| 77 | ASN1_TYPE **tmp_a = &a; | ||
| 78 | ASN1_primitive_free((ASN1_VALUE **)tmp_a, NULL); | ||
| 79 | } | ||
| 80 | a->type = type; | ||
| 81 | if (type == V_ASN1_BOOLEAN) | ||
| 82 | a->value.boolean = value ? 0xff : 0; | ||
| 83 | else | ||
| 84 | a->value.ptr = value; | ||
| 85 | } | ||
| 86 | |||
| 87 | int | ||
| 88 | ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value) | ||
| 89 | { | ||
| 90 | if (!value || (type == V_ASN1_BOOLEAN)) { | ||
| 91 | void *p = (void *)value; | ||
| 92 | ASN1_TYPE_set(a, type, p); | ||
| 93 | } else if (type == V_ASN1_OBJECT) { | ||
| 94 | ASN1_OBJECT *odup; | ||
| 95 | odup = OBJ_dup(value); | ||
| 96 | if (!odup) | ||
| 97 | return 0; | ||
| 98 | ASN1_TYPE_set(a, type, odup); | ||
| 99 | } else { | ||
| 100 | ASN1_STRING *sdup; | ||
| 101 | sdup = ASN1_STRING_dup(value); | ||
| 102 | if (!sdup) | ||
| 103 | return 0; | ||
| 104 | ASN1_TYPE_set(a, type, sdup); | ||
| 105 | } | ||
| 106 | return 1; | ||
| 107 | } | ||
| 108 | |||
| 109 | /* Returns 0 if they are equal, != 0 otherwise. */ | ||
| 110 | int | ||
| 111 | ASN1_TYPE_cmp(ASN1_TYPE *a, ASN1_TYPE *b) | ||
| 112 | { | ||
| 113 | int result = -1; | ||
| 114 | |||
| 115 | if (!a || !b || a->type != b->type) | ||
| 116 | return -1; | ||
| 117 | |||
| 118 | switch (a->type) { | ||
| 119 | case V_ASN1_OBJECT: | ||
| 120 | result = OBJ_cmp(a->value.object, b->value.object); | ||
| 121 | break; | ||
| 122 | case V_ASN1_BOOLEAN: | ||
| 123 | result = a->value.boolean - b->value.boolean; | ||
| 124 | break; | ||
| 125 | case V_ASN1_NULL: | ||
| 126 | result = 0; /* They do not have content. */ | ||
| 127 | break; | ||
| 128 | |||
| 129 | case V_ASN1_INTEGER: | ||
| 130 | case V_ASN1_NEG_INTEGER: | ||
| 131 | case V_ASN1_ENUMERATED: | ||
| 132 | case V_ASN1_NEG_ENUMERATED: | ||
| 133 | case V_ASN1_BIT_STRING: | ||
| 134 | case V_ASN1_OCTET_STRING: | ||
| 135 | case V_ASN1_SEQUENCE: | ||
| 136 | case V_ASN1_SET: | ||
| 137 | case V_ASN1_NUMERICSTRING: | ||
| 138 | case V_ASN1_PRINTABLESTRING: | ||
| 139 | case V_ASN1_T61STRING: | ||
| 140 | case V_ASN1_VIDEOTEXSTRING: | ||
| 141 | case V_ASN1_IA5STRING: | ||
| 142 | case V_ASN1_UTCTIME: | ||
| 143 | case V_ASN1_GENERALIZEDTIME: | ||
| 144 | case V_ASN1_GRAPHICSTRING: | ||
| 145 | case V_ASN1_VISIBLESTRING: | ||
| 146 | case V_ASN1_GENERALSTRING: | ||
| 147 | case V_ASN1_UNIVERSALSTRING: | ||
| 148 | case V_ASN1_BMPSTRING: | ||
| 149 | case V_ASN1_UTF8STRING: | ||
| 150 | case V_ASN1_OTHER: | ||
| 151 | default: | ||
| 152 | result = ASN1_STRING_cmp((ASN1_STRING *)a->value.ptr, | ||
| 153 | (ASN1_STRING *)b->value.ptr); | ||
| 154 | break; | ||
| 155 | } | ||
| 156 | |||
| 157 | return result; | ||
| 158 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_utf8.c b/src/lib/libcrypto/asn1/a_utf8.c deleted file mode 100644 index 113a3a2e36..0000000000 --- a/src/lib/libcrypto/asn1/a_utf8.c +++ /dev/null | |||
| @@ -1,199 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_utf8.c,v 1.8 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | |||
| 63 | #include "asn1_locl.h" | ||
| 64 | |||
| 65 | /* UTF8 utilities */ | ||
| 66 | |||
| 67 | /* | ||
| 68 | * This parses a UTF8 string one character at a time. It is passed a pointer | ||
| 69 | * to the string and the length of the string. It sets 'value' to the value of | ||
| 70 | * the current character. It returns the number of characters read or a | ||
| 71 | * negative error code: | ||
| 72 | * -1 = string too short | ||
| 73 | * -2 = illegal character | ||
| 74 | * -3 = subsequent characters not of the form 10xxxxxx | ||
| 75 | * -4 = character encoded incorrectly (not minimal length). | ||
| 76 | */ | ||
| 77 | |||
| 78 | int | ||
| 79 | UTF8_getc(const unsigned char *str, int len, unsigned long *val) | ||
| 80 | { | ||
| 81 | const unsigned char *p; | ||
| 82 | unsigned long value; | ||
| 83 | int ret; | ||
| 84 | if (len <= 0) | ||
| 85 | return 0; | ||
| 86 | p = str; | ||
| 87 | |||
| 88 | /* Check syntax and work out the encoded value (if correct) */ | ||
| 89 | if ((*p & 0x80) == 0) { | ||
| 90 | value = *p++ & 0x7f; | ||
| 91 | ret = 1; | ||
| 92 | } else if ((*p & 0xe0) == 0xc0) { | ||
| 93 | if (*p < 0xc2) | ||
| 94 | return -2; | ||
| 95 | if (len < 2) | ||
| 96 | return -1; | ||
| 97 | if ((p[1] & 0xc0) != 0x80) | ||
| 98 | return -3; | ||
| 99 | value = (*p++ & 0x1f) << 6; | ||
| 100 | value |= *p++ & 0x3f; | ||
| 101 | if (value < 0x80) | ||
| 102 | return -4; | ||
| 103 | ret = 2; | ||
| 104 | } else if ((*p & 0xf0) == 0xe0) { | ||
| 105 | if (len < 3) | ||
| 106 | return -1; | ||
| 107 | if (((p[1] & 0xc0) != 0x80) || | ||
| 108 | ((p[2] & 0xc0) != 0x80)) | ||
| 109 | return -3; | ||
| 110 | value = (*p++ & 0xf) << 12; | ||
| 111 | value |= (*p++ & 0x3f) << 6; | ||
| 112 | value |= *p++ & 0x3f; | ||
| 113 | if (value < 0x800) | ||
| 114 | return -4; | ||
| 115 | /* surrogate pair code points are not valid */ | ||
| 116 | if (value >= 0xd800 && value < 0xe000) | ||
| 117 | return -2; | ||
| 118 | ret = 3; | ||
| 119 | } else if ((*p & 0xf8) == 0xf0 && (*p < 0xf5)) { | ||
| 120 | if (len < 4) | ||
| 121 | return -1; | ||
| 122 | if (((p[1] & 0xc0) != 0x80) || | ||
| 123 | ((p[2] & 0xc0) != 0x80) || | ||
| 124 | ((p[3] & 0xc0) != 0x80)) | ||
| 125 | return -3; | ||
| 126 | value = ((unsigned long)(*p++ & 0x7)) << 18; | ||
| 127 | value |= (*p++ & 0x3f) << 12; | ||
| 128 | value |= (*p++ & 0x3f) << 6; | ||
| 129 | value |= *p++ & 0x3f; | ||
| 130 | if (value < 0x10000) | ||
| 131 | return -4; | ||
| 132 | if (value > UNICODE_MAX) | ||
| 133 | return -2; | ||
| 134 | ret = 4; | ||
| 135 | } else | ||
| 136 | return -2; | ||
| 137 | *val = value; | ||
| 138 | return ret; | ||
| 139 | } | ||
| 140 | |||
| 141 | /* This takes a Unicode code point 'value' and writes its UTF-8 encoded form | ||
| 142 | * in 'str' where 'str' is a buffer of at least length 'len'. If 'str' | ||
| 143 | * is NULL, then nothing is written and just the return code is determined. | ||
| 144 | |||
| 145 | * Returns less than zero on error: | ||
| 146 | * -1 if 'str' is not NULL and 'len' is too small | ||
| 147 | * -2 if 'value' is an invalid character (surrogate or out-of-range) | ||
| 148 | * | ||
| 149 | * Otherwise, returns the number of bytes in 'value's encoded form | ||
| 150 | * (i.e., the number of bytes written to 'str' when it's not NULL). | ||
| 151 | * | ||
| 152 | * It will need at most 4 characters. | ||
| 153 | */ | ||
| 154 | |||
| 155 | int | ||
| 156 | UTF8_putc(unsigned char *str, int len, unsigned long value) | ||
| 157 | { | ||
| 158 | if (value < 0x80) { | ||
| 159 | if (str != NULL) { | ||
| 160 | if (len < 1) | ||
| 161 | return -1; | ||
| 162 | str[0] = (unsigned char)value; | ||
| 163 | } | ||
| 164 | return 1; | ||
| 165 | } | ||
| 166 | if (value < 0x800) { | ||
| 167 | if (str != NULL) { | ||
| 168 | if (len < 2) | ||
| 169 | return -1; | ||
| 170 | str[0] = (unsigned char)(((value >> 6) & 0x1f) | 0xc0); | ||
| 171 | str[1] = (unsigned char)((value & 0x3f) | 0x80); | ||
| 172 | } | ||
| 173 | return 2; | ||
| 174 | } | ||
| 175 | if (value < 0x10000) { | ||
| 176 | if (UNICODE_IS_SURROGATE(value)) | ||
| 177 | return -2; | ||
| 178 | if (str != NULL) { | ||
| 179 | if (len < 3) | ||
| 180 | return -1; | ||
| 181 | str[0] = (unsigned char)(((value >> 12) & 0xf) | 0xe0); | ||
| 182 | str[1] = (unsigned char)(((value >> 6) & 0x3f) | 0x80); | ||
| 183 | str[2] = (unsigned char)((value & 0x3f) | 0x80); | ||
| 184 | } | ||
| 185 | return 3; | ||
| 186 | } | ||
| 187 | if (value <= UNICODE_MAX) { | ||
| 188 | if (str != NULL) { | ||
| 189 | if (len < 4) | ||
| 190 | return -1; | ||
| 191 | str[0] = (unsigned char)(((value >> 18) & 0x7) | 0xf0); | ||
| 192 | str[1] = (unsigned char)(((value >> 12) & 0x3f) | 0x80); | ||
| 193 | str[2] = (unsigned char)(((value >> 6) & 0x3f) | 0x80); | ||
| 194 | str[3] = (unsigned char)((value & 0x3f) | 0x80); | ||
| 195 | } | ||
| 196 | return 4; | ||
| 197 | } | ||
| 198 | return -2; | ||
| 199 | } | ||
diff --git a/src/lib/libcrypto/asn1/a_verify.c b/src/lib/libcrypto/asn1/a_verify.c deleted file mode 100644 index 3fc79b78f6..0000000000 --- a/src/lib/libcrypto/asn1/a_verify.c +++ /dev/null | |||
| @@ -1,172 +0,0 @@ | |||
| 1 | /* $OpenBSD: a_verify.c,v 1.21 2015/01/28 04:14:31 beck Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <sys/types.h> | ||
| 60 | |||
| 61 | #include <stdio.h> | ||
| 62 | #include <time.h> | ||
| 63 | |||
| 64 | #include <openssl/bn.h> | ||
| 65 | #include <openssl/buffer.h> | ||
| 66 | #include <openssl/err.h> | ||
| 67 | #include <openssl/evp.h> | ||
| 68 | #include <openssl/objects.h> | ||
| 69 | #include <openssl/x509.h> | ||
| 70 | |||
| 71 | #include "asn1_locl.h" | ||
| 72 | |||
| 73 | int | ||
| 74 | ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *a, | ||
| 75 | ASN1_BIT_STRING *signature, void *asn, EVP_PKEY *pkey) | ||
| 76 | { | ||
| 77 | EVP_MD_CTX ctx; | ||
| 78 | unsigned char *buf_in = NULL; | ||
| 79 | int ret = -1, inl; | ||
| 80 | |||
| 81 | int mdnid, pknid; | ||
| 82 | |||
| 83 | if (!pkey) { | ||
| 84 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, ERR_R_PASSED_NULL_PARAMETER); | ||
| 85 | return -1; | ||
| 86 | } | ||
| 87 | |||
| 88 | if (signature->type == V_ASN1_BIT_STRING && signature->flags & 0x7) | ||
| 89 | { | ||
| 90 | ASN1err(ASN1_F_ASN1_VERIFY, | ||
| 91 | ASN1_R_INVALID_BIT_STRING_BITS_LEFT); | ||
| 92 | return -1; | ||
| 93 | } | ||
| 94 | |||
| 95 | EVP_MD_CTX_init(&ctx); | ||
| 96 | |||
| 97 | /* Convert signature OID into digest and public key OIDs */ | ||
| 98 | if (!OBJ_find_sigid_algs(OBJ_obj2nid(a->algorithm), &mdnid, &pknid)) { | ||
| 99 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, | ||
| 100 | ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM); | ||
| 101 | goto err; | ||
| 102 | } | ||
| 103 | if (mdnid == NID_undef) { | ||
| 104 | if (!pkey->ameth || !pkey->ameth->item_verify) { | ||
| 105 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, | ||
| 106 | ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM); | ||
| 107 | goto err; | ||
| 108 | } | ||
| 109 | ret = pkey->ameth->item_verify(&ctx, it, asn, a, | ||
| 110 | signature, pkey); | ||
| 111 | /* Return value of 2 means carry on, anything else means we | ||
| 112 | * exit straight away: either a fatal error of the underlying | ||
| 113 | * verification routine handles all verification. | ||
| 114 | */ | ||
| 115 | if (ret != 2) | ||
| 116 | goto err; | ||
| 117 | ret = -1; | ||
| 118 | } else { | ||
| 119 | const EVP_MD *type; | ||
| 120 | type = EVP_get_digestbynid(mdnid); | ||
| 121 | if (type == NULL) { | ||
| 122 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, | ||
| 123 | ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM); | ||
| 124 | goto err; | ||
| 125 | } | ||
| 126 | |||
| 127 | /* Check public key OID matches public key type */ | ||
| 128 | if (EVP_PKEY_type(pknid) != pkey->ameth->pkey_id) { | ||
| 129 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, | ||
| 130 | ASN1_R_WRONG_PUBLIC_KEY_TYPE); | ||
| 131 | goto err; | ||
| 132 | } | ||
| 133 | |||
| 134 | if (!EVP_DigestVerifyInit(&ctx, NULL, type, NULL, pkey)) { | ||
| 135 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, ERR_R_EVP_LIB); | ||
| 136 | ret = 0; | ||
| 137 | goto err; | ||
| 138 | } | ||
| 139 | |||
| 140 | } | ||
| 141 | |||
| 142 | inl = ASN1_item_i2d(asn, &buf_in, it); | ||
| 143 | |||
| 144 | if (buf_in == NULL) { | ||
| 145 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, ERR_R_MALLOC_FAILURE); | ||
| 146 | goto err; | ||
| 147 | } | ||
| 148 | |||
| 149 | if (!EVP_DigestVerifyUpdate(&ctx, buf_in, inl)) { | ||
| 150 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, ERR_R_EVP_LIB); | ||
| 151 | ret = 0; | ||
| 152 | goto err; | ||
| 153 | } | ||
| 154 | |||
| 155 | OPENSSL_cleanse(buf_in, (unsigned int)inl); | ||
| 156 | free(buf_in); | ||
| 157 | |||
| 158 | if (EVP_DigestVerifyFinal(&ctx, signature->data, | ||
| 159 | (size_t)signature->length) <= 0) { | ||
| 160 | ASN1err(ASN1_F_ASN1_ITEM_VERIFY, ERR_R_EVP_LIB); | ||
| 161 | ret = 0; | ||
| 162 | goto err; | ||
| 163 | } | ||
| 164 | /* we don't need to zero the 'ctx' because we just checked | ||
| 165 | * public information */ | ||
| 166 | /* memset(&ctx,0,sizeof(ctx)); */ | ||
| 167 | ret = 1; | ||
| 168 | |||
| 169 | err: | ||
| 170 | EVP_MD_CTX_cleanup(&ctx); | ||
| 171 | return (ret); | ||
| 172 | } | ||
diff --git a/src/lib/libcrypto/asn1/ameth_lib.c b/src/lib/libcrypto/asn1/ameth_lib.c deleted file mode 100644 index 168321618c..0000000000 --- a/src/lib/libcrypto/asn1/ameth_lib.c +++ /dev/null | |||
| @@ -1,457 +0,0 @@ | |||
| 1 | /* $OpenBSD: ameth_lib.c,v 1.15 2014/11/09 19:17:13 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2006. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2006 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 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/opensslconf.h> | ||
| 63 | |||
| 64 | #include <openssl/asn1t.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | |||
| 67 | #ifndef OPENSSL_NO_ENGINE | ||
| 68 | #include <openssl/engine.h> | ||
| 69 | #endif | ||
| 70 | |||
| 71 | #include "asn1_locl.h" | ||
| 72 | |||
| 73 | extern const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[]; | ||
| 74 | extern const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[]; | ||
| 75 | extern const EVP_PKEY_ASN1_METHOD dh_asn1_meth; | ||
| 76 | extern const EVP_PKEY_ASN1_METHOD eckey_asn1_meth; | ||
| 77 | extern const EVP_PKEY_ASN1_METHOD gostr01_asn1_meths[]; | ||
| 78 | extern const EVP_PKEY_ASN1_METHOD gostimit_asn1_meth; | ||
| 79 | extern const EVP_PKEY_ASN1_METHOD hmac_asn1_meth; | ||
| 80 | extern const EVP_PKEY_ASN1_METHOD cmac_asn1_meth; | ||
| 81 | |||
| 82 | /* Keep this sorted in type order !! */ | ||
| 83 | static const EVP_PKEY_ASN1_METHOD *standard_methods[] = { | ||
| 84 | #ifndef OPENSSL_NO_RSA | ||
| 85 | &rsa_asn1_meths[0], | ||
| 86 | &rsa_asn1_meths[1], | ||
| 87 | #endif | ||
| 88 | #ifndef OPENSSL_NO_DH | ||
| 89 | &dh_asn1_meth, | ||
| 90 | #endif | ||
| 91 | #ifndef OPENSSL_NO_DSA | ||
| 92 | &dsa_asn1_meths[0], | ||
| 93 | &dsa_asn1_meths[1], | ||
| 94 | &dsa_asn1_meths[2], | ||
| 95 | &dsa_asn1_meths[3], | ||
| 96 | &dsa_asn1_meths[4], | ||
| 97 | #endif | ||
| 98 | #ifndef OPENSSL_NO_EC | ||
| 99 | &eckey_asn1_meth, | ||
| 100 | #endif | ||
| 101 | #ifndef OPENSSL_NO_GOST | ||
| 102 | &gostr01_asn1_meths[0], | ||
| 103 | &gostimit_asn1_meth, | ||
| 104 | #endif | ||
| 105 | &hmac_asn1_meth, | ||
| 106 | &cmac_asn1_meth, | ||
| 107 | #ifndef OPENSSL_NO_GOST | ||
| 108 | &gostr01_asn1_meths[1], | ||
| 109 | &gostr01_asn1_meths[2], | ||
| 110 | #endif | ||
| 111 | }; | ||
| 112 | |||
| 113 | typedef int sk_cmp_fn_type(const char * const *a, const char * const *b); | ||
| 114 | DECLARE_STACK_OF(EVP_PKEY_ASN1_METHOD) | ||
| 115 | static STACK_OF(EVP_PKEY_ASN1_METHOD) *app_methods = NULL; | ||
| 116 | |||
| 117 | DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *, | ||
| 118 | const EVP_PKEY_ASN1_METHOD *, ameth); | ||
| 119 | |||
| 120 | static int | ||
| 121 | ameth_cmp(const EVP_PKEY_ASN1_METHOD * const *a, | ||
| 122 | const EVP_PKEY_ASN1_METHOD * const *b) | ||
| 123 | { | ||
| 124 | return ((*a)->pkey_id - (*b)->pkey_id); | ||
| 125 | } | ||
| 126 | |||
| 127 | IMPLEMENT_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_ASN1_METHOD *, | ||
| 128 | const EVP_PKEY_ASN1_METHOD *, ameth); | ||
| 129 | |||
| 130 | int | ||
| 131 | EVP_PKEY_asn1_get_count(void) | ||
| 132 | { | ||
| 133 | int num = sizeof(standard_methods) / sizeof(EVP_PKEY_ASN1_METHOD *); | ||
| 134 | if (app_methods) | ||
| 135 | num += sk_EVP_PKEY_ASN1_METHOD_num(app_methods); | ||
| 136 | return num; | ||
| 137 | } | ||
| 138 | |||
| 139 | const EVP_PKEY_ASN1_METHOD * | ||
| 140 | EVP_PKEY_asn1_get0(int idx) | ||
| 141 | { | ||
| 142 | int num = sizeof(standard_methods) / sizeof(EVP_PKEY_ASN1_METHOD *); | ||
| 143 | if (idx < 0) | ||
| 144 | return NULL; | ||
| 145 | if (idx < num) | ||
| 146 | return standard_methods[idx]; | ||
| 147 | idx -= num; | ||
| 148 | return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx); | ||
| 149 | } | ||
| 150 | |||
| 151 | static const EVP_PKEY_ASN1_METHOD * | ||
| 152 | pkey_asn1_find(int type) | ||
| 153 | { | ||
| 154 | EVP_PKEY_ASN1_METHOD tmp; | ||
| 155 | const EVP_PKEY_ASN1_METHOD *t = &tmp, **ret; | ||
| 156 | tmp.pkey_id = type; | ||
| 157 | if (app_methods) { | ||
| 158 | int idx; | ||
| 159 | idx = sk_EVP_PKEY_ASN1_METHOD_find(app_methods, &tmp); | ||
| 160 | if (idx >= 0) | ||
| 161 | return sk_EVP_PKEY_ASN1_METHOD_value(app_methods, idx); | ||
| 162 | } | ||
| 163 | ret = OBJ_bsearch_ameth(&t, standard_methods, | ||
| 164 | sizeof(standard_methods) / sizeof(EVP_PKEY_ASN1_METHOD *)); | ||
| 165 | if (!ret || !*ret) | ||
| 166 | return NULL; | ||
| 167 | return *ret; | ||
| 168 | } | ||
| 169 | |||
| 170 | /* Find an implementation of an ASN1 algorithm. If 'pe' is not NULL | ||
| 171 | * also search through engines and set *pe to a functional reference | ||
| 172 | * to the engine implementing 'type' or NULL if no engine implements | ||
| 173 | * it. | ||
| 174 | */ | ||
| 175 | |||
| 176 | const EVP_PKEY_ASN1_METHOD * | ||
| 177 | EVP_PKEY_asn1_find(ENGINE **pe, int type) | ||
| 178 | { | ||
| 179 | const EVP_PKEY_ASN1_METHOD *t; | ||
| 180 | |||
| 181 | for (;;) { | ||
| 182 | t = pkey_asn1_find(type); | ||
| 183 | if (!t || !(t->pkey_flags & ASN1_PKEY_ALIAS)) | ||
| 184 | break; | ||
| 185 | type = t->pkey_base_id; | ||
| 186 | } | ||
| 187 | if (pe) { | ||
| 188 | #ifndef OPENSSL_NO_ENGINE | ||
| 189 | ENGINE *e; | ||
| 190 | /* type will contain the final unaliased type */ | ||
| 191 | e = ENGINE_get_pkey_asn1_meth_engine(type); | ||
| 192 | if (e) { | ||
| 193 | *pe = e; | ||
| 194 | return ENGINE_get_pkey_asn1_meth(e, type); | ||
| 195 | } | ||
| 196 | #endif | ||
| 197 | *pe = NULL; | ||
| 198 | } | ||
| 199 | return t; | ||
| 200 | } | ||
| 201 | |||
| 202 | const EVP_PKEY_ASN1_METHOD * | ||
| 203 | EVP_PKEY_asn1_find_str(ENGINE **pe, const char *str, int len) | ||
| 204 | { | ||
| 205 | int i; | ||
| 206 | const EVP_PKEY_ASN1_METHOD *ameth; | ||
| 207 | if (len == -1) | ||
| 208 | len = strlen(str); | ||
| 209 | if (pe) { | ||
| 210 | #ifndef OPENSSL_NO_ENGINE | ||
| 211 | ENGINE *e; | ||
| 212 | ameth = ENGINE_pkey_asn1_find_str(&e, str, len); | ||
| 213 | if (ameth) { | ||
| 214 | /* Convert structural into | ||
| 215 | * functional reference | ||
| 216 | */ | ||
| 217 | if (!ENGINE_init(e)) | ||
| 218 | ameth = NULL; | ||
| 219 | ENGINE_free(e); | ||
| 220 | *pe = e; | ||
| 221 | return ameth; | ||
| 222 | } | ||
| 223 | #endif | ||
| 224 | *pe = NULL; | ||
| 225 | } | ||
| 226 | for (i = 0; i < EVP_PKEY_asn1_get_count(); i++) { | ||
| 227 | ameth = EVP_PKEY_asn1_get0(i); | ||
| 228 | if (ameth->pkey_flags & ASN1_PKEY_ALIAS) | ||
| 229 | continue; | ||
| 230 | if (((int)strlen(ameth->pem_str) == len) && | ||
| 231 | !strncasecmp(ameth->pem_str, str, len)) | ||
| 232 | return ameth; | ||
| 233 | } | ||
| 234 | return NULL; | ||
| 235 | } | ||
| 236 | |||
| 237 | int | ||
| 238 | EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth) | ||
| 239 | { | ||
| 240 | if (app_methods == NULL) { | ||
| 241 | app_methods = sk_EVP_PKEY_ASN1_METHOD_new(ameth_cmp); | ||
| 242 | if (!app_methods) | ||
| 243 | return 0; | ||
| 244 | } | ||
| 245 | if (!sk_EVP_PKEY_ASN1_METHOD_push(app_methods, ameth)) | ||
| 246 | return 0; | ||
| 247 | sk_EVP_PKEY_ASN1_METHOD_sort(app_methods); | ||
| 248 | return 1; | ||
| 249 | } | ||
| 250 | |||
| 251 | int | ||
| 252 | EVP_PKEY_asn1_add_alias(int to, int from) | ||
| 253 | { | ||
| 254 | EVP_PKEY_ASN1_METHOD *ameth; | ||
| 255 | |||
| 256 | ameth = EVP_PKEY_asn1_new(from, ASN1_PKEY_ALIAS, NULL, NULL); | ||
| 257 | if (!ameth) | ||
| 258 | return 0; | ||
| 259 | ameth->pkey_base_id = to; | ||
| 260 | if (!EVP_PKEY_asn1_add0(ameth)) { | ||
| 261 | EVP_PKEY_asn1_free(ameth); | ||
| 262 | return 0; | ||
| 263 | } | ||
| 264 | return 1; | ||
| 265 | } | ||
| 266 | |||
| 267 | int | ||
| 268 | EVP_PKEY_asn1_get0_info(int *ppkey_id, int *ppkey_base_id, int *ppkey_flags, | ||
| 269 | const char **pinfo, const char **ppem_str, | ||
| 270 | const EVP_PKEY_ASN1_METHOD *ameth) | ||
| 271 | { | ||
| 272 | if (!ameth) | ||
| 273 | return 0; | ||
| 274 | if (ppkey_id) | ||
| 275 | *ppkey_id = ameth->pkey_id; | ||
| 276 | if (ppkey_base_id) | ||
| 277 | *ppkey_base_id = ameth->pkey_base_id; | ||
| 278 | if (ppkey_flags) | ||
| 279 | *ppkey_flags = ameth->pkey_flags; | ||
| 280 | if (pinfo) | ||
| 281 | *pinfo = ameth->info; | ||
| 282 | if (ppem_str) | ||
| 283 | *ppem_str = ameth->pem_str; | ||
| 284 | return 1; | ||
| 285 | } | ||
| 286 | |||
| 287 | const EVP_PKEY_ASN1_METHOD* | ||
| 288 | EVP_PKEY_get0_asn1(EVP_PKEY *pkey) | ||
| 289 | { | ||
| 290 | return pkey->ameth; | ||
| 291 | } | ||
| 292 | |||
| 293 | EVP_PKEY_ASN1_METHOD* | ||
| 294 | EVP_PKEY_asn1_new(int id, int flags, const char *pem_str, const char *info) | ||
| 295 | { | ||
| 296 | EVP_PKEY_ASN1_METHOD *ameth; | ||
| 297 | |||
| 298 | ameth = calloc(1, sizeof(EVP_PKEY_ASN1_METHOD)); | ||
| 299 | if (!ameth) | ||
| 300 | return NULL; | ||
| 301 | |||
| 302 | ameth->pkey_id = id; | ||
| 303 | ameth->pkey_base_id = id; | ||
| 304 | ameth->pkey_flags = flags | ASN1_PKEY_DYNAMIC; | ||
| 305 | |||
| 306 | if (info) { | ||
| 307 | ameth->info = strdup(info); | ||
| 308 | if (!ameth->info) | ||
| 309 | goto err; | ||
| 310 | } else | ||
| 311 | ameth->info = NULL; | ||
| 312 | |||
| 313 | if (pem_str) { | ||
| 314 | ameth->pem_str = strdup(pem_str); | ||
| 315 | if (!ameth->pem_str) | ||
| 316 | goto err; | ||
| 317 | } else | ||
| 318 | ameth->pem_str = NULL; | ||
| 319 | |||
| 320 | ameth->pub_decode = 0; | ||
| 321 | ameth->pub_encode = 0; | ||
| 322 | ameth->pub_cmp = 0; | ||
| 323 | ameth->pub_print = 0; | ||
| 324 | |||
| 325 | ameth->priv_decode = 0; | ||
| 326 | ameth->priv_encode = 0; | ||
| 327 | ameth->priv_print = 0; | ||
| 328 | |||
| 329 | ameth->old_priv_encode = 0; | ||
| 330 | ameth->old_priv_decode = 0; | ||
| 331 | |||
| 332 | ameth->item_verify = 0; | ||
| 333 | ameth->item_sign = 0; | ||
| 334 | |||
| 335 | ameth->pkey_size = 0; | ||
| 336 | ameth->pkey_bits = 0; | ||
| 337 | |||
| 338 | ameth->param_decode = 0; | ||
| 339 | ameth->param_encode = 0; | ||
| 340 | ameth->param_missing = 0; | ||
| 341 | ameth->param_copy = 0; | ||
| 342 | ameth->param_cmp = 0; | ||
| 343 | ameth->param_print = 0; | ||
| 344 | |||
| 345 | ameth->pkey_free = 0; | ||
| 346 | ameth->pkey_ctrl = 0; | ||
| 347 | |||
| 348 | return ameth; | ||
| 349 | |||
| 350 | err: | ||
| 351 | EVP_PKEY_asn1_free(ameth); | ||
| 352 | return NULL; | ||
| 353 | } | ||
| 354 | |||
| 355 | void | ||
| 356 | EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, const EVP_PKEY_ASN1_METHOD *src) | ||
| 357 | { | ||
| 358 | dst->pub_decode = src->pub_decode; | ||
| 359 | dst->pub_encode = src->pub_encode; | ||
| 360 | dst->pub_cmp = src->pub_cmp; | ||
| 361 | dst->pub_print = src->pub_print; | ||
| 362 | |||
| 363 | dst->priv_decode = src->priv_decode; | ||
| 364 | dst->priv_encode = src->priv_encode; | ||
| 365 | dst->priv_print = src->priv_print; | ||
| 366 | |||
| 367 | dst->old_priv_encode = src->old_priv_encode; | ||
| 368 | dst->old_priv_decode = src->old_priv_decode; | ||
| 369 | |||
| 370 | dst->pkey_size = src->pkey_size; | ||
| 371 | dst->pkey_bits = src->pkey_bits; | ||
| 372 | |||
| 373 | dst->param_decode = src->param_decode; | ||
| 374 | dst->param_encode = src->param_encode; | ||
| 375 | dst->param_missing = src->param_missing; | ||
| 376 | dst->param_copy = src->param_copy; | ||
| 377 | dst->param_cmp = src->param_cmp; | ||
| 378 | dst->param_print = src->param_print; | ||
| 379 | |||
| 380 | dst->pkey_free = src->pkey_free; | ||
| 381 | dst->pkey_ctrl = src->pkey_ctrl; | ||
| 382 | |||
| 383 | dst->item_sign = src->item_sign; | ||
| 384 | dst->item_verify = src->item_verify; | ||
| 385 | } | ||
| 386 | |||
| 387 | void | ||
| 388 | EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth) | ||
| 389 | { | ||
| 390 | if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC)) { | ||
| 391 | free(ameth->pem_str); | ||
| 392 | free(ameth->info); | ||
| 393 | free(ameth); | ||
| 394 | } | ||
| 395 | } | ||
| 396 | |||
| 397 | void | ||
| 398 | EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 399 | int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub), | ||
| 400 | int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk), | ||
| 401 | int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b), | ||
| 402 | int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 403 | ASN1_PCTX *pctx), | ||
| 404 | int (*pkey_size)(const EVP_PKEY *pk), | ||
| 405 | int (*pkey_bits)(const EVP_PKEY *pk)) | ||
| 406 | { | ||
| 407 | ameth->pub_decode = pub_decode; | ||
| 408 | ameth->pub_encode = pub_encode; | ||
| 409 | ameth->pub_cmp = pub_cmp; | ||
| 410 | ameth->pub_print = pub_print; | ||
| 411 | ameth->pkey_size = pkey_size; | ||
| 412 | ameth->pkey_bits = pkey_bits; | ||
| 413 | } | ||
| 414 | |||
| 415 | void | ||
| 416 | EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 417 | int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf), | ||
| 418 | int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk), | ||
| 419 | int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 420 | ASN1_PCTX *pctx)) | ||
| 421 | { | ||
| 422 | ameth->priv_decode = priv_decode; | ||
| 423 | ameth->priv_encode = priv_encode; | ||
| 424 | ameth->priv_print = priv_print; | ||
| 425 | } | ||
| 426 | |||
| 427 | void | ||
| 428 | EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 429 | int (*param_decode)(EVP_PKEY *pkey, const unsigned char **pder, int derlen), | ||
| 430 | int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder), | ||
| 431 | int (*param_missing)(const EVP_PKEY *pk), | ||
| 432 | int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from), | ||
| 433 | int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b), | ||
| 434 | int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 435 | ASN1_PCTX *pctx)) | ||
| 436 | { | ||
| 437 | ameth->param_decode = param_decode; | ||
| 438 | ameth->param_encode = param_encode; | ||
| 439 | ameth->param_missing = param_missing; | ||
| 440 | ameth->param_copy = param_copy; | ||
| 441 | ameth->param_cmp = param_cmp; | ||
| 442 | ameth->param_print = param_print; | ||
| 443 | } | ||
| 444 | |||
| 445 | void | ||
| 446 | EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 447 | void (*pkey_free)(EVP_PKEY *pkey)) | ||
| 448 | { | ||
| 449 | ameth->pkey_free = pkey_free; | ||
| 450 | } | ||
| 451 | |||
| 452 | void | ||
| 453 | EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth, | ||
| 454 | int (*pkey_ctrl)(EVP_PKEY *pkey, int op, long arg1, void *arg2)) | ||
| 455 | { | ||
| 456 | ameth->pkey_ctrl = pkey_ctrl; | ||
| 457 | } | ||
diff --git a/src/lib/libcrypto/asn1/asn1.h b/src/lib/libcrypto/asn1/asn1.h deleted file mode 100644 index 5ec89db3f0..0000000000 --- a/src/lib/libcrypto/asn1/asn1.h +++ /dev/null | |||
| @@ -1,1355 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn1.h,v 1.29 2015/01/28 04:14:31 beck Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #ifndef HEADER_ASN1_H | ||
| 60 | #define HEADER_ASN1_H | ||
| 61 | |||
| 62 | #include <time.h> | ||
| 63 | |||
| 64 | #include <openssl/opensslconf.h> | ||
| 65 | |||
| 66 | #ifndef OPENSSL_NO_BIO | ||
| 67 | #include <openssl/bio.h> | ||
| 68 | #endif | ||
| 69 | #include <openssl/stack.h> | ||
| 70 | #include <openssl/safestack.h> | ||
| 71 | |||
| 72 | #include <openssl/ossl_typ.h> | ||
| 73 | #ifndef OPENSSL_NO_DEPRECATED | ||
| 74 | #include <openssl/bn.h> | ||
| 75 | #endif | ||
| 76 | |||
| 77 | #ifdef __cplusplus | ||
| 78 | extern "C" { | ||
| 79 | #endif | ||
| 80 | |||
| 81 | #define V_ASN1_UNIVERSAL 0x00 | ||
| 82 | #define V_ASN1_APPLICATION 0x40 | ||
| 83 | #define V_ASN1_CONTEXT_SPECIFIC 0x80 | ||
| 84 | #define V_ASN1_PRIVATE 0xc0 | ||
| 85 | |||
| 86 | #define V_ASN1_CONSTRUCTED 0x20 | ||
| 87 | #define V_ASN1_PRIMITIVE_TAG 0x1f | ||
| 88 | #define V_ASN1_PRIMATIVE_TAG 0x1f | ||
| 89 | |||
| 90 | #define V_ASN1_APP_CHOOSE -2 /* let the recipient choose */ | ||
| 91 | #define V_ASN1_OTHER -3 /* used in ASN1_TYPE */ | ||
| 92 | #define V_ASN1_ANY -4 /* used in ASN1 template code */ | ||
| 93 | |||
| 94 | #define V_ASN1_NEG 0x100 /* negative flag */ | ||
| 95 | |||
| 96 | #define V_ASN1_UNDEF -1 | ||
| 97 | #define V_ASN1_EOC 0 | ||
| 98 | #define V_ASN1_BOOLEAN 1 /**/ | ||
| 99 | #define V_ASN1_INTEGER 2 | ||
| 100 | #define V_ASN1_NEG_INTEGER (2 | V_ASN1_NEG) | ||
| 101 | #define V_ASN1_BIT_STRING 3 | ||
| 102 | #define V_ASN1_OCTET_STRING 4 | ||
| 103 | #define V_ASN1_NULL 5 | ||
| 104 | #define V_ASN1_OBJECT 6 | ||
| 105 | #define V_ASN1_OBJECT_DESCRIPTOR 7 | ||
| 106 | #define V_ASN1_EXTERNAL 8 | ||
| 107 | #define V_ASN1_REAL 9 | ||
| 108 | #define V_ASN1_ENUMERATED 10 | ||
| 109 | #define V_ASN1_NEG_ENUMERATED (10 | V_ASN1_NEG) | ||
| 110 | #define V_ASN1_UTF8STRING 12 | ||
| 111 | #define V_ASN1_SEQUENCE 16 | ||
| 112 | #define V_ASN1_SET 17 | ||
| 113 | #define V_ASN1_NUMERICSTRING 18 /**/ | ||
| 114 | #define V_ASN1_PRINTABLESTRING 19 | ||
| 115 | #define V_ASN1_T61STRING 20 | ||
| 116 | #define V_ASN1_TELETEXSTRING 20 /* alias */ | ||
| 117 | #define V_ASN1_VIDEOTEXSTRING 21 /**/ | ||
| 118 | #define V_ASN1_IA5STRING 22 | ||
| 119 | #define V_ASN1_UTCTIME 23 | ||
| 120 | #define V_ASN1_GENERALIZEDTIME 24 /**/ | ||
| 121 | #define V_ASN1_GRAPHICSTRING 25 /**/ | ||
| 122 | #define V_ASN1_ISO64STRING 26 /**/ | ||
| 123 | #define V_ASN1_VISIBLESTRING 26 /* alias */ | ||
| 124 | #define V_ASN1_GENERALSTRING 27 /**/ | ||
| 125 | #define V_ASN1_UNIVERSALSTRING 28 /**/ | ||
| 126 | #define V_ASN1_BMPSTRING 30 | ||
| 127 | |||
| 128 | /* For use with d2i_ASN1_type_bytes() */ | ||
| 129 | #define B_ASN1_NUMERICSTRING 0x0001 | ||
| 130 | #define B_ASN1_PRINTABLESTRING 0x0002 | ||
| 131 | #define B_ASN1_T61STRING 0x0004 | ||
| 132 | #define B_ASN1_TELETEXSTRING 0x0004 | ||
| 133 | #define B_ASN1_VIDEOTEXSTRING 0x0008 | ||
| 134 | #define B_ASN1_IA5STRING 0x0010 | ||
| 135 | #define B_ASN1_GRAPHICSTRING 0x0020 | ||
| 136 | #define B_ASN1_ISO64STRING 0x0040 | ||
| 137 | #define B_ASN1_VISIBLESTRING 0x0040 | ||
| 138 | #define B_ASN1_GENERALSTRING 0x0080 | ||
| 139 | #define B_ASN1_UNIVERSALSTRING 0x0100 | ||
| 140 | #define B_ASN1_OCTET_STRING 0x0200 | ||
| 141 | #define B_ASN1_BIT_STRING 0x0400 | ||
| 142 | #define B_ASN1_BMPSTRING 0x0800 | ||
| 143 | #define B_ASN1_UNKNOWN 0x1000 | ||
| 144 | #define B_ASN1_UTF8STRING 0x2000 | ||
| 145 | #define B_ASN1_UTCTIME 0x4000 | ||
| 146 | #define B_ASN1_GENERALIZEDTIME 0x8000 | ||
| 147 | #define B_ASN1_SEQUENCE 0x10000 | ||
| 148 | |||
| 149 | /* For use with ASN1_mbstring_copy() */ | ||
| 150 | #define MBSTRING_FLAG 0x1000 | ||
| 151 | #define MBSTRING_UTF8 (MBSTRING_FLAG) | ||
| 152 | #define MBSTRING_ASC (MBSTRING_FLAG|1) | ||
| 153 | #define MBSTRING_BMP (MBSTRING_FLAG|2) | ||
| 154 | #define MBSTRING_UNIV (MBSTRING_FLAG|4) | ||
| 155 | |||
| 156 | #define SMIME_OLDMIME 0x400 | ||
| 157 | #define SMIME_CRLFEOL 0x800 | ||
| 158 | #define SMIME_STREAM 0x1000 | ||
| 159 | |||
| 160 | struct X509_algor_st; | ||
| 161 | DECLARE_STACK_OF(X509_ALGOR) | ||
| 162 | |||
| 163 | #define DECLARE_ASN1_SET_OF(type) /* filled in by mkstack.pl */ | ||
| 164 | #define IMPLEMENT_ASN1_SET_OF(type) /* nothing, no longer needed */ | ||
| 165 | |||
| 166 | /* We MUST make sure that, except for constness, asn1_ctx_st and | ||
| 167 | asn1_const_ctx are exactly the same. Fortunately, as soon as | ||
| 168 | the old ASN1 parsing macros are gone, we can throw this away | ||
| 169 | as well... */ | ||
| 170 | typedef struct asn1_ctx_st { | ||
| 171 | unsigned char *p;/* work char pointer */ | ||
| 172 | int eos; /* end of sequence read for indefinite encoding */ | ||
| 173 | int error; /* error code to use when returning an error */ | ||
| 174 | int inf; /* constructed if 0x20, indefinite is 0x21 */ | ||
| 175 | int tag; /* tag from last 'get object' */ | ||
| 176 | int xclass; /* class from last 'get object' */ | ||
| 177 | long slen; /* length of last 'get object' */ | ||
| 178 | unsigned char *max; /* largest value of p allowed */ | ||
| 179 | unsigned char *q;/* temporary variable */ | ||
| 180 | unsigned char **pp;/* variable */ | ||
| 181 | int line; /* used in error processing */ | ||
| 182 | } ASN1_CTX; | ||
| 183 | |||
| 184 | typedef struct asn1_const_ctx_st { | ||
| 185 | const unsigned char *p;/* work char pointer */ | ||
| 186 | int eos; /* end of sequence read for indefinite encoding */ | ||
| 187 | int error; /* error code to use when returning an error */ | ||
| 188 | int inf; /* constructed if 0x20, indefinite is 0x21 */ | ||
| 189 | int tag; /* tag from last 'get object' */ | ||
| 190 | int xclass; /* class from last 'get object' */ | ||
| 191 | long slen; /* length of last 'get object' */ | ||
| 192 | const unsigned char *max; /* largest value of p allowed */ | ||
| 193 | const unsigned char *q;/* temporary variable */ | ||
| 194 | const unsigned char **pp;/* variable */ | ||
| 195 | int line; /* used in error processing */ | ||
| 196 | } ASN1_const_CTX; | ||
| 197 | |||
| 198 | /* These are used internally in the ASN1_OBJECT to keep track of | ||
| 199 | * whether the names and data need to be free()ed */ | ||
| 200 | #define ASN1_OBJECT_FLAG_DYNAMIC 0x01 /* internal use */ | ||
| 201 | #define ASN1_OBJECT_FLAG_CRITICAL 0x02 /* critical x509v3 object id */ | ||
| 202 | #define ASN1_OBJECT_FLAG_DYNAMIC_STRINGS 0x04 /* internal use */ | ||
| 203 | #define ASN1_OBJECT_FLAG_DYNAMIC_DATA 0x08 /* internal use */ | ||
| 204 | typedef struct asn1_object_st { | ||
| 205 | const char *sn, *ln; | ||
| 206 | int nid; | ||
| 207 | int length; | ||
| 208 | const unsigned char *data; /* data remains const after init */ | ||
| 209 | int flags; /* Should we free this one */ | ||
| 210 | } ASN1_OBJECT; | ||
| 211 | |||
| 212 | #define ASN1_STRING_FLAG_BITS_LEFT 0x08 /* Set if 0x07 has bits left value */ | ||
| 213 | /* This indicates that the ASN1_STRING is not a real value but just a place | ||
| 214 | * holder for the location where indefinite length constructed data should | ||
| 215 | * be inserted in the memory buffer | ||
| 216 | */ | ||
| 217 | #define ASN1_STRING_FLAG_NDEF 0x010 | ||
| 218 | |||
| 219 | /* This flag is used by the CMS code to indicate that a string is not | ||
| 220 | * complete and is a place holder for content when it had all been | ||
| 221 | * accessed. The flag will be reset when content has been written to it. | ||
| 222 | */ | ||
| 223 | |||
| 224 | #define ASN1_STRING_FLAG_CONT 0x020 | ||
| 225 | /* This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING | ||
| 226 | * type. | ||
| 227 | */ | ||
| 228 | #define ASN1_STRING_FLAG_MSTRING 0x040 | ||
| 229 | /* This is the base type that holds just about everything :-) */ | ||
| 230 | struct asn1_string_st { | ||
| 231 | int length; | ||
| 232 | int type; | ||
| 233 | unsigned char *data; | ||
| 234 | /* The value of the following field depends on the type being | ||
| 235 | * held. It is mostly being used for BIT_STRING so if the | ||
| 236 | * input data has a non-zero 'unused bits' value, it will be | ||
| 237 | * handled correctly */ | ||
| 238 | long flags; | ||
| 239 | }; | ||
| 240 | |||
| 241 | /* ASN1_ENCODING structure: this is used to save the received | ||
| 242 | * encoding of an ASN1 type. This is useful to get round | ||
| 243 | * problems with invalid encodings which can break signatures. | ||
| 244 | */ | ||
| 245 | |||
| 246 | typedef struct ASN1_ENCODING_st { | ||
| 247 | unsigned char *enc; /* DER encoding */ | ||
| 248 | long len; /* Length of encoding */ | ||
| 249 | int modified; /* set to 1 if 'enc' is invalid */ | ||
| 250 | } ASN1_ENCODING; | ||
| 251 | |||
| 252 | /* Used with ASN1 LONG type: if a long is set to this it is omitted */ | ||
| 253 | #define ASN1_LONG_UNDEF 0x7fffffffL | ||
| 254 | |||
| 255 | #define STABLE_FLAGS_MALLOC 0x01 | ||
| 256 | #define STABLE_NO_MASK 0x02 | ||
| 257 | #define DIRSTRING_TYPE \ | ||
| 258 | (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING) | ||
| 259 | #define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING) | ||
| 260 | |||
| 261 | typedef struct asn1_string_table_st { | ||
| 262 | int nid; | ||
| 263 | long minsize; | ||
| 264 | long maxsize; | ||
| 265 | unsigned long mask; | ||
| 266 | unsigned long flags; | ||
| 267 | } ASN1_STRING_TABLE; | ||
| 268 | |||
| 269 | DECLARE_STACK_OF(ASN1_STRING_TABLE) | ||
| 270 | |||
| 271 | /* size limits: this stuff is taken straight from RFC2459 */ | ||
| 272 | |||
| 273 | #define ub_name 32768 | ||
| 274 | #define ub_common_name 64 | ||
| 275 | #define ub_locality_name 128 | ||
| 276 | #define ub_state_name 128 | ||
| 277 | #define ub_organization_name 64 | ||
| 278 | #define ub_organization_unit_name 64 | ||
| 279 | #define ub_title 64 | ||
| 280 | #define ub_email_address 128 | ||
| 281 | |||
| 282 | /* Declarations for template structures: for full definitions | ||
| 283 | * see asn1t.h | ||
| 284 | */ | ||
| 285 | typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE; | ||
| 286 | typedef struct ASN1_TLC_st ASN1_TLC; | ||
| 287 | /* This is just an opaque pointer */ | ||
| 288 | typedef struct ASN1_VALUE_st ASN1_VALUE; | ||
| 289 | |||
| 290 | /* Declare ASN1 functions: the implement macro in in asn1t.h */ | ||
| 291 | |||
| 292 | #define DECLARE_ASN1_FUNCTIONS(type) DECLARE_ASN1_FUNCTIONS_name(type, type) | ||
| 293 | |||
| 294 | #define DECLARE_ASN1_ALLOC_FUNCTIONS(type) \ | ||
| 295 | DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, type) | ||
| 296 | |||
| 297 | #define DECLARE_ASN1_FUNCTIONS_name(type, name) \ | ||
| 298 | DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ | ||
| 299 | DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name) | ||
| 300 | |||
| 301 | #define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \ | ||
| 302 | DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ | ||
| 303 | DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) | ||
| 304 | |||
| 305 | #define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \ | ||
| 306 | type *d2i_##name(type **a, const unsigned char **in, long len); \ | ||
| 307 | int i2d_##name(type *a, unsigned char **out); \ | ||
| 308 | DECLARE_ASN1_ITEM(itname) | ||
| 309 | |||
| 310 | #define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \ | ||
| 311 | type *d2i_##name(type **a, const unsigned char **in, long len); \ | ||
| 312 | int i2d_##name(const type *a, unsigned char **out); \ | ||
| 313 | DECLARE_ASN1_ITEM(name) | ||
| 314 | |||
| 315 | #define DECLARE_ASN1_NDEF_FUNCTION(name) \ | ||
| 316 | int i2d_##name##_NDEF(name *a, unsigned char **out); | ||
| 317 | |||
| 318 | #define DECLARE_ASN1_FUNCTIONS_const(name) \ | ||
| 319 | DECLARE_ASN1_ALLOC_FUNCTIONS(name) \ | ||
| 320 | DECLARE_ASN1_ENCODE_FUNCTIONS_const(name, name) | ||
| 321 | |||
| 322 | #define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ | ||
| 323 | type *name##_new(void); \ | ||
| 324 | void name##_free(type *a); | ||
| 325 | |||
| 326 | #define DECLARE_ASN1_PRINT_FUNCTION(stname) \ | ||
| 327 | DECLARE_ASN1_PRINT_FUNCTION_fname(stname, stname) | ||
| 328 | |||
| 329 | #define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \ | ||
| 330 | int fname##_print_ctx(BIO *out, stname *x, int indent, \ | ||
| 331 | const ASN1_PCTX *pctx); | ||
| 332 | |||
| 333 | #define D2I_OF(type) type *(*)(type **,const unsigned char **,long) | ||
| 334 | #define I2D_OF(type) int (*)(type *,unsigned char **) | ||
| 335 | #define I2D_OF_const(type) int (*)(const type *,unsigned char **) | ||
| 336 | |||
| 337 | #define CHECKED_D2I_OF(type, d2i) \ | ||
| 338 | ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0))) | ||
| 339 | #define CHECKED_I2D_OF(type, i2d) \ | ||
| 340 | ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0))) | ||
| 341 | #define CHECKED_NEW_OF(type, xnew) \ | ||
| 342 | ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0))) | ||
| 343 | #define CHECKED_PTR_OF(type, p) \ | ||
| 344 | ((void*) (1 ? p : (type*)0)) | ||
| 345 | #define CHECKED_PPTR_OF(type, p) \ | ||
| 346 | ((void**) (1 ? p : (type**)0)) | ||
| 347 | |||
| 348 | #define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long) | ||
| 349 | #define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(type *,unsigned char **) | ||
| 350 | #define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type) | ||
| 351 | |||
| 352 | TYPEDEF_D2I2D_OF(void); | ||
| 353 | |||
| 354 | /* The following macros and typedefs allow an ASN1_ITEM | ||
| 355 | * to be embedded in a structure and referenced. Since | ||
| 356 | * the ASN1_ITEM pointers need to be globally accessible | ||
| 357 | * (possibly from shared libraries) they may exist in | ||
| 358 | * different forms. On platforms that support it the | ||
| 359 | * ASN1_ITEM structure itself will be globally exported. | ||
| 360 | * Other platforms will export a function that returns | ||
| 361 | * an ASN1_ITEM pointer. | ||
| 362 | * | ||
| 363 | * To handle both cases transparently the macros below | ||
| 364 | * should be used instead of hard coding an ASN1_ITEM | ||
| 365 | * pointer in a structure. | ||
| 366 | * | ||
| 367 | * The structure will look like this: | ||
| 368 | * | ||
| 369 | * typedef struct SOMETHING_st { | ||
| 370 | * ... | ||
| 371 | * ASN1_ITEM_EXP *iptr; | ||
| 372 | * ... | ||
| 373 | * } SOMETHING; | ||
| 374 | * | ||
| 375 | * It would be initialised as e.g.: | ||
| 376 | * | ||
| 377 | * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...}; | ||
| 378 | * | ||
| 379 | * and the actual pointer extracted with: | ||
| 380 | * | ||
| 381 | * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr); | ||
| 382 | * | ||
| 383 | * Finally an ASN1_ITEM pointer can be extracted from an | ||
| 384 | * appropriate reference with: ASN1_ITEM_rptr(X509). This | ||
| 385 | * would be used when a function takes an ASN1_ITEM * argument. | ||
| 386 | * | ||
| 387 | */ | ||
| 388 | |||
| 389 | |||
| 390 | /* ASN1_ITEM pointer exported type */ | ||
| 391 | typedef const ASN1_ITEM ASN1_ITEM_EXP; | ||
| 392 | |||
| 393 | /* Macro to obtain ASN1_ITEM pointer from exported type */ | ||
| 394 | #define ASN1_ITEM_ptr(iptr) (iptr) | ||
| 395 | |||
| 396 | /* Macro to include ASN1_ITEM pointer from base type */ | ||
| 397 | #define ASN1_ITEM_ref(iptr) (&(iptr##_it)) | ||
| 398 | |||
| 399 | #define ASN1_ITEM_rptr(ref) (&(ref##_it)) | ||
| 400 | |||
| 401 | #define DECLARE_ASN1_ITEM(name) \ | ||
| 402 | extern const ASN1_ITEM name##_it; | ||
| 403 | |||
| 404 | |||
| 405 | /* Parameters used by ASN1_STRING_print_ex() */ | ||
| 406 | |||
| 407 | /* These determine which characters to escape: | ||
| 408 | * RFC2253 special characters, control characters and | ||
| 409 | * MSB set characters | ||
| 410 | */ | ||
| 411 | |||
| 412 | #define ASN1_STRFLGS_ESC_2253 1 | ||
| 413 | #define ASN1_STRFLGS_ESC_CTRL 2 | ||
| 414 | #define ASN1_STRFLGS_ESC_MSB 4 | ||
| 415 | |||
| 416 | |||
| 417 | /* This flag determines how we do escaping: normally | ||
| 418 | * RC2253 backslash only, set this to use backslash and | ||
| 419 | * quote. | ||
| 420 | */ | ||
| 421 | |||
| 422 | #define ASN1_STRFLGS_ESC_QUOTE 8 | ||
| 423 | |||
| 424 | |||
| 425 | /* These three flags are internal use only. */ | ||
| 426 | |||
| 427 | /* Character is a valid PrintableString character */ | ||
| 428 | #define CHARTYPE_PRINTABLESTRING 0x10 | ||
| 429 | /* Character needs escaping if it is the first character */ | ||
| 430 | #define CHARTYPE_FIRST_ESC_2253 0x20 | ||
| 431 | /* Character needs escaping if it is the last character */ | ||
| 432 | #define CHARTYPE_LAST_ESC_2253 0x40 | ||
| 433 | |||
| 434 | /* NB the internal flags are safely reused below by flags | ||
| 435 | * handled at the top level. | ||
| 436 | */ | ||
| 437 | |||
| 438 | /* If this is set we convert all character strings | ||
| 439 | * to UTF8 first | ||
| 440 | */ | ||
| 441 | |||
| 442 | #define ASN1_STRFLGS_UTF8_CONVERT 0x10 | ||
| 443 | |||
| 444 | /* If this is set we don't attempt to interpret content: | ||
| 445 | * just assume all strings are 1 byte per character. This | ||
| 446 | * will produce some pretty odd looking output! | ||
| 447 | */ | ||
| 448 | |||
| 449 | #define ASN1_STRFLGS_IGNORE_TYPE 0x20 | ||
| 450 | |||
| 451 | /* If this is set we include the string type in the output */ | ||
| 452 | #define ASN1_STRFLGS_SHOW_TYPE 0x40 | ||
| 453 | |||
| 454 | /* This determines which strings to display and which to | ||
| 455 | * 'dump' (hex dump of content octets or DER encoding). We can | ||
| 456 | * only dump non character strings or everything. If we | ||
| 457 | * don't dump 'unknown' they are interpreted as character | ||
| 458 | * strings with 1 octet per character and are subject to | ||
| 459 | * the usual escaping options. | ||
| 460 | */ | ||
| 461 | |||
| 462 | #define ASN1_STRFLGS_DUMP_ALL 0x80 | ||
| 463 | #define ASN1_STRFLGS_DUMP_UNKNOWN 0x100 | ||
| 464 | |||
| 465 | /* These determine what 'dumping' does, we can dump the | ||
| 466 | * content octets or the DER encoding: both use the | ||
| 467 | * RFC2253 #NNNNN notation. | ||
| 468 | */ | ||
| 469 | |||
| 470 | #define ASN1_STRFLGS_DUMP_DER 0x200 | ||
| 471 | |||
| 472 | /* All the string flags consistent with RFC2253, | ||
| 473 | * escaping control characters isn't essential in | ||
| 474 | * RFC2253 but it is advisable anyway. | ||
| 475 | */ | ||
| 476 | |||
| 477 | #define ASN1_STRFLGS_RFC2253 (ASN1_STRFLGS_ESC_2253 | \ | ||
| 478 | ASN1_STRFLGS_ESC_CTRL | \ | ||
| 479 | ASN1_STRFLGS_ESC_MSB | \ | ||
| 480 | ASN1_STRFLGS_UTF8_CONVERT | \ | ||
| 481 | ASN1_STRFLGS_DUMP_UNKNOWN | \ | ||
| 482 | ASN1_STRFLGS_DUMP_DER) | ||
| 483 | |||
| 484 | DECLARE_STACK_OF(ASN1_INTEGER) | ||
| 485 | DECLARE_ASN1_SET_OF(ASN1_INTEGER) | ||
| 486 | |||
| 487 | DECLARE_STACK_OF(ASN1_GENERALSTRING) | ||
| 488 | |||
| 489 | typedef struct asn1_type_st { | ||
| 490 | int type; | ||
| 491 | union { | ||
| 492 | char *ptr; | ||
| 493 | ASN1_BOOLEAN boolean; | ||
| 494 | ASN1_STRING * asn1_string; | ||
| 495 | ASN1_OBJECT * object; | ||
| 496 | ASN1_INTEGER * integer; | ||
| 497 | ASN1_ENUMERATED * enumerated; | ||
| 498 | ASN1_BIT_STRING * bit_string; | ||
| 499 | ASN1_OCTET_STRING * octet_string; | ||
| 500 | ASN1_PRINTABLESTRING * printablestring; | ||
| 501 | ASN1_T61STRING * t61string; | ||
| 502 | ASN1_IA5STRING * ia5string; | ||
| 503 | ASN1_GENERALSTRING * generalstring; | ||
| 504 | ASN1_BMPSTRING * bmpstring; | ||
| 505 | ASN1_UNIVERSALSTRING * universalstring; | ||
| 506 | ASN1_UTCTIME * utctime; | ||
| 507 | ASN1_GENERALIZEDTIME * generalizedtime; | ||
| 508 | ASN1_VISIBLESTRING * visiblestring; | ||
| 509 | ASN1_UTF8STRING * utf8string; | ||
| 510 | /* set and sequence are left complete and still | ||
| 511 | * contain the set or sequence bytes */ | ||
| 512 | ASN1_STRING * set; | ||
| 513 | ASN1_STRING * sequence; | ||
| 514 | ASN1_VALUE * asn1_value; | ||
| 515 | } value; | ||
| 516 | } ASN1_TYPE; | ||
| 517 | |||
| 518 | DECLARE_STACK_OF(ASN1_TYPE) | ||
| 519 | DECLARE_ASN1_SET_OF(ASN1_TYPE) | ||
| 520 | |||
| 521 | typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY; | ||
| 522 | |||
| 523 | DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY) | ||
| 524 | DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SET_ANY) | ||
| 525 | |||
| 526 | typedef struct NETSCAPE_X509_st { | ||
| 527 | ASN1_OCTET_STRING *header; | ||
| 528 | X509 *cert; | ||
| 529 | } NETSCAPE_X509; | ||
| 530 | |||
| 531 | /* This is used to contain a list of bit names */ | ||
| 532 | typedef struct BIT_STRING_BITNAME_st { | ||
| 533 | int bitnum; | ||
| 534 | const char *lname; | ||
| 535 | const char *sname; | ||
| 536 | } BIT_STRING_BITNAME; | ||
| 537 | |||
| 538 | |||
| 539 | #define M_ASN1_STRING_length(x) ((x)->length) | ||
| 540 | #define M_ASN1_STRING_length_set(x, n) ((x)->length = (n)) | ||
| 541 | #define M_ASN1_STRING_type(x) ((x)->type) | ||
| 542 | #define M_ASN1_STRING_data(x) ((x)->data) | ||
| 543 | |||
| 544 | /* Macros for string operations */ | ||
| 545 | #define M_ASN1_BIT_STRING_new() (ASN1_BIT_STRING *)\ | ||
| 546 | ASN1_STRING_type_new(V_ASN1_BIT_STRING) | ||
| 547 | #define M_ASN1_BIT_STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 548 | #define M_ASN1_BIT_STRING_dup(a) (ASN1_BIT_STRING *)\ | ||
| 549 | ASN1_STRING_dup((const ASN1_STRING *)a) | ||
| 550 | #define M_ASN1_BIT_STRING_cmp(a,b) ASN1_STRING_cmp(\ | ||
| 551 | (const ASN1_STRING *)a,(const ASN1_STRING *)b) | ||
| 552 | #define M_ASN1_BIT_STRING_set(a,b,c) ASN1_STRING_set((ASN1_STRING *)a,b,c) | ||
| 553 | |||
| 554 | #define M_ASN1_INTEGER_new() (ASN1_INTEGER *)\ | ||
| 555 | ASN1_STRING_type_new(V_ASN1_INTEGER) | ||
| 556 | #define M_ASN1_INTEGER_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 557 | #define M_ASN1_INTEGER_dup(a) (ASN1_INTEGER *)\ | ||
| 558 | ASN1_STRING_dup((const ASN1_STRING *)a) | ||
| 559 | #define M_ASN1_INTEGER_cmp(a,b) ASN1_STRING_cmp(\ | ||
| 560 | (const ASN1_STRING *)a,(const ASN1_STRING *)b) | ||
| 561 | |||
| 562 | #define M_ASN1_ENUMERATED_new() (ASN1_ENUMERATED *)\ | ||
| 563 | ASN1_STRING_type_new(V_ASN1_ENUMERATED) | ||
| 564 | #define M_ASN1_ENUMERATED_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 565 | #define M_ASN1_ENUMERATED_dup(a) (ASN1_ENUMERATED *)\ | ||
| 566 | ASN1_STRING_dup((const ASN1_STRING *)a) | ||
| 567 | #define M_ASN1_ENUMERATED_cmp(a,b) ASN1_STRING_cmp(\ | ||
| 568 | (const ASN1_STRING *)a,(const ASN1_STRING *)b) | ||
| 569 | |||
| 570 | #define M_ASN1_OCTET_STRING_new() (ASN1_OCTET_STRING *)\ | ||
| 571 | ASN1_STRING_type_new(V_ASN1_OCTET_STRING) | ||
| 572 | #define M_ASN1_OCTET_STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 573 | #define M_ASN1_OCTET_STRING_dup(a) (ASN1_OCTET_STRING *)\ | ||
| 574 | ASN1_STRING_dup((const ASN1_STRING *)a) | ||
| 575 | #define M_ASN1_OCTET_STRING_cmp(a,b) ASN1_STRING_cmp(\ | ||
| 576 | (const ASN1_STRING *)a,(const ASN1_STRING *)b) | ||
| 577 | #define M_ASN1_OCTET_STRING_set(a,b,c) ASN1_STRING_set((ASN1_STRING *)a,b,c) | ||
| 578 | #define M_ASN1_OCTET_STRING_print(a,b) ASN1_STRING_print(a,(ASN1_STRING *)b) | ||
| 579 | #define M_i2d_ASN1_OCTET_STRING(a,pp) \ | ||
| 580 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_OCTET_STRING,\ | ||
| 581 | V_ASN1_UNIVERSAL) | ||
| 582 | |||
| 583 | #define B_ASN1_TIME \ | ||
| 584 | B_ASN1_UTCTIME | \ | ||
| 585 | B_ASN1_GENERALIZEDTIME | ||
| 586 | |||
| 587 | #define B_ASN1_PRINTABLE \ | ||
| 588 | B_ASN1_NUMERICSTRING| \ | ||
| 589 | B_ASN1_PRINTABLESTRING| \ | ||
| 590 | B_ASN1_T61STRING| \ | ||
| 591 | B_ASN1_IA5STRING| \ | ||
| 592 | B_ASN1_BIT_STRING| \ | ||
| 593 | B_ASN1_UNIVERSALSTRING|\ | ||
| 594 | B_ASN1_BMPSTRING|\ | ||
| 595 | B_ASN1_UTF8STRING|\ | ||
| 596 | B_ASN1_SEQUENCE|\ | ||
| 597 | B_ASN1_UNKNOWN | ||
| 598 | |||
| 599 | #define B_ASN1_DIRECTORYSTRING \ | ||
| 600 | B_ASN1_PRINTABLESTRING| \ | ||
| 601 | B_ASN1_TELETEXSTRING|\ | ||
| 602 | B_ASN1_BMPSTRING|\ | ||
| 603 | B_ASN1_UNIVERSALSTRING|\ | ||
| 604 | B_ASN1_UTF8STRING | ||
| 605 | |||
| 606 | #define B_ASN1_DISPLAYTEXT \ | ||
| 607 | B_ASN1_IA5STRING| \ | ||
| 608 | B_ASN1_VISIBLESTRING| \ | ||
| 609 | B_ASN1_BMPSTRING|\ | ||
| 610 | B_ASN1_UTF8STRING | ||
| 611 | |||
| 612 | #define M_ASN1_PRINTABLE_new() ASN1_STRING_type_new(V_ASN1_T61STRING) | ||
| 613 | #define M_ASN1_PRINTABLE_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 614 | #define M_i2d_ASN1_PRINTABLE(a,pp) i2d_ASN1_bytes((ASN1_STRING *)a,\ | ||
| 615 | pp,a->type,V_ASN1_UNIVERSAL) | ||
| 616 | #define M_d2i_ASN1_PRINTABLE(a,pp,l) \ | ||
| 617 | d2i_ASN1_type_bytes((ASN1_STRING **)a,pp,l, \ | ||
| 618 | B_ASN1_PRINTABLE) | ||
| 619 | |||
| 620 | #define M_DIRECTORYSTRING_new() ASN1_STRING_type_new(V_ASN1_PRINTABLESTRING) | ||
| 621 | #define M_DIRECTORYSTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 622 | #define M_i2d_DIRECTORYSTRING(a,pp) i2d_ASN1_bytes((ASN1_STRING *)a,\ | ||
| 623 | pp,a->type,V_ASN1_UNIVERSAL) | ||
| 624 | #define M_d2i_DIRECTORYSTRING(a,pp,l) \ | ||
| 625 | d2i_ASN1_type_bytes((ASN1_STRING **)a,pp,l, \ | ||
| 626 | B_ASN1_DIRECTORYSTRING) | ||
| 627 | |||
| 628 | #define M_DISPLAYTEXT_new() ASN1_STRING_type_new(V_ASN1_VISIBLESTRING) | ||
| 629 | #define M_DISPLAYTEXT_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 630 | #define M_i2d_DISPLAYTEXT(a,pp) i2d_ASN1_bytes((ASN1_STRING *)a,\ | ||
| 631 | pp,a->type,V_ASN1_UNIVERSAL) | ||
| 632 | #define M_d2i_DISPLAYTEXT(a,pp,l) \ | ||
| 633 | d2i_ASN1_type_bytes((ASN1_STRING **)a,pp,l, \ | ||
| 634 | B_ASN1_DISPLAYTEXT) | ||
| 635 | |||
| 636 | #define M_ASN1_PRINTABLESTRING_new() (ASN1_PRINTABLESTRING *)\ | ||
| 637 | ASN1_STRING_type_new(V_ASN1_PRINTABLESTRING) | ||
| 638 | #define M_ASN1_PRINTABLESTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 639 | #define M_i2d_ASN1_PRINTABLESTRING(a,pp) \ | ||
| 640 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_PRINTABLESTRING,\ | ||
| 641 | V_ASN1_UNIVERSAL) | ||
| 642 | #define M_d2i_ASN1_PRINTABLESTRING(a,pp,l) \ | ||
| 643 | (ASN1_PRINTABLESTRING *)d2i_ASN1_type_bytes\ | ||
| 644 | ((ASN1_STRING **)a,pp,l,B_ASN1_PRINTABLESTRING) | ||
| 645 | |||
| 646 | #define M_ASN1_T61STRING_new() (ASN1_T61STRING *)\ | ||
| 647 | ASN1_STRING_type_new(V_ASN1_T61STRING) | ||
| 648 | #define M_ASN1_T61STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 649 | #define M_i2d_ASN1_T61STRING(a,pp) \ | ||
| 650 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_T61STRING,\ | ||
| 651 | V_ASN1_UNIVERSAL) | ||
| 652 | #define M_d2i_ASN1_T61STRING(a,pp,l) \ | ||
| 653 | (ASN1_T61STRING *)d2i_ASN1_type_bytes\ | ||
| 654 | ((ASN1_STRING **)a,pp,l,B_ASN1_T61STRING) | ||
| 655 | |||
| 656 | #define M_ASN1_IA5STRING_new() (ASN1_IA5STRING *)\ | ||
| 657 | ASN1_STRING_type_new(V_ASN1_IA5STRING) | ||
| 658 | #define M_ASN1_IA5STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 659 | #define M_ASN1_IA5STRING_dup(a) \ | ||
| 660 | (ASN1_IA5STRING *)ASN1_STRING_dup((const ASN1_STRING *)a) | ||
| 661 | #define M_i2d_ASN1_IA5STRING(a,pp) \ | ||
| 662 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_IA5STRING,\ | ||
| 663 | V_ASN1_UNIVERSAL) | ||
| 664 | #define M_d2i_ASN1_IA5STRING(a,pp,l) \ | ||
| 665 | (ASN1_IA5STRING *)d2i_ASN1_type_bytes((ASN1_STRING **)a,pp,l,\ | ||
| 666 | B_ASN1_IA5STRING) | ||
| 667 | |||
| 668 | #define M_ASN1_UTCTIME_new() (ASN1_UTCTIME *)\ | ||
| 669 | ASN1_STRING_type_new(V_ASN1_UTCTIME) | ||
| 670 | #define M_ASN1_UTCTIME_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 671 | #define M_ASN1_UTCTIME_dup(a) (ASN1_UTCTIME *)\ | ||
| 672 | ASN1_STRING_dup((const ASN1_STRING *)a) | ||
| 673 | |||
| 674 | #define M_ASN1_GENERALIZEDTIME_new() (ASN1_GENERALIZEDTIME *)\ | ||
| 675 | ASN1_STRING_type_new(V_ASN1_GENERALIZEDTIME) | ||
| 676 | #define M_ASN1_GENERALIZEDTIME_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 677 | #define M_ASN1_GENERALIZEDTIME_dup(a) (ASN1_GENERALIZEDTIME *)ASN1_STRING_dup(\ | ||
| 678 | (const ASN1_STRING *)a) | ||
| 679 | |||
| 680 | #define M_ASN1_TIME_new() (ASN1_TIME *)\ | ||
| 681 | ASN1_STRING_type_new(V_ASN1_UTCTIME) | ||
| 682 | #define M_ASN1_TIME_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 683 | #define M_ASN1_TIME_dup(a) (ASN1_TIME *)\ | ||
| 684 | ASN1_STRING_dup((const ASN1_STRING *)a) | ||
| 685 | |||
| 686 | #define M_ASN1_GENERALSTRING_new() (ASN1_GENERALSTRING *)\ | ||
| 687 | ASN1_STRING_type_new(V_ASN1_GENERALSTRING) | ||
| 688 | #define M_ASN1_GENERALSTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 689 | #define M_i2d_ASN1_GENERALSTRING(a,pp) \ | ||
| 690 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_GENERALSTRING,\ | ||
| 691 | V_ASN1_UNIVERSAL) | ||
| 692 | #define M_d2i_ASN1_GENERALSTRING(a,pp,l) \ | ||
| 693 | (ASN1_GENERALSTRING *)d2i_ASN1_type_bytes\ | ||
| 694 | ((ASN1_STRING **)a,pp,l,B_ASN1_GENERALSTRING) | ||
| 695 | |||
| 696 | #define M_ASN1_UNIVERSALSTRING_new() (ASN1_UNIVERSALSTRING *)\ | ||
| 697 | ASN1_STRING_type_new(V_ASN1_UNIVERSALSTRING) | ||
| 698 | #define M_ASN1_UNIVERSALSTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 699 | #define M_i2d_ASN1_UNIVERSALSTRING(a,pp) \ | ||
| 700 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_UNIVERSALSTRING,\ | ||
| 701 | V_ASN1_UNIVERSAL) | ||
| 702 | #define M_d2i_ASN1_UNIVERSALSTRING(a,pp,l) \ | ||
| 703 | (ASN1_UNIVERSALSTRING *)d2i_ASN1_type_bytes\ | ||
| 704 | ((ASN1_STRING **)a,pp,l,B_ASN1_UNIVERSALSTRING) | ||
| 705 | |||
| 706 | #define M_ASN1_BMPSTRING_new() (ASN1_BMPSTRING *)\ | ||
| 707 | ASN1_STRING_type_new(V_ASN1_BMPSTRING) | ||
| 708 | #define M_ASN1_BMPSTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 709 | #define M_i2d_ASN1_BMPSTRING(a,pp) \ | ||
| 710 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_BMPSTRING,\ | ||
| 711 | V_ASN1_UNIVERSAL) | ||
| 712 | #define M_d2i_ASN1_BMPSTRING(a,pp,l) \ | ||
| 713 | (ASN1_BMPSTRING *)d2i_ASN1_type_bytes\ | ||
| 714 | ((ASN1_STRING **)a,pp,l,B_ASN1_BMPSTRING) | ||
| 715 | |||
| 716 | #define M_ASN1_VISIBLESTRING_new() (ASN1_VISIBLESTRING *)\ | ||
| 717 | ASN1_STRING_type_new(V_ASN1_VISIBLESTRING) | ||
| 718 | #define M_ASN1_VISIBLESTRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 719 | #define M_i2d_ASN1_VISIBLESTRING(a,pp) \ | ||
| 720 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_VISIBLESTRING,\ | ||
| 721 | V_ASN1_UNIVERSAL) | ||
| 722 | #define M_d2i_ASN1_VISIBLESTRING(a,pp,l) \ | ||
| 723 | (ASN1_VISIBLESTRING *)d2i_ASN1_type_bytes\ | ||
| 724 | ((ASN1_STRING **)a,pp,l,B_ASN1_VISIBLESTRING) | ||
| 725 | |||
| 726 | #define M_ASN1_UTF8STRING_new() (ASN1_UTF8STRING *)\ | ||
| 727 | ASN1_STRING_type_new(V_ASN1_UTF8STRING) | ||
| 728 | #define M_ASN1_UTF8STRING_free(a) ASN1_STRING_free((ASN1_STRING *)a) | ||
| 729 | #define M_i2d_ASN1_UTF8STRING(a,pp) \ | ||
| 730 | i2d_ASN1_bytes((ASN1_STRING *)a,pp,V_ASN1_UTF8STRING,\ | ||
| 731 | V_ASN1_UNIVERSAL) | ||
| 732 | #define M_d2i_ASN1_UTF8STRING(a,pp,l) \ | ||
| 733 | (ASN1_UTF8STRING *)d2i_ASN1_type_bytes\ | ||
| 734 | ((ASN1_STRING **)a,pp,l,B_ASN1_UTF8STRING) | ||
| 735 | |||
| 736 | /* for the is_set parameter to i2d_ASN1_SET */ | ||
| 737 | #define IS_SEQUENCE 0 | ||
| 738 | #define IS_SET 1 | ||
| 739 | |||
| 740 | DECLARE_ASN1_FUNCTIONS_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE) | ||
| 741 | |||
| 742 | int ASN1_TYPE_get(ASN1_TYPE *a); | ||
| 743 | void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value); | ||
| 744 | int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value); | ||
| 745 | int ASN1_TYPE_cmp(ASN1_TYPE *a, ASN1_TYPE *b); | ||
| 746 | |||
| 747 | ASN1_OBJECT *ASN1_OBJECT_new(void ); | ||
| 748 | void ASN1_OBJECT_free(ASN1_OBJECT *a); | ||
| 749 | int i2d_ASN1_OBJECT(ASN1_OBJECT *a, unsigned char **pp); | ||
| 750 | ASN1_OBJECT *c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, | ||
| 751 | long length); | ||
| 752 | ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, | ||
| 753 | long length); | ||
| 754 | |||
| 755 | DECLARE_ASN1_ITEM(ASN1_OBJECT) | ||
| 756 | |||
| 757 | DECLARE_STACK_OF(ASN1_OBJECT) | ||
| 758 | DECLARE_ASN1_SET_OF(ASN1_OBJECT) | ||
| 759 | |||
| 760 | ASN1_STRING *ASN1_STRING_new(void); | ||
| 761 | void ASN1_STRING_free(ASN1_STRING *a); | ||
| 762 | int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str); | ||
| 763 | ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a); | ||
| 764 | ASN1_STRING *ASN1_STRING_type_new(int type ); | ||
| 765 | int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b); | ||
| 766 | /* Since this is used to store all sorts of things, via macros, for now, make | ||
| 767 | its data void * */ | ||
| 768 | int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len); | ||
| 769 | void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len); | ||
| 770 | int ASN1_STRING_length(const ASN1_STRING *x); | ||
| 771 | void ASN1_STRING_length_set(ASN1_STRING *x, int n); | ||
| 772 | int ASN1_STRING_type(ASN1_STRING *x); | ||
| 773 | unsigned char * ASN1_STRING_data(ASN1_STRING *x); | ||
| 774 | |||
| 775 | DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING) | ||
| 776 | int i2c_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **pp); | ||
| 777 | ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, | ||
| 778 | const unsigned char **pp, long length); | ||
| 779 | int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length ); | ||
| 780 | int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value); | ||
| 781 | int ASN1_BIT_STRING_get_bit(ASN1_BIT_STRING *a, int n); | ||
| 782 | int ASN1_BIT_STRING_check(ASN1_BIT_STRING *a, | ||
| 783 | unsigned char *flags, int flags_len); | ||
| 784 | |||
| 785 | #ifndef OPENSSL_NO_BIO | ||
| 786 | int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs, | ||
| 787 | BIT_STRING_BITNAME *tbl, int indent); | ||
| 788 | #endif | ||
| 789 | int ASN1_BIT_STRING_num_asc(char *name, BIT_STRING_BITNAME *tbl); | ||
| 790 | int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, char *name, int value, | ||
| 791 | BIT_STRING_BITNAME *tbl); | ||
| 792 | |||
| 793 | int i2d_ASN1_BOOLEAN(int a, unsigned char **pp); | ||
| 794 | int d2i_ASN1_BOOLEAN(int *a, const unsigned char **pp, long length); | ||
| 795 | |||
| 796 | DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER) | ||
| 797 | int i2c_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp); | ||
| 798 | ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp, | ||
| 799 | long length); | ||
| 800 | ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp, | ||
| 801 | long length); | ||
| 802 | ASN1_INTEGER * ASN1_INTEGER_dup(const ASN1_INTEGER *x); | ||
| 803 | int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y); | ||
| 804 | |||
| 805 | DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED) | ||
| 806 | |||
| 807 | int ASN1_UTCTIME_check(ASN1_UTCTIME *a); | ||
| 808 | ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t); | ||
| 809 | ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, | ||
| 810 | int offset_day, long offset_sec); | ||
| 811 | int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str); | ||
| 812 | int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t); | ||
| 813 | |||
| 814 | int ASN1_GENERALIZEDTIME_check(ASN1_GENERALIZEDTIME *a); | ||
| 815 | ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s, | ||
| 816 | time_t t); | ||
| 817 | ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, | ||
| 818 | time_t t, int offset_day, long offset_sec); | ||
| 819 | int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str); | ||
| 820 | |||
| 821 | DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING) | ||
| 822 | ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a); | ||
| 823 | int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a, | ||
| 824 | const ASN1_OCTET_STRING *b); | ||
| 825 | int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data, | ||
| 826 | int len); | ||
| 827 | |||
| 828 | DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING) | ||
| 829 | DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING) | ||
| 830 | DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING) | ||
| 831 | DECLARE_ASN1_FUNCTIONS(ASN1_NULL) | ||
| 832 | DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING) | ||
| 833 | |||
| 834 | DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE) | ||
| 835 | |||
| 836 | DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING) | ||
| 837 | DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT) | ||
| 838 | DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING) | ||
| 839 | DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING) | ||
| 840 | DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING) | ||
| 841 | DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING) | ||
| 842 | DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME) | ||
| 843 | DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME) | ||
| 844 | DECLARE_ASN1_FUNCTIONS(ASN1_TIME) | ||
| 845 | |||
| 846 | DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF) | ||
| 847 | |||
| 848 | ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t); | ||
| 849 | ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t, int offset_day, | ||
| 850 | long offset_sec); | ||
| 851 | int ASN1_TIME_check(ASN1_TIME *t); | ||
| 852 | ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t, | ||
| 853 | ASN1_GENERALIZEDTIME **out); | ||
| 854 | int ASN1_TIME_set_string(ASN1_TIME *s, const char *str); | ||
| 855 | |||
| 856 | int i2d_ASN1_SET(STACK_OF(OPENSSL_BLOCK) *a, unsigned char **pp, | ||
| 857 | i2d_of_void *i2d, int ex_tag, int ex_class, int is_set); | ||
| 858 | STACK_OF(OPENSSL_BLOCK) *d2i_ASN1_SET(STACK_OF(OPENSSL_BLOCK) **a, | ||
| 859 | const unsigned char **pp, long length, d2i_of_void *d2i, | ||
| 860 | void (*free_func)(OPENSSL_BLOCK), int ex_tag, int ex_class); | ||
| 861 | |||
| 862 | #ifndef OPENSSL_NO_BIO | ||
| 863 | int i2a_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *a); | ||
| 864 | int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size); | ||
| 865 | int i2a_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *a); | ||
| 866 | int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size); | ||
| 867 | int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a); | ||
| 868 | int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size); | ||
| 869 | int i2a_ASN1_STRING(BIO *bp, ASN1_STRING *a, int type); | ||
| 870 | #endif | ||
| 871 | int i2t_ASN1_OBJECT(char *buf, int buf_len, ASN1_OBJECT *a); | ||
| 872 | |||
| 873 | int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num); | ||
| 874 | ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len, | ||
| 875 | const char *sn, const char *ln); | ||
| 876 | |||
| 877 | int ASN1_INTEGER_set(ASN1_INTEGER *a, long v); | ||
| 878 | long ASN1_INTEGER_get(const ASN1_INTEGER *a); | ||
| 879 | ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai); | ||
| 880 | BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn); | ||
| 881 | |||
| 882 | int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v); | ||
| 883 | long ASN1_ENUMERATED_get(ASN1_ENUMERATED *a); | ||
| 884 | ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(BIGNUM *bn, ASN1_ENUMERATED *ai); | ||
| 885 | BIGNUM *ASN1_ENUMERATED_to_BN(ASN1_ENUMERATED *ai, BIGNUM *bn); | ||
| 886 | |||
| 887 | /* General */ | ||
| 888 | /* given a string, return the correct type, max is the maximum length */ | ||
| 889 | int ASN1_PRINTABLE_type(const unsigned char *s, int max); | ||
| 890 | |||
| 891 | int i2d_ASN1_bytes(ASN1_STRING *a, unsigned char **pp, int tag, int xclass); | ||
| 892 | ASN1_STRING *d2i_ASN1_bytes(ASN1_STRING **a, const unsigned char **pp, | ||
| 893 | long length, int Ptag, int Pclass); | ||
| 894 | unsigned long ASN1_tag2bit(int tag); | ||
| 895 | /* type is one or more of the B_ASN1_ values. */ | ||
| 896 | ASN1_STRING *d2i_ASN1_type_bytes(ASN1_STRING **a, const unsigned char **pp, | ||
| 897 | long length, int type); | ||
| 898 | |||
| 899 | /* PARSING */ | ||
| 900 | int asn1_Finish(ASN1_CTX *c); | ||
| 901 | int asn1_const_Finish(ASN1_const_CTX *c); | ||
| 902 | |||
| 903 | /* SPECIALS */ | ||
| 904 | int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag, | ||
| 905 | int *pclass, long omax); | ||
| 906 | int ASN1_check_infinite_end(unsigned char **p, long len); | ||
| 907 | int ASN1_const_check_infinite_end(const unsigned char **p, long len); | ||
| 908 | void ASN1_put_object(unsigned char **pp, int constructed, int length, int tag, | ||
| 909 | int xclass); | ||
| 910 | int ASN1_put_eoc(unsigned char **pp); | ||
| 911 | int ASN1_object_size(int constructed, int length, int tag); | ||
| 912 | |||
| 913 | /* Used to implement other functions */ | ||
| 914 | void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x); | ||
| 915 | |||
| 916 | #define ASN1_dup_of(type,i2d,d2i,x) \ | ||
| 917 | ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \ | ||
| 918 | CHECKED_D2I_OF(type, d2i), \ | ||
| 919 | CHECKED_PTR_OF(type, x))) | ||
| 920 | |||
| 921 | #define ASN1_dup_of_const(type,i2d,d2i,x) \ | ||
| 922 | ((type*)ASN1_dup(CHECKED_I2D_OF(const type, i2d), \ | ||
| 923 | CHECKED_D2I_OF(type, d2i), \ | ||
| 924 | CHECKED_PTR_OF(const type, x))) | ||
| 925 | |||
| 926 | void *ASN1_item_dup(const ASN1_ITEM *it, void *x); | ||
| 927 | |||
| 928 | /* ASN1 alloc/free macros for when a type is only used internally */ | ||
| 929 | |||
| 930 | #define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type)) | ||
| 931 | #define M_ASN1_free_of(x, type) \ | ||
| 932 | ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type)) | ||
| 933 | |||
| 934 | void *ASN1_d2i_fp(void *(*xnew)(void), d2i_of_void *d2i, FILE *in, void **x); | ||
| 935 | |||
| 936 | #define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \ | ||
| 937 | ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \ | ||
| 938 | CHECKED_D2I_OF(type, d2i), \ | ||
| 939 | in, \ | ||
| 940 | CHECKED_PPTR_OF(type, x))) | ||
| 941 | |||
| 942 | void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x); | ||
| 943 | int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x); | ||
| 944 | |||
| 945 | #define ASN1_i2d_fp_of(type,i2d,out,x) \ | ||
| 946 | (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \ | ||
| 947 | out, \ | ||
| 948 | CHECKED_PTR_OF(type, x))) | ||
| 949 | |||
| 950 | #define ASN1_i2d_fp_of_const(type,i2d,out,x) \ | ||
| 951 | (ASN1_i2d_fp(CHECKED_I2D_OF(const type, i2d), \ | ||
| 952 | out, \ | ||
| 953 | CHECKED_PTR_OF(const type, x))) | ||
| 954 | |||
| 955 | int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x); | ||
| 956 | int ASN1_STRING_print_ex_fp(FILE *fp, ASN1_STRING *str, unsigned long flags); | ||
| 957 | |||
| 958 | int ASN1_STRING_to_UTF8(unsigned char **out, ASN1_STRING *in); | ||
| 959 | |||
| 960 | #ifndef OPENSSL_NO_BIO | ||
| 961 | void *ASN1_d2i_bio(void *(*xnew)(void), d2i_of_void *d2i, BIO *in, void **x); | ||
| 962 | |||
| 963 | #define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \ | ||
| 964 | ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \ | ||
| 965 | CHECKED_D2I_OF(type, d2i), \ | ||
| 966 | in, \ | ||
| 967 | CHECKED_PPTR_OF(type, x))) | ||
| 968 | |||
| 969 | void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x); | ||
| 970 | int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x); | ||
| 971 | |||
| 972 | #define ASN1_i2d_bio_of(type,i2d,out,x) \ | ||
| 973 | (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \ | ||
| 974 | out, \ | ||
| 975 | CHECKED_PTR_OF(type, x))) | ||
| 976 | |||
| 977 | #define ASN1_i2d_bio_of_const(type,i2d,out,x) \ | ||
| 978 | (ASN1_i2d_bio(CHECKED_I2D_OF(const type, i2d), \ | ||
| 979 | out, \ | ||
| 980 | CHECKED_PTR_OF(const type, x))) | ||
| 981 | |||
| 982 | int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x); | ||
| 983 | int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a); | ||
| 984 | int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a); | ||
| 985 | int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a); | ||
| 986 | int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v); | ||
| 987 | int ASN1_STRING_print_ex(BIO *out, ASN1_STRING *str, unsigned long flags); | ||
| 988 | int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num, | ||
| 989 | unsigned char *buf, int off); | ||
| 990 | int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent); | ||
| 991 | int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, int dump); | ||
| 992 | #endif | ||
| 993 | const char *ASN1_tag2str(int tag); | ||
| 994 | |||
| 995 | /* Used to load and write netscape format cert */ | ||
| 996 | |||
| 997 | DECLARE_ASN1_FUNCTIONS(NETSCAPE_X509) | ||
| 998 | |||
| 999 | int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s); | ||
| 1000 | |||
| 1001 | int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len); | ||
| 1002 | int ASN1_TYPE_get_octetstring(ASN1_TYPE *a, unsigned char *data, int max_len); | ||
| 1003 | int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, unsigned char *data, | ||
| 1004 | int len); | ||
| 1005 | int ASN1_TYPE_get_int_octetstring(ASN1_TYPE *a, long *num, unsigned char *data, | ||
| 1006 | int max_len); | ||
| 1007 | |||
| 1008 | STACK_OF(OPENSSL_BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len, | ||
| 1009 | d2i_of_void *d2i, void (*free_func)(OPENSSL_BLOCK)); | ||
| 1010 | unsigned char *ASN1_seq_pack(STACK_OF(OPENSSL_BLOCK) *safes, i2d_of_void *i2d, | ||
| 1011 | unsigned char **buf, int *len ); | ||
| 1012 | void *ASN1_unpack_string(ASN1_STRING *oct, d2i_of_void *d2i); | ||
| 1013 | void *ASN1_item_unpack(ASN1_STRING *oct, const ASN1_ITEM *it); | ||
| 1014 | ASN1_STRING *ASN1_pack_string(void *obj, i2d_of_void *i2d, | ||
| 1015 | ASN1_OCTET_STRING **oct); | ||
| 1016 | |||
| 1017 | ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, | ||
| 1018 | ASN1_OCTET_STRING **oct); | ||
| 1019 | |||
| 1020 | void ASN1_STRING_set_default_mask(unsigned long mask); | ||
| 1021 | int ASN1_STRING_set_default_mask_asc(const char *p); | ||
| 1022 | unsigned long ASN1_STRING_get_default_mask(void); | ||
| 1023 | int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, | ||
| 1024 | int inform, unsigned long mask); | ||
| 1025 | int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, | ||
| 1026 | int inform, unsigned long mask, long minsize, long maxsize); | ||
| 1027 | |||
| 1028 | ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, | ||
| 1029 | const unsigned char *in, int inlen, int inform, int nid); | ||
| 1030 | ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid); | ||
| 1031 | int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long); | ||
| 1032 | void ASN1_STRING_TABLE_cleanup(void); | ||
| 1033 | |||
| 1034 | /* ASN1 template functions */ | ||
| 1035 | |||
| 1036 | /* Old API compatible functions */ | ||
| 1037 | ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it); | ||
| 1038 | void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it); | ||
| 1039 | ASN1_VALUE * ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in, | ||
| 1040 | long len, const ASN1_ITEM *it); | ||
| 1041 | int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it); | ||
| 1042 | int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it); | ||
| 1043 | |||
| 1044 | void ASN1_add_oid_module(void); | ||
| 1045 | |||
| 1046 | ASN1_TYPE *ASN1_generate_nconf(char *str, CONF *nconf); | ||
| 1047 | ASN1_TYPE *ASN1_generate_v3(char *str, X509V3_CTX *cnf); | ||
| 1048 | |||
| 1049 | /* ASN1 Print flags */ | ||
| 1050 | |||
| 1051 | /* Indicate missing OPTIONAL fields */ | ||
| 1052 | #define ASN1_PCTX_FLAGS_SHOW_ABSENT 0x001 | ||
| 1053 | /* Mark start and end of SEQUENCE */ | ||
| 1054 | #define ASN1_PCTX_FLAGS_SHOW_SEQUENCE 0x002 | ||
| 1055 | /* Mark start and end of SEQUENCE/SET OF */ | ||
| 1056 | #define ASN1_PCTX_FLAGS_SHOW_SSOF 0x004 | ||
| 1057 | /* Show the ASN1 type of primitives */ | ||
| 1058 | #define ASN1_PCTX_FLAGS_SHOW_TYPE 0x008 | ||
| 1059 | /* Don't show ASN1 type of ANY */ | ||
| 1060 | #define ASN1_PCTX_FLAGS_NO_ANY_TYPE 0x010 | ||
| 1061 | /* Don't show ASN1 type of MSTRINGs */ | ||
| 1062 | #define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE 0x020 | ||
| 1063 | /* Don't show field names in SEQUENCE */ | ||
| 1064 | #define ASN1_PCTX_FLAGS_NO_FIELD_NAME 0x040 | ||
| 1065 | /* Show structure names of each SEQUENCE field */ | ||
| 1066 | #define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME 0x080 | ||
| 1067 | /* Don't show structure name even at top level */ | ||
| 1068 | #define ASN1_PCTX_FLAGS_NO_STRUCT_NAME 0x100 | ||
| 1069 | |||
| 1070 | int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent, | ||
| 1071 | const ASN1_ITEM *it, const ASN1_PCTX *pctx); | ||
| 1072 | ASN1_PCTX *ASN1_PCTX_new(void); | ||
| 1073 | void ASN1_PCTX_free(ASN1_PCTX *p); | ||
| 1074 | unsigned long ASN1_PCTX_get_flags(ASN1_PCTX *p); | ||
| 1075 | void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags); | ||
| 1076 | unsigned long ASN1_PCTX_get_nm_flags(ASN1_PCTX *p); | ||
| 1077 | void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags); | ||
| 1078 | unsigned long ASN1_PCTX_get_cert_flags(ASN1_PCTX *p); | ||
| 1079 | void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags); | ||
| 1080 | unsigned long ASN1_PCTX_get_oid_flags(ASN1_PCTX *p); | ||
| 1081 | void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags); | ||
| 1082 | unsigned long ASN1_PCTX_get_str_flags(ASN1_PCTX *p); | ||
| 1083 | void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags); | ||
| 1084 | |||
| 1085 | BIO_METHOD *BIO_f_asn1(void); | ||
| 1086 | |||
| 1087 | BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it); | ||
| 1088 | |||
| 1089 | int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, | ||
| 1090 | const ASN1_ITEM *it); | ||
| 1091 | int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, | ||
| 1092 | const char *hdr, const ASN1_ITEM *it); | ||
| 1093 | int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags, | ||
| 1094 | int ctype_nid, int econt_nid, STACK_OF(X509_ALGOR) *mdalgs, | ||
| 1095 | const ASN1_ITEM *it); | ||
| 1096 | ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it); | ||
| 1097 | int SMIME_crlf_copy(BIO *in, BIO *out, int flags); | ||
| 1098 | int SMIME_text(BIO *in, BIO *out); | ||
| 1099 | |||
| 1100 | /* BEGIN ERROR CODES */ | ||
| 1101 | /* The following lines are auto generated by the script mkerr.pl. Any changes | ||
| 1102 | * made after this point may be overwritten when the script is next run. | ||
| 1103 | */ | ||
| 1104 | void ERR_load_ASN1_strings(void); | ||
| 1105 | |||
| 1106 | /* Error codes for the ASN1 functions. */ | ||
| 1107 | |||
| 1108 | /* Function codes. */ | ||
| 1109 | #define ASN1_F_A2D_ASN1_OBJECT 100 | ||
| 1110 | #define ASN1_F_A2I_ASN1_ENUMERATED 101 | ||
| 1111 | #define ASN1_F_A2I_ASN1_INTEGER 102 | ||
| 1112 | #define ASN1_F_A2I_ASN1_STRING 103 | ||
| 1113 | #define ASN1_F_APPEND_EXP 176 | ||
| 1114 | #define ASN1_F_ASN1_BIT_STRING_SET_BIT 183 | ||
| 1115 | #define ASN1_F_ASN1_CB 177 | ||
| 1116 | #define ASN1_F_ASN1_CHECK_TLEN 104 | ||
| 1117 | #define ASN1_F_ASN1_COLLATE_PRIMITIVE 105 | ||
| 1118 | #define ASN1_F_ASN1_COLLECT 106 | ||
| 1119 | #define ASN1_F_ASN1_D2I_EX_PRIMITIVE 108 | ||
| 1120 | #define ASN1_F_ASN1_D2I_FP 109 | ||
| 1121 | #define ASN1_F_ASN1_D2I_READ_BIO 107 | ||
| 1122 | #define ASN1_F_ASN1_DIGEST 184 | ||
| 1123 | #define ASN1_F_ASN1_DO_ADB 110 | ||
| 1124 | #define ASN1_F_ASN1_DUP 111 | ||
| 1125 | #define ASN1_F_ASN1_ENUMERATED_SET 112 | ||
| 1126 | #define ASN1_F_ASN1_ENUMERATED_TO_BN 113 | ||
| 1127 | #define ASN1_F_ASN1_EX_C2I 204 | ||
| 1128 | #define ASN1_F_ASN1_FIND_END 190 | ||
| 1129 | #define ASN1_F_ASN1_GENERALIZEDTIME_ADJ 216 | ||
| 1130 | #define ASN1_F_ASN1_GENERALIZEDTIME_SET 185 | ||
| 1131 | #define ASN1_F_ASN1_GENERATE_V3 178 | ||
| 1132 | #define ASN1_F_ASN1_GET_OBJECT 114 | ||
| 1133 | #define ASN1_F_ASN1_HEADER_NEW 115 | ||
| 1134 | #define ASN1_F_ASN1_I2D_BIO 116 | ||
| 1135 | #define ASN1_F_ASN1_I2D_FP 117 | ||
| 1136 | #define ASN1_F_ASN1_INTEGER_SET 118 | ||
| 1137 | #define ASN1_F_ASN1_INTEGER_TO_BN 119 | ||
| 1138 | #define ASN1_F_ASN1_ITEM_D2I_FP 206 | ||
| 1139 | #define ASN1_F_ASN1_ITEM_DUP 191 | ||
| 1140 | #define ASN1_F_ASN1_ITEM_EX_COMBINE_NEW 121 | ||
| 1141 | #define ASN1_F_ASN1_ITEM_EX_D2I 120 | ||
| 1142 | #define ASN1_F_ASN1_ITEM_I2D_BIO 192 | ||
| 1143 | #define ASN1_F_ASN1_ITEM_I2D_FP 193 | ||
| 1144 | #define ASN1_F_ASN1_ITEM_PACK 198 | ||
| 1145 | #define ASN1_F_ASN1_ITEM_SIGN 195 | ||
| 1146 | #define ASN1_F_ASN1_ITEM_SIGN_CTX 220 | ||
| 1147 | #define ASN1_F_ASN1_ITEM_UNPACK 199 | ||
| 1148 | #define ASN1_F_ASN1_ITEM_VERIFY 197 | ||
| 1149 | #define ASN1_F_ASN1_MBSTRING_NCOPY 122 | ||
| 1150 | #define ASN1_F_ASN1_OBJECT_NEW 123 | ||
| 1151 | #define ASN1_F_ASN1_OUTPUT_DATA 214 | ||
| 1152 | #define ASN1_F_ASN1_PACK_STRING 124 | ||
| 1153 | #define ASN1_F_ASN1_PCTX_NEW 205 | ||
| 1154 | #define ASN1_F_ASN1_PKCS5_PBE_SET 125 | ||
| 1155 | #define ASN1_F_ASN1_SEQ_PACK 126 | ||
| 1156 | #define ASN1_F_ASN1_SEQ_UNPACK 127 | ||
| 1157 | #define ASN1_F_ASN1_SIGN 128 | ||
| 1158 | #define ASN1_F_ASN1_STR2TYPE 179 | ||
| 1159 | #define ASN1_F_ASN1_STRING_SET 186 | ||
| 1160 | #define ASN1_F_ASN1_STRING_TABLE_ADD 129 | ||
| 1161 | #define ASN1_F_ASN1_STRING_TYPE_NEW 130 | ||
| 1162 | #define ASN1_F_ASN1_TEMPLATE_EX_D2I 132 | ||
| 1163 | #define ASN1_F_ASN1_TEMPLATE_NEW 133 | ||
| 1164 | #define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I 131 | ||
| 1165 | #define ASN1_F_ASN1_TIME_ADJ 217 | ||
| 1166 | #define ASN1_F_ASN1_TIME_SET 175 | ||
| 1167 | #define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING 134 | ||
| 1168 | #define ASN1_F_ASN1_TYPE_GET_OCTETSTRING 135 | ||
| 1169 | #define ASN1_F_ASN1_UNPACK_STRING 136 | ||
| 1170 | #define ASN1_F_ASN1_UTCTIME_ADJ 218 | ||
| 1171 | #define ASN1_F_ASN1_UTCTIME_SET 187 | ||
| 1172 | #define ASN1_F_ASN1_VERIFY 137 | ||
| 1173 | #define ASN1_F_B64_READ_ASN1 209 | ||
| 1174 | #define ASN1_F_B64_WRITE_ASN1 210 | ||
| 1175 | #define ASN1_F_BIO_NEW_NDEF 208 | ||
| 1176 | #define ASN1_F_BITSTR_CB 180 | ||
| 1177 | #define ASN1_F_BN_TO_ASN1_ENUMERATED 138 | ||
| 1178 | #define ASN1_F_BN_TO_ASN1_INTEGER 139 | ||
| 1179 | #define ASN1_F_C2I_ASN1_BIT_STRING 189 | ||
| 1180 | #define ASN1_F_C2I_ASN1_INTEGER 194 | ||
| 1181 | #define ASN1_F_C2I_ASN1_OBJECT 196 | ||
| 1182 | #define ASN1_F_COLLECT_DATA 140 | ||
| 1183 | #define ASN1_F_D2I_ASN1_BIT_STRING 141 | ||
| 1184 | #define ASN1_F_D2I_ASN1_BOOLEAN 142 | ||
| 1185 | #define ASN1_F_D2I_ASN1_BYTES 143 | ||
| 1186 | #define ASN1_F_D2I_ASN1_GENERALIZEDTIME 144 | ||
| 1187 | #define ASN1_F_D2I_ASN1_HEADER 145 | ||
| 1188 | #define ASN1_F_D2I_ASN1_INTEGER 146 | ||
| 1189 | #define ASN1_F_D2I_ASN1_OBJECT 147 | ||
| 1190 | #define ASN1_F_D2I_ASN1_SET 148 | ||
| 1191 | #define ASN1_F_D2I_ASN1_TYPE_BYTES 149 | ||
| 1192 | #define ASN1_F_D2I_ASN1_UINTEGER 150 | ||
| 1193 | #define ASN1_F_D2I_ASN1_UTCTIME 151 | ||
| 1194 | #define ASN1_F_D2I_AUTOPRIVATEKEY 207 | ||
| 1195 | #define ASN1_F_D2I_NETSCAPE_RSA 152 | ||
| 1196 | #define ASN1_F_D2I_NETSCAPE_RSA_2 153 | ||
| 1197 | #define ASN1_F_D2I_PRIVATEKEY 154 | ||
| 1198 | #define ASN1_F_D2I_PUBLICKEY 155 | ||
| 1199 | #define ASN1_F_D2I_RSA_NET 200 | ||
| 1200 | #define ASN1_F_D2I_RSA_NET_2 201 | ||
| 1201 | #define ASN1_F_D2I_X509 156 | ||
| 1202 | #define ASN1_F_D2I_X509_CINF 157 | ||
| 1203 | #define ASN1_F_D2I_X509_PKEY 159 | ||
| 1204 | #define ASN1_F_I2D_ASN1_BIO_STREAM 211 | ||
| 1205 | #define ASN1_F_I2D_ASN1_SET 188 | ||
| 1206 | #define ASN1_F_I2D_ASN1_TIME 160 | ||
| 1207 | #define ASN1_F_I2D_DSA_PUBKEY 161 | ||
| 1208 | #define ASN1_F_I2D_EC_PUBKEY 181 | ||
| 1209 | #define ASN1_F_I2D_PRIVATEKEY 163 | ||
| 1210 | #define ASN1_F_I2D_PUBLICKEY 164 | ||
| 1211 | #define ASN1_F_I2D_RSA_NET 162 | ||
| 1212 | #define ASN1_F_I2D_RSA_PUBKEY 165 | ||
| 1213 | #define ASN1_F_LONG_C2I 166 | ||
| 1214 | #define ASN1_F_OID_MODULE_INIT 174 | ||
| 1215 | #define ASN1_F_PARSE_TAGGING 182 | ||
| 1216 | #define ASN1_F_PKCS5_PBE2_SET_IV 167 | ||
| 1217 | #define ASN1_F_PKCS5_PBE_SET 202 | ||
| 1218 | #define ASN1_F_PKCS5_PBE_SET0_ALGOR 215 | ||
| 1219 | #define ASN1_F_PKCS5_PBKDF2_SET 219 | ||
| 1220 | #define ASN1_F_SMIME_READ_ASN1 212 | ||
| 1221 | #define ASN1_F_SMIME_TEXT 213 | ||
| 1222 | #define ASN1_F_X509_CINF_NEW 168 | ||
| 1223 | #define ASN1_F_X509_CRL_ADD0_REVOKED 169 | ||
| 1224 | #define ASN1_F_X509_INFO_NEW 170 | ||
| 1225 | #define ASN1_F_X509_NAME_ENCODE 203 | ||
| 1226 | #define ASN1_F_X509_NAME_EX_D2I 158 | ||
| 1227 | #define ASN1_F_X509_NAME_EX_NEW 171 | ||
| 1228 | #define ASN1_F_X509_NEW 172 | ||
| 1229 | #define ASN1_F_X509_PKEY_NEW 173 | ||
| 1230 | |||
| 1231 | /* Reason codes. */ | ||
| 1232 | #define ASN1_R_ADDING_OBJECT 171 | ||
| 1233 | #define ASN1_R_ASN1_PARSE_ERROR 203 | ||
| 1234 | #define ASN1_R_ASN1_SIG_PARSE_ERROR 204 | ||
| 1235 | #define ASN1_R_AUX_ERROR 100 | ||
| 1236 | #define ASN1_R_BAD_CLASS 101 | ||
| 1237 | #define ASN1_R_BAD_OBJECT_HEADER 102 | ||
| 1238 | #define ASN1_R_BAD_PASSWORD_READ 103 | ||
| 1239 | #define ASN1_R_BAD_TAG 104 | ||
| 1240 | #define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214 | ||
| 1241 | #define ASN1_R_BN_LIB 105 | ||
| 1242 | #define ASN1_R_BOOLEAN_IS_WRONG_LENGTH 106 | ||
| 1243 | #define ASN1_R_BUFFER_TOO_SMALL 107 | ||
| 1244 | #define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 108 | ||
| 1245 | #define ASN1_R_CONTEXT_NOT_INITIALISED 217 | ||
| 1246 | #define ASN1_R_DATA_IS_WRONG 109 | ||
| 1247 | #define ASN1_R_DECODE_ERROR 110 | ||
| 1248 | #define ASN1_R_DECODING_ERROR 111 | ||
| 1249 | #define ASN1_R_DEPTH_EXCEEDED 174 | ||
| 1250 | #define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED 198 | ||
| 1251 | #define ASN1_R_ENCODE_ERROR 112 | ||
| 1252 | #define ASN1_R_ERROR_GETTING_TIME 173 | ||
| 1253 | #define ASN1_R_ERROR_LOADING_SECTION 172 | ||
| 1254 | #define ASN1_R_ERROR_PARSING_SET_ELEMENT 113 | ||
| 1255 | #define ASN1_R_ERROR_SETTING_CIPHER_PARAMS 114 | ||
| 1256 | #define ASN1_R_EXPECTING_AN_INTEGER 115 | ||
| 1257 | #define ASN1_R_EXPECTING_AN_OBJECT 116 | ||
| 1258 | #define ASN1_R_EXPECTING_A_BOOLEAN 117 | ||
| 1259 | #define ASN1_R_EXPECTING_A_TIME 118 | ||
| 1260 | #define ASN1_R_EXPLICIT_LENGTH_MISMATCH 119 | ||
| 1261 | #define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED 120 | ||
| 1262 | #define ASN1_R_FIELD_MISSING 121 | ||
| 1263 | #define ASN1_R_FIRST_NUM_TOO_LARGE 122 | ||
| 1264 | #define ASN1_R_HEADER_TOO_LONG 123 | ||
| 1265 | #define ASN1_R_ILLEGAL_BITSTRING_FORMAT 175 | ||
| 1266 | #define ASN1_R_ILLEGAL_BOOLEAN 176 | ||
| 1267 | #define ASN1_R_ILLEGAL_CHARACTERS 124 | ||
| 1268 | #define ASN1_R_ILLEGAL_FORMAT 177 | ||
| 1269 | #define ASN1_R_ILLEGAL_HEX 178 | ||
| 1270 | #define ASN1_R_ILLEGAL_IMPLICIT_TAG 179 | ||
| 1271 | #define ASN1_R_ILLEGAL_INTEGER 180 | ||
| 1272 | #define ASN1_R_ILLEGAL_NESTED_TAGGING 181 | ||
| 1273 | #define ASN1_R_ILLEGAL_NULL 125 | ||
| 1274 | #define ASN1_R_ILLEGAL_NULL_VALUE 182 | ||
| 1275 | #define ASN1_R_ILLEGAL_OBJECT 183 | ||
| 1276 | #define ASN1_R_ILLEGAL_OPTIONAL_ANY 126 | ||
| 1277 | #define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE 170 | ||
| 1278 | #define ASN1_R_ILLEGAL_TAGGED_ANY 127 | ||
| 1279 | #define ASN1_R_ILLEGAL_TIME_VALUE 184 | ||
| 1280 | #define ASN1_R_INTEGER_NOT_ASCII_FORMAT 185 | ||
| 1281 | #define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG 128 | ||
| 1282 | #define ASN1_R_INVALID_BIT_STRING_BITS_LEFT 220 | ||
| 1283 | #define ASN1_R_INVALID_BMPSTRING_LENGTH 129 | ||
| 1284 | #define ASN1_R_INVALID_DIGIT 130 | ||
| 1285 | #define ASN1_R_INVALID_MIME_TYPE 205 | ||
| 1286 | #define ASN1_R_INVALID_MODIFIER 186 | ||
| 1287 | #define ASN1_R_INVALID_NUMBER 187 | ||
| 1288 | #define ASN1_R_INVALID_OBJECT_ENCODING 216 | ||
| 1289 | #define ASN1_R_INVALID_SEPARATOR 131 | ||
| 1290 | #define ASN1_R_INVALID_TIME_FORMAT 132 | ||
| 1291 | #define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH 133 | ||
| 1292 | #define ASN1_R_INVALID_UTF8STRING 134 | ||
| 1293 | #define ASN1_R_IV_TOO_LARGE 135 | ||
| 1294 | #define ASN1_R_LENGTH_ERROR 136 | ||
| 1295 | #define ASN1_R_LIST_ERROR 188 | ||
| 1296 | #define ASN1_R_MIME_NO_CONTENT_TYPE 206 | ||
| 1297 | #define ASN1_R_MIME_PARSE_ERROR 207 | ||
| 1298 | #define ASN1_R_MIME_SIG_PARSE_ERROR 208 | ||
| 1299 | #define ASN1_R_MISSING_EOC 137 | ||
| 1300 | #define ASN1_R_MISSING_SECOND_NUMBER 138 | ||
| 1301 | #define ASN1_R_MISSING_VALUE 189 | ||
| 1302 | #define ASN1_R_MSTRING_NOT_UNIVERSAL 139 | ||
| 1303 | #define ASN1_R_MSTRING_WRONG_TAG 140 | ||
| 1304 | #define ASN1_R_NESTED_ASN1_STRING 197 | ||
| 1305 | #define ASN1_R_NON_HEX_CHARACTERS 141 | ||
| 1306 | #define ASN1_R_NOT_ASCII_FORMAT 190 | ||
| 1307 | #define ASN1_R_NOT_ENOUGH_DATA 142 | ||
| 1308 | #define ASN1_R_NO_CONTENT_TYPE 209 | ||
| 1309 | #define ASN1_R_NO_DEFAULT_DIGEST 201 | ||
| 1310 | #define ASN1_R_NO_MATCHING_CHOICE_TYPE 143 | ||
| 1311 | #define ASN1_R_NO_MULTIPART_BODY_FAILURE 210 | ||
| 1312 | #define ASN1_R_NO_MULTIPART_BOUNDARY 211 | ||
| 1313 | #define ASN1_R_NO_SIG_CONTENT_TYPE 212 | ||
| 1314 | #define ASN1_R_NULL_IS_WRONG_LENGTH 144 | ||
| 1315 | #define ASN1_R_OBJECT_NOT_ASCII_FORMAT 191 | ||
| 1316 | #define ASN1_R_ODD_NUMBER_OF_CHARS 145 | ||
| 1317 | #define ASN1_R_PRIVATE_KEY_HEADER_MISSING 146 | ||
| 1318 | #define ASN1_R_SECOND_NUMBER_TOO_LARGE 147 | ||
| 1319 | #define ASN1_R_SEQUENCE_LENGTH_MISMATCH 148 | ||
| 1320 | #define ASN1_R_SEQUENCE_NOT_CONSTRUCTED 149 | ||
| 1321 | #define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG 192 | ||
| 1322 | #define ASN1_R_SHORT_LINE 150 | ||
| 1323 | #define ASN1_R_SIG_INVALID_MIME_TYPE 213 | ||
| 1324 | #define ASN1_R_STREAMING_NOT_SUPPORTED 202 | ||
| 1325 | #define ASN1_R_STRING_TOO_LONG 151 | ||
| 1326 | #define ASN1_R_STRING_TOO_SHORT 152 | ||
| 1327 | #define ASN1_R_TAG_VALUE_TOO_HIGH 153 | ||
| 1328 | #define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154 | ||
| 1329 | #define ASN1_R_TIME_NOT_ASCII_FORMAT 193 | ||
| 1330 | #define ASN1_R_TOO_LONG 155 | ||
| 1331 | #define ASN1_R_TYPE_NOT_CONSTRUCTED 156 | ||
| 1332 | #define ASN1_R_UNABLE_TO_DECODE_RSA_KEY 157 | ||
| 1333 | #define ASN1_R_UNABLE_TO_DECODE_RSA_PRIVATE_KEY 158 | ||
| 1334 | #define ASN1_R_UNEXPECTED_EOC 159 | ||
| 1335 | #define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH 215 | ||
| 1336 | #define ASN1_R_UNKNOWN_FORMAT 160 | ||
| 1337 | #define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM 161 | ||
| 1338 | #define ASN1_R_UNKNOWN_OBJECT_TYPE 162 | ||
| 1339 | #define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE 163 | ||
| 1340 | #define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199 | ||
| 1341 | #define ASN1_R_UNKNOWN_TAG 194 | ||
| 1342 | #define ASN1_R_UNKOWN_FORMAT 195 | ||
| 1343 | #define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164 | ||
| 1344 | #define ASN1_R_UNSUPPORTED_CIPHER 165 | ||
| 1345 | #define ASN1_R_UNSUPPORTED_ENCRYPTION_ALGORITHM 166 | ||
| 1346 | #define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167 | ||
| 1347 | #define ASN1_R_UNSUPPORTED_TYPE 196 | ||
| 1348 | #define ASN1_R_WRONG_PUBLIC_KEY_TYPE 200 | ||
| 1349 | #define ASN1_R_WRONG_TAG 168 | ||
| 1350 | #define ASN1_R_WRONG_TYPE 169 | ||
| 1351 | |||
| 1352 | #ifdef __cplusplus | ||
| 1353 | } | ||
| 1354 | #endif | ||
| 1355 | #endif | ||
diff --git a/src/lib/libcrypto/asn1/asn1_err.c b/src/lib/libcrypto/asn1/asn1_err.c deleted file mode 100644 index 8fd5cf6765..0000000000 --- a/src/lib/libcrypto/asn1/asn1_err.c +++ /dev/null | |||
| @@ -1,333 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn1_err.c,v 1.19 2015/02/15 14:35:30 miod Exp $ */ | ||
| 2 | /* ==================================================================== | ||
| 3 | * Copyright (c) 1999-2011 The OpenSSL Project. All rights reserved. | ||
| 4 | * | ||
| 5 | * Redistribution and use in source and binary forms, with or without | ||
| 6 | * modification, are permitted provided that the following conditions | ||
| 7 | * are met: | ||
| 8 | * | ||
| 9 | * 1. Redistributions of source code must retain the above copyright | ||
| 10 | * notice, this list of conditions and the following disclaimer. | ||
| 11 | * | ||
| 12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 13 | * notice, this list of conditions and the following disclaimer in | ||
| 14 | * the documentation and/or other materials provided with the | ||
| 15 | * distribution. | ||
| 16 | * | ||
| 17 | * 3. All advertising materials mentioning features or use of this | ||
| 18 | * software must display the following acknowledgment: | ||
| 19 | * "This product includes software developed by the OpenSSL Project | ||
| 20 | * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" | ||
| 21 | * | ||
| 22 | * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to | ||
| 23 | * endorse or promote products derived from this software without | ||
| 24 | * prior written permission. For written permission, please contact | ||
| 25 | * openssl-core@OpenSSL.org. | ||
| 26 | * | ||
| 27 | * 5. Products derived from this software may not be called "OpenSSL" | ||
| 28 | * nor may "OpenSSL" appear in their names without prior written | ||
| 29 | * permission of the OpenSSL Project. | ||
| 30 | * | ||
| 31 | * 6. Redistributions of any form whatsoever must retain the following | ||
| 32 | * acknowledgment: | ||
| 33 | * "This product includes software developed by the OpenSSL Project | ||
| 34 | * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" | ||
| 35 | * | ||
| 36 | * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY | ||
| 37 | * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 38 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | ||
| 39 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR | ||
| 40 | * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | ||
| 41 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
| 42 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
| 43 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 44 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | ||
| 45 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | ||
| 46 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED | ||
| 47 | * OF THE POSSIBILITY OF SUCH DAMAGE. | ||
| 48 | * ==================================================================== | ||
| 49 | * | ||
| 50 | * This product includes cryptographic software written by Eric Young | ||
| 51 | * (eay@cryptsoft.com). This product includes software written by Tim | ||
| 52 | * Hudson (tjh@cryptsoft.com). | ||
| 53 | * | ||
| 54 | */ | ||
| 55 | |||
| 56 | /* NOTE: this file was auto generated by the mkerr.pl script: any changes | ||
| 57 | * made to it will be overwritten when the script next updates this file, | ||
| 58 | * only reason strings will be preserved. | ||
| 59 | */ | ||
| 60 | |||
| 61 | #include <stdio.h> | ||
| 62 | |||
| 63 | #include <openssl/opensslconf.h> | ||
| 64 | |||
| 65 | #include <openssl/err.h> | ||
| 66 | #include <openssl/asn1.h> | ||
| 67 | |||
| 68 | /* BEGIN ERROR CODES */ | ||
| 69 | #ifndef OPENSSL_NO_ERR | ||
| 70 | |||
| 71 | #define ERR_FUNC(func) ERR_PACK(ERR_LIB_ASN1,func,0) | ||
| 72 | #define ERR_REASON(reason) ERR_PACK(ERR_LIB_ASN1,0,reason) | ||
| 73 | |||
| 74 | static ERR_STRING_DATA ASN1_str_functs[] = { | ||
| 75 | {ERR_FUNC(ASN1_F_A2D_ASN1_OBJECT), "a2d_ASN1_OBJECT"}, | ||
| 76 | {ERR_FUNC(ASN1_F_A2I_ASN1_ENUMERATED), "a2i_ASN1_ENUMERATED"}, | ||
| 77 | {ERR_FUNC(ASN1_F_A2I_ASN1_INTEGER), "a2i_ASN1_INTEGER"}, | ||
| 78 | {ERR_FUNC(ASN1_F_A2I_ASN1_STRING), "a2i_ASN1_STRING"}, | ||
| 79 | {ERR_FUNC(ASN1_F_APPEND_EXP), "APPEND_EXP"}, | ||
| 80 | {ERR_FUNC(ASN1_F_ASN1_BIT_STRING_SET_BIT), "ASN1_BIT_STRING_set_bit"}, | ||
| 81 | {ERR_FUNC(ASN1_F_ASN1_CB), "ASN1_CB"}, | ||
| 82 | {ERR_FUNC(ASN1_F_ASN1_CHECK_TLEN), "ASN1_CHECK_TLEN"}, | ||
| 83 | {ERR_FUNC(ASN1_F_ASN1_COLLATE_PRIMITIVE), "ASN1_COLLATE_PRIMITIVE"}, | ||
| 84 | {ERR_FUNC(ASN1_F_ASN1_COLLECT), "ASN1_COLLECT"}, | ||
| 85 | {ERR_FUNC(ASN1_F_ASN1_D2I_EX_PRIMITIVE), "ASN1_D2I_EX_PRIMITIVE"}, | ||
| 86 | {ERR_FUNC(ASN1_F_ASN1_D2I_FP), "ASN1_d2i_fp"}, | ||
| 87 | {ERR_FUNC(ASN1_F_ASN1_D2I_READ_BIO), "ASN1_D2I_READ_BIO"}, | ||
| 88 | {ERR_FUNC(ASN1_F_ASN1_DIGEST), "ASN1_digest"}, | ||
| 89 | {ERR_FUNC(ASN1_F_ASN1_DO_ADB), "ASN1_DO_ADB"}, | ||
| 90 | {ERR_FUNC(ASN1_F_ASN1_DUP), "ASN1_dup"}, | ||
| 91 | {ERR_FUNC(ASN1_F_ASN1_ENUMERATED_SET), "ASN1_ENUMERATED_set"}, | ||
| 92 | {ERR_FUNC(ASN1_F_ASN1_ENUMERATED_TO_BN), "ASN1_ENUMERATED_to_BN"}, | ||
| 93 | {ERR_FUNC(ASN1_F_ASN1_EX_C2I), "ASN1_EX_C2I"}, | ||
| 94 | {ERR_FUNC(ASN1_F_ASN1_FIND_END), "ASN1_FIND_END"}, | ||
| 95 | {ERR_FUNC(ASN1_F_ASN1_GENERALIZEDTIME_ADJ), "ASN1_GENERALIZEDTIME_adj"}, | ||
| 96 | {ERR_FUNC(ASN1_F_ASN1_GENERALIZEDTIME_SET), "ASN1_GENERALIZEDTIME_set"}, | ||
| 97 | {ERR_FUNC(ASN1_F_ASN1_GENERATE_V3), "ASN1_generate_v3"}, | ||
| 98 | {ERR_FUNC(ASN1_F_ASN1_GET_OBJECT), "ASN1_get_object"}, | ||
| 99 | {ERR_FUNC(ASN1_F_ASN1_HEADER_NEW), "ASN1_HEADER_NEW"}, | ||
| 100 | {ERR_FUNC(ASN1_F_ASN1_I2D_BIO), "ASN1_i2d_bio"}, | ||
| 101 | {ERR_FUNC(ASN1_F_ASN1_I2D_FP), "ASN1_i2d_fp"}, | ||
| 102 | {ERR_FUNC(ASN1_F_ASN1_INTEGER_SET), "ASN1_INTEGER_set"}, | ||
| 103 | {ERR_FUNC(ASN1_F_ASN1_INTEGER_TO_BN), "ASN1_INTEGER_to_BN"}, | ||
| 104 | {ERR_FUNC(ASN1_F_ASN1_ITEM_D2I_FP), "ASN1_item_d2i_fp"}, | ||
| 105 | {ERR_FUNC(ASN1_F_ASN1_ITEM_DUP), "ASN1_item_dup"}, | ||
| 106 | {ERR_FUNC(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW), "ASN1_ITEM_EX_COMBINE_NEW"}, | ||
| 107 | {ERR_FUNC(ASN1_F_ASN1_ITEM_EX_D2I), "ASN1_ITEM_EX_D2I"}, | ||
| 108 | {ERR_FUNC(ASN1_F_ASN1_ITEM_I2D_BIO), "ASN1_item_i2d_bio"}, | ||
| 109 | {ERR_FUNC(ASN1_F_ASN1_ITEM_I2D_FP), "ASN1_item_i2d_fp"}, | ||
| 110 | {ERR_FUNC(ASN1_F_ASN1_ITEM_PACK), "ASN1_item_pack"}, | ||
| 111 | {ERR_FUNC(ASN1_F_ASN1_ITEM_SIGN), "ASN1_item_sign"}, | ||
| 112 | {ERR_FUNC(ASN1_F_ASN1_ITEM_SIGN_CTX), "ASN1_item_sign_ctx"}, | ||
| 113 | {ERR_FUNC(ASN1_F_ASN1_ITEM_UNPACK), "ASN1_item_unpack"}, | ||
| 114 | {ERR_FUNC(ASN1_F_ASN1_ITEM_VERIFY), "ASN1_item_verify"}, | ||
| 115 | {ERR_FUNC(ASN1_F_ASN1_MBSTRING_NCOPY), "ASN1_mbstring_ncopy"}, | ||
| 116 | {ERR_FUNC(ASN1_F_ASN1_OBJECT_NEW), "ASN1_OBJECT_new"}, | ||
| 117 | {ERR_FUNC(ASN1_F_ASN1_OUTPUT_DATA), "ASN1_OUTPUT_DATA"}, | ||
| 118 | {ERR_FUNC(ASN1_F_ASN1_PACK_STRING), "ASN1_pack_string"}, | ||
| 119 | {ERR_FUNC(ASN1_F_ASN1_PCTX_NEW), "ASN1_PCTX_new"}, | ||
| 120 | {ERR_FUNC(ASN1_F_ASN1_PKCS5_PBE_SET), "ASN1_PKCS5_PBE_SET"}, | ||
| 121 | {ERR_FUNC(ASN1_F_ASN1_SEQ_PACK), "ASN1_seq_pack"}, | ||
| 122 | {ERR_FUNC(ASN1_F_ASN1_SEQ_UNPACK), "ASN1_seq_unpack"}, | ||
| 123 | {ERR_FUNC(ASN1_F_ASN1_SIGN), "ASN1_sign"}, | ||
| 124 | {ERR_FUNC(ASN1_F_ASN1_STR2TYPE), "ASN1_STR2TYPE"}, | ||
| 125 | {ERR_FUNC(ASN1_F_ASN1_STRING_SET), "ASN1_STRING_set"}, | ||
| 126 | {ERR_FUNC(ASN1_F_ASN1_STRING_TABLE_ADD), "ASN1_STRING_TABLE_add"}, | ||
| 127 | {ERR_FUNC(ASN1_F_ASN1_STRING_TYPE_NEW), "ASN1_STRING_type_new"}, | ||
| 128 | {ERR_FUNC(ASN1_F_ASN1_TEMPLATE_EX_D2I), "ASN1_TEMPLATE_EX_D2I"}, | ||
| 129 | {ERR_FUNC(ASN1_F_ASN1_TEMPLATE_NEW), "ASN1_TEMPLATE_NEW"}, | ||
| 130 | {ERR_FUNC(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I), "ASN1_TEMPLATE_NOEXP_D2I"}, | ||
| 131 | {ERR_FUNC(ASN1_F_ASN1_TIME_ADJ), "ASN1_TIME_adj"}, | ||
| 132 | {ERR_FUNC(ASN1_F_ASN1_TIME_SET), "ASN1_TIME_set"}, | ||
| 133 | {ERR_FUNC(ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING), "ASN1_TYPE_get_int_octetstring"}, | ||
| 134 | {ERR_FUNC(ASN1_F_ASN1_TYPE_GET_OCTETSTRING), "ASN1_TYPE_get_octetstring"}, | ||
| 135 | {ERR_FUNC(ASN1_F_ASN1_UNPACK_STRING), "ASN1_unpack_string"}, | ||
| 136 | {ERR_FUNC(ASN1_F_ASN1_UTCTIME_ADJ), "ASN1_UTCTIME_adj"}, | ||
| 137 | {ERR_FUNC(ASN1_F_ASN1_UTCTIME_SET), "ASN1_UTCTIME_set"}, | ||
| 138 | {ERR_FUNC(ASN1_F_ASN1_VERIFY), "ASN1_verify"}, | ||
| 139 | {ERR_FUNC(ASN1_F_B64_READ_ASN1), "B64_READ_ASN1"}, | ||
| 140 | {ERR_FUNC(ASN1_F_B64_WRITE_ASN1), "B64_WRITE_ASN1"}, | ||
| 141 | {ERR_FUNC(ASN1_F_BIO_NEW_NDEF), "BIO_new_NDEF"}, | ||
| 142 | {ERR_FUNC(ASN1_F_BITSTR_CB), "BITSTR_CB"}, | ||
| 143 | {ERR_FUNC(ASN1_F_BN_TO_ASN1_ENUMERATED), "BN_to_ASN1_ENUMERATED"}, | ||
| 144 | {ERR_FUNC(ASN1_F_BN_TO_ASN1_INTEGER), "BN_to_ASN1_INTEGER"}, | ||
| 145 | {ERR_FUNC(ASN1_F_C2I_ASN1_BIT_STRING), "c2i_ASN1_BIT_STRING"}, | ||
| 146 | {ERR_FUNC(ASN1_F_C2I_ASN1_INTEGER), "c2i_ASN1_INTEGER"}, | ||
| 147 | {ERR_FUNC(ASN1_F_C2I_ASN1_OBJECT), "c2i_ASN1_OBJECT"}, | ||
| 148 | {ERR_FUNC(ASN1_F_COLLECT_DATA), "COLLECT_DATA"}, | ||
| 149 | {ERR_FUNC(ASN1_F_D2I_ASN1_BIT_STRING), "D2I_ASN1_BIT_STRING"}, | ||
| 150 | {ERR_FUNC(ASN1_F_D2I_ASN1_BOOLEAN), "d2i_ASN1_BOOLEAN"}, | ||
| 151 | {ERR_FUNC(ASN1_F_D2I_ASN1_BYTES), "d2i_ASN1_bytes"}, | ||
| 152 | {ERR_FUNC(ASN1_F_D2I_ASN1_GENERALIZEDTIME), "D2I_ASN1_GENERALIZEDTIME"}, | ||
| 153 | {ERR_FUNC(ASN1_F_D2I_ASN1_HEADER), "D2I_ASN1_HEADER"}, | ||
| 154 | {ERR_FUNC(ASN1_F_D2I_ASN1_INTEGER), "D2I_ASN1_INTEGER"}, | ||
| 155 | {ERR_FUNC(ASN1_F_D2I_ASN1_OBJECT), "d2i_ASN1_OBJECT"}, | ||
| 156 | {ERR_FUNC(ASN1_F_D2I_ASN1_SET), "d2i_ASN1_SET"}, | ||
| 157 | {ERR_FUNC(ASN1_F_D2I_ASN1_TYPE_BYTES), "d2i_ASN1_type_bytes"}, | ||
| 158 | {ERR_FUNC(ASN1_F_D2I_ASN1_UINTEGER), "d2i_ASN1_UINTEGER"}, | ||
| 159 | {ERR_FUNC(ASN1_F_D2I_ASN1_UTCTIME), "D2I_ASN1_UTCTIME"}, | ||
| 160 | {ERR_FUNC(ASN1_F_D2I_AUTOPRIVATEKEY), "d2i_AutoPrivateKey"}, | ||
| 161 | {ERR_FUNC(ASN1_F_D2I_NETSCAPE_RSA), "d2i_Netscape_RSA"}, | ||
| 162 | {ERR_FUNC(ASN1_F_D2I_NETSCAPE_RSA_2), "D2I_NETSCAPE_RSA_2"}, | ||
| 163 | {ERR_FUNC(ASN1_F_D2I_PRIVATEKEY), "d2i_PrivateKey"}, | ||
| 164 | {ERR_FUNC(ASN1_F_D2I_PUBLICKEY), "d2i_PublicKey"}, | ||
| 165 | {ERR_FUNC(ASN1_F_D2I_RSA_NET), "d2i_RSA_NET"}, | ||
| 166 | {ERR_FUNC(ASN1_F_D2I_RSA_NET_2), "D2I_RSA_NET_2"}, | ||
| 167 | {ERR_FUNC(ASN1_F_D2I_X509), "D2I_X509"}, | ||
| 168 | {ERR_FUNC(ASN1_F_D2I_X509_CINF), "D2I_X509_CINF"}, | ||
| 169 | {ERR_FUNC(ASN1_F_D2I_X509_PKEY), "d2i_X509_PKEY"}, | ||
| 170 | {ERR_FUNC(ASN1_F_I2D_ASN1_BIO_STREAM), "i2d_ASN1_bio_stream"}, | ||
| 171 | {ERR_FUNC(ASN1_F_I2D_ASN1_SET), "i2d_ASN1_SET"}, | ||
| 172 | {ERR_FUNC(ASN1_F_I2D_ASN1_TIME), "I2D_ASN1_TIME"}, | ||
| 173 | {ERR_FUNC(ASN1_F_I2D_DSA_PUBKEY), "i2d_DSA_PUBKEY"}, | ||
| 174 | {ERR_FUNC(ASN1_F_I2D_EC_PUBKEY), "i2d_EC_PUBKEY"}, | ||
| 175 | {ERR_FUNC(ASN1_F_I2D_PRIVATEKEY), "i2d_PrivateKey"}, | ||
| 176 | {ERR_FUNC(ASN1_F_I2D_PUBLICKEY), "i2d_PublicKey"}, | ||
| 177 | {ERR_FUNC(ASN1_F_I2D_RSA_NET), "i2d_RSA_NET"}, | ||
| 178 | {ERR_FUNC(ASN1_F_I2D_RSA_PUBKEY), "i2d_RSA_PUBKEY"}, | ||
| 179 | {ERR_FUNC(ASN1_F_LONG_C2I), "LONG_C2I"}, | ||
| 180 | {ERR_FUNC(ASN1_F_OID_MODULE_INIT), "OID_MODULE_INIT"}, | ||
| 181 | {ERR_FUNC(ASN1_F_PARSE_TAGGING), "PARSE_TAGGING"}, | ||
| 182 | {ERR_FUNC(ASN1_F_PKCS5_PBE2_SET_IV), "PKCS5_pbe2_set_iv"}, | ||
| 183 | {ERR_FUNC(ASN1_F_PKCS5_PBE_SET), "PKCS5_pbe_set"}, | ||
| 184 | {ERR_FUNC(ASN1_F_PKCS5_PBE_SET0_ALGOR), "PKCS5_pbe_set0_algor"}, | ||
| 185 | {ERR_FUNC(ASN1_F_PKCS5_PBKDF2_SET), "PKCS5_pbkdf2_set"}, | ||
| 186 | {ERR_FUNC(ASN1_F_SMIME_READ_ASN1), "SMIME_read_ASN1"}, | ||
| 187 | {ERR_FUNC(ASN1_F_SMIME_TEXT), "SMIME_text"}, | ||
| 188 | {ERR_FUNC(ASN1_F_X509_CINF_NEW), "X509_CINF_NEW"}, | ||
| 189 | {ERR_FUNC(ASN1_F_X509_CRL_ADD0_REVOKED), "X509_CRL_add0_revoked"}, | ||
| 190 | {ERR_FUNC(ASN1_F_X509_INFO_NEW), "X509_INFO_new"}, | ||
| 191 | {ERR_FUNC(ASN1_F_X509_NAME_ENCODE), "X509_NAME_ENCODE"}, | ||
| 192 | {ERR_FUNC(ASN1_F_X509_NAME_EX_D2I), "X509_NAME_EX_D2I"}, | ||
| 193 | {ERR_FUNC(ASN1_F_X509_NAME_EX_NEW), "X509_NAME_EX_NEW"}, | ||
| 194 | {ERR_FUNC(ASN1_F_X509_NEW), "X509_NEW"}, | ||
| 195 | {ERR_FUNC(ASN1_F_X509_PKEY_NEW), "X509_PKEY_new"}, | ||
| 196 | {0, NULL} | ||
| 197 | }; | ||
| 198 | |||
| 199 | static ERR_STRING_DATA ASN1_str_reasons[] = { | ||
| 200 | {ERR_REASON(ASN1_R_ADDING_OBJECT) , "adding object"}, | ||
| 201 | {ERR_REASON(ASN1_R_ASN1_PARSE_ERROR) , "asn1 parse error"}, | ||
| 202 | {ERR_REASON(ASN1_R_ASN1_SIG_PARSE_ERROR) , "asn1 sig parse error"}, | ||
| 203 | {ERR_REASON(ASN1_R_AUX_ERROR) , "aux error"}, | ||
| 204 | {ERR_REASON(ASN1_R_BAD_CLASS) , "bad class"}, | ||
| 205 | {ERR_REASON(ASN1_R_BAD_OBJECT_HEADER) , "bad object header"}, | ||
| 206 | {ERR_REASON(ASN1_R_BAD_PASSWORD_READ) , "bad password read"}, | ||
| 207 | {ERR_REASON(ASN1_R_BAD_TAG) , "bad tag"}, | ||
| 208 | {ERR_REASON(ASN1_R_BMPSTRING_IS_WRONG_LENGTH), "bmpstring is wrong length"}, | ||
| 209 | {ERR_REASON(ASN1_R_BN_LIB) , "bn lib"}, | ||
| 210 | {ERR_REASON(ASN1_R_BOOLEAN_IS_WRONG_LENGTH), "boolean is wrong length"}, | ||
| 211 | {ERR_REASON(ASN1_R_BUFFER_TOO_SMALL) , "buffer too small"}, | ||
| 212 | {ERR_REASON(ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER), "cipher has no object identifier"}, | ||
| 213 | {ERR_REASON(ASN1_R_CONTEXT_NOT_INITIALISED), "context not initialised"}, | ||
| 214 | {ERR_REASON(ASN1_R_DATA_IS_WRONG) , "data is wrong"}, | ||
| 215 | {ERR_REASON(ASN1_R_DECODE_ERROR) , "decode error"}, | ||
| 216 | {ERR_REASON(ASN1_R_DECODING_ERROR) , "decoding error"}, | ||
| 217 | {ERR_REASON(ASN1_R_DEPTH_EXCEEDED) , "depth exceeded"}, | ||
| 218 | {ERR_REASON(ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED), "digest and key type not supported"}, | ||
| 219 | {ERR_REASON(ASN1_R_ENCODE_ERROR) , "encode error"}, | ||
| 220 | {ERR_REASON(ASN1_R_ERROR_GETTING_TIME) , "error getting time"}, | ||
| 221 | {ERR_REASON(ASN1_R_ERROR_LOADING_SECTION), "error loading section"}, | ||
| 222 | {ERR_REASON(ASN1_R_ERROR_PARSING_SET_ELEMENT), "error parsing set element"}, | ||
| 223 | {ERR_REASON(ASN1_R_ERROR_SETTING_CIPHER_PARAMS), "error setting cipher params"}, | ||
| 224 | {ERR_REASON(ASN1_R_EXPECTING_AN_INTEGER) , "expecting an integer"}, | ||
| 225 | {ERR_REASON(ASN1_R_EXPECTING_AN_OBJECT) , "expecting an object"}, | ||
| 226 | {ERR_REASON(ASN1_R_EXPECTING_A_BOOLEAN) , "expecting a boolean"}, | ||
| 227 | {ERR_REASON(ASN1_R_EXPECTING_A_TIME) , "expecting a time"}, | ||
| 228 | {ERR_REASON(ASN1_R_EXPLICIT_LENGTH_MISMATCH), "explicit length mismatch"}, | ||
| 229 | {ERR_REASON(ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED), "explicit tag not constructed"}, | ||
| 230 | {ERR_REASON(ASN1_R_FIELD_MISSING) , "field missing"}, | ||
| 231 | {ERR_REASON(ASN1_R_FIRST_NUM_TOO_LARGE) , "first num too large"}, | ||
| 232 | {ERR_REASON(ASN1_R_HEADER_TOO_LONG) , "header too long"}, | ||
| 233 | {ERR_REASON(ASN1_R_ILLEGAL_BITSTRING_FORMAT), "illegal bitstring format"}, | ||
| 234 | {ERR_REASON(ASN1_R_ILLEGAL_BOOLEAN) , "illegal boolean"}, | ||
| 235 | {ERR_REASON(ASN1_R_ILLEGAL_CHARACTERS) , "illegal characters"}, | ||
| 236 | {ERR_REASON(ASN1_R_ILLEGAL_FORMAT) , "illegal format"}, | ||
| 237 | {ERR_REASON(ASN1_R_ILLEGAL_HEX) , "illegal hex"}, | ||
| 238 | {ERR_REASON(ASN1_R_ILLEGAL_IMPLICIT_TAG) , "illegal implicit tag"}, | ||
| 239 | {ERR_REASON(ASN1_R_ILLEGAL_INTEGER) , "illegal integer"}, | ||
| 240 | {ERR_REASON(ASN1_R_ILLEGAL_NESTED_TAGGING), "illegal nested tagging"}, | ||
| 241 | {ERR_REASON(ASN1_R_ILLEGAL_NULL) , "illegal null"}, | ||
| 242 | {ERR_REASON(ASN1_R_ILLEGAL_NULL_VALUE) , "illegal null value"}, | ||
| 243 | {ERR_REASON(ASN1_R_ILLEGAL_OBJECT) , "illegal object"}, | ||
| 244 | {ERR_REASON(ASN1_R_ILLEGAL_OPTIONAL_ANY) , "illegal optional any"}, | ||
| 245 | {ERR_REASON(ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE), "illegal options on item template"}, | ||
| 246 | {ERR_REASON(ASN1_R_ILLEGAL_TAGGED_ANY) , "illegal tagged any"}, | ||
| 247 | {ERR_REASON(ASN1_R_ILLEGAL_TIME_VALUE) , "illegal time value"}, | ||
| 248 | {ERR_REASON(ASN1_R_INTEGER_NOT_ASCII_FORMAT), "integer not ascii format"}, | ||
| 249 | {ERR_REASON(ASN1_R_INTEGER_TOO_LARGE_FOR_LONG), "integer too large for long"}, | ||
| 250 | {ERR_REASON(ASN1_R_INVALID_BIT_STRING_BITS_LEFT), "invalid bit string bits left"}, | ||
| 251 | {ERR_REASON(ASN1_R_INVALID_BMPSTRING_LENGTH), "invalid bmpstring length"}, | ||
| 252 | {ERR_REASON(ASN1_R_INVALID_DIGIT) , "invalid digit"}, | ||
| 253 | {ERR_REASON(ASN1_R_INVALID_MIME_TYPE) , "invalid mime type"}, | ||
| 254 | {ERR_REASON(ASN1_R_INVALID_MODIFIER) , "invalid modifier"}, | ||
| 255 | {ERR_REASON(ASN1_R_INVALID_NUMBER) , "invalid number"}, | ||
| 256 | {ERR_REASON(ASN1_R_INVALID_OBJECT_ENCODING), "invalid object encoding"}, | ||
| 257 | {ERR_REASON(ASN1_R_INVALID_SEPARATOR) , "invalid separator"}, | ||
| 258 | {ERR_REASON(ASN1_R_INVALID_TIME_FORMAT) , "invalid time format"}, | ||
| 259 | {ERR_REASON(ASN1_R_INVALID_UNIVERSALSTRING_LENGTH), "invalid universalstring length"}, | ||
| 260 | {ERR_REASON(ASN1_R_INVALID_UTF8STRING) , "invalid utf8string"}, | ||
| 261 | {ERR_REASON(ASN1_R_IV_TOO_LARGE) , "iv too large"}, | ||
| 262 | {ERR_REASON(ASN1_R_LENGTH_ERROR) , "length error"}, | ||
| 263 | {ERR_REASON(ASN1_R_LIST_ERROR) , "list error"}, | ||
| 264 | {ERR_REASON(ASN1_R_MIME_NO_CONTENT_TYPE) , "mime no content type"}, | ||
| 265 | {ERR_REASON(ASN1_R_MIME_PARSE_ERROR) , "mime parse error"}, | ||
| 266 | {ERR_REASON(ASN1_R_MIME_SIG_PARSE_ERROR) , "mime sig parse error"}, | ||
| 267 | {ERR_REASON(ASN1_R_MISSING_EOC) , "missing eoc"}, | ||
| 268 | {ERR_REASON(ASN1_R_MISSING_SECOND_NUMBER), "missing second number"}, | ||
| 269 | {ERR_REASON(ASN1_R_MISSING_VALUE) , "missing value"}, | ||
| 270 | {ERR_REASON(ASN1_R_MSTRING_NOT_UNIVERSAL), "mstring not universal"}, | ||
| 271 | {ERR_REASON(ASN1_R_MSTRING_WRONG_TAG) , "mstring wrong tag"}, | ||
| 272 | {ERR_REASON(ASN1_R_NESTED_ASN1_STRING) , "nested asn1 string"}, | ||
| 273 | {ERR_REASON(ASN1_R_NON_HEX_CHARACTERS) , "non hex characters"}, | ||
| 274 | {ERR_REASON(ASN1_R_NOT_ASCII_FORMAT) , "not ascii format"}, | ||
| 275 | {ERR_REASON(ASN1_R_NOT_ENOUGH_DATA) , "not enough data"}, | ||
| 276 | {ERR_REASON(ASN1_R_NO_CONTENT_TYPE) , "no content type"}, | ||
| 277 | {ERR_REASON(ASN1_R_NO_DEFAULT_DIGEST) , "no default digest"}, | ||
| 278 | {ERR_REASON(ASN1_R_NO_MATCHING_CHOICE_TYPE), "no matching choice type"}, | ||
| 279 | {ERR_REASON(ASN1_R_NO_MULTIPART_BODY_FAILURE), "no multipart body failure"}, | ||
| 280 | {ERR_REASON(ASN1_R_NO_MULTIPART_BOUNDARY), "no multipart boundary"}, | ||
| 281 | {ERR_REASON(ASN1_R_NO_SIG_CONTENT_TYPE) , "no sig content type"}, | ||
| 282 | {ERR_REASON(ASN1_R_NULL_IS_WRONG_LENGTH) , "null is wrong length"}, | ||
| 283 | {ERR_REASON(ASN1_R_OBJECT_NOT_ASCII_FORMAT), "object not ascii format"}, | ||
| 284 | {ERR_REASON(ASN1_R_ODD_NUMBER_OF_CHARS) , "odd number of chars"}, | ||
| 285 | {ERR_REASON(ASN1_R_PRIVATE_KEY_HEADER_MISSING), "private key header missing"}, | ||
| 286 | {ERR_REASON(ASN1_R_SECOND_NUMBER_TOO_LARGE), "second number too large"}, | ||
| 287 | {ERR_REASON(ASN1_R_SEQUENCE_LENGTH_MISMATCH), "sequence length mismatch"}, | ||
| 288 | {ERR_REASON(ASN1_R_SEQUENCE_NOT_CONSTRUCTED), "sequence not constructed"}, | ||
| 289 | {ERR_REASON(ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG), "sequence or set needs config"}, | ||
| 290 | {ERR_REASON(ASN1_R_SHORT_LINE) , "short line"}, | ||
| 291 | {ERR_REASON(ASN1_R_SIG_INVALID_MIME_TYPE), "sig invalid mime type"}, | ||
| 292 | {ERR_REASON(ASN1_R_STREAMING_NOT_SUPPORTED), "streaming not supported"}, | ||
| 293 | {ERR_REASON(ASN1_R_STRING_TOO_LONG) , "string too long"}, | ||
| 294 | {ERR_REASON(ASN1_R_STRING_TOO_SHORT) , "string too short"}, | ||
| 295 | {ERR_REASON(ASN1_R_TAG_VALUE_TOO_HIGH) , "tag value too high"}, | ||
| 296 | {ERR_REASON(ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD), "the asn1 object identifier is not known for this md"}, | ||
| 297 | {ERR_REASON(ASN1_R_TIME_NOT_ASCII_FORMAT), "time not ascii format"}, | ||
| 298 | {ERR_REASON(ASN1_R_TOO_LONG) , "too long"}, | ||
| 299 | {ERR_REASON(ASN1_R_TYPE_NOT_CONSTRUCTED) , "type not constructed"}, | ||
| 300 | {ERR_REASON(ASN1_R_UNABLE_TO_DECODE_RSA_KEY), "unable to decode rsa key"}, | ||
| 301 | {ERR_REASON(ASN1_R_UNABLE_TO_DECODE_RSA_PRIVATE_KEY), "unable to decode rsa private key"}, | ||
| 302 | {ERR_REASON(ASN1_R_UNEXPECTED_EOC) , "unexpected eoc"}, | ||
| 303 | {ERR_REASON(ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH), "universalstring is wrong length"}, | ||
| 304 | {ERR_REASON(ASN1_R_UNKNOWN_FORMAT) , "unknown format"}, | ||
| 305 | {ERR_REASON(ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM), "unknown message digest algorithm"}, | ||
| 306 | {ERR_REASON(ASN1_R_UNKNOWN_OBJECT_TYPE) , "unknown object type"}, | ||
| 307 | {ERR_REASON(ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE), "unknown public key type"}, | ||
| 308 | {ERR_REASON(ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM), "unknown signature algorithm"}, | ||
| 309 | {ERR_REASON(ASN1_R_UNKNOWN_TAG) , "unknown tag"}, | ||
| 310 | {ERR_REASON(ASN1_R_UNKOWN_FORMAT) , "unknown format"}, | ||
| 311 | {ERR_REASON(ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE), "unsupported any defined by type"}, | ||
| 312 | {ERR_REASON(ASN1_R_UNSUPPORTED_CIPHER) , "unsupported cipher"}, | ||
| 313 | {ERR_REASON(ASN1_R_UNSUPPORTED_ENCRYPTION_ALGORITHM), "unsupported encryption algorithm"}, | ||
| 314 | {ERR_REASON(ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE), "unsupported public key type"}, | ||
| 315 | {ERR_REASON(ASN1_R_UNSUPPORTED_TYPE) , "unsupported type"}, | ||
| 316 | {ERR_REASON(ASN1_R_WRONG_PUBLIC_KEY_TYPE), "wrong public key type"}, | ||
| 317 | {ERR_REASON(ASN1_R_WRONG_TAG) , "wrong tag"}, | ||
| 318 | {ERR_REASON(ASN1_R_WRONG_TYPE) , "wrong type"}, | ||
| 319 | {0, NULL} | ||
| 320 | }; | ||
| 321 | |||
| 322 | #endif | ||
| 323 | |||
| 324 | void | ||
| 325 | ERR_load_ASN1_strings(void) | ||
| 326 | { | ||
| 327 | #ifndef OPENSSL_NO_ERR | ||
| 328 | if (ERR_func_error_string(ASN1_str_functs[0].error) == NULL) { | ||
| 329 | ERR_load_strings(0, ASN1_str_functs); | ||
| 330 | ERR_load_strings(0, ASN1_str_reasons); | ||
| 331 | } | ||
| 332 | #endif | ||
| 333 | } | ||
diff --git a/src/lib/libcrypto/asn1/asn1_gen.c b/src/lib/libcrypto/asn1/asn1_gen.c deleted file mode 100644 index 08a5dec4a6..0000000000 --- a/src/lib/libcrypto/asn1/asn1_gen.c +++ /dev/null | |||
| @@ -1,811 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn1_gen.c,v 1.14 2015/07/18 14:40:59 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2002. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2002 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 | #include <string.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | #include <openssl/x509v3.h> | ||
| 64 | |||
| 65 | #define ASN1_GEN_FLAG 0x10000 | ||
| 66 | #define ASN1_GEN_FLAG_IMP (ASN1_GEN_FLAG|1) | ||
| 67 | #define ASN1_GEN_FLAG_EXP (ASN1_GEN_FLAG|2) | ||
| 68 | #define ASN1_GEN_FLAG_TAG (ASN1_GEN_FLAG|3) | ||
| 69 | #define ASN1_GEN_FLAG_BITWRAP (ASN1_GEN_FLAG|4) | ||
| 70 | #define ASN1_GEN_FLAG_OCTWRAP (ASN1_GEN_FLAG|5) | ||
| 71 | #define ASN1_GEN_FLAG_SEQWRAP (ASN1_GEN_FLAG|6) | ||
| 72 | #define ASN1_GEN_FLAG_SETWRAP (ASN1_GEN_FLAG|7) | ||
| 73 | #define ASN1_GEN_FLAG_FORMAT (ASN1_GEN_FLAG|8) | ||
| 74 | |||
| 75 | #define ASN1_GEN_STR(str,val){str, sizeof(str) - 1, val} | ||
| 76 | |||
| 77 | #define ASN1_FLAG_EXP_MAX 20 | ||
| 78 | |||
| 79 | /* Input formats */ | ||
| 80 | |||
| 81 | /* ASCII: default */ | ||
| 82 | #define ASN1_GEN_FORMAT_ASCII 1 | ||
| 83 | /* UTF8 */ | ||
| 84 | #define ASN1_GEN_FORMAT_UTF8 2 | ||
| 85 | /* Hex */ | ||
| 86 | #define ASN1_GEN_FORMAT_HEX 3 | ||
| 87 | /* List of bits */ | ||
| 88 | #define ASN1_GEN_FORMAT_BITLIST 4 | ||
| 89 | |||
| 90 | struct tag_name_st { | ||
| 91 | const char *strnam; | ||
| 92 | int len; | ||
| 93 | int tag; | ||
| 94 | }; | ||
| 95 | |||
| 96 | typedef struct { | ||
| 97 | int exp_tag; | ||
| 98 | int exp_class; | ||
| 99 | int exp_constructed; | ||
| 100 | int exp_pad; | ||
| 101 | long exp_len; | ||
| 102 | } tag_exp_type; | ||
| 103 | |||
| 104 | typedef struct { | ||
| 105 | int imp_tag; | ||
| 106 | int imp_class; | ||
| 107 | int utype; | ||
| 108 | int format; | ||
| 109 | const char *str; | ||
| 110 | tag_exp_type exp_list[ASN1_FLAG_EXP_MAX]; | ||
| 111 | int exp_count; | ||
| 112 | } tag_exp_arg; | ||
| 113 | |||
| 114 | static int bitstr_cb(const char *elem, int len, void *bitstr); | ||
| 115 | static int asn1_cb(const char *elem, int len, void *bitstr); | ||
| 116 | static int append_exp(tag_exp_arg *arg, int exp_tag, int exp_class, | ||
| 117 | int exp_constructed, int exp_pad, int imp_ok); | ||
| 118 | static int parse_tagging(const char *vstart, int vlen, int *ptag, int *pclass); | ||
| 119 | static ASN1_TYPE *asn1_multi(int utype, const char *section, X509V3_CTX *cnf); | ||
| 120 | static ASN1_TYPE *asn1_str2type(const char *str, int format, int utype); | ||
| 121 | static int asn1_str2tag(const char *tagstr, int len); | ||
| 122 | |||
| 123 | ASN1_TYPE * | ||
| 124 | ASN1_generate_nconf(char *str, CONF *nconf) | ||
| 125 | { | ||
| 126 | X509V3_CTX cnf; | ||
| 127 | |||
| 128 | if (!nconf) | ||
| 129 | return ASN1_generate_v3(str, NULL); | ||
| 130 | |||
| 131 | X509V3_set_nconf(&cnf, nconf); | ||
| 132 | return ASN1_generate_v3(str, &cnf); | ||
| 133 | } | ||
| 134 | |||
| 135 | ASN1_TYPE * | ||
| 136 | ASN1_generate_v3(char *str, X509V3_CTX *cnf) | ||
| 137 | { | ||
| 138 | ASN1_TYPE *ret; | ||
| 139 | tag_exp_arg asn1_tags; | ||
| 140 | tag_exp_type *etmp; | ||
| 141 | |||
| 142 | int i, len; | ||
| 143 | |||
| 144 | unsigned char *orig_der = NULL, *new_der = NULL; | ||
| 145 | const unsigned char *cpy_start; | ||
| 146 | unsigned char *p; | ||
| 147 | const unsigned char *cp; | ||
| 148 | int cpy_len; | ||
| 149 | long hdr_len; | ||
| 150 | int hdr_constructed = 0, hdr_tag, hdr_class; | ||
| 151 | int r; | ||
| 152 | |||
| 153 | asn1_tags.imp_tag = -1; | ||
| 154 | asn1_tags.imp_class = -1; | ||
| 155 | asn1_tags.format = ASN1_GEN_FORMAT_ASCII; | ||
| 156 | asn1_tags.exp_count = 0; | ||
| 157 | if (CONF_parse_list(str, ',', 1, asn1_cb, &asn1_tags) != 0) | ||
| 158 | return NULL; | ||
| 159 | |||
| 160 | if ((asn1_tags.utype == V_ASN1_SEQUENCE) || | ||
| 161 | (asn1_tags.utype == V_ASN1_SET)) { | ||
| 162 | if (!cnf) { | ||
| 163 | ASN1err(ASN1_F_ASN1_GENERATE_V3, | ||
| 164 | ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG); | ||
| 165 | return NULL; | ||
| 166 | } | ||
| 167 | ret = asn1_multi(asn1_tags.utype, asn1_tags.str, cnf); | ||
| 168 | } else | ||
| 169 | ret = asn1_str2type(asn1_tags.str, asn1_tags.format, | ||
| 170 | asn1_tags.utype); | ||
| 171 | |||
| 172 | if (!ret) | ||
| 173 | return NULL; | ||
| 174 | |||
| 175 | /* If no tagging return base type */ | ||
| 176 | if ((asn1_tags.imp_tag == -1) && (asn1_tags.exp_count == 0)) | ||
| 177 | return ret; | ||
| 178 | |||
| 179 | /* Generate the encoding */ | ||
| 180 | cpy_len = i2d_ASN1_TYPE(ret, &orig_der); | ||
| 181 | ASN1_TYPE_free(ret); | ||
| 182 | ret = NULL; | ||
| 183 | /* Set point to start copying for modified encoding */ | ||
| 184 | cpy_start = orig_der; | ||
| 185 | |||
| 186 | /* Do we need IMPLICIT tagging? */ | ||
| 187 | if (asn1_tags.imp_tag != -1) { | ||
| 188 | /* If IMPLICIT we will replace the underlying tag */ | ||
| 189 | /* Skip existing tag+len */ | ||
| 190 | r = ASN1_get_object(&cpy_start, &hdr_len, &hdr_tag, | ||
| 191 | &hdr_class, cpy_len); | ||
| 192 | if (r & 0x80) | ||
| 193 | goto err; | ||
| 194 | /* Update copy length */ | ||
| 195 | cpy_len -= cpy_start - orig_der; | ||
| 196 | /* For IMPLICIT tagging the length should match the | ||
| 197 | * original length and constructed flag should be | ||
| 198 | * consistent. | ||
| 199 | */ | ||
| 200 | if (r & 0x1) { | ||
| 201 | /* Indefinite length constructed */ | ||
| 202 | hdr_constructed = 2; | ||
| 203 | hdr_len = 0; | ||
| 204 | } else | ||
| 205 | /* Just retain constructed flag */ | ||
| 206 | hdr_constructed = r & V_ASN1_CONSTRUCTED; | ||
| 207 | /* Work out new length with IMPLICIT tag: ignore constructed | ||
| 208 | * because it will mess up if indefinite length | ||
| 209 | */ | ||
| 210 | len = ASN1_object_size(0, hdr_len, asn1_tags.imp_tag); | ||
| 211 | } else | ||
| 212 | len = cpy_len; | ||
| 213 | |||
| 214 | /* Work out length in any EXPLICIT, starting from end */ | ||
| 215 | |||
| 216 | for (i = 0, etmp = asn1_tags.exp_list + asn1_tags.exp_count - 1; | ||
| 217 | i < asn1_tags.exp_count; i++, etmp--) { | ||
| 218 | /* Content length: number of content octets + any padding */ | ||
| 219 | len += etmp->exp_pad; | ||
| 220 | etmp->exp_len = len; | ||
| 221 | /* Total object length: length including new header */ | ||
| 222 | len = ASN1_object_size(0, len, etmp->exp_tag); | ||
| 223 | } | ||
| 224 | |||
| 225 | /* Allocate buffer for new encoding */ | ||
| 226 | |||
| 227 | new_der = malloc(len); | ||
| 228 | if (!new_der) | ||
| 229 | goto err; | ||
| 230 | |||
| 231 | /* Generate tagged encoding */ | ||
| 232 | p = new_der; | ||
| 233 | |||
| 234 | /* Output explicit tags first */ | ||
| 235 | for (i = 0, etmp = asn1_tags.exp_list; i < asn1_tags.exp_count; | ||
| 236 | i++, etmp++) { | ||
| 237 | ASN1_put_object(&p, etmp->exp_constructed, etmp->exp_len, | ||
| 238 | etmp->exp_tag, etmp->exp_class); | ||
| 239 | if (etmp->exp_pad) | ||
| 240 | *p++ = 0; | ||
| 241 | } | ||
| 242 | |||
| 243 | /* If IMPLICIT, output tag */ | ||
| 244 | |||
| 245 | if (asn1_tags.imp_tag != -1) { | ||
| 246 | if (asn1_tags.imp_class == V_ASN1_UNIVERSAL && | ||
| 247 | (asn1_tags.imp_tag == V_ASN1_SEQUENCE || | ||
| 248 | asn1_tags.imp_tag == V_ASN1_SET)) | ||
| 249 | hdr_constructed = V_ASN1_CONSTRUCTED; | ||
| 250 | ASN1_put_object(&p, hdr_constructed, hdr_len, | ||
| 251 | asn1_tags.imp_tag, asn1_tags.imp_class); | ||
| 252 | } | ||
| 253 | |||
| 254 | /* Copy across original encoding */ | ||
| 255 | memcpy(p, cpy_start, cpy_len); | ||
| 256 | |||
| 257 | cp = new_der; | ||
| 258 | |||
| 259 | /* Obtain new ASN1_TYPE structure */ | ||
| 260 | ret = d2i_ASN1_TYPE(NULL, &cp, len); | ||
| 261 | |||
| 262 | err: | ||
| 263 | free(orig_der); | ||
| 264 | free(new_der); | ||
| 265 | |||
| 266 | return ret; | ||
| 267 | } | ||
| 268 | |||
| 269 | static int | ||
| 270 | asn1_cb(const char *elem, int len, void *bitstr) | ||
| 271 | { | ||
| 272 | tag_exp_arg *arg = bitstr; | ||
| 273 | int i; | ||
| 274 | int utype; | ||
| 275 | int vlen = 0; | ||
| 276 | const char *p, *vstart = NULL; | ||
| 277 | |||
| 278 | int tmp_tag, tmp_class; | ||
| 279 | |||
| 280 | for (i = 0, p = elem; i < len; p++, i++) { | ||
| 281 | /* Look for the ':' in name value pairs */ | ||
| 282 | if (*p == ':') { | ||
| 283 | vstart = p + 1; | ||
| 284 | vlen = len - (vstart - elem); | ||
| 285 | len = p - elem; | ||
| 286 | break; | ||
| 287 | } | ||
| 288 | } | ||
| 289 | |||
| 290 | utype = asn1_str2tag(elem, len); | ||
| 291 | |||
| 292 | if (utype == -1) { | ||
| 293 | ASN1err(ASN1_F_ASN1_CB, ASN1_R_UNKNOWN_TAG); | ||
| 294 | ERR_asprintf_error_data("tag=%s", elem); | ||
| 295 | return -1; | ||
| 296 | } | ||
| 297 | |||
| 298 | /* If this is not a modifier mark end of string and exit */ | ||
| 299 | if (!(utype & ASN1_GEN_FLAG)) { | ||
| 300 | arg->utype = utype; | ||
| 301 | arg->str = vstart; | ||
| 302 | /* If no value and not end of string, error */ | ||
| 303 | if (!vstart && elem[len]) { | ||
| 304 | ASN1err(ASN1_F_ASN1_CB, ASN1_R_MISSING_VALUE); | ||
| 305 | return -1; | ||
| 306 | } | ||
| 307 | return 0; | ||
| 308 | } | ||
| 309 | |||
| 310 | switch (utype) { | ||
| 311 | |||
| 312 | case ASN1_GEN_FLAG_IMP: | ||
| 313 | /* Check for illegal multiple IMPLICIT tagging */ | ||
| 314 | if (arg->imp_tag != -1) { | ||
| 315 | ASN1err(ASN1_F_ASN1_CB, ASN1_R_ILLEGAL_NESTED_TAGGING); | ||
| 316 | return -1; | ||
| 317 | } | ||
| 318 | if (!parse_tagging(vstart, vlen, &arg->imp_tag, | ||
| 319 | &arg->imp_class)) | ||
| 320 | return -1; | ||
| 321 | break; | ||
| 322 | |||
| 323 | case ASN1_GEN_FLAG_EXP: | ||
| 324 | if (!parse_tagging(vstart, vlen, &tmp_tag, &tmp_class)) | ||
| 325 | return -1; | ||
| 326 | if (!append_exp(arg, tmp_tag, tmp_class, 1, 0, 0)) | ||
| 327 | return -1; | ||
| 328 | break; | ||
| 329 | |||
| 330 | case ASN1_GEN_FLAG_SEQWRAP: | ||
| 331 | if (!append_exp(arg, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, 1, 0, 1)) | ||
| 332 | return -1; | ||
| 333 | break; | ||
| 334 | |||
| 335 | case ASN1_GEN_FLAG_SETWRAP: | ||
| 336 | if (!append_exp(arg, V_ASN1_SET, V_ASN1_UNIVERSAL, 1, 0, 1)) | ||
| 337 | return -1; | ||
| 338 | break; | ||
| 339 | |||
| 340 | case ASN1_GEN_FLAG_BITWRAP: | ||
| 341 | if (!append_exp(arg, V_ASN1_BIT_STRING, V_ASN1_UNIVERSAL, 0, 1, 1)) | ||
| 342 | return -1; | ||
| 343 | break; | ||
| 344 | |||
| 345 | case ASN1_GEN_FLAG_OCTWRAP: | ||
| 346 | if (!append_exp(arg, V_ASN1_OCTET_STRING, V_ASN1_UNIVERSAL, 0, 0, 1)) | ||
| 347 | return -1; | ||
| 348 | break; | ||
| 349 | |||
| 350 | case ASN1_GEN_FLAG_FORMAT: | ||
| 351 | if (vstart == NULL) { | ||
| 352 | ASN1err(ASN1_F_ASN1_CB, ASN1_R_ILLEGAL_FORMAT); | ||
| 353 | return -1; | ||
| 354 | } | ||
| 355 | if (!strncmp(vstart, "ASCII", 5)) | ||
| 356 | arg->format = ASN1_GEN_FORMAT_ASCII; | ||
| 357 | else if (!strncmp(vstart, "UTF8", 4)) | ||
| 358 | arg->format = ASN1_GEN_FORMAT_UTF8; | ||
| 359 | else if (!strncmp(vstart, "HEX", 3)) | ||
| 360 | arg->format = ASN1_GEN_FORMAT_HEX; | ||
| 361 | else if (!strncmp(vstart, "BITLIST", 7)) | ||
| 362 | arg->format = ASN1_GEN_FORMAT_BITLIST; | ||
| 363 | else { | ||
| 364 | ASN1err(ASN1_F_ASN1_CB, ASN1_R_UNKOWN_FORMAT); | ||
| 365 | return -1; | ||
| 366 | } | ||
| 367 | break; | ||
| 368 | |||
| 369 | } | ||
| 370 | |||
| 371 | return 1; | ||
| 372 | } | ||
| 373 | |||
| 374 | static int | ||
| 375 | parse_tagging(const char *vstart, int vlen, int *ptag, int *pclass) | ||
| 376 | { | ||
| 377 | long tag_num; | ||
| 378 | char *eptr; | ||
| 379 | |||
| 380 | if (!vstart) | ||
| 381 | return 0; | ||
| 382 | tag_num = strtoul(vstart, &eptr, 10); | ||
| 383 | /* Check we haven't gone past max length: should be impossible */ | ||
| 384 | if (eptr && *eptr && (eptr > vstart + vlen)) | ||
| 385 | return 0; | ||
| 386 | if (tag_num < 0) { | ||
| 387 | ASN1err(ASN1_F_PARSE_TAGGING, ASN1_R_INVALID_NUMBER); | ||
| 388 | return 0; | ||
| 389 | } | ||
| 390 | *ptag = tag_num; | ||
| 391 | /* If we have non numeric characters, parse them */ | ||
| 392 | if (eptr) | ||
| 393 | vlen -= eptr - vstart; | ||
| 394 | else | ||
| 395 | vlen = 0; | ||
| 396 | if (vlen) { | ||
| 397 | switch (*eptr) { | ||
| 398 | |||
| 399 | case 'U': | ||
| 400 | *pclass = V_ASN1_UNIVERSAL; | ||
| 401 | break; | ||
| 402 | |||
| 403 | case 'A': | ||
| 404 | *pclass = V_ASN1_APPLICATION; | ||
| 405 | break; | ||
| 406 | |||
| 407 | case 'P': | ||
| 408 | *pclass = V_ASN1_PRIVATE; | ||
| 409 | break; | ||
| 410 | |||
| 411 | case 'C': | ||
| 412 | *pclass = V_ASN1_CONTEXT_SPECIFIC; | ||
| 413 | break; | ||
| 414 | |||
| 415 | default: | ||
| 416 | ASN1err(ASN1_F_PARSE_TAGGING, ASN1_R_INVALID_MODIFIER); | ||
| 417 | ERR_asprintf_error_data("Char=%c", *eptr); | ||
| 418 | return 0; | ||
| 419 | break; | ||
| 420 | |||
| 421 | } | ||
| 422 | } else | ||
| 423 | *pclass = V_ASN1_CONTEXT_SPECIFIC; | ||
| 424 | |||
| 425 | return 1; | ||
| 426 | |||
| 427 | } | ||
| 428 | |||
| 429 | /* Handle multiple types: SET and SEQUENCE */ | ||
| 430 | |||
| 431 | static ASN1_TYPE * | ||
| 432 | asn1_multi(int utype, const char *section, X509V3_CTX *cnf) | ||
| 433 | { | ||
| 434 | ASN1_TYPE *ret = NULL; | ||
| 435 | STACK_OF(ASN1_TYPE) *sk = NULL; | ||
| 436 | STACK_OF(CONF_VALUE) *sect = NULL; | ||
| 437 | unsigned char *der = NULL; | ||
| 438 | int derlen; | ||
| 439 | int i; | ||
| 440 | sk = sk_ASN1_TYPE_new_null(); | ||
| 441 | if (!sk) | ||
| 442 | goto bad; | ||
| 443 | if (section) { | ||
| 444 | if (!cnf) | ||
| 445 | goto bad; | ||
| 446 | sect = X509V3_get_section(cnf, (char *)section); | ||
| 447 | if (!sect) | ||
| 448 | goto bad; | ||
| 449 | for (i = 0; i < sk_CONF_VALUE_num(sect); i++) { | ||
| 450 | ASN1_TYPE *typ = ASN1_generate_v3( | ||
| 451 | sk_CONF_VALUE_value(sect, i)->value, cnf); | ||
| 452 | if (!typ) | ||
| 453 | goto bad; | ||
| 454 | if (!sk_ASN1_TYPE_push(sk, typ)) | ||
| 455 | goto bad; | ||
| 456 | } | ||
| 457 | } | ||
| 458 | |||
| 459 | /* Now we has a STACK of the components, convert to the correct form */ | ||
| 460 | |||
| 461 | if (utype == V_ASN1_SET) | ||
| 462 | derlen = i2d_ASN1_SET_ANY(sk, &der); | ||
| 463 | else | ||
| 464 | derlen = i2d_ASN1_SEQUENCE_ANY(sk, &der); | ||
| 465 | |||
| 466 | if (derlen < 0) | ||
| 467 | goto bad; | ||
| 468 | |||
| 469 | if (!(ret = ASN1_TYPE_new())) | ||
| 470 | goto bad; | ||
| 471 | |||
| 472 | if (!(ret->value.asn1_string = ASN1_STRING_type_new(utype))) | ||
| 473 | goto bad; | ||
| 474 | |||
| 475 | ret->type = utype; | ||
| 476 | |||
| 477 | ret->value.asn1_string->data = der; | ||
| 478 | ret->value.asn1_string->length = derlen; | ||
| 479 | |||
| 480 | der = NULL; | ||
| 481 | |||
| 482 | bad: | ||
| 483 | free(der); | ||
| 484 | if (sk) | ||
| 485 | sk_ASN1_TYPE_pop_free(sk, ASN1_TYPE_free); | ||
| 486 | if (sect) | ||
| 487 | X509V3_section_free(cnf, sect); | ||
| 488 | |||
| 489 | return ret; | ||
| 490 | } | ||
| 491 | |||
| 492 | static int | ||
| 493 | append_exp(tag_exp_arg *arg, int exp_tag, int exp_class, int exp_constructed, | ||
| 494 | int exp_pad, int imp_ok) | ||
| 495 | { | ||
| 496 | tag_exp_type *exp_tmp; | ||
| 497 | |||
| 498 | /* Can only have IMPLICIT if permitted */ | ||
| 499 | if ((arg->imp_tag != -1) && !imp_ok) { | ||
| 500 | ASN1err(ASN1_F_APPEND_EXP, ASN1_R_ILLEGAL_IMPLICIT_TAG); | ||
| 501 | return 0; | ||
| 502 | } | ||
| 503 | |||
| 504 | if (arg->exp_count == ASN1_FLAG_EXP_MAX) { | ||
| 505 | ASN1err(ASN1_F_APPEND_EXP, ASN1_R_DEPTH_EXCEEDED); | ||
| 506 | return 0; | ||
| 507 | } | ||
| 508 | |||
| 509 | exp_tmp = &arg->exp_list[arg->exp_count++]; | ||
| 510 | |||
| 511 | /* If IMPLICIT set tag to implicit value then | ||
| 512 | * reset implicit tag since it has been used. | ||
| 513 | */ | ||
| 514 | if (arg->imp_tag != -1) { | ||
| 515 | exp_tmp->exp_tag = arg->imp_tag; | ||
| 516 | exp_tmp->exp_class = arg->imp_class; | ||
| 517 | arg->imp_tag = -1; | ||
| 518 | arg->imp_class = -1; | ||
| 519 | } else { | ||
| 520 | exp_tmp->exp_tag = exp_tag; | ||
| 521 | exp_tmp->exp_class = exp_class; | ||
| 522 | } | ||
| 523 | exp_tmp->exp_constructed = exp_constructed; | ||
| 524 | exp_tmp->exp_pad = exp_pad; | ||
| 525 | |||
| 526 | return 1; | ||
| 527 | } | ||
| 528 | |||
| 529 | static int | ||
| 530 | asn1_str2tag(const char *tagstr, int len) | ||
| 531 | { | ||
| 532 | unsigned int i; | ||
| 533 | static const struct tag_name_st *tntmp, tnst [] = { | ||
| 534 | ASN1_GEN_STR("BOOL", V_ASN1_BOOLEAN), | ||
| 535 | ASN1_GEN_STR("BOOLEAN", V_ASN1_BOOLEAN), | ||
| 536 | ASN1_GEN_STR("NULL", V_ASN1_NULL), | ||
| 537 | ASN1_GEN_STR("INT", V_ASN1_INTEGER), | ||
| 538 | ASN1_GEN_STR("INTEGER", V_ASN1_INTEGER), | ||
| 539 | ASN1_GEN_STR("ENUM", V_ASN1_ENUMERATED), | ||
| 540 | ASN1_GEN_STR("ENUMERATED", V_ASN1_ENUMERATED), | ||
| 541 | ASN1_GEN_STR("OID", V_ASN1_OBJECT), | ||
| 542 | ASN1_GEN_STR("OBJECT", V_ASN1_OBJECT), | ||
| 543 | ASN1_GEN_STR("UTCTIME", V_ASN1_UTCTIME), | ||
| 544 | ASN1_GEN_STR("UTC", V_ASN1_UTCTIME), | ||
| 545 | ASN1_GEN_STR("GENERALIZEDTIME", V_ASN1_GENERALIZEDTIME), | ||
| 546 | ASN1_GEN_STR("GENTIME", V_ASN1_GENERALIZEDTIME), | ||
| 547 | ASN1_GEN_STR("OCT", V_ASN1_OCTET_STRING), | ||
| 548 | ASN1_GEN_STR("OCTETSTRING", V_ASN1_OCTET_STRING), | ||
| 549 | ASN1_GEN_STR("BITSTR", V_ASN1_BIT_STRING), | ||
| 550 | ASN1_GEN_STR("BITSTRING", V_ASN1_BIT_STRING), | ||
| 551 | ASN1_GEN_STR("UNIVERSALSTRING", V_ASN1_UNIVERSALSTRING), | ||
| 552 | ASN1_GEN_STR("UNIV", V_ASN1_UNIVERSALSTRING), | ||
| 553 | ASN1_GEN_STR("IA5", V_ASN1_IA5STRING), | ||
| 554 | ASN1_GEN_STR("IA5STRING", V_ASN1_IA5STRING), | ||
| 555 | ASN1_GEN_STR("UTF8", V_ASN1_UTF8STRING), | ||
| 556 | ASN1_GEN_STR("UTF8String", V_ASN1_UTF8STRING), | ||
| 557 | ASN1_GEN_STR("BMP", V_ASN1_BMPSTRING), | ||
| 558 | ASN1_GEN_STR("BMPSTRING", V_ASN1_BMPSTRING), | ||
| 559 | ASN1_GEN_STR("VISIBLESTRING", V_ASN1_VISIBLESTRING), | ||
| 560 | ASN1_GEN_STR("VISIBLE", V_ASN1_VISIBLESTRING), | ||
| 561 | ASN1_GEN_STR("PRINTABLESTRING", V_ASN1_PRINTABLESTRING), | ||
| 562 | ASN1_GEN_STR("PRINTABLE", V_ASN1_PRINTABLESTRING), | ||
| 563 | ASN1_GEN_STR("T61", V_ASN1_T61STRING), | ||
| 564 | ASN1_GEN_STR("T61STRING", V_ASN1_T61STRING), | ||
| 565 | ASN1_GEN_STR("TELETEXSTRING", V_ASN1_T61STRING), | ||
| 566 | ASN1_GEN_STR("GeneralString", V_ASN1_GENERALSTRING), | ||
| 567 | ASN1_GEN_STR("GENSTR", V_ASN1_GENERALSTRING), | ||
| 568 | ASN1_GEN_STR("NUMERIC", V_ASN1_NUMERICSTRING), | ||
| 569 | ASN1_GEN_STR("NUMERICSTRING", V_ASN1_NUMERICSTRING), | ||
| 570 | |||
| 571 | /* Special cases */ | ||
| 572 | ASN1_GEN_STR("SEQUENCE", V_ASN1_SEQUENCE), | ||
| 573 | ASN1_GEN_STR("SEQ", V_ASN1_SEQUENCE), | ||
| 574 | ASN1_GEN_STR("SET", V_ASN1_SET), | ||
| 575 | /* type modifiers */ | ||
| 576 | /* Explicit tag */ | ||
| 577 | ASN1_GEN_STR("EXP", ASN1_GEN_FLAG_EXP), | ||
| 578 | ASN1_GEN_STR("EXPLICIT", ASN1_GEN_FLAG_EXP), | ||
| 579 | /* Implicit tag */ | ||
| 580 | ASN1_GEN_STR("IMP", ASN1_GEN_FLAG_IMP), | ||
| 581 | ASN1_GEN_STR("IMPLICIT", ASN1_GEN_FLAG_IMP), | ||
| 582 | /* OCTET STRING wrapper */ | ||
| 583 | ASN1_GEN_STR("OCTWRAP", ASN1_GEN_FLAG_OCTWRAP), | ||
| 584 | /* SEQUENCE wrapper */ | ||
| 585 | ASN1_GEN_STR("SEQWRAP", ASN1_GEN_FLAG_SEQWRAP), | ||
| 586 | /* SET wrapper */ | ||
| 587 | ASN1_GEN_STR("SETWRAP", ASN1_GEN_FLAG_SETWRAP), | ||
| 588 | /* BIT STRING wrapper */ | ||
| 589 | ASN1_GEN_STR("BITWRAP", ASN1_GEN_FLAG_BITWRAP), | ||
| 590 | ASN1_GEN_STR("FORM", ASN1_GEN_FLAG_FORMAT), | ||
| 591 | ASN1_GEN_STR("FORMAT", ASN1_GEN_FLAG_FORMAT), | ||
| 592 | }; | ||
| 593 | |||
| 594 | if (len == -1) | ||
| 595 | len = strlen(tagstr); | ||
| 596 | |||
| 597 | tntmp = tnst; | ||
| 598 | for (i = 0; i < sizeof(tnst) / sizeof(struct tag_name_st); | ||
| 599 | i++, tntmp++) { | ||
| 600 | if ((len == tntmp->len) && !strncmp(tntmp->strnam, tagstr, len)) | ||
| 601 | return tntmp->tag; | ||
| 602 | } | ||
| 603 | |||
| 604 | return -1; | ||
| 605 | } | ||
| 606 | |||
| 607 | static ASN1_TYPE * | ||
| 608 | asn1_str2type(const char *str, int format, int utype) | ||
| 609 | { | ||
| 610 | ASN1_TYPE *atmp = NULL; | ||
| 611 | CONF_VALUE vtmp; | ||
| 612 | unsigned char *rdata; | ||
| 613 | long rdlen; | ||
| 614 | int no_unused = 1; | ||
| 615 | |||
| 616 | if (!(atmp = ASN1_TYPE_new())) { | ||
| 617 | ASN1err(ASN1_F_ASN1_STR2TYPE, ERR_R_MALLOC_FAILURE); | ||
| 618 | return NULL; | ||
| 619 | } | ||
| 620 | |||
| 621 | if (!str) | ||
| 622 | str = ""; | ||
| 623 | |||
| 624 | switch (utype) { | ||
| 625 | |||
| 626 | case V_ASN1_NULL: | ||
| 627 | if (str && *str) { | ||
| 628 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 629 | ASN1_R_ILLEGAL_NULL_VALUE); | ||
| 630 | goto bad_form; | ||
| 631 | } | ||
| 632 | break; | ||
| 633 | |||
| 634 | case V_ASN1_BOOLEAN: | ||
| 635 | if (format != ASN1_GEN_FORMAT_ASCII) { | ||
| 636 | ASN1err(ASN1_F_ASN1_STR2TYPE, ASN1_R_NOT_ASCII_FORMAT); | ||
| 637 | goto bad_form; | ||
| 638 | } | ||
| 639 | vtmp.name = NULL; | ||
| 640 | vtmp.section = NULL; | ||
| 641 | vtmp.value = (char *)str; | ||
| 642 | if (!X509V3_get_value_bool(&vtmp, &atmp->value.boolean)) { | ||
| 643 | ASN1err(ASN1_F_ASN1_STR2TYPE, ASN1_R_ILLEGAL_BOOLEAN); | ||
| 644 | goto bad_str; | ||
| 645 | } | ||
| 646 | break; | ||
| 647 | |||
| 648 | case V_ASN1_INTEGER: | ||
| 649 | case V_ASN1_ENUMERATED: | ||
| 650 | if (format != ASN1_GEN_FORMAT_ASCII) { | ||
| 651 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 652 | ASN1_R_INTEGER_NOT_ASCII_FORMAT); | ||
| 653 | goto bad_form; | ||
| 654 | } | ||
| 655 | if (!(atmp->value.integer = | ||
| 656 | s2i_ASN1_INTEGER(NULL, (char *)str))) { | ||
| 657 | ASN1err(ASN1_F_ASN1_STR2TYPE, ASN1_R_ILLEGAL_INTEGER); | ||
| 658 | goto bad_str; | ||
| 659 | } | ||
| 660 | break; | ||
| 661 | |||
| 662 | case V_ASN1_OBJECT: | ||
| 663 | if (format != ASN1_GEN_FORMAT_ASCII) { | ||
| 664 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 665 | ASN1_R_OBJECT_NOT_ASCII_FORMAT); | ||
| 666 | goto bad_form; | ||
| 667 | } | ||
| 668 | if (!(atmp->value.object = OBJ_txt2obj(str, 0))) { | ||
| 669 | ASN1err(ASN1_F_ASN1_STR2TYPE, ASN1_R_ILLEGAL_OBJECT); | ||
| 670 | goto bad_str; | ||
| 671 | } | ||
| 672 | break; | ||
| 673 | |||
| 674 | case V_ASN1_UTCTIME: | ||
| 675 | case V_ASN1_GENERALIZEDTIME: | ||
| 676 | if (format != ASN1_GEN_FORMAT_ASCII) { | ||
| 677 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 678 | ASN1_R_TIME_NOT_ASCII_FORMAT); | ||
| 679 | goto bad_form; | ||
| 680 | } | ||
| 681 | if (!(atmp->value.asn1_string = ASN1_STRING_new())) { | ||
| 682 | ASN1err(ASN1_F_ASN1_STR2TYPE, ERR_R_MALLOC_FAILURE); | ||
| 683 | goto bad_str; | ||
| 684 | } | ||
| 685 | if (!ASN1_STRING_set(atmp->value.asn1_string, str, -1)) { | ||
| 686 | ASN1err(ASN1_F_ASN1_STR2TYPE, ERR_R_MALLOC_FAILURE); | ||
| 687 | goto bad_str; | ||
| 688 | } | ||
| 689 | atmp->value.asn1_string->type = utype; | ||
| 690 | if (!ASN1_TIME_check(atmp->value.asn1_string)) { | ||
| 691 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 692 | ASN1_R_ILLEGAL_TIME_VALUE); | ||
| 693 | goto bad_str; | ||
| 694 | } | ||
| 695 | break; | ||
| 696 | |||
| 697 | case V_ASN1_BMPSTRING: | ||
| 698 | case V_ASN1_PRINTABLESTRING: | ||
| 699 | case V_ASN1_IA5STRING: | ||
| 700 | case V_ASN1_T61STRING: | ||
| 701 | case V_ASN1_UTF8STRING: | ||
| 702 | case V_ASN1_VISIBLESTRING: | ||
| 703 | case V_ASN1_UNIVERSALSTRING: | ||
| 704 | case V_ASN1_GENERALSTRING: | ||
| 705 | case V_ASN1_NUMERICSTRING: | ||
| 706 | |||
| 707 | if (format == ASN1_GEN_FORMAT_ASCII) | ||
| 708 | format = MBSTRING_ASC; | ||
| 709 | else if (format == ASN1_GEN_FORMAT_UTF8) | ||
| 710 | format = MBSTRING_UTF8; | ||
| 711 | else { | ||
| 712 | ASN1err(ASN1_F_ASN1_STR2TYPE, ASN1_R_ILLEGAL_FORMAT); | ||
| 713 | goto bad_form; | ||
| 714 | } | ||
| 715 | |||
| 716 | if (ASN1_mbstring_copy(&atmp->value.asn1_string, | ||
| 717 | (unsigned char *)str, -1, format, | ||
| 718 | ASN1_tag2bit(utype)) <= 0) { | ||
| 719 | ASN1err(ASN1_F_ASN1_STR2TYPE, ERR_R_MALLOC_FAILURE); | ||
| 720 | goto bad_str; | ||
| 721 | } | ||
| 722 | break; | ||
| 723 | |||
| 724 | case V_ASN1_BIT_STRING: | ||
| 725 | case V_ASN1_OCTET_STRING: | ||
| 726 | if (!(atmp->value.asn1_string = ASN1_STRING_new())) { | ||
| 727 | ASN1err(ASN1_F_ASN1_STR2TYPE, ERR_R_MALLOC_FAILURE); | ||
| 728 | goto bad_form; | ||
| 729 | } | ||
| 730 | |||
| 731 | if (format == ASN1_GEN_FORMAT_HEX) { | ||
| 732 | |||
| 733 | if (!(rdata = string_to_hex((char *)str, &rdlen))) { | ||
| 734 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 735 | ASN1_R_ILLEGAL_HEX); | ||
| 736 | goto bad_str; | ||
| 737 | } | ||
| 738 | |||
| 739 | atmp->value.asn1_string->data = rdata; | ||
| 740 | atmp->value.asn1_string->length = rdlen; | ||
| 741 | atmp->value.asn1_string->type = utype; | ||
| 742 | |||
| 743 | } else if (format == ASN1_GEN_FORMAT_ASCII) { | ||
| 744 | if (ASN1_STRING_set(atmp->value.asn1_string, str, | ||
| 745 | -1) == 0) { | ||
| 746 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 747 | ERR_R_MALLOC_FAILURE); | ||
| 748 | goto bad_str; | ||
| 749 | } | ||
| 750 | } else if ((format == ASN1_GEN_FORMAT_BITLIST) && | ||
| 751 | (utype == V_ASN1_BIT_STRING)) { | ||
| 752 | if (!CONF_parse_list(str, ',', 1, bitstr_cb, | ||
| 753 | atmp->value.bit_string)) { | ||
| 754 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 755 | ASN1_R_LIST_ERROR); | ||
| 756 | goto bad_str; | ||
| 757 | } | ||
| 758 | no_unused = 0; | ||
| 759 | |||
| 760 | } else { | ||
| 761 | ASN1err(ASN1_F_ASN1_STR2TYPE, | ||
| 762 | ASN1_R_ILLEGAL_BITSTRING_FORMAT); | ||
| 763 | goto bad_form; | ||
| 764 | } | ||
| 765 | |||
| 766 | if ((utype == V_ASN1_BIT_STRING) && no_unused) { | ||
| 767 | atmp->value.asn1_string->flags &= | ||
| 768 | ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); | ||
| 769 | atmp->value.asn1_string->flags |= | ||
| 770 | ASN1_STRING_FLAG_BITS_LEFT; | ||
| 771 | } | ||
| 772 | |||
| 773 | break; | ||
| 774 | |||
| 775 | default: | ||
| 776 | ASN1err(ASN1_F_ASN1_STR2TYPE, ASN1_R_UNSUPPORTED_TYPE); | ||
| 777 | goto bad_str; | ||
| 778 | break; | ||
| 779 | } | ||
| 780 | |||
| 781 | atmp->type = utype; | ||
| 782 | return atmp; | ||
| 783 | |||
| 784 | bad_str: | ||
| 785 | ERR_asprintf_error_data("string=%s", str); | ||
| 786 | bad_form: | ||
| 787 | ASN1_TYPE_free(atmp); | ||
| 788 | return NULL; | ||
| 789 | } | ||
| 790 | |||
| 791 | static int | ||
| 792 | bitstr_cb(const char *elem, int len, void *bitstr) | ||
| 793 | { | ||
| 794 | long bitnum; | ||
| 795 | char *eptr; | ||
| 796 | |||
| 797 | if (!elem) | ||
| 798 | return 0; | ||
| 799 | bitnum = strtoul(elem, &eptr, 10); | ||
| 800 | if (eptr && *eptr && (eptr != elem + len)) | ||
| 801 | return 0; | ||
| 802 | if (bitnum < 0) { | ||
| 803 | ASN1err(ASN1_F_BITSTR_CB, ASN1_R_INVALID_NUMBER); | ||
| 804 | return 0; | ||
| 805 | } | ||
| 806 | if (!ASN1_BIT_STRING_set_bit(bitstr, bitnum, 1)) { | ||
| 807 | ASN1err(ASN1_F_BITSTR_CB, ERR_R_MALLOC_FAILURE); | ||
| 808 | return 0; | ||
| 809 | } | ||
| 810 | return 1; | ||
| 811 | } | ||
diff --git a/src/lib/libcrypto/asn1/asn1_lib.c b/src/lib/libcrypto/asn1/asn1_lib.c deleted file mode 100644 index 5d14a2780f..0000000000 --- a/src/lib/libcrypto/asn1/asn1_lib.c +++ /dev/null | |||
| @@ -1,486 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn1_lib.c,v 1.36 2015/07/29 14:53:20 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <limits.h> | ||
| 60 | #include <stdio.h> | ||
| 61 | #include <string.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | |||
| 66 | static int asn1_get_length(const unsigned char **pp, int *inf, long *rl, int max); | ||
| 67 | static void asn1_put_length(unsigned char **pp, int length); | ||
| 68 | |||
| 69 | static int | ||
| 70 | _asn1_check_infinite_end(const unsigned char **p, long len) | ||
| 71 | { | ||
| 72 | /* If there is 0 or 1 byte left, the length check should pick | ||
| 73 | * things up */ | ||
| 74 | if (len <= 0) | ||
| 75 | return (1); | ||
| 76 | else if ((len >= 2) && ((*p)[0] == 0) && ((*p)[1] == 0)) { | ||
| 77 | (*p) += 2; | ||
| 78 | return (1); | ||
| 79 | } | ||
| 80 | return (0); | ||
| 81 | } | ||
| 82 | |||
| 83 | int | ||
| 84 | ASN1_check_infinite_end(unsigned char **p, long len) | ||
| 85 | { | ||
| 86 | return _asn1_check_infinite_end((const unsigned char **)p, len); | ||
| 87 | } | ||
| 88 | |||
| 89 | int | ||
| 90 | ASN1_const_check_infinite_end(const unsigned char **p, long len) | ||
| 91 | { | ||
| 92 | return _asn1_check_infinite_end(p, len); | ||
| 93 | } | ||
| 94 | |||
| 95 | int | ||
| 96 | ASN1_get_object(const unsigned char **pp, long *plength, int *ptag, | ||
| 97 | int *pclass, long omax) | ||
| 98 | { | ||
| 99 | int i, ret; | ||
| 100 | long l; | ||
| 101 | const unsigned char *p= *pp; | ||
| 102 | int tag, xclass, inf; | ||
| 103 | long max = omax; | ||
| 104 | |||
| 105 | if (!max) | ||
| 106 | goto err; | ||
| 107 | ret = (*p & V_ASN1_CONSTRUCTED); | ||
| 108 | xclass = (*p & V_ASN1_PRIVATE); | ||
| 109 | i= *p & V_ASN1_PRIMITIVE_TAG; | ||
| 110 | if (i == V_ASN1_PRIMITIVE_TAG) { /* high-tag */ | ||
| 111 | p++; | ||
| 112 | if (--max == 0) | ||
| 113 | goto err; | ||
| 114 | l = 0; | ||
| 115 | while (*p & 0x80) { | ||
| 116 | l <<= 7L; | ||
| 117 | l |= *(p++) & 0x7f; | ||
| 118 | if (--max == 0) | ||
| 119 | goto err; | ||
| 120 | if (l > (INT_MAX >> 7L)) | ||
| 121 | goto err; | ||
| 122 | } | ||
| 123 | l <<= 7L; | ||
| 124 | l |= *(p++) & 0x7f; | ||
| 125 | tag = (int)l; | ||
| 126 | if (--max == 0) | ||
| 127 | goto err; | ||
| 128 | } else { | ||
| 129 | tag = i; | ||
| 130 | p++; | ||
| 131 | if (--max == 0) | ||
| 132 | goto err; | ||
| 133 | } | ||
| 134 | *ptag = tag; | ||
| 135 | *pclass = xclass; | ||
| 136 | if (!asn1_get_length(&p, &inf, plength, (int)max)) | ||
| 137 | goto err; | ||
| 138 | |||
| 139 | if (inf && !(ret & V_ASN1_CONSTRUCTED)) | ||
| 140 | goto err; | ||
| 141 | |||
| 142 | if (*plength > (omax - (p - *pp))) { | ||
| 143 | ASN1err(ASN1_F_ASN1_GET_OBJECT, ASN1_R_TOO_LONG); | ||
| 144 | /* Set this so that even if things are not long enough | ||
| 145 | * the values are set correctly */ | ||
| 146 | ret |= 0x80; | ||
| 147 | } | ||
| 148 | *pp = p; | ||
| 149 | return (ret | inf); | ||
| 150 | |||
| 151 | err: | ||
| 152 | ASN1err(ASN1_F_ASN1_GET_OBJECT, ASN1_R_HEADER_TOO_LONG); | ||
| 153 | return (0x80); | ||
| 154 | } | ||
| 155 | |||
| 156 | static int | ||
| 157 | asn1_get_length(const unsigned char **pp, int *inf, long *rl, int max) | ||
| 158 | { | ||
| 159 | const unsigned char *p= *pp; | ||
| 160 | unsigned long ret = 0; | ||
| 161 | unsigned int i; | ||
| 162 | |||
| 163 | if (max-- < 1) | ||
| 164 | return (0); | ||
| 165 | if (*p == 0x80) { | ||
| 166 | *inf = 1; | ||
| 167 | ret = 0; | ||
| 168 | p++; | ||
| 169 | } else { | ||
| 170 | *inf = 0; | ||
| 171 | i= *p & 0x7f; | ||
| 172 | if (*(p++) & 0x80) { | ||
| 173 | if (max < (int)i) | ||
| 174 | return (0); | ||
| 175 | /* skip leading zeroes */ | ||
| 176 | while (i && *p == 0) { | ||
| 177 | p++; | ||
| 178 | i--; | ||
| 179 | } | ||
| 180 | if (i > sizeof(long)) | ||
| 181 | return 0; | ||
| 182 | while (i-- > 0) { | ||
| 183 | ret <<= 8L; | ||
| 184 | ret |= *(p++); | ||
| 185 | } | ||
| 186 | } else | ||
| 187 | ret = i; | ||
| 188 | } | ||
| 189 | if (ret > LONG_MAX) | ||
| 190 | return 0; | ||
| 191 | *pp = p; | ||
| 192 | *rl = (long)ret; | ||
| 193 | return (1); | ||
| 194 | } | ||
| 195 | |||
| 196 | /* class 0 is constructed | ||
| 197 | * constructed == 2 for indefinite length constructed */ | ||
| 198 | void | ||
| 199 | ASN1_put_object(unsigned char **pp, int constructed, int length, int tag, | ||
| 200 | int xclass) | ||
| 201 | { | ||
| 202 | unsigned char *p= *pp; | ||
| 203 | int i, ttag; | ||
| 204 | |||
| 205 | i = (constructed) ? V_ASN1_CONSTRUCTED : 0; | ||
| 206 | i |= (xclass & V_ASN1_PRIVATE); | ||
| 207 | if (tag < 31) | ||
| 208 | *(p++) = i | (tag & V_ASN1_PRIMITIVE_TAG); | ||
| 209 | else { | ||
| 210 | *(p++) = i | V_ASN1_PRIMITIVE_TAG; | ||
| 211 | for(i = 0, ttag = tag; ttag > 0; i++) | ||
| 212 | ttag >>= 7; | ||
| 213 | ttag = i; | ||
| 214 | while (i-- > 0) { | ||
| 215 | p[i] = tag & 0x7f; | ||
| 216 | if (i != (ttag - 1)) | ||
| 217 | p[i] |= 0x80; | ||
| 218 | tag >>= 7; | ||
| 219 | } | ||
| 220 | p += ttag; | ||
| 221 | } | ||
| 222 | if (constructed == 2) | ||
| 223 | *(p++) = 0x80; | ||
| 224 | else | ||
| 225 | asn1_put_length(&p, length); | ||
| 226 | *pp = p; | ||
| 227 | } | ||
| 228 | |||
| 229 | int | ||
| 230 | ASN1_put_eoc(unsigned char **pp) | ||
| 231 | { | ||
| 232 | unsigned char *p = *pp; | ||
| 233 | |||
| 234 | *p++ = 0; | ||
| 235 | *p++ = 0; | ||
| 236 | *pp = p; | ||
| 237 | return 2; | ||
| 238 | } | ||
| 239 | |||
| 240 | static void | ||
| 241 | asn1_put_length(unsigned char **pp, int length) | ||
| 242 | { | ||
| 243 | unsigned char *p= *pp; | ||
| 244 | |||
| 245 | int i, l; | ||
| 246 | if (length <= 127) | ||
| 247 | *(p++) = (unsigned char)length; | ||
| 248 | else { | ||
| 249 | l = length; | ||
| 250 | for (i = 0; l > 0; i++) | ||
| 251 | l >>= 8; | ||
| 252 | *(p++) = i | 0x80; | ||
| 253 | l = i; | ||
| 254 | while (i-- > 0) { | ||
| 255 | p[i] = length & 0xff; | ||
| 256 | length >>= 8; | ||
| 257 | } | ||
| 258 | p += l; | ||
| 259 | } | ||
| 260 | *pp = p; | ||
| 261 | } | ||
| 262 | |||
| 263 | int | ||
| 264 | ASN1_object_size(int constructed, int length, int tag) | ||
| 265 | { | ||
| 266 | int ret; | ||
| 267 | |||
| 268 | ret = length; | ||
| 269 | ret++; | ||
| 270 | if (tag >= 31) { | ||
| 271 | while (tag > 0) { | ||
| 272 | tag >>= 7; | ||
| 273 | ret++; | ||
| 274 | } | ||
| 275 | } | ||
| 276 | if (constructed == 2) | ||
| 277 | return ret + 3; | ||
| 278 | ret++; | ||
| 279 | if (length > 127) { | ||
| 280 | while (length > 0) { | ||
| 281 | length >>= 8; | ||
| 282 | ret++; | ||
| 283 | } | ||
| 284 | } | ||
| 285 | return (ret); | ||
| 286 | } | ||
| 287 | |||
| 288 | static int | ||
| 289 | _asn1_Finish(ASN1_const_CTX *c) | ||
| 290 | { | ||
| 291 | if ((c->inf == (1|V_ASN1_CONSTRUCTED)) && (!c->eos)) { | ||
| 292 | if (!ASN1_const_check_infinite_end(&c->p, c->slen)) { | ||
| 293 | c->error = ERR_R_MISSING_ASN1_EOS; | ||
| 294 | return (0); | ||
| 295 | } | ||
| 296 | } | ||
| 297 | if (((c->slen != 0) && !(c->inf & 1)) || | ||
| 298 | ((c->slen < 0) && (c->inf & 1))) { | ||
| 299 | c->error = ERR_R_ASN1_LENGTH_MISMATCH; | ||
| 300 | return (0); | ||
| 301 | } | ||
| 302 | return (1); | ||
| 303 | } | ||
| 304 | |||
| 305 | int | ||
| 306 | asn1_Finish(ASN1_CTX *c) | ||
| 307 | { | ||
| 308 | return _asn1_Finish((ASN1_const_CTX *)c); | ||
| 309 | } | ||
| 310 | |||
| 311 | int | ||
| 312 | asn1_const_Finish(ASN1_const_CTX *c) | ||
| 313 | { | ||
| 314 | return _asn1_Finish(c); | ||
| 315 | } | ||
| 316 | |||
| 317 | int | ||
| 318 | asn1_GetSequence(ASN1_const_CTX *c, long *length) | ||
| 319 | { | ||
| 320 | const unsigned char *q; | ||
| 321 | |||
| 322 | q = c->p; | ||
| 323 | c->inf = ASN1_get_object(&(c->p), &(c->slen), &(c->tag), &(c->xclass), | ||
| 324 | *length); | ||
| 325 | if (c->inf & 0x80) { | ||
| 326 | c->error = ERR_R_BAD_GET_ASN1_OBJECT_CALL; | ||
| 327 | return (0); | ||
| 328 | } | ||
| 329 | if (c->tag != V_ASN1_SEQUENCE) { | ||
| 330 | c->error = ERR_R_EXPECTING_AN_ASN1_SEQUENCE; | ||
| 331 | return (0); | ||
| 332 | } | ||
| 333 | (*length) -= (c->p - q); | ||
| 334 | if (c->max && (*length < 0)) { | ||
| 335 | c->error = ERR_R_ASN1_LENGTH_MISMATCH; | ||
| 336 | return (0); | ||
| 337 | } | ||
| 338 | if (c->inf == (1|V_ASN1_CONSTRUCTED)) | ||
| 339 | c->slen= *length+ *(c->pp) - c->p; | ||
| 340 | c->eos = 0; | ||
| 341 | return (1); | ||
| 342 | } | ||
| 343 | |||
| 344 | int | ||
| 345 | ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str) | ||
| 346 | { | ||
| 347 | if (str == NULL) | ||
| 348 | return 0; | ||
| 349 | dst->type = str->type; | ||
| 350 | if (!ASN1_STRING_set(dst, str->data, str->length)) | ||
| 351 | return 0; | ||
| 352 | dst->flags = str->flags; | ||
| 353 | return 1; | ||
| 354 | } | ||
| 355 | |||
| 356 | ASN1_STRING * | ||
| 357 | ASN1_STRING_dup(const ASN1_STRING *str) | ||
| 358 | { | ||
| 359 | ASN1_STRING *ret; | ||
| 360 | |||
| 361 | if (!str) | ||
| 362 | return NULL; | ||
| 363 | ret = ASN1_STRING_new(); | ||
| 364 | if (!ret) | ||
| 365 | return NULL; | ||
| 366 | if (!ASN1_STRING_copy(ret, str)) { | ||
| 367 | ASN1_STRING_free(ret); | ||
| 368 | return NULL; | ||
| 369 | } | ||
| 370 | return ret; | ||
| 371 | } | ||
| 372 | |||
| 373 | int | ||
| 374 | ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len) | ||
| 375 | { | ||
| 376 | const char *data = _data; | ||
| 377 | |||
| 378 | if (len < 0) { | ||
| 379 | if (data == NULL) | ||
| 380 | return (0); | ||
| 381 | else | ||
| 382 | len = strlen(data); | ||
| 383 | } | ||
| 384 | if ((str->length < len) || (str->data == NULL)) { | ||
| 385 | unsigned char *tmp; | ||
| 386 | tmp = realloc(str->data, len + 1); | ||
| 387 | if (tmp == NULL) { | ||
| 388 | ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE); | ||
| 389 | return (0); | ||
| 390 | } | ||
| 391 | str->data = tmp; | ||
| 392 | } | ||
| 393 | str->length = len; | ||
| 394 | if (data != NULL) { | ||
| 395 | memmove(str->data, data, len); | ||
| 396 | } | ||
| 397 | str->data[str->length]='\0'; | ||
| 398 | return (1); | ||
| 399 | } | ||
| 400 | |||
| 401 | void | ||
| 402 | ASN1_STRING_set0(ASN1_STRING *str, void *data, int len) | ||
| 403 | { | ||
| 404 | free(str->data); | ||
| 405 | str->data = data; | ||
| 406 | str->length = len; | ||
| 407 | } | ||
| 408 | |||
| 409 | ASN1_STRING * | ||
| 410 | ASN1_STRING_new(void) | ||
| 411 | { | ||
| 412 | return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING)); | ||
| 413 | } | ||
| 414 | |||
| 415 | ASN1_STRING * | ||
| 416 | ASN1_STRING_type_new(int type) | ||
| 417 | { | ||
| 418 | ASN1_STRING *ret; | ||
| 419 | |||
| 420 | ret = malloc(sizeof(ASN1_STRING)); | ||
| 421 | if (ret == NULL) { | ||
| 422 | ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE); | ||
| 423 | return (NULL); | ||
| 424 | } | ||
| 425 | ret->length = 0; | ||
| 426 | ret->type = type; | ||
| 427 | ret->data = NULL; | ||
| 428 | ret->flags = 0; | ||
| 429 | return (ret); | ||
| 430 | } | ||
| 431 | |||
| 432 | void | ||
| 433 | ASN1_STRING_free(ASN1_STRING *a) | ||
| 434 | { | ||
| 435 | if (a == NULL) | ||
| 436 | return; | ||
| 437 | if (a->data && !(a->flags & ASN1_STRING_FLAG_NDEF)) | ||
| 438 | free(a->data); | ||
| 439 | free(a); | ||
| 440 | } | ||
| 441 | |||
| 442 | int | ||
| 443 | ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b) | ||
| 444 | { | ||
| 445 | int i; | ||
| 446 | |||
| 447 | i = (a->length - b->length); | ||
| 448 | if (i == 0) { | ||
| 449 | i = memcmp(a->data, b->data, a->length); | ||
| 450 | if (i == 0) | ||
| 451 | return (a->type - b->type); | ||
| 452 | else | ||
| 453 | return (i); | ||
| 454 | } else | ||
| 455 | return (i); | ||
| 456 | } | ||
| 457 | |||
| 458 | void | ||
| 459 | asn1_add_error(const unsigned char *address, int offset) | ||
| 460 | { | ||
| 461 | ERR_asprintf_error_data("offset=%d", offset); | ||
| 462 | } | ||
| 463 | |||
| 464 | int | ||
| 465 | ASN1_STRING_length(const ASN1_STRING *x) | ||
| 466 | { | ||
| 467 | return (x->length); | ||
| 468 | } | ||
| 469 | |||
| 470 | void | ||
| 471 | ASN1_STRING_length_set(ASN1_STRING *x, int len) | ||
| 472 | { | ||
| 473 | x->length = len; | ||
| 474 | } | ||
| 475 | |||
| 476 | int | ||
| 477 | ASN1_STRING_type(ASN1_STRING *x) | ||
| 478 | { | ||
| 479 | return (x->type); | ||
| 480 | } | ||
| 481 | |||
| 482 | unsigned char * | ||
| 483 | ASN1_STRING_data(ASN1_STRING *x) | ||
| 484 | { | ||
| 485 | return (x->data); | ||
| 486 | } | ||
diff --git a/src/lib/libcrypto/asn1/asn1_locl.h b/src/lib/libcrypto/asn1/asn1_locl.h deleted file mode 100644 index c6c80aa6aa..0000000000 --- a/src/lib/libcrypto/asn1/asn1_locl.h +++ /dev/null | |||
| @@ -1,151 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn1_locl.h,v 1.5 2014/06/12 15:49:27 deraadt Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2006. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2006 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 | /* Internal ASN1 structures and functions: not for application use */ | ||
| 60 | |||
| 61 | /* ASN1 print context structure */ | ||
| 62 | |||
| 63 | struct asn1_pctx_st { | ||
| 64 | unsigned long flags; | ||
| 65 | unsigned long nm_flags; | ||
| 66 | unsigned long cert_flags; | ||
| 67 | unsigned long oid_flags; | ||
| 68 | unsigned long str_flags; | ||
| 69 | } /* ASN1_PCTX */; | ||
| 70 | |||
| 71 | /* ASN1 public key method structure */ | ||
| 72 | |||
| 73 | struct evp_pkey_asn1_method_st { | ||
| 74 | int pkey_id; | ||
| 75 | int pkey_base_id; | ||
| 76 | unsigned long pkey_flags; | ||
| 77 | |||
| 78 | char *pem_str; | ||
| 79 | char *info; | ||
| 80 | |||
| 81 | int (*pub_decode)(EVP_PKEY *pk, X509_PUBKEY *pub); | ||
| 82 | int (*pub_encode)(X509_PUBKEY *pub, const EVP_PKEY *pk); | ||
| 83 | int (*pub_cmp)(const EVP_PKEY *a, const EVP_PKEY *b); | ||
| 84 | int (*pub_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 85 | ASN1_PCTX *pctx); | ||
| 86 | |||
| 87 | int (*priv_decode)(EVP_PKEY *pk, PKCS8_PRIV_KEY_INFO *p8inf); | ||
| 88 | int (*priv_encode)(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk); | ||
| 89 | int (*priv_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 90 | ASN1_PCTX *pctx); | ||
| 91 | |||
| 92 | int (*pkey_size)(const EVP_PKEY *pk); | ||
| 93 | int (*pkey_bits)(const EVP_PKEY *pk); | ||
| 94 | |||
| 95 | int (*param_decode)(EVP_PKEY *pkey, const unsigned char **pder, | ||
| 96 | int derlen); | ||
| 97 | int (*param_encode)(const EVP_PKEY *pkey, unsigned char **pder); | ||
| 98 | int (*param_missing)(const EVP_PKEY *pk); | ||
| 99 | int (*param_copy)(EVP_PKEY *to, const EVP_PKEY *from); | ||
| 100 | int (*param_cmp)(const EVP_PKEY *a, const EVP_PKEY *b); | ||
| 101 | int (*param_print)(BIO *out, const EVP_PKEY *pkey, int indent, | ||
| 102 | ASN1_PCTX *pctx); | ||
| 103 | int (*sig_print)(BIO *out, const X509_ALGOR *sigalg, | ||
| 104 | const ASN1_STRING *sig, int indent, ASN1_PCTX *pctx); | ||
| 105 | |||
| 106 | void (*pkey_free)(EVP_PKEY *pkey); | ||
| 107 | int (*pkey_ctrl)(EVP_PKEY *pkey, int op, long arg1, void *arg2); | ||
| 108 | |||
| 109 | /* Legacy functions for old PEM */ | ||
| 110 | |||
| 111 | int (*old_priv_decode)(EVP_PKEY *pkey, const unsigned char **pder, | ||
| 112 | int derlen); | ||
| 113 | int (*old_priv_encode)(const EVP_PKEY *pkey, unsigned char **pder); | ||
| 114 | /* Custom ASN1 signature verification */ | ||
| 115 | int (*item_verify)(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn, | ||
| 116 | X509_ALGOR *a, ASN1_BIT_STRING *sig, EVP_PKEY *pkey); | ||
| 117 | int (*item_sign)(EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn, | ||
| 118 | X509_ALGOR *alg1, X509_ALGOR *alg2, ASN1_BIT_STRING *sig); | ||
| 119 | |||
| 120 | } /* EVP_PKEY_ASN1_METHOD */; | ||
| 121 | |||
| 122 | /* Method to handle CRL access. | ||
| 123 | * In general a CRL could be very large (several Mb) and can consume large | ||
| 124 | * amounts of resources if stored in memory by multiple processes. | ||
| 125 | * This method allows general CRL operations to be redirected to more | ||
| 126 | * efficient callbacks: for example a CRL entry database. | ||
| 127 | */ | ||
| 128 | |||
| 129 | #define X509_CRL_METHOD_DYNAMIC 1 | ||
| 130 | |||
| 131 | struct x509_crl_method_st { | ||
| 132 | int flags; | ||
| 133 | int (*crl_init)(X509_CRL *crl); | ||
| 134 | int (*crl_free)(X509_CRL *crl); | ||
| 135 | int (*crl_lookup)(X509_CRL *crl, X509_REVOKED **ret, | ||
| 136 | ASN1_INTEGER *ser, X509_NAME *issuer); | ||
| 137 | int (*crl_verify)(X509_CRL *crl, EVP_PKEY *pk); | ||
| 138 | }; | ||
| 139 | |||
| 140 | /* | ||
| 141 | * Unicode codepoint constants | ||
| 142 | */ | ||
| 143 | #define UNICODE_MAX 0x10FFFF | ||
| 144 | #define UNICODE_SURROGATE_MIN 0x00D800 | ||
| 145 | #define UNICODE_SURROGATE_MAX 0x00DFFF | ||
| 146 | |||
| 147 | #define UNICODE_IS_SURROGATE(x) \ | ||
| 148 | ((x) >= UNICODE_SURROGATE_MIN && (x) <= UNICODE_SURROGATE_MAX) | ||
| 149 | |||
| 150 | int UTF8_getc(const unsigned char *str, int len, unsigned long *val); | ||
| 151 | int UTF8_putc(unsigned char *str, int len, unsigned long value); | ||
diff --git a/src/lib/libcrypto/asn1/asn1_mac.h b/src/lib/libcrypto/asn1/asn1_mac.h deleted file mode 100644 index fd524dc21c..0000000000 --- a/src/lib/libcrypto/asn1/asn1_mac.h +++ /dev/null | |||
| @@ -1,426 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn1_mac.h,v 1.14 2014/06/27 04:41:09 miod Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #ifndef HEADER_ASN1_MAC_H | ||
| 60 | #define HEADER_ASN1_MAC_H | ||
| 61 | |||
| 62 | #include <openssl/asn1.h> | ||
| 63 | |||
| 64 | #ifdef __cplusplus | ||
| 65 | extern "C" { | ||
| 66 | #endif | ||
| 67 | |||
| 68 | #ifndef ASN1_MAC_ERR_LIB | ||
| 69 | #define ASN1_MAC_ERR_LIB ERR_LIB_ASN1 | ||
| 70 | #endif | ||
| 71 | |||
| 72 | #define ASN1_MAC_H_err(f,r,line) \ | ||
| 73 | ERR_PUT_error(ASN1_MAC_ERR_LIB,(f),(r),__FILE__,(line)) | ||
| 74 | |||
| 75 | #define M_ASN1_D2I_vars(a,type,func) \ | ||
| 76 | ASN1_const_CTX c; \ | ||
| 77 | type ret=NULL; \ | ||
| 78 | \ | ||
| 79 | c.pp=(const unsigned char **)pp; \ | ||
| 80 | c.q= *(const unsigned char **)pp; \ | ||
| 81 | c.error=ERR_R_NESTED_ASN1_ERROR; \ | ||
| 82 | if ((a == NULL) || ((*a) == NULL)) \ | ||
| 83 | { if ((ret=(type)func()) == NULL) \ | ||
| 84 | { c.line=__LINE__; goto err; } } \ | ||
| 85 | else ret=(*a); | ||
| 86 | |||
| 87 | #define M_ASN1_D2I_Init() \ | ||
| 88 | c.p= *(const unsigned char **)pp; \ | ||
| 89 | c.max=(length == 0)?0:(c.p+length); | ||
| 90 | |||
| 91 | #define M_ASN1_D2I_Finish_2(a) \ | ||
| 92 | if (!asn1_const_Finish(&c)) \ | ||
| 93 | { c.line=__LINE__; goto err; } \ | ||
| 94 | *(const unsigned char **)pp=c.p; \ | ||
| 95 | if (a != NULL) (*a)=ret; \ | ||
| 96 | return(ret); | ||
| 97 | |||
| 98 | #define M_ASN1_D2I_Finish(a,func,e) \ | ||
| 99 | M_ASN1_D2I_Finish_2(a); \ | ||
| 100 | err:\ | ||
| 101 | ASN1_MAC_H_err((e),c.error,c.line); \ | ||
| 102 | asn1_add_error(*(const unsigned char **)pp,(int)(c.q- *pp)); \ | ||
| 103 | if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); \ | ||
| 104 | return(NULL) | ||
| 105 | |||
| 106 | #define M_ASN1_D2I_start_sequence() \ | ||
| 107 | if (!asn1_GetSequence(&c,&length)) \ | ||
| 108 | { c.line=__LINE__; goto err; } | ||
| 109 | /* Begin reading ASN1 without a surrounding sequence */ | ||
| 110 | #define M_ASN1_D2I_begin() \ | ||
| 111 | c.slen = length; | ||
| 112 | |||
| 113 | /* End reading ASN1 with no check on length */ | ||
| 114 | #define M_ASN1_D2I_Finish_nolen(a, func, e) \ | ||
| 115 | *pp=c.p; \ | ||
| 116 | if (a != NULL) (*a)=ret; \ | ||
| 117 | return(ret); \ | ||
| 118 | err:\ | ||
| 119 | ASN1_MAC_H_err((e),c.error,c.line); \ | ||
| 120 | asn1_add_error(*pp,(int)(c.q- *pp)); \ | ||
| 121 | if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); \ | ||
| 122 | return(NULL) | ||
| 123 | |||
| 124 | #define M_ASN1_D2I_end_sequence() \ | ||
| 125 | (((c.inf&1) == 0)?(c.slen <= 0): \ | ||
| 126 | (c.eos=ASN1_const_check_infinite_end(&c.p,c.slen))) | ||
| 127 | |||
| 128 | /* Don't use this with d2i_ASN1_BOOLEAN() */ | ||
| 129 | #define M_ASN1_D2I_get(b, func) \ | ||
| 130 | c.q=c.p; \ | ||
| 131 | if (func(&(b),&c.p,c.slen) == NULL) \ | ||
| 132 | {c.line=__LINE__; goto err; } \ | ||
| 133 | c.slen-=(c.p-c.q); | ||
| 134 | |||
| 135 | /* Don't use this with d2i_ASN1_BOOLEAN() */ | ||
| 136 | #define M_ASN1_D2I_get_x(type,b,func) \ | ||
| 137 | c.q=c.p; \ | ||
| 138 | if (((D2I_OF(type))func)(&(b),&c.p,c.slen) == NULL) \ | ||
| 139 | {c.line=__LINE__; goto err; } \ | ||
| 140 | c.slen-=(c.p-c.q); | ||
| 141 | |||
| 142 | /* use this instead () */ | ||
| 143 | #define M_ASN1_D2I_get_int(b,func) \ | ||
| 144 | c.q=c.p; \ | ||
| 145 | if (func(&(b),&c.p,c.slen) < 0) \ | ||
| 146 | {c.line=__LINE__; goto err; } \ | ||
| 147 | c.slen-=(c.p-c.q); | ||
| 148 | |||
| 149 | #define M_ASN1_D2I_get_opt(b,func,type) \ | ||
| 150 | if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) \ | ||
| 151 | == (V_ASN1_UNIVERSAL|(type)))) \ | ||
| 152 | { \ | ||
| 153 | M_ASN1_D2I_get(b,func); \ | ||
| 154 | } | ||
| 155 | |||
| 156 | #define M_ASN1_D2I_get_int_opt(b,func,type) \ | ||
| 157 | if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) \ | ||
| 158 | == (V_ASN1_UNIVERSAL|(type)))) \ | ||
| 159 | { \ | ||
| 160 | M_ASN1_D2I_get_int(b,func); \ | ||
| 161 | } | ||
| 162 | |||
| 163 | #define M_ASN1_D2I_get_imp(b,func, type) \ | ||
| 164 | M_ASN1_next=(_tmp& V_ASN1_CONSTRUCTED)|type; \ | ||
| 165 | c.q=c.p; \ | ||
| 166 | if (func(&(b),&c.p,c.slen) == NULL) \ | ||
| 167 | {c.line=__LINE__; M_ASN1_next_prev = _tmp; goto err; } \ | ||
| 168 | c.slen-=(c.p-c.q);\ | ||
| 169 | M_ASN1_next_prev=_tmp; | ||
| 170 | |||
| 171 | #define M_ASN1_D2I_get_IMP_opt(b,func,tag,type) \ | ||
| 172 | if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) == \ | ||
| 173 | (V_ASN1_CONTEXT_SPECIFIC|(tag)))) \ | ||
| 174 | { \ | ||
| 175 | unsigned char _tmp = M_ASN1_next; \ | ||
| 176 | M_ASN1_D2I_get_imp(b,func, type);\ | ||
| 177 | } | ||
| 178 | |||
| 179 | #define M_ASN1_D2I_get_set_type(type,r,func,free_func) \ | ||
| 180 | M_ASN1_D2I_get_imp_set_type(type,r,func,free_func, \ | ||
| 181 | V_ASN1_SET,V_ASN1_UNIVERSAL); | ||
| 182 | |||
| 183 | #define M_ASN1_D2I_get_set_opt_type(type,r,func,free_func) \ | ||
| 184 | if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ | ||
| 185 | V_ASN1_CONSTRUCTED|V_ASN1_SET)))\ | ||
| 186 | { M_ASN1_D2I_get_set_type(type,r,func,free_func); } | ||
| 187 | |||
| 188 | #define M_ASN1_I2D_len_SET_opt(a,f) \ | ||
| 189 | if ((a != NULL) && (sk_num(a) != 0)) \ | ||
| 190 | M_ASN1_I2D_len_SET(a,f); | ||
| 191 | |||
| 192 | #define M_ASN1_I2D_put_SET_opt(a,f) \ | ||
| 193 | if ((a != NULL) && (sk_num(a) != 0)) \ | ||
| 194 | M_ASN1_I2D_put_SET(a,f); | ||
| 195 | |||
| 196 | #define M_ASN1_I2D_put_SEQUENCE_opt(a,f) \ | ||
| 197 | if ((a != NULL) && (sk_num(a) != 0)) \ | ||
| 198 | M_ASN1_I2D_put_SEQUENCE(a,f); | ||
| 199 | |||
| 200 | #define M_ASN1_I2D_put_SEQUENCE_opt_type(type,a,f) \ | ||
| 201 | if ((a != NULL) && (sk_##type##_num(a) != 0)) \ | ||
| 202 | M_ASN1_I2D_put_SEQUENCE_type(type,a,f); | ||
| 203 | |||
| 204 | #define M_ASN1_D2I_get_IMP_set_opt_type(type,b,func,free_func,tag) \ | ||
| 205 | if ((c.slen != 0) && \ | ||
| 206 | (M_ASN1_next == \ | ||
| 207 | (V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))\ | ||
| 208 | { \ | ||
| 209 | M_ASN1_D2I_get_imp_set_type(type,b,func,free_func,\ | ||
| 210 | tag,V_ASN1_CONTEXT_SPECIFIC); \ | ||
| 211 | } | ||
| 212 | |||
| 213 | #define M_ASN1_D2I_get_seq_type(type,r,func,free_func) \ | ||
| 214 | M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,\ | ||
| 215 | V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL) | ||
| 216 | |||
| 217 | #define M_ASN1_D2I_get_seq_opt_type(type,r,func,free_func) \ | ||
| 218 | if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ | ||
| 219 | V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))\ | ||
| 220 | { M_ASN1_D2I_get_seq_type(type,r,func,free_func); } | ||
| 221 | |||
| 222 | #define M_ASN1_D2I_get_IMP_set_type(type,r,func,free_func,x) \ | ||
| 223 | M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,\ | ||
| 224 | x,V_ASN1_CONTEXT_SPECIFIC); | ||
| 225 | |||
| 226 | #define M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,a,b) \ | ||
| 227 | c.q=c.p; \ | ||
| 228 | if (d2i_ASN1_SET_OF_##type(&(r),&c.p,c.slen,func,\ | ||
| 229 | free_func,a,b) == NULL) \ | ||
| 230 | { c.line=__LINE__; goto err; } \ | ||
| 231 | c.slen-=(c.p-c.q); | ||
| 232 | |||
| 233 | #define M_ASN1_D2I_get_set_strings(r,func,a,b) \ | ||
| 234 | c.q=c.p; \ | ||
| 235 | if (d2i_ASN1_STRING_SET(&(r),&c.p,c.slen,a,b) == NULL) \ | ||
| 236 | { c.line=__LINE__; goto err; } \ | ||
| 237 | c.slen-=(c.p-c.q); | ||
| 238 | |||
| 239 | #define M_ASN1_D2I_get_EXP_opt(r,func,tag) \ | ||
| 240 | if ((c.slen != 0L) && (M_ASN1_next == \ | ||
| 241 | (V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ | ||
| 242 | { \ | ||
| 243 | int Tinf,Ttag,Tclass; \ | ||
| 244 | long Tlen; \ | ||
| 245 | \ | ||
| 246 | c.q=c.p; \ | ||
| 247 | Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ | ||
| 248 | if (Tinf & 0x80) \ | ||
| 249 | { c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \ | ||
| 250 | c.line=__LINE__; goto err; } \ | ||
| 251 | if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ | ||
| 252 | Tlen = c.slen - (c.p - c.q) - 2; \ | ||
| 253 | if (func(&(r),&c.p,Tlen) == NULL) \ | ||
| 254 | { c.line=__LINE__; goto err; } \ | ||
| 255 | if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ | ||
| 256 | Tlen = c.slen - (c.p - c.q); \ | ||
| 257 | if(!ASN1_const_check_infinite_end(&c.p, Tlen)) \ | ||
| 258 | { c.error=ERR_R_MISSING_ASN1_EOS; \ | ||
| 259 | c.line=__LINE__; goto err; } \ | ||
| 260 | }\ | ||
| 261 | c.slen-=(c.p-c.q); \ | ||
| 262 | } | ||
| 263 | |||
| 264 | #define M_ASN1_D2I_get_EXP_set_opt_type(type,r,func,free_func,tag,b) \ | ||
| 265 | if ((c.slen != 0) && (M_ASN1_next == \ | ||
| 266 | (V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ | ||
| 267 | { \ | ||
| 268 | int Tinf,Ttag,Tclass; \ | ||
| 269 | long Tlen; \ | ||
| 270 | \ | ||
| 271 | c.q=c.p; \ | ||
| 272 | Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ | ||
| 273 | if (Tinf & 0x80) \ | ||
| 274 | { c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \ | ||
| 275 | c.line=__LINE__; goto err; } \ | ||
| 276 | if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ | ||
| 277 | Tlen = c.slen - (c.p - c.q) - 2; \ | ||
| 278 | if (d2i_ASN1_SET_OF_##type(&(r),&c.p,Tlen,func, \ | ||
| 279 | free_func,b,V_ASN1_UNIVERSAL) == NULL) \ | ||
| 280 | { c.line=__LINE__; goto err; } \ | ||
| 281 | if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ | ||
| 282 | Tlen = c.slen - (c.p - c.q); \ | ||
| 283 | if(!ASN1_check_infinite_end(&c.p, Tlen)) \ | ||
| 284 | { c.error=ERR_R_MISSING_ASN1_EOS; \ | ||
| 285 | c.line=__LINE__; goto err; } \ | ||
| 286 | }\ | ||
| 287 | c.slen-=(c.p-c.q); \ | ||
| 288 | } | ||
| 289 | |||
| 290 | /* BIG UGLY WARNING! This is so damn ugly I wanna puke. Unfortunately, | ||
| 291 | some macros that use ASN1_const_CTX still insist on writing in the input | ||
| 292 | stream. ARGH! ARGH! ARGH! Let's get rid of this macro package. | ||
| 293 | Please? -- Richard Levitte */ | ||
| 294 | #define M_ASN1_next (*((unsigned char *)(c.p))) | ||
| 295 | #define M_ASN1_next_prev (*((unsigned char *)(c.q))) | ||
| 296 | |||
| 297 | /*************************************************/ | ||
| 298 | |||
| 299 | #define M_ASN1_I2D_vars(a) int r=0,ret=0; \ | ||
| 300 | unsigned char *p; \ | ||
| 301 | if (a == NULL) return(0) | ||
| 302 | |||
| 303 | /* Length Macros */ | ||
| 304 | #define M_ASN1_I2D_len(a,f) ret+=f(a,NULL) | ||
| 305 | #define M_ASN1_I2D_len_IMP_opt(a,f) if (a != NULL) M_ASN1_I2D_len(a,f) | ||
| 306 | |||
| 307 | #define M_ASN1_I2D_len_SET_type(type,a,f) \ | ||
| 308 | ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SET, \ | ||
| 309 | V_ASN1_UNIVERSAL,IS_SET); | ||
| 310 | |||
| 311 | #define M_ASN1_I2D_len_SEQUENCE_type(type,a,f) \ | ||
| 312 | ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SEQUENCE, \ | ||
| 313 | V_ASN1_UNIVERSAL,IS_SEQUENCE) | ||
| 314 | |||
| 315 | #define M_ASN1_I2D_len_SEQUENCE_opt(a,f) \ | ||
| 316 | if ((a != NULL) && (sk_num(a) != 0)) \ | ||
| 317 | M_ASN1_I2D_len_SEQUENCE(a,f); | ||
| 318 | |||
| 319 | #define M_ASN1_I2D_len_SEQUENCE_opt_type(type,a,f) \ | ||
| 320 | if ((a != NULL) && (sk_##type##_num(a) != 0)) \ | ||
| 321 | M_ASN1_I2D_len_SEQUENCE_type(type,a,f); | ||
| 322 | |||
| 323 | #define M_ASN1_I2D_len_IMP_SET_type(type,a,f,x) \ | ||
| 324 | ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ | ||
| 325 | V_ASN1_CONTEXT_SPECIFIC,IS_SET); | ||
| 326 | |||
| 327 | #define M_ASN1_I2D_len_IMP_SET_opt_type(type,a,f,x) \ | ||
| 328 | if ((a != NULL) && (sk_##type##_num(a) != 0)) \ | ||
| 329 | ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ | ||
| 330 | V_ASN1_CONTEXT_SPECIFIC,IS_SET); | ||
| 331 | |||
| 332 | #define M_ASN1_I2D_len_IMP_SEQUENCE_opt_type(type,a,f,x) \ | ||
| 333 | if ((a != NULL) && (sk_##type##_num(a) != 0)) \ | ||
| 334 | ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ | ||
| 335 | V_ASN1_CONTEXT_SPECIFIC, \ | ||
| 336 | IS_SEQUENCE); | ||
| 337 | |||
| 338 | #define M_ASN1_I2D_len_EXP_opt(a,f,mtag,v) \ | ||
| 339 | if (a != NULL)\ | ||
| 340 | { \ | ||
| 341 | v=f(a,NULL); \ | ||
| 342 | ret+=ASN1_object_size(1,v,mtag); \ | ||
| 343 | } | ||
| 344 | |||
| 345 | #define M_ASN1_I2D_len_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) \ | ||
| 346 | if ((a != NULL) && (sk_##type##_num(a) != 0))\ | ||
| 347 | { \ | ||
| 348 | v=i2d_ASN1_SET_OF_##type(a,NULL,f,tag, \ | ||
| 349 | V_ASN1_UNIVERSAL, \ | ||
| 350 | IS_SEQUENCE); \ | ||
| 351 | ret+=ASN1_object_size(1,v,mtag); \ | ||
| 352 | } | ||
| 353 | |||
| 354 | /* Put Macros */ | ||
| 355 | #define M_ASN1_I2D_put(a,f) f(a,&p) | ||
| 356 | |||
| 357 | #define M_ASN1_I2D_put_IMP_opt(a,f,t) \ | ||
| 358 | if (a != NULL) \ | ||
| 359 | { \ | ||
| 360 | unsigned char *q=p; \ | ||
| 361 | f(a,&p); \ | ||
| 362 | *q=(V_ASN1_CONTEXT_SPECIFIC|t|(*q&V_ASN1_CONSTRUCTED));\ | ||
| 363 | } | ||
| 364 | |||
| 365 | #define M_ASN1_I2D_put_SET_type(type,a,f) \ | ||
| 366 | i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET) | ||
| 367 | #define M_ASN1_I2D_put_IMP_SET_type(type,a,f,x) \ | ||
| 368 | i2d_ASN1_SET_OF_##type(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET) | ||
| 369 | |||
| 370 | #define M_ASN1_I2D_put_SEQUENCE_type(type,a,f) \ | ||
| 371 | i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, \ | ||
| 372 | IS_SEQUENCE) | ||
| 373 | |||
| 374 | #define M_ASN1_I2D_put_SEQUENCE_opt(a,f) \ | ||
| 375 | if ((a != NULL) && (sk_num(a) != 0)) \ | ||
| 376 | M_ASN1_I2D_put_SEQUENCE(a,f); | ||
| 377 | |||
| 378 | #define M_ASN1_I2D_put_IMP_SET_opt_type(type,a,f,x) \ | ||
| 379 | if ((a != NULL) && (sk_##type##_num(a) != 0)) \ | ||
| 380 | { i2d_ASN1_SET_OF_##type(a,&p,f,x, \ | ||
| 381 | V_ASN1_CONTEXT_SPECIFIC, \ | ||
| 382 | IS_SET); } | ||
| 383 | |||
| 384 | #define M_ASN1_I2D_put_IMP_SEQUENCE_opt_type(type,a,f,x) \ | ||
| 385 | if ((a != NULL) && (sk_##type##_num(a) != 0)) \ | ||
| 386 | { i2d_ASN1_SET_OF_##type(a,&p,f,x, \ | ||
| 387 | V_ASN1_CONTEXT_SPECIFIC, \ | ||
| 388 | IS_SEQUENCE); } | ||
| 389 | |||
| 390 | #define M_ASN1_I2D_put_EXP_opt(a,f,tag,v) \ | ||
| 391 | if (a != NULL) \ | ||
| 392 | { \ | ||
| 393 | ASN1_put_object(&p,1,v,tag,V_ASN1_CONTEXT_SPECIFIC); \ | ||
| 394 | f(a,&p); \ | ||
| 395 | } | ||
| 396 | |||
| 397 | #define M_ASN1_I2D_put_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) \ | ||
| 398 | if ((a != NULL) && (sk_##type##_num(a) != 0)) \ | ||
| 399 | { \ | ||
| 400 | ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \ | ||
| 401 | i2d_ASN1_SET_OF_##type(a,&p,f,tag,V_ASN1_UNIVERSAL, \ | ||
| 402 | IS_SEQUENCE); \ | ||
| 403 | } | ||
| 404 | |||
| 405 | #define M_ASN1_I2D_seq_total() \ | ||
| 406 | r=ASN1_object_size(1,ret,V_ASN1_SEQUENCE); \ | ||
| 407 | if (pp == NULL) return(r); \ | ||
| 408 | p= *pp; \ | ||
| 409 | ASN1_put_object(&p,1,ret,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL) | ||
| 410 | |||
| 411 | #define M_ASN1_I2D_INF_seq_start(tag,ctx) \ | ||
| 412 | *(p++)=(V_ASN1_CONSTRUCTED|(tag)|(ctx)); \ | ||
| 413 | *(p++)=0x80 | ||
| 414 | |||
| 415 | #define M_ASN1_I2D_INF_seq_end() *(p++)=0x00; *(p++)=0x00 | ||
| 416 | |||
| 417 | #define M_ASN1_I2D_finish() *pp=p; \ | ||
| 418 | return(r); | ||
| 419 | |||
| 420 | int asn1_GetSequence(ASN1_const_CTX *c, long *length); | ||
| 421 | void asn1_add_error(const unsigned char *address, int offset); | ||
| 422 | #ifdef __cplusplus | ||
| 423 | } | ||
| 424 | #endif | ||
| 425 | |||
| 426 | #endif | ||
diff --git a/src/lib/libcrypto/asn1/asn1_par.c b/src/lib/libcrypto/asn1/asn1_par.c deleted file mode 100644 index b5742fe97d..0000000000 --- a/src/lib/libcrypto/asn1/asn1_par.c +++ /dev/null | |||
| @@ -1,397 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn1_par.c,v 1.22 2015/02/07 13:19:15 doug Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/buffer.h> | ||
| 63 | #include <openssl/objects.h> | ||
| 64 | |||
| 65 | static int asn1_print_info(BIO *bp, int tag, int xclass, int constructed, | ||
| 66 | int indent); | ||
| 67 | static int asn1_parse2(BIO *bp, const unsigned char **pp, long length, | ||
| 68 | int offset, int depth, int indent, int dump); | ||
| 69 | |||
| 70 | static int | ||
| 71 | asn1_print_info(BIO *bp, int tag, int xclass, int constructed, | ||
| 72 | int indent) | ||
| 73 | { | ||
| 74 | char str[128]; | ||
| 75 | const char *p; | ||
| 76 | |||
| 77 | if (constructed & V_ASN1_CONSTRUCTED) | ||
| 78 | p="cons: "; | ||
| 79 | else | ||
| 80 | p="prim: "; | ||
| 81 | if (BIO_write(bp, p, 6) < 6) | ||
| 82 | goto err; | ||
| 83 | BIO_indent(bp, indent, 128); | ||
| 84 | |||
| 85 | p = str; | ||
| 86 | if ((xclass & V_ASN1_PRIVATE) == V_ASN1_PRIVATE) | ||
| 87 | snprintf(str, sizeof str, "priv [ %d ] ", tag); | ||
| 88 | else if ((xclass & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC) | ||
| 89 | snprintf(str, sizeof str, "cont [ %d ]", tag); | ||
| 90 | else if ((xclass & V_ASN1_APPLICATION) == V_ASN1_APPLICATION) | ||
| 91 | snprintf(str, sizeof str, "appl [ %d ]", tag); | ||
| 92 | else if (tag > 30) | ||
| 93 | snprintf(str, sizeof str, "<ASN1 %d>", tag); | ||
| 94 | else | ||
| 95 | p = ASN1_tag2str(tag); | ||
| 96 | |||
| 97 | if (BIO_printf(bp, "%-18s", p) <= 0) | ||
| 98 | goto err; | ||
| 99 | return (1); | ||
| 100 | err: | ||
| 101 | return (0); | ||
| 102 | } | ||
| 103 | |||
| 104 | int | ||
| 105 | ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent) | ||
| 106 | { | ||
| 107 | return (asn1_parse2(bp, &pp, len, 0, 0, indent, 0)); | ||
| 108 | } | ||
| 109 | |||
| 110 | int | ||
| 111 | ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, int dump) | ||
| 112 | { | ||
| 113 | return (asn1_parse2(bp, &pp, len, 0, 0, indent, dump)); | ||
| 114 | } | ||
| 115 | |||
| 116 | static int | ||
| 117 | asn1_parse2(BIO *bp, const unsigned char **pp, long length, int offset, | ||
| 118 | int depth, int indent, int dump) | ||
| 119 | { | ||
| 120 | const unsigned char *p, *ep, *tot, *op, *opp; | ||
| 121 | long len; | ||
| 122 | int tag, xclass, ret = 0; | ||
| 123 | int nl, hl, j, r; | ||
| 124 | ASN1_OBJECT *o = NULL; | ||
| 125 | ASN1_OCTET_STRING *os = NULL; | ||
| 126 | /* ASN1_BMPSTRING *bmp=NULL;*/ | ||
| 127 | int dump_indent; | ||
| 128 | |||
| 129 | dump_indent = 6; /* Because we know BIO_dump_indent() */ | ||
| 130 | p = *pp; | ||
| 131 | tot = p + length; | ||
| 132 | op = p - 1; | ||
| 133 | while ((p < tot) && (op < p)) { | ||
| 134 | op = p; | ||
| 135 | j = ASN1_get_object(&p, &len, &tag, &xclass, length); | ||
| 136 | |||
| 137 | if (j & 0x80) { | ||
| 138 | if (BIO_write(bp, "Error in encoding\n", 18) <= 0) | ||
| 139 | goto end; | ||
| 140 | ret = 0; | ||
| 141 | goto end; | ||
| 142 | } | ||
| 143 | hl = (p - op); | ||
| 144 | length -= hl; | ||
| 145 | /* if j == 0x21 it is a constructed indefinite length object */ | ||
| 146 | if (BIO_printf(bp, "%5ld:", (long)offset + | ||
| 147 | (long)(op - *pp)) <= 0) | ||
| 148 | goto end; | ||
| 149 | |||
| 150 | if (j != (V_ASN1_CONSTRUCTED | 1)) { | ||
| 151 | if (BIO_printf(bp, "d=%-2d hl=%ld l=%4ld ", | ||
| 152 | depth, (long)hl, len) <= 0) | ||
| 153 | goto end; | ||
| 154 | } else { | ||
| 155 | if (BIO_printf(bp, "d=%-2d hl=%ld l=inf ", | ||
| 156 | depth, (long)hl) <= 0) | ||
| 157 | goto end; | ||
| 158 | } | ||
| 159 | if (!asn1_print_info(bp, tag, xclass, j, (indent) ? depth : 0)) | ||
| 160 | goto end; | ||
| 161 | if (j & V_ASN1_CONSTRUCTED) { | ||
| 162 | ep = p + len; | ||
| 163 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 164 | goto end; | ||
| 165 | if (len > length) { | ||
| 166 | BIO_printf(bp, "length is greater than %ld\n", | ||
| 167 | length); | ||
| 168 | ret = 0; | ||
| 169 | goto end; | ||
| 170 | } | ||
| 171 | if ((j == 0x21) && (len == 0)) { | ||
| 172 | for (;;) { | ||
| 173 | r = asn1_parse2(bp, &p, (long)(tot - p), | ||
| 174 | offset + (p - *pp), depth + 1, | ||
| 175 | indent, dump); | ||
| 176 | if (r == 0) { | ||
| 177 | ret = 0; | ||
| 178 | goto end; | ||
| 179 | } | ||
| 180 | if ((r == 2) || (p >= tot)) | ||
| 181 | break; | ||
| 182 | } | ||
| 183 | } else | ||
| 184 | while (p < ep) { | ||
| 185 | r = asn1_parse2(bp, &p, (long)len, | ||
| 186 | offset + (p - *pp), depth + 1, | ||
| 187 | indent, dump); | ||
| 188 | if (r == 0) { | ||
| 189 | ret = 0; | ||
| 190 | goto end; | ||
| 191 | } | ||
| 192 | } | ||
| 193 | } else if (xclass != 0) { | ||
| 194 | p += len; | ||
| 195 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 196 | goto end; | ||
| 197 | } else { | ||
| 198 | nl = 0; | ||
| 199 | if ((tag == V_ASN1_PRINTABLESTRING) || | ||
| 200 | (tag == V_ASN1_T61STRING) || | ||
| 201 | (tag == V_ASN1_IA5STRING) || | ||
| 202 | (tag == V_ASN1_VISIBLESTRING) || | ||
| 203 | (tag == V_ASN1_NUMERICSTRING) || | ||
| 204 | (tag == V_ASN1_UTF8STRING) || | ||
| 205 | (tag == V_ASN1_UTCTIME) || | ||
| 206 | (tag == V_ASN1_GENERALIZEDTIME)) { | ||
| 207 | if (BIO_write(bp, ":", 1) <= 0) | ||
| 208 | goto end; | ||
| 209 | if ((len > 0) && | ||
| 210 | BIO_write(bp, (const char *)p, (int)len) != | ||
| 211 | (int)len) | ||
| 212 | goto end; | ||
| 213 | } else if (tag == V_ASN1_OBJECT) { | ||
| 214 | opp = op; | ||
| 215 | if (d2i_ASN1_OBJECT(&o, &opp, len + hl) != | ||
| 216 | NULL) { | ||
| 217 | if (BIO_write(bp, ":", 1) <= 0) | ||
| 218 | goto end; | ||
| 219 | i2a_ASN1_OBJECT(bp, o); | ||
| 220 | } else { | ||
| 221 | if (BIO_write(bp, ":BAD OBJECT", | ||
| 222 | 11) <= 0) | ||
| 223 | goto end; | ||
| 224 | } | ||
| 225 | } else if (tag == V_ASN1_BOOLEAN) { | ||
| 226 | int ii; | ||
| 227 | |||
| 228 | opp = op; | ||
| 229 | ii = d2i_ASN1_BOOLEAN(NULL, &opp, len + hl); | ||
| 230 | if (ii < 0) { | ||
| 231 | if (BIO_write(bp, "Bad boolean\n", | ||
| 232 | 12) <= 0) | ||
| 233 | goto end; | ||
| 234 | } | ||
| 235 | BIO_printf(bp, ":%d", ii); | ||
| 236 | } else if (tag == V_ASN1_BMPSTRING) { | ||
| 237 | /* do the BMP thang */ | ||
| 238 | } else if (tag == V_ASN1_OCTET_STRING) { | ||
| 239 | int i, printable = 1; | ||
| 240 | |||
| 241 | opp = op; | ||
| 242 | os = d2i_ASN1_OCTET_STRING(NULL, &opp, len + hl); | ||
| 243 | if (os != NULL && os->length > 0) { | ||
| 244 | opp = os->data; | ||
| 245 | /* testing whether the octet string is | ||
| 246 | * printable */ | ||
| 247 | for (i = 0; i < os->length; i++) { | ||
| 248 | if (((opp[i] < ' ') && | ||
| 249 | (opp[i] != '\n') && | ||
| 250 | (opp[i] != '\r') && | ||
| 251 | (opp[i] != '\t')) || | ||
| 252 | (opp[i] > '~')) { | ||
| 253 | printable = 0; | ||
| 254 | break; | ||
| 255 | } | ||
| 256 | } | ||
| 257 | if (printable) { | ||
| 258 | /* printable string */ | ||
| 259 | if (BIO_write(bp, ":", 1) <= 0) | ||
| 260 | goto end; | ||
| 261 | if (BIO_write(bp, (const char *)opp, | ||
| 262 | os->length) <= 0) | ||
| 263 | goto end; | ||
| 264 | } else if (!dump) { | ||
| 265 | /* not printable => print octet string | ||
| 266 | * as hex dump */ | ||
| 267 | if (BIO_write(bp, "[HEX DUMP]:", 11) <= 0) | ||
| 268 | goto end; | ||
| 269 | for (i = 0; i < os->length; i++) { | ||
| 270 | if (BIO_printf(bp, | ||
| 271 | "%02X", opp[i]) <= 0) | ||
| 272 | goto end; | ||
| 273 | } | ||
| 274 | } else { | ||
| 275 | /* print the normal dump */ | ||
| 276 | if (!nl) { | ||
| 277 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 278 | goto end; | ||
| 279 | } | ||
| 280 | if (BIO_dump_indent(bp, | ||
| 281 | (const char *)opp, | ||
| 282 | ((dump == -1 || dump > | ||
| 283 | os->length) ? os->length : dump), | ||
| 284 | dump_indent) <= 0) | ||
| 285 | goto end; | ||
| 286 | nl = 1; | ||
| 287 | } | ||
| 288 | } | ||
| 289 | M_ASN1_OCTET_STRING_free(os); | ||
| 290 | os = NULL; | ||
| 291 | } else if (tag == V_ASN1_INTEGER) { | ||
| 292 | ASN1_INTEGER *bs; | ||
| 293 | int i; | ||
| 294 | |||
| 295 | opp = op; | ||
| 296 | bs = d2i_ASN1_INTEGER(NULL, &opp, len + hl); | ||
| 297 | if (bs != NULL) { | ||
| 298 | if (BIO_write(bp, ":", 1) <= 0) | ||
| 299 | goto end; | ||
| 300 | if (bs->type == V_ASN1_NEG_INTEGER) | ||
| 301 | if (BIO_write(bp, "-", 1) <= 0) | ||
| 302 | goto end; | ||
| 303 | for (i = 0; i < bs->length; i++) { | ||
| 304 | if (BIO_printf(bp, "%02X", | ||
| 305 | bs->data[i]) <= 0) | ||
| 306 | goto end; | ||
| 307 | } | ||
| 308 | if (bs->length == 0) { | ||
| 309 | if (BIO_write(bp, "00", 2) <= 0) | ||
| 310 | goto end; | ||
| 311 | } | ||
| 312 | } else { | ||
| 313 | if (BIO_write(bp, "BAD INTEGER", 11) <= 0) | ||
| 314 | goto end; | ||
| 315 | } | ||
| 316 | M_ASN1_INTEGER_free(bs); | ||
| 317 | } else if (tag == V_ASN1_ENUMERATED) { | ||
| 318 | ASN1_ENUMERATED *bs; | ||
| 319 | int i; | ||
| 320 | |||
| 321 | opp = op; | ||
| 322 | bs = d2i_ASN1_ENUMERATED(NULL, &opp, len + hl); | ||
| 323 | if (bs != NULL) { | ||
| 324 | if (BIO_write(bp, ":", 1) <= 0) | ||
| 325 | goto end; | ||
| 326 | if (bs->type == V_ASN1_NEG_ENUMERATED) | ||
| 327 | if (BIO_write(bp, "-", 1) <= 0) | ||
| 328 | goto end; | ||
| 329 | for (i = 0; i < bs->length; i++) { | ||
| 330 | if (BIO_printf(bp, "%02X", | ||
| 331 | bs->data[i]) <= 0) | ||
| 332 | goto end; | ||
| 333 | } | ||
| 334 | if (bs->length == 0) { | ||
| 335 | if (BIO_write(bp, "00", 2) <= 0) | ||
| 336 | goto end; | ||
| 337 | } | ||
| 338 | } else { | ||
| 339 | if (BIO_write(bp, "BAD ENUMERATED", 14) <= 0) | ||
| 340 | goto end; | ||
| 341 | } | ||
| 342 | M_ASN1_ENUMERATED_free(bs); | ||
| 343 | } else if (len > 0 && dump) { | ||
| 344 | if (!nl) { | ||
| 345 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 346 | goto end; | ||
| 347 | } | ||
| 348 | if (BIO_dump_indent(bp, (const char *)p, | ||
| 349 | ((dump == -1 || dump > len) ? len : dump), | ||
| 350 | dump_indent) <= 0) | ||
| 351 | goto end; | ||
| 352 | nl = 1; | ||
| 353 | } | ||
| 354 | |||
| 355 | if (!nl) { | ||
| 356 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 357 | goto end; | ||
| 358 | } | ||
| 359 | p += len; | ||
| 360 | if ((tag == V_ASN1_EOC) && (xclass == 0)) { | ||
| 361 | ret = 2; /* End of sequence */ | ||
| 362 | goto end; | ||
| 363 | } | ||
| 364 | } | ||
| 365 | length -= len; | ||
| 366 | } | ||
| 367 | ret = 1; | ||
| 368 | |||
| 369 | end: | ||
| 370 | if (o != NULL) | ||
| 371 | ASN1_OBJECT_free(o); | ||
| 372 | M_ASN1_OCTET_STRING_free(os); | ||
| 373 | *pp = p; | ||
| 374 | return (ret); | ||
| 375 | } | ||
| 376 | |||
| 377 | const char * | ||
| 378 | ASN1_tag2str(int tag) | ||
| 379 | { | ||
| 380 | static const char * const tag2str[] = { | ||
| 381 | "EOC", "BOOLEAN", "INTEGER", "BIT STRING", "OCTET STRING", /* 0-4 */ | ||
| 382 | "NULL", "OBJECT", "OBJECT DESCRIPTOR", "EXTERNAL", "REAL", /* 5-9 */ | ||
| 383 | "ENUMERATED", "<ASN1 11>", "UTF8STRING", "<ASN1 13>", /* 10-13 */ | ||
| 384 | "<ASN1 14>", "<ASN1 15>", "SEQUENCE", "SET", /* 15-17 */ | ||
| 385 | "NUMERICSTRING", "PRINTABLESTRING", "T61STRING", /* 18-20 */ | ||
| 386 | "VIDEOTEXSTRING", "IA5STRING", "UTCTIME", "GENERALIZEDTIME", /* 21-24 */ | ||
| 387 | "GRAPHICSTRING", "VISIBLESTRING", "GENERALSTRING", /* 25-27 */ | ||
| 388 | "UNIVERSALSTRING", "<ASN1 29>", "BMPSTRING" /* 28-30 */ | ||
| 389 | }; | ||
| 390 | |||
| 391 | if ((tag == V_ASN1_NEG_INTEGER) || (tag == V_ASN1_NEG_ENUMERATED)) | ||
| 392 | tag &= ~0x100; | ||
| 393 | |||
| 394 | if (tag < 0 || tag > 30) | ||
| 395 | return "(unknown)"; | ||
| 396 | return tag2str[tag]; | ||
| 397 | } | ||
diff --git a/src/lib/libcrypto/asn1/asn1t.h b/src/lib/libcrypto/asn1/asn1t.h deleted file mode 100644 index 27f591c464..0000000000 --- a/src/lib/libcrypto/asn1/asn1t.h +++ /dev/null | |||
| @@ -1,880 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn1t.h,v 1.13 2015/07/25 17:20:02 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000-2005 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 | #ifndef HEADER_ASN1T_H | ||
| 59 | #define HEADER_ASN1T_H | ||
| 60 | |||
| 61 | #include <stddef.h> | ||
| 62 | |||
| 63 | #include <openssl/opensslconf.h> | ||
| 64 | |||
| 65 | #include <openssl/asn1.h> | ||
| 66 | |||
| 67 | /* ASN1 template defines, structures and functions */ | ||
| 68 | |||
| 69 | #ifdef __cplusplus | ||
| 70 | extern "C" { | ||
| 71 | #endif | ||
| 72 | |||
| 73 | #ifndef LIBRESSL_INTERNAL | ||
| 74 | |||
| 75 | /* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ | ||
| 76 | #define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr)) | ||
| 77 | |||
| 78 | |||
| 79 | /* Macros for start and end of ASN1_ITEM definition */ | ||
| 80 | |||
| 81 | #define ASN1_ITEM_start(itname) \ | ||
| 82 | const ASN1_ITEM itname##_it = { | ||
| 83 | |||
| 84 | #define ASN1_ITEM_end(itname) \ | ||
| 85 | }; | ||
| 86 | |||
| 87 | |||
| 88 | |||
| 89 | /* Macros to aid ASN1 template writing */ | ||
| 90 | |||
| 91 | #define ASN1_ITEM_TEMPLATE(tname) \ | ||
| 92 | static const ASN1_TEMPLATE tname##_item_tt | ||
| 93 | |||
| 94 | #define ASN1_ITEM_TEMPLATE_END(tname) \ | ||
| 95 | ;\ | ||
| 96 | ASN1_ITEM_start(tname) \ | ||
| 97 | ASN1_ITYPE_PRIMITIVE,\ | ||
| 98 | -1,\ | ||
| 99 | &tname##_item_tt,\ | ||
| 100 | 0,\ | ||
| 101 | NULL,\ | ||
| 102 | 0,\ | ||
| 103 | #tname \ | ||
| 104 | ASN1_ITEM_end(tname) | ||
| 105 | |||
| 106 | |||
| 107 | /* This is a ASN1 type which just embeds a template */ | ||
| 108 | |||
| 109 | /* This pair helps declare a SEQUENCE. We can do: | ||
| 110 | * | ||
| 111 | * ASN1_SEQUENCE(stname) = { | ||
| 112 | * ... SEQUENCE components ... | ||
| 113 | * } ASN1_SEQUENCE_END(stname) | ||
| 114 | * | ||
| 115 | * This will produce an ASN1_ITEM called stname_it | ||
| 116 | * for a structure called stname. | ||
| 117 | * | ||
| 118 | * If you want the same structure but a different | ||
| 119 | * name then use: | ||
| 120 | * | ||
| 121 | * ASN1_SEQUENCE(itname) = { | ||
| 122 | * ... SEQUENCE components ... | ||
| 123 | * } ASN1_SEQUENCE_END_name(stname, itname) | ||
| 124 | * | ||
| 125 | * This will create an item called itname_it using | ||
| 126 | * a structure called stname. | ||
| 127 | */ | ||
| 128 | |||
| 129 | #define ASN1_SEQUENCE(tname) \ | ||
| 130 | static const ASN1_TEMPLATE tname##_seq_tt[] | ||
| 131 | |||
| 132 | #define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname) | ||
| 133 | |||
| 134 | #define ASN1_SEQUENCE_END_name(stname, tname) \ | ||
| 135 | ;\ | ||
| 136 | ASN1_ITEM_start(tname) \ | ||
| 137 | ASN1_ITYPE_SEQUENCE,\ | ||
| 138 | V_ASN1_SEQUENCE,\ | ||
| 139 | tname##_seq_tt,\ | ||
| 140 | sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | ||
| 141 | NULL,\ | ||
| 142 | sizeof(stname),\ | ||
| 143 | #stname \ | ||
| 144 | ASN1_ITEM_end(tname) | ||
| 145 | |||
| 146 | #define ASN1_NDEF_SEQUENCE(tname) \ | ||
| 147 | ASN1_SEQUENCE(tname) | ||
| 148 | |||
| 149 | #define ASN1_NDEF_SEQUENCE_cb(tname, cb) \ | ||
| 150 | ASN1_SEQUENCE_cb(tname, cb) | ||
| 151 | |||
| 152 | #define ASN1_SEQUENCE_cb(tname, cb) \ | ||
| 153 | static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ | ||
| 154 | ASN1_SEQUENCE(tname) | ||
| 155 | |||
| 156 | #define ASN1_BROKEN_SEQUENCE(tname) \ | ||
| 157 | static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \ | ||
| 158 | ASN1_SEQUENCE(tname) | ||
| 159 | |||
| 160 | #define ASN1_SEQUENCE_ref(tname, cb, lck) \ | ||
| 161 | static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), lck, cb, 0}; \ | ||
| 162 | ASN1_SEQUENCE(tname) | ||
| 163 | |||
| 164 | #define ASN1_SEQUENCE_enc(tname, enc, cb) \ | ||
| 165 | static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \ | ||
| 166 | ASN1_SEQUENCE(tname) | ||
| 167 | |||
| 168 | #define ASN1_NDEF_SEQUENCE_END(tname) \ | ||
| 169 | ;\ | ||
| 170 | ASN1_ITEM_start(tname) \ | ||
| 171 | ASN1_ITYPE_NDEF_SEQUENCE,\ | ||
| 172 | V_ASN1_SEQUENCE,\ | ||
| 173 | tname##_seq_tt,\ | ||
| 174 | sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | ||
| 175 | NULL,\ | ||
| 176 | sizeof(tname),\ | ||
| 177 | #tname \ | ||
| 178 | ASN1_ITEM_end(tname) | ||
| 179 | |||
| 180 | #define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname) | ||
| 181 | |||
| 182 | #define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) | ||
| 183 | |||
| 184 | #define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) | ||
| 185 | |||
| 186 | #define ASN1_SEQUENCE_END_ref(stname, tname) \ | ||
| 187 | ;\ | ||
| 188 | ASN1_ITEM_start(tname) \ | ||
| 189 | ASN1_ITYPE_SEQUENCE,\ | ||
| 190 | V_ASN1_SEQUENCE,\ | ||
| 191 | tname##_seq_tt,\ | ||
| 192 | sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | ||
| 193 | &tname##_aux,\ | ||
| 194 | sizeof(stname),\ | ||
| 195 | #stname \ | ||
| 196 | ASN1_ITEM_end(tname) | ||
| 197 | |||
| 198 | #define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \ | ||
| 199 | ;\ | ||
| 200 | ASN1_ITEM_start(tname) \ | ||
| 201 | ASN1_ITYPE_NDEF_SEQUENCE,\ | ||
| 202 | V_ASN1_SEQUENCE,\ | ||
| 203 | tname##_seq_tt,\ | ||
| 204 | sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ | ||
| 205 | &tname##_aux,\ | ||
| 206 | sizeof(stname),\ | ||
| 207 | #stname \ | ||
| 208 | ASN1_ITEM_end(tname) | ||
| 209 | |||
| 210 | |||
| 211 | /* This pair helps declare a CHOICE type. We can do: | ||
| 212 | * | ||
| 213 | * ASN1_CHOICE(chname) = { | ||
| 214 | * ... CHOICE options ... | ||
| 215 | * ASN1_CHOICE_END(chname) | ||
| 216 | * | ||
| 217 | * This will produce an ASN1_ITEM called chname_it | ||
| 218 | * for a structure called chname. The structure | ||
| 219 | * definition must look like this: | ||
| 220 | * typedef struct { | ||
| 221 | * int type; | ||
| 222 | * union { | ||
| 223 | * ASN1_SOMETHING *opt1; | ||
| 224 | * ASN1_SOMEOTHER *opt2; | ||
| 225 | * } value; | ||
| 226 | * } chname; | ||
| 227 | * | ||
| 228 | * the name of the selector must be 'type'. | ||
| 229 | * to use an alternative selector name use the | ||
| 230 | * ASN1_CHOICE_END_selector() version. | ||
| 231 | */ | ||
| 232 | |||
| 233 | #define ASN1_CHOICE(tname) \ | ||
| 234 | static const ASN1_TEMPLATE tname##_ch_tt[] | ||
| 235 | |||
| 236 | #define ASN1_CHOICE_cb(tname, cb) \ | ||
| 237 | static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ | ||
| 238 | ASN1_CHOICE(tname) | ||
| 239 | |||
| 240 | #define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname) | ||
| 241 | |||
| 242 | #define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type) | ||
| 243 | |||
| 244 | #define ASN1_CHOICE_END_selector(stname, tname, selname) \ | ||
| 245 | ;\ | ||
| 246 | ASN1_ITEM_start(tname) \ | ||
| 247 | ASN1_ITYPE_CHOICE,\ | ||
| 248 | offsetof(stname,selname) ,\ | ||
| 249 | tname##_ch_tt,\ | ||
| 250 | sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ | ||
| 251 | NULL,\ | ||
| 252 | sizeof(stname),\ | ||
| 253 | #stname \ | ||
| 254 | ASN1_ITEM_end(tname) | ||
| 255 | |||
| 256 | #define ASN1_CHOICE_END_cb(stname, tname, selname) \ | ||
| 257 | ;\ | ||
| 258 | ASN1_ITEM_start(tname) \ | ||
| 259 | ASN1_ITYPE_CHOICE,\ | ||
| 260 | offsetof(stname,selname) ,\ | ||
| 261 | tname##_ch_tt,\ | ||
| 262 | sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ | ||
| 263 | &tname##_aux,\ | ||
| 264 | sizeof(stname),\ | ||
| 265 | #stname \ | ||
| 266 | ASN1_ITEM_end(tname) | ||
| 267 | |||
| 268 | /* This helps with the template wrapper form of ASN1_ITEM */ | ||
| 269 | |||
| 270 | #define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \ | ||
| 271 | (flags), (tag), 0,\ | ||
| 272 | #name, ASN1_ITEM_ref(type) } | ||
| 273 | |||
| 274 | /* These help with SEQUENCE or CHOICE components */ | ||
| 275 | |||
| 276 | /* used to declare other types */ | ||
| 277 | |||
| 278 | #define ASN1_EX_TYPE(flags, tag, stname, field, type) { \ | ||
| 279 | (flags), (tag), offsetof(stname, field),\ | ||
| 280 | #field, ASN1_ITEM_ref(type) } | ||
| 281 | |||
| 282 | /* used when the structure is combined with the parent */ | ||
| 283 | |||
| 284 | #define ASN1_EX_COMBINE(flags, tag, type) { \ | ||
| 285 | (flags)|ASN1_TFLG_COMBINE, (tag), 0, NULL, ASN1_ITEM_ref(type) } | ||
| 286 | |||
| 287 | /* implicit and explicit helper macros */ | ||
| 288 | |||
| 289 | #define ASN1_IMP_EX(stname, field, type, tag, ex) \ | ||
| 290 | ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | ex, tag, stname, field, type) | ||
| 291 | |||
| 292 | #define ASN1_EXP_EX(stname, field, type, tag, ex) \ | ||
| 293 | ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | ex, tag, stname, field, type) | ||
| 294 | |||
| 295 | /* Any defined by macros: the field used is in the table itself */ | ||
| 296 | |||
| 297 | #define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } | ||
| 298 | #define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } | ||
| 299 | /* Plain simple type */ | ||
| 300 | #define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type) | ||
| 301 | |||
| 302 | /* OPTIONAL simple type */ | ||
| 303 | #define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type) | ||
| 304 | |||
| 305 | /* IMPLICIT tagged simple type */ | ||
| 306 | #define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0) | ||
| 307 | |||
| 308 | /* IMPLICIT tagged OPTIONAL simple type */ | ||
| 309 | #define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) | ||
| 310 | |||
| 311 | /* Same as above but EXPLICIT */ | ||
| 312 | |||
| 313 | #define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0) | ||
| 314 | #define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) | ||
| 315 | |||
| 316 | /* SEQUENCE OF type */ | ||
| 317 | #define ASN1_SEQUENCE_OF(stname, field, type) \ | ||
| 318 | ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type) | ||
| 319 | |||
| 320 | /* OPTIONAL SEQUENCE OF */ | ||
| 321 | #define ASN1_SEQUENCE_OF_OPT(stname, field, type) \ | ||
| 322 | ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) | ||
| 323 | |||
| 324 | /* Same as above but for SET OF */ | ||
| 325 | |||
| 326 | #define ASN1_SET_OF(stname, field, type) \ | ||
| 327 | ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type) | ||
| 328 | |||
| 329 | #define ASN1_SET_OF_OPT(stname, field, type) \ | ||
| 330 | ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) | ||
| 331 | |||
| 332 | /* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */ | ||
| 333 | |||
| 334 | #define ASN1_IMP_SET_OF(stname, field, type, tag) \ | ||
| 335 | ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) | ||
| 336 | |||
| 337 | #define ASN1_EXP_SET_OF(stname, field, type, tag) \ | ||
| 338 | ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) | ||
| 339 | |||
| 340 | #define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \ | ||
| 341 | ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) | ||
| 342 | |||
| 343 | #define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \ | ||
| 344 | ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) | ||
| 345 | |||
| 346 | #define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \ | ||
| 347 | ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) | ||
| 348 | |||
| 349 | #define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \ | ||
| 350 | ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) | ||
| 351 | |||
| 352 | #define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \ | ||
| 353 | ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) | ||
| 354 | |||
| 355 | #define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \ | ||
| 356 | ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) | ||
| 357 | |||
| 358 | /* EXPLICIT using indefinite length constructed form */ | ||
| 359 | #define ASN1_NDEF_EXP(stname, field, type, tag) \ | ||
| 360 | ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF) | ||
| 361 | |||
| 362 | /* EXPLICIT OPTIONAL using indefinite length constructed form */ | ||
| 363 | #define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \ | ||
| 364 | ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF) | ||
| 365 | |||
| 366 | /* Macros for the ASN1_ADB structure */ | ||
| 367 | |||
| 368 | #define ASN1_ADB(name) \ | ||
| 369 | static const ASN1_ADB_TABLE name##_adbtbl[] | ||
| 370 | |||
| 371 | |||
| 372 | #define ASN1_ADB_END(name, flags, field, app_table, def, none) \ | ||
| 373 | ;\ | ||
| 374 | static const ASN1_ADB name##_adb = {\ | ||
| 375 | flags,\ | ||
| 376 | offsetof(name, field),\ | ||
| 377 | app_table,\ | ||
| 378 | name##_adbtbl,\ | ||
| 379 | sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ | ||
| 380 | def,\ | ||
| 381 | none\ | ||
| 382 | } | ||
| 383 | |||
| 384 | |||
| 385 | #define ADB_ENTRY(val, template) {val, template} | ||
| 386 | |||
| 387 | #define ASN1_ADB_TEMPLATE(name) \ | ||
| 388 | static const ASN1_TEMPLATE name##_tt | ||
| 389 | |||
| 390 | #endif /* !LIBRESSL_INTERNAL */ | ||
| 391 | |||
| 392 | /* This is the ASN1 template structure that defines | ||
| 393 | * a wrapper round the actual type. It determines the | ||
| 394 | * actual position of the field in the value structure, | ||
| 395 | * various flags such as OPTIONAL and the field name. | ||
| 396 | */ | ||
| 397 | |||
| 398 | struct ASN1_TEMPLATE_st { | ||
| 399 | unsigned long flags; /* Various flags */ | ||
| 400 | long tag; /* tag, not used if no tagging */ | ||
| 401 | unsigned long offset; /* Offset of this field in structure */ | ||
| 402 | #ifndef NO_ASN1_FIELD_NAMES | ||
| 403 | const char *field_name; /* Field name */ | ||
| 404 | #endif | ||
| 405 | ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */ | ||
| 406 | }; | ||
| 407 | |||
| 408 | /* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */ | ||
| 409 | |||
| 410 | #define ASN1_TEMPLATE_item(t) (t->item_ptr) | ||
| 411 | #define ASN1_TEMPLATE_adb(t) (t->item_ptr) | ||
| 412 | |||
| 413 | typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE; | ||
| 414 | typedef struct ASN1_ADB_st ASN1_ADB; | ||
| 415 | |||
| 416 | struct ASN1_ADB_st { | ||
| 417 | unsigned long flags; /* Various flags */ | ||
| 418 | unsigned long offset; /* Offset of selector field */ | ||
| 419 | STACK_OF(ASN1_ADB_TABLE) **app_items; /* Application defined items */ | ||
| 420 | const ASN1_ADB_TABLE *tbl; /* Table of possible types */ | ||
| 421 | long tblcount; /* Number of entries in tbl */ | ||
| 422 | const ASN1_TEMPLATE *default_tt; /* Type to use if no match */ | ||
| 423 | const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */ | ||
| 424 | }; | ||
| 425 | |||
| 426 | struct ASN1_ADB_TABLE_st { | ||
| 427 | long value; /* NID for an object or value for an int */ | ||
| 428 | const ASN1_TEMPLATE tt; /* item for this value */ | ||
| 429 | }; | ||
| 430 | |||
| 431 | /* template flags */ | ||
| 432 | |||
| 433 | /* Field is optional */ | ||
| 434 | #define ASN1_TFLG_OPTIONAL (0x1) | ||
| 435 | |||
| 436 | /* Field is a SET OF */ | ||
| 437 | #define ASN1_TFLG_SET_OF (0x1 << 1) | ||
| 438 | |||
| 439 | /* Field is a SEQUENCE OF */ | ||
| 440 | #define ASN1_TFLG_SEQUENCE_OF (0x2 << 1) | ||
| 441 | |||
| 442 | /* Special case: this refers to a SET OF that | ||
| 443 | * will be sorted into DER order when encoded *and* | ||
| 444 | * the corresponding STACK will be modified to match | ||
| 445 | * the new order. | ||
| 446 | */ | ||
| 447 | #define ASN1_TFLG_SET_ORDER (0x3 << 1) | ||
| 448 | |||
| 449 | /* Mask for SET OF or SEQUENCE OF */ | ||
| 450 | #define ASN1_TFLG_SK_MASK (0x3 << 1) | ||
| 451 | |||
| 452 | /* These flags mean the tag should be taken from the | ||
| 453 | * tag field. If EXPLICIT then the underlying type | ||
| 454 | * is used for the inner tag. | ||
| 455 | */ | ||
| 456 | |||
| 457 | /* IMPLICIT tagging */ | ||
| 458 | #define ASN1_TFLG_IMPTAG (0x1 << 3) | ||
| 459 | |||
| 460 | |||
| 461 | /* EXPLICIT tagging, inner tag from underlying type */ | ||
| 462 | #define ASN1_TFLG_EXPTAG (0x2 << 3) | ||
| 463 | |||
| 464 | #define ASN1_TFLG_TAG_MASK (0x3 << 3) | ||
| 465 | |||
| 466 | /* context specific IMPLICIT */ | ||
| 467 | #define ASN1_TFLG_IMPLICIT ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT | ||
| 468 | |||
| 469 | /* context specific EXPLICIT */ | ||
| 470 | #define ASN1_TFLG_EXPLICIT ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT | ||
| 471 | |||
| 472 | /* If tagging is in force these determine the | ||
| 473 | * type of tag to use. Otherwise the tag is | ||
| 474 | * determined by the underlying type. These | ||
| 475 | * values reflect the actual octet format. | ||
| 476 | */ | ||
| 477 | |||
| 478 | /* Universal tag */ | ||
| 479 | #define ASN1_TFLG_UNIVERSAL (0x0<<6) | ||
| 480 | /* Application tag */ | ||
| 481 | #define ASN1_TFLG_APPLICATION (0x1<<6) | ||
| 482 | /* Context specific tag */ | ||
| 483 | #define ASN1_TFLG_CONTEXT (0x2<<6) | ||
| 484 | /* Private tag */ | ||
| 485 | #define ASN1_TFLG_PRIVATE (0x3<<6) | ||
| 486 | |||
| 487 | #define ASN1_TFLG_TAG_CLASS (0x3<<6) | ||
| 488 | |||
| 489 | /* These are for ANY DEFINED BY type. In this case | ||
| 490 | * the 'item' field points to an ASN1_ADB structure | ||
| 491 | * which contains a table of values to decode the | ||
| 492 | * relevant type | ||
| 493 | */ | ||
| 494 | |||
| 495 | #define ASN1_TFLG_ADB_MASK (0x3<<8) | ||
| 496 | |||
| 497 | #define ASN1_TFLG_ADB_OID (0x1<<8) | ||
| 498 | |||
| 499 | #define ASN1_TFLG_ADB_INT (0x1<<9) | ||
| 500 | |||
| 501 | /* This flag means a parent structure is passed | ||
| 502 | * instead of the field: this is useful is a | ||
| 503 | * SEQUENCE is being combined with a CHOICE for | ||
| 504 | * example. Since this means the structure and | ||
| 505 | * item name will differ we need to use the | ||
| 506 | * ASN1_CHOICE_END_name() macro for example. | ||
| 507 | */ | ||
| 508 | |||
| 509 | #define ASN1_TFLG_COMBINE (0x1<<10) | ||
| 510 | |||
| 511 | /* This flag when present in a SEQUENCE OF, SET OF | ||
| 512 | * or EXPLICIT causes indefinite length constructed | ||
| 513 | * encoding to be used if required. | ||
| 514 | */ | ||
| 515 | |||
| 516 | #define ASN1_TFLG_NDEF (0x1<<11) | ||
| 517 | |||
| 518 | /* This is the actual ASN1 item itself */ | ||
| 519 | |||
| 520 | struct ASN1_ITEM_st { | ||
| 521 | char itype; /* The item type, primitive, SEQUENCE, CHOICE or extern */ | ||
| 522 | long utype; /* underlying type */ | ||
| 523 | const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains the contents */ | ||
| 524 | long tcount; /* Number of templates if SEQUENCE or CHOICE */ | ||
| 525 | const void *funcs; /* functions that handle this type */ | ||
| 526 | long size; /* Structure size (usually)*/ | ||
| 527 | #ifndef NO_ASN1_FIELD_NAMES | ||
| 528 | const char *sname; /* Structure name */ | ||
| 529 | #endif | ||
| 530 | }; | ||
| 531 | |||
| 532 | /* These are values for the itype field and | ||
| 533 | * determine how the type is interpreted. | ||
| 534 | * | ||
| 535 | * For PRIMITIVE types the underlying type | ||
| 536 | * determines the behaviour if items is NULL. | ||
| 537 | * | ||
| 538 | * Otherwise templates must contain a single | ||
| 539 | * template and the type is treated in the | ||
| 540 | * same way as the type specified in the template. | ||
| 541 | * | ||
| 542 | * For SEQUENCE types the templates field points | ||
| 543 | * to the members, the size field is the | ||
| 544 | * structure size. | ||
| 545 | * | ||
| 546 | * For CHOICE types the templates field points | ||
| 547 | * to each possible member (typically a union) | ||
| 548 | * and the 'size' field is the offset of the | ||
| 549 | * selector. | ||
| 550 | * | ||
| 551 | * The 'funcs' field is used for application | ||
| 552 | * specific functions. | ||
| 553 | * | ||
| 554 | * The EXTERN type uses a new style d2i/i2d. | ||
| 555 | * The new style should be used where possible | ||
| 556 | * because it avoids things like the d2i IMPLICIT | ||
| 557 | * hack. | ||
| 558 | * | ||
| 559 | * MSTRING is a multiple string type, it is used | ||
| 560 | * for a CHOICE of character strings where the | ||
| 561 | * actual strings all occupy an ASN1_STRING | ||
| 562 | * structure. In this case the 'utype' field | ||
| 563 | * has a special meaning, it is used as a mask | ||
| 564 | * of acceptable types using the B_ASN1 constants. | ||
| 565 | * | ||
| 566 | * NDEF_SEQUENCE is the same as SEQUENCE except | ||
| 567 | * that it will use indefinite length constructed | ||
| 568 | * encoding if requested. | ||
| 569 | * | ||
| 570 | */ | ||
| 571 | |||
| 572 | #define ASN1_ITYPE_PRIMITIVE 0x0 | ||
| 573 | |||
| 574 | #define ASN1_ITYPE_SEQUENCE 0x1 | ||
| 575 | |||
| 576 | #define ASN1_ITYPE_CHOICE 0x2 | ||
| 577 | |||
| 578 | #define ASN1_ITYPE_EXTERN 0x4 | ||
| 579 | |||
| 580 | #define ASN1_ITYPE_MSTRING 0x5 | ||
| 581 | |||
| 582 | #define ASN1_ITYPE_NDEF_SEQUENCE 0x6 | ||
| 583 | |||
| 584 | /* Cache for ASN1 tag and length, so we | ||
| 585 | * don't keep re-reading it for things | ||
| 586 | * like CHOICE | ||
| 587 | */ | ||
| 588 | |||
| 589 | struct ASN1_TLC_st{ | ||
| 590 | char valid; /* Values below are valid */ | ||
| 591 | int ret; /* return value */ | ||
| 592 | long plen; /* length */ | ||
| 593 | int ptag; /* class value */ | ||
| 594 | int pclass; /* class value */ | ||
| 595 | int hdrlen; /* header length */ | ||
| 596 | }; | ||
| 597 | |||
| 598 | /* Typedefs for ASN1 function pointers */ | ||
| 599 | |||
| 600 | typedef ASN1_VALUE * ASN1_new_func(void); | ||
| 601 | typedef void ASN1_free_func(ASN1_VALUE *a); | ||
| 602 | typedef ASN1_VALUE * ASN1_d2i_func(ASN1_VALUE **a, const unsigned char ** in, long length); | ||
| 603 | typedef int ASN1_i2d_func(ASN1_VALUE * a, unsigned char **in); | ||
| 604 | |||
| 605 | typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_ITEM *it, | ||
| 606 | int tag, int aclass, char opt, ASN1_TLC *ctx); | ||
| 607 | |||
| 608 | typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass); | ||
| 609 | typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 610 | typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 611 | |||
| 612 | typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval, | ||
| 613 | int indent, const char *fname, | ||
| 614 | const ASN1_PCTX *pctx); | ||
| 615 | |||
| 616 | typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it); | ||
| 617 | typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it); | ||
| 618 | typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval, const ASN1_ITEM *it, int indent, const ASN1_PCTX *pctx); | ||
| 619 | |||
| 620 | typedef struct ASN1_EXTERN_FUNCS_st { | ||
| 621 | void *app_data; | ||
| 622 | ASN1_ex_new_func *asn1_ex_new; | ||
| 623 | ASN1_ex_free_func *asn1_ex_free; | ||
| 624 | ASN1_ex_free_func *asn1_ex_clear; | ||
| 625 | ASN1_ex_d2i *asn1_ex_d2i; | ||
| 626 | ASN1_ex_i2d *asn1_ex_i2d; | ||
| 627 | ASN1_ex_print_func *asn1_ex_print; | ||
| 628 | } ASN1_EXTERN_FUNCS; | ||
| 629 | |||
| 630 | typedef struct ASN1_PRIMITIVE_FUNCS_st { | ||
| 631 | void *app_data; | ||
| 632 | unsigned long flags; | ||
| 633 | ASN1_ex_new_func *prim_new; | ||
| 634 | ASN1_ex_free_func *prim_free; | ||
| 635 | ASN1_ex_free_func *prim_clear; | ||
| 636 | ASN1_primitive_c2i *prim_c2i; | ||
| 637 | ASN1_primitive_i2c *prim_i2c; | ||
| 638 | ASN1_primitive_print *prim_print; | ||
| 639 | } ASN1_PRIMITIVE_FUNCS; | ||
| 640 | |||
| 641 | /* This is the ASN1_AUX structure: it handles various | ||
| 642 | * miscellaneous requirements. For example the use of | ||
| 643 | * reference counts and an informational callback. | ||
| 644 | * | ||
| 645 | * The "informational callback" is called at various | ||
| 646 | * points during the ASN1 encoding and decoding. It can | ||
| 647 | * be used to provide minor customisation of the structures | ||
| 648 | * used. This is most useful where the supplied routines | ||
| 649 | * *almost* do the right thing but need some extra help | ||
| 650 | * at a few points. If the callback returns zero then | ||
| 651 | * it is assumed a fatal error has occurred and the | ||
| 652 | * main operation should be abandoned. | ||
| 653 | * | ||
| 654 | * If major changes in the default behaviour are required | ||
| 655 | * then an external type is more appropriate. | ||
| 656 | */ | ||
| 657 | |||
| 658 | typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it, | ||
| 659 | void *exarg); | ||
| 660 | |||
| 661 | typedef struct ASN1_AUX_st { | ||
| 662 | void *app_data; | ||
| 663 | int flags; | ||
| 664 | int ref_offset; /* Offset of reference value */ | ||
| 665 | int ref_lock; /* Lock type to use */ | ||
| 666 | ASN1_aux_cb *asn1_cb; | ||
| 667 | int enc_offset; /* Offset of ASN1_ENCODING structure */ | ||
| 668 | } ASN1_AUX; | ||
| 669 | |||
| 670 | /* For print related callbacks exarg points to this structure */ | ||
| 671 | typedef struct ASN1_PRINT_ARG_st { | ||
| 672 | BIO *out; | ||
| 673 | int indent; | ||
| 674 | const ASN1_PCTX *pctx; | ||
| 675 | } ASN1_PRINT_ARG; | ||
| 676 | |||
| 677 | /* For streaming related callbacks exarg points to this structure */ | ||
| 678 | typedef struct ASN1_STREAM_ARG_st { | ||
| 679 | /* BIO to stream through */ | ||
| 680 | BIO *out; | ||
| 681 | /* BIO with filters appended */ | ||
| 682 | BIO *ndef_bio; | ||
| 683 | /* Streaming I/O boundary */ | ||
| 684 | unsigned char **boundary; | ||
| 685 | } ASN1_STREAM_ARG; | ||
| 686 | |||
| 687 | /* Flags in ASN1_AUX */ | ||
| 688 | |||
| 689 | /* Use a reference count */ | ||
| 690 | #define ASN1_AFLG_REFCOUNT 1 | ||
| 691 | /* Save the encoding of structure (useful for signatures) */ | ||
| 692 | #define ASN1_AFLG_ENCODING 2 | ||
| 693 | /* The Sequence length is invalid */ | ||
| 694 | #define ASN1_AFLG_BROKEN 4 | ||
| 695 | |||
| 696 | /* operation values for asn1_cb */ | ||
| 697 | |||
| 698 | #define ASN1_OP_NEW_PRE 0 | ||
| 699 | #define ASN1_OP_NEW_POST 1 | ||
| 700 | #define ASN1_OP_FREE_PRE 2 | ||
| 701 | #define ASN1_OP_FREE_POST 3 | ||
| 702 | #define ASN1_OP_D2I_PRE 4 | ||
| 703 | #define ASN1_OP_D2I_POST 5 | ||
| 704 | #define ASN1_OP_I2D_PRE 6 | ||
| 705 | #define ASN1_OP_I2D_POST 7 | ||
| 706 | #define ASN1_OP_PRINT_PRE 8 | ||
| 707 | #define ASN1_OP_PRINT_POST 9 | ||
| 708 | #define ASN1_OP_STREAM_PRE 10 | ||
| 709 | #define ASN1_OP_STREAM_POST 11 | ||
| 710 | #define ASN1_OP_DETACHED_PRE 12 | ||
| 711 | #define ASN1_OP_DETACHED_POST 13 | ||
| 712 | |||
| 713 | #ifndef LIBRESSL_INTERNAL | ||
| 714 | |||
| 715 | /* Macro to implement a primitive type */ | ||
| 716 | #define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0) | ||
| 717 | #define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \ | ||
| 718 | ASN1_ITEM_start(itname) \ | ||
| 719 | ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \ | ||
| 720 | ASN1_ITEM_end(itname) | ||
| 721 | |||
| 722 | /* Macro to implement a multi string type */ | ||
| 723 | #define IMPLEMENT_ASN1_MSTRING(itname, mask) \ | ||
| 724 | ASN1_ITEM_start(itname) \ | ||
| 725 | ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \ | ||
| 726 | ASN1_ITEM_end(itname) | ||
| 727 | #define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \ | ||
| 728 | ASN1_ITEM_start(sname) \ | ||
| 729 | ASN1_ITYPE_EXTERN, \ | ||
| 730 | tag, \ | ||
| 731 | NULL, \ | ||
| 732 | 0, \ | ||
| 733 | &fptrs, \ | ||
| 734 | 0, \ | ||
| 735 | #sname \ | ||
| 736 | ASN1_ITEM_end(sname) | ||
| 737 | |||
| 738 | /* Macro to implement standard functions in terms of ASN1_ITEM structures */ | ||
| 739 | |||
| 740 | #define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname) | ||
| 741 | |||
| 742 | #define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname) | ||
| 743 | |||
| 744 | #define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \ | ||
| 745 | IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname) | ||
| 746 | |||
| 747 | #define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \ | ||
| 748 | IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname) | ||
| 749 | |||
| 750 | #define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \ | ||
| 751 | IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname) | ||
| 752 | |||
| 753 | #define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \ | ||
| 754 | pre stname *fname##_new(void) \ | ||
| 755 | { \ | ||
| 756 | return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ | ||
| 757 | } \ | ||
| 758 | pre void fname##_free(stname *a) \ | ||
| 759 | { \ | ||
| 760 | ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ | ||
| 761 | } | ||
| 762 | |||
| 763 | #define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \ | ||
| 764 | stname *fname##_new(void) \ | ||
| 765 | { \ | ||
| 766 | return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ | ||
| 767 | } \ | ||
| 768 | void fname##_free(stname *a) \ | ||
| 769 | { \ | ||
| 770 | ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ | ||
| 771 | } | ||
| 772 | |||
| 773 | #define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \ | ||
| 774 | IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ | ||
| 775 | IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) | ||
| 776 | |||
| 777 | #define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ | ||
| 778 | stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ | ||
| 779 | { \ | ||
| 780 | return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ | ||
| 781 | } \ | ||
| 782 | int i2d_##fname(stname *a, unsigned char **out) \ | ||
| 783 | { \ | ||
| 784 | return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ | ||
| 785 | } | ||
| 786 | |||
| 787 | #define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \ | ||
| 788 | int i2d_##stname##_NDEF(stname *a, unsigned char **out) \ | ||
| 789 | { \ | ||
| 790 | return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\ | ||
| 791 | } | ||
| 792 | |||
| 793 | /* This includes evil casts to remove const: they will go away when full | ||
| 794 | * ASN1 constification is done. | ||
| 795 | */ | ||
| 796 | #define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ | ||
| 797 | stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ | ||
| 798 | { \ | ||
| 799 | return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ | ||
| 800 | } \ | ||
| 801 | int i2d_##fname(const stname *a, unsigned char **out) \ | ||
| 802 | { \ | ||
| 803 | return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ | ||
| 804 | } | ||
| 805 | |||
| 806 | #define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \ | ||
| 807 | stname * stname##_dup(stname *x) \ | ||
| 808 | { \ | ||
| 809 | return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \ | ||
| 810 | } | ||
| 811 | |||
| 812 | #define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \ | ||
| 813 | IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname) | ||
| 814 | |||
| 815 | #define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \ | ||
| 816 | int fname##_print_ctx(BIO *out, stname *x, int indent, \ | ||
| 817 | const ASN1_PCTX *pctx) \ | ||
| 818 | { \ | ||
| 819 | return ASN1_item_print(out, (ASN1_VALUE *)x, indent, \ | ||
| 820 | ASN1_ITEM_rptr(itname), pctx); \ | ||
| 821 | } | ||
| 822 | |||
| 823 | #define IMPLEMENT_ASN1_FUNCTIONS_const(name) \ | ||
| 824 | IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name) | ||
| 825 | |||
| 826 | #define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \ | ||
| 827 | IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ | ||
| 828 | IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) | ||
| 829 | |||
| 830 | #endif /* !LIBRESSL_INTERNAL */ | ||
| 831 | |||
| 832 | /* external definitions for primitive types */ | ||
| 833 | |||
| 834 | DECLARE_ASN1_ITEM(ASN1_BOOLEAN) | ||
| 835 | DECLARE_ASN1_ITEM(ASN1_TBOOLEAN) | ||
| 836 | DECLARE_ASN1_ITEM(ASN1_FBOOLEAN) | ||
| 837 | DECLARE_ASN1_ITEM(ASN1_SEQUENCE) | ||
| 838 | DECLARE_ASN1_ITEM(CBIGNUM) | ||
| 839 | DECLARE_ASN1_ITEM(BIGNUM) | ||
| 840 | DECLARE_ASN1_ITEM(LONG) | ||
| 841 | DECLARE_ASN1_ITEM(ZLONG) | ||
| 842 | |||
| 843 | DECLARE_STACK_OF(ASN1_VALUE) | ||
| 844 | |||
| 845 | /* Functions used internally by the ASN1 code */ | ||
| 846 | |||
| 847 | int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 848 | void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 849 | int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); | ||
| 850 | int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 851 | |||
| 852 | void ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); | ||
| 853 | int ASN1_template_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_TEMPLATE *tt); | ||
| 854 | int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, const ASN1_ITEM *it, | ||
| 855 | int tag, int aclass, char opt, ASN1_TLC *ctx); | ||
| 856 | |||
| 857 | int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, int tag, int aclass); | ||
| 858 | int ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_TEMPLATE *tt); | ||
| 859 | void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 860 | |||
| 861 | int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it); | ||
| 862 | |||
| 863 | int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 864 | int asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it); | ||
| 865 | |||
| 866 | ASN1_VALUE ** asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); | ||
| 867 | |||
| 868 | const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int nullerr); | ||
| 869 | |||
| 870 | int asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it); | ||
| 871 | |||
| 872 | void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 873 | void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 874 | int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 875 | int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen, const ASN1_ITEM *it); | ||
| 876 | |||
| 877 | #ifdef __cplusplus | ||
| 878 | } | ||
| 879 | #endif | ||
| 880 | #endif | ||
diff --git a/src/lib/libcrypto/asn1/asn_mime.c b/src/lib/libcrypto/asn1/asn_mime.c deleted file mode 100644 index 1d82f1a76f..0000000000 --- a/src/lib/libcrypto/asn1/asn_mime.c +++ /dev/null | |||
| @@ -1,1019 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn_mime.c,v 1.26 2015/02/22 15:19:56 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 1999-2008 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 | */ | ||
| 54 | |||
| 55 | #include <ctype.h> | ||
| 56 | #include <stdio.h> | ||
| 57 | #include <stdlib.h> | ||
| 58 | #include <string.h> | ||
| 59 | |||
| 60 | #include <openssl/asn1.h> | ||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | #include <openssl/x509.h> | ||
| 64 | |||
| 65 | #include "asn1_locl.h" | ||
| 66 | |||
| 67 | /* Generalised MIME like utilities for streaming ASN1. Although many | ||
| 68 | * have a PKCS7/CMS like flavour others are more general purpose. | ||
| 69 | */ | ||
| 70 | |||
| 71 | /* MIME format structures | ||
| 72 | * Note that all are translated to lower case apart from | ||
| 73 | * parameter values. Quotes are stripped off | ||
| 74 | */ | ||
| 75 | |||
| 76 | typedef struct { | ||
| 77 | char *param_name; /* Param name e.g. "micalg" */ | ||
| 78 | char *param_value; /* Param value e.g. "sha1" */ | ||
| 79 | } MIME_PARAM; | ||
| 80 | |||
| 81 | DECLARE_STACK_OF(MIME_PARAM) | ||
| 82 | |||
| 83 | typedef struct { | ||
| 84 | char *name; /* Name of line e.g. "content-type" */ | ||
| 85 | char *value; /* Value of line e.g. "text/plain" */ | ||
| 86 | STACK_OF(MIME_PARAM) *params; /* Zero or more parameters */ | ||
| 87 | } MIME_HEADER; | ||
| 88 | |||
| 89 | DECLARE_STACK_OF(MIME_HEADER) | ||
| 90 | |||
| 91 | static int asn1_output_data(BIO *out, BIO *data, ASN1_VALUE *val, int flags, | ||
| 92 | const ASN1_ITEM *it); | ||
| 93 | static char * strip_ends(char *name); | ||
| 94 | static char * strip_start(char *name); | ||
| 95 | static char * strip_end(char *name); | ||
| 96 | static MIME_HEADER *mime_hdr_new(char *name, char *value); | ||
| 97 | static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value); | ||
| 98 | static STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio); | ||
| 99 | static int mime_hdr_cmp(const MIME_HEADER * const *a, | ||
| 100 | const MIME_HEADER * const *b); | ||
| 101 | static int mime_param_cmp(const MIME_PARAM * const *a, | ||
| 102 | const MIME_PARAM * const *b); | ||
| 103 | static void mime_param_free(MIME_PARAM *param); | ||
| 104 | static int mime_bound_check(char *line, int linelen, char *bound, int blen); | ||
| 105 | static int multi_split(BIO *bio, char *bound, STACK_OF(BIO) **ret); | ||
| 106 | static int strip_eol(char *linebuf, int *plen); | ||
| 107 | static MIME_HEADER *mime_hdr_find(STACK_OF(MIME_HEADER) *hdrs, char *name); | ||
| 108 | static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name); | ||
| 109 | static void mime_hdr_free(MIME_HEADER *hdr); | ||
| 110 | |||
| 111 | #define MAX_SMLEN 1024 | ||
| 112 | #define mime_debug(x) /* x */ | ||
| 113 | |||
| 114 | /* Output an ASN1 structure in BER format streaming if necessary */ | ||
| 115 | |||
| 116 | int | ||
| 117 | i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, | ||
| 118 | const ASN1_ITEM *it) | ||
| 119 | { | ||
| 120 | /* If streaming create stream BIO and copy all content through it */ | ||
| 121 | if (flags & SMIME_STREAM) { | ||
| 122 | BIO *bio, *tbio; | ||
| 123 | bio = BIO_new_NDEF(out, val, it); | ||
| 124 | if (!bio) { | ||
| 125 | ASN1err(ASN1_F_I2D_ASN1_BIO_STREAM, | ||
| 126 | ERR_R_MALLOC_FAILURE); | ||
| 127 | return 0; | ||
| 128 | } | ||
| 129 | SMIME_crlf_copy(in, bio, flags); | ||
| 130 | (void)BIO_flush(bio); | ||
| 131 | /* Free up successive BIOs until we hit the old output BIO */ | ||
| 132 | do { | ||
| 133 | tbio = BIO_pop(bio); | ||
| 134 | BIO_free(bio); | ||
| 135 | bio = tbio; | ||
| 136 | } while (bio != out); | ||
| 137 | } | ||
| 138 | /* else just write out ASN1 structure which will have all content | ||
| 139 | * stored internally | ||
| 140 | */ | ||
| 141 | else | ||
| 142 | ASN1_item_i2d_bio(it, out, val); | ||
| 143 | return 1; | ||
| 144 | } | ||
| 145 | |||
| 146 | /* Base 64 read and write of ASN1 structure */ | ||
| 147 | |||
| 148 | static int | ||
| 149 | B64_write_ASN1(BIO *out, ASN1_VALUE *val, BIO *in, int flags, | ||
| 150 | const ASN1_ITEM *it) | ||
| 151 | { | ||
| 152 | BIO *b64; | ||
| 153 | int r; | ||
| 154 | |||
| 155 | b64 = BIO_new(BIO_f_base64()); | ||
| 156 | if (!b64) { | ||
| 157 | ASN1err(ASN1_F_B64_WRITE_ASN1, ERR_R_MALLOC_FAILURE); | ||
| 158 | return 0; | ||
| 159 | } | ||
| 160 | /* prepend the b64 BIO so all data is base64 encoded. | ||
| 161 | */ | ||
| 162 | out = BIO_push(b64, out); | ||
| 163 | r = i2d_ASN1_bio_stream(out, val, in, flags, it); | ||
| 164 | (void)BIO_flush(out); | ||
| 165 | BIO_pop(out); | ||
| 166 | BIO_free(b64); | ||
| 167 | return r; | ||
| 168 | } | ||
| 169 | |||
| 170 | /* Streaming ASN1 PEM write */ | ||
| 171 | |||
| 172 | int | ||
| 173 | PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, | ||
| 174 | const char *hdr, const ASN1_ITEM *it) | ||
| 175 | { | ||
| 176 | int r; | ||
| 177 | |||
| 178 | BIO_printf(out, "-----BEGIN %s-----\n", hdr); | ||
| 179 | r = B64_write_ASN1(out, val, in, flags, it); | ||
| 180 | BIO_printf(out, "-----END %s-----\n", hdr); | ||
| 181 | return r; | ||
| 182 | } | ||
| 183 | |||
| 184 | static ASN1_VALUE * | ||
| 185 | b64_read_asn1(BIO *bio, const ASN1_ITEM *it) | ||
| 186 | { | ||
| 187 | BIO *b64; | ||
| 188 | ASN1_VALUE *val; | ||
| 189 | if (!(b64 = BIO_new(BIO_f_base64()))) { | ||
| 190 | ASN1err(ASN1_F_B64_READ_ASN1, ERR_R_MALLOC_FAILURE); | ||
| 191 | return 0; | ||
| 192 | } | ||
| 193 | bio = BIO_push(b64, bio); | ||
| 194 | val = ASN1_item_d2i_bio(it, bio, NULL); | ||
| 195 | if (!val) | ||
| 196 | ASN1err(ASN1_F_B64_READ_ASN1, ASN1_R_DECODE_ERROR); | ||
| 197 | (void)BIO_flush(bio); | ||
| 198 | bio = BIO_pop(bio); | ||
| 199 | BIO_free(b64); | ||
| 200 | return val; | ||
| 201 | } | ||
| 202 | |||
| 203 | /* Generate the MIME "micalg" parameter from RFC3851, RFC4490 */ | ||
| 204 | |||
| 205 | static int | ||
| 206 | asn1_write_micalg(BIO *out, STACK_OF(X509_ALGOR) *mdalgs) | ||
| 207 | { | ||
| 208 | const EVP_MD *md; | ||
| 209 | int i, have_unknown = 0, write_comma, ret = 0, md_nid; | ||
| 210 | |||
| 211 | have_unknown = 0; | ||
| 212 | write_comma = 0; | ||
| 213 | for (i = 0; i < sk_X509_ALGOR_num(mdalgs); i++) { | ||
| 214 | if (write_comma) | ||
| 215 | BIO_write(out, ",", 1); | ||
| 216 | write_comma = 1; | ||
| 217 | md_nid = OBJ_obj2nid(sk_X509_ALGOR_value(mdalgs, i)->algorithm); | ||
| 218 | md = EVP_get_digestbynid(md_nid); | ||
| 219 | if (md && md->md_ctrl) { | ||
| 220 | int rv; | ||
| 221 | char *micstr; | ||
| 222 | rv = md->md_ctrl(NULL, EVP_MD_CTRL_MICALG, 0, &micstr); | ||
| 223 | if (rv > 0) { | ||
| 224 | BIO_puts(out, micstr); | ||
| 225 | free(micstr); | ||
| 226 | continue; | ||
| 227 | } | ||
| 228 | if (rv != -2) | ||
| 229 | goto err; | ||
| 230 | } | ||
| 231 | switch (md_nid) { | ||
| 232 | case NID_sha1: | ||
| 233 | BIO_puts(out, "sha1"); | ||
| 234 | break; | ||
| 235 | |||
| 236 | case NID_md5: | ||
| 237 | BIO_puts(out, "md5"); | ||
| 238 | break; | ||
| 239 | |||
| 240 | case NID_sha256: | ||
| 241 | BIO_puts(out, "sha-256"); | ||
| 242 | break; | ||
| 243 | |||
| 244 | case NID_sha384: | ||
| 245 | BIO_puts(out, "sha-384"); | ||
| 246 | break; | ||
| 247 | |||
| 248 | case NID_sha512: | ||
| 249 | BIO_puts(out, "sha-512"); | ||
| 250 | break; | ||
| 251 | |||
| 252 | case NID_id_GostR3411_94: | ||
| 253 | BIO_puts(out, "gostr3411-94"); | ||
| 254 | goto err; | ||
| 255 | break; | ||
| 256 | |||
| 257 | default: | ||
| 258 | if (have_unknown) | ||
| 259 | write_comma = 0; | ||
| 260 | else { | ||
| 261 | BIO_puts(out, "unknown"); | ||
| 262 | have_unknown = 1; | ||
| 263 | } | ||
| 264 | break; | ||
| 265 | |||
| 266 | } | ||
| 267 | } | ||
| 268 | |||
| 269 | ret = 1; | ||
| 270 | |||
| 271 | err: | ||
| 272 | return ret; | ||
| 273 | } | ||
| 274 | |||
| 275 | /* SMIME sender */ | ||
| 276 | |||
| 277 | int | ||
| 278 | SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags, | ||
| 279 | int ctype_nid, int econt_nid, STACK_OF(X509_ALGOR) *mdalgs, | ||
| 280 | const ASN1_ITEM *it) | ||
| 281 | { | ||
| 282 | char bound[33], c; | ||
| 283 | int i; | ||
| 284 | const char *mime_prefix, *mime_eol, *cname = "smime.p7m"; | ||
| 285 | const char *msg_type = NULL; | ||
| 286 | |||
| 287 | if (flags & SMIME_OLDMIME) | ||
| 288 | mime_prefix = "application/x-pkcs7-"; | ||
| 289 | else | ||
| 290 | mime_prefix = "application/pkcs7-"; | ||
| 291 | |||
| 292 | if (flags & SMIME_CRLFEOL) | ||
| 293 | mime_eol = "\r\n"; | ||
| 294 | else | ||
| 295 | mime_eol = "\n"; | ||
| 296 | if ((flags & SMIME_DETACHED) && data) { | ||
| 297 | /* We want multipart/signed */ | ||
| 298 | /* Generate a random boundary */ | ||
| 299 | arc4random_buf(bound, 32); | ||
| 300 | for (i = 0; i < 32; i++) { | ||
| 301 | c = bound[i] & 0xf; | ||
| 302 | if (c < 10) | ||
| 303 | c += '0'; | ||
| 304 | else | ||
| 305 | c += 'A' - 10; | ||
| 306 | bound[i] = c; | ||
| 307 | } | ||
| 308 | bound[32] = 0; | ||
| 309 | BIO_printf(bio, "MIME-Version: 1.0%s", mime_eol); | ||
| 310 | BIO_printf(bio, "Content-Type: multipart/signed;"); | ||
| 311 | BIO_printf(bio, " protocol=\"%ssignature\";", mime_prefix); | ||
| 312 | BIO_puts(bio, " micalg=\""); | ||
| 313 | asn1_write_micalg(bio, mdalgs); | ||
| 314 | BIO_printf(bio, "\"; boundary=\"----%s\"%s%s", | ||
| 315 | bound, mime_eol, mime_eol); | ||
| 316 | BIO_printf(bio, "This is an S/MIME signed message%s%s", | ||
| 317 | mime_eol, mime_eol); | ||
| 318 | /* Now write out the first part */ | ||
| 319 | BIO_printf(bio, "------%s%s", bound, mime_eol); | ||
| 320 | if (!asn1_output_data(bio, data, val, flags, it)) | ||
| 321 | return 0; | ||
| 322 | BIO_printf(bio, "%s------%s%s", mime_eol, bound, mime_eol); | ||
| 323 | |||
| 324 | /* Headers for signature */ | ||
| 325 | |||
| 326 | BIO_printf(bio, "Content-Type: %ssignature;", mime_prefix); | ||
| 327 | BIO_printf(bio, " name=\"smime.p7s\"%s", mime_eol); | ||
| 328 | BIO_printf(bio, "Content-Transfer-Encoding: base64%s", | ||
| 329 | mime_eol); | ||
| 330 | BIO_printf(bio, "Content-Disposition: attachment;"); | ||
| 331 | BIO_printf(bio, " filename=\"smime.p7s\"%s%s", | ||
| 332 | mime_eol, mime_eol); | ||
| 333 | B64_write_ASN1(bio, val, NULL, 0, it); | ||
| 334 | BIO_printf(bio, "%s------%s--%s%s", mime_eol, bound, | ||
| 335 | mime_eol, mime_eol); | ||
| 336 | return 1; | ||
| 337 | } | ||
| 338 | |||
| 339 | /* Determine smime-type header */ | ||
| 340 | |||
| 341 | if (ctype_nid == NID_pkcs7_enveloped) | ||
| 342 | msg_type = "enveloped-data"; | ||
| 343 | else if (ctype_nid == NID_pkcs7_signed) { | ||
| 344 | if (econt_nid == NID_id_smime_ct_receipt) | ||
| 345 | msg_type = "signed-receipt"; | ||
| 346 | else if (sk_X509_ALGOR_num(mdalgs) >= 0) | ||
| 347 | msg_type = "signed-data"; | ||
| 348 | else | ||
| 349 | msg_type = "certs-only"; | ||
| 350 | } else if (ctype_nid == NID_id_smime_ct_compressedData) { | ||
| 351 | msg_type = "compressed-data"; | ||
| 352 | cname = "smime.p7z"; | ||
| 353 | } | ||
| 354 | /* MIME headers */ | ||
| 355 | BIO_printf(bio, "MIME-Version: 1.0%s", mime_eol); | ||
| 356 | BIO_printf(bio, "Content-Disposition: attachment;"); | ||
| 357 | BIO_printf(bio, " filename=\"%s\"%s", cname, mime_eol); | ||
| 358 | BIO_printf(bio, "Content-Type: %smime;", mime_prefix); | ||
| 359 | if (msg_type) | ||
| 360 | BIO_printf(bio, " smime-type=%s;", msg_type); | ||
| 361 | BIO_printf(bio, " name=\"%s\"%s", cname, mime_eol); | ||
| 362 | BIO_printf(bio, "Content-Transfer-Encoding: base64%s%s", | ||
| 363 | mime_eol, mime_eol); | ||
| 364 | if (!B64_write_ASN1(bio, val, data, flags, it)) | ||
| 365 | return 0; | ||
| 366 | BIO_printf(bio, "%s", mime_eol); | ||
| 367 | return 1; | ||
| 368 | } | ||
| 369 | |||
| 370 | /* Handle output of ASN1 data */ | ||
| 371 | |||
| 372 | |||
| 373 | static int | ||
| 374 | asn1_output_data(BIO *out, BIO *data, ASN1_VALUE *val, int flags, | ||
| 375 | const ASN1_ITEM *it) | ||
| 376 | { | ||
| 377 | BIO *tmpbio; | ||
| 378 | const ASN1_AUX *aux = it->funcs; | ||
| 379 | ASN1_STREAM_ARG sarg; | ||
| 380 | int rv = 1; | ||
| 381 | |||
| 382 | /* If data is not deteched or resigning then the output BIO is | ||
| 383 | * already set up to finalise when it is written through. | ||
| 384 | */ | ||
| 385 | if (!(flags & SMIME_DETACHED) || (flags & PKCS7_REUSE_DIGEST)) { | ||
| 386 | SMIME_crlf_copy(data, out, flags); | ||
| 387 | return 1; | ||
| 388 | } | ||
| 389 | |||
| 390 | if (!aux || !aux->asn1_cb) { | ||
| 391 | ASN1err(ASN1_F_ASN1_OUTPUT_DATA, | ||
| 392 | ASN1_R_STREAMING_NOT_SUPPORTED); | ||
| 393 | return 0; | ||
| 394 | } | ||
| 395 | |||
| 396 | sarg.out = out; | ||
| 397 | sarg.ndef_bio = NULL; | ||
| 398 | sarg.boundary = NULL; | ||
| 399 | |||
| 400 | /* Let ASN1 code prepend any needed BIOs */ | ||
| 401 | |||
| 402 | if (aux->asn1_cb(ASN1_OP_DETACHED_PRE, &val, it, &sarg) <= 0) | ||
| 403 | return 0; | ||
| 404 | |||
| 405 | /* Copy data across, passing through filter BIOs for processing */ | ||
| 406 | SMIME_crlf_copy(data, sarg.ndef_bio, flags); | ||
| 407 | |||
| 408 | /* Finalize structure */ | ||
| 409 | if (aux->asn1_cb(ASN1_OP_DETACHED_POST, &val, it, &sarg) <= 0) | ||
| 410 | rv = 0; | ||
| 411 | |||
| 412 | /* Now remove any digests prepended to the BIO */ | ||
| 413 | |||
| 414 | while (sarg.ndef_bio != out) { | ||
| 415 | tmpbio = BIO_pop(sarg.ndef_bio); | ||
| 416 | BIO_free(sarg.ndef_bio); | ||
| 417 | sarg.ndef_bio = tmpbio; | ||
| 418 | } | ||
| 419 | |||
| 420 | return rv; | ||
| 421 | } | ||
| 422 | |||
| 423 | /* SMIME reader: handle multipart/signed and opaque signing. | ||
| 424 | * in multipart case the content is placed in a memory BIO | ||
| 425 | * pointed to by "bcont". In opaque this is set to NULL | ||
| 426 | */ | ||
| 427 | |||
| 428 | ASN1_VALUE * | ||
| 429 | SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it) | ||
| 430 | { | ||
| 431 | BIO *asnin; | ||
| 432 | STACK_OF(MIME_HEADER) *headers = NULL; | ||
| 433 | STACK_OF(BIO) *parts = NULL; | ||
| 434 | MIME_HEADER *hdr; | ||
| 435 | MIME_PARAM *prm; | ||
| 436 | ASN1_VALUE *val; | ||
| 437 | int ret; | ||
| 438 | |||
| 439 | if (bcont) | ||
| 440 | *bcont = NULL; | ||
| 441 | |||
| 442 | if (!(headers = mime_parse_hdr(bio))) { | ||
| 443 | ASN1err(ASN1_F_SMIME_READ_ASN1, ASN1_R_MIME_PARSE_ERROR); | ||
| 444 | return NULL; | ||
| 445 | } | ||
| 446 | |||
| 447 | if (!(hdr = mime_hdr_find(headers, "content-type")) || !hdr->value) { | ||
| 448 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 449 | ASN1err(ASN1_F_SMIME_READ_ASN1, ASN1_R_NO_CONTENT_TYPE); | ||
| 450 | return NULL; | ||
| 451 | } | ||
| 452 | |||
| 453 | /* Handle multipart/signed */ | ||
| 454 | |||
| 455 | if (!strcmp(hdr->value, "multipart/signed")) { | ||
| 456 | /* Split into two parts */ | ||
| 457 | prm = mime_param_find(hdr, "boundary"); | ||
| 458 | if (!prm || !prm->param_value) { | ||
| 459 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 460 | ASN1err(ASN1_F_SMIME_READ_ASN1, | ||
| 461 | ASN1_R_NO_MULTIPART_BOUNDARY); | ||
| 462 | return NULL; | ||
| 463 | } | ||
| 464 | ret = multi_split(bio, prm->param_value, &parts); | ||
| 465 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 466 | if (!ret || (sk_BIO_num(parts) != 2) ) { | ||
| 467 | ASN1err(ASN1_F_SMIME_READ_ASN1, | ||
| 468 | ASN1_R_NO_MULTIPART_BODY_FAILURE); | ||
| 469 | sk_BIO_pop_free(parts, BIO_vfree); | ||
| 470 | return NULL; | ||
| 471 | } | ||
| 472 | |||
| 473 | /* Parse the signature piece */ | ||
| 474 | asnin = sk_BIO_value(parts, 1); | ||
| 475 | |||
| 476 | if (!(headers = mime_parse_hdr(asnin))) { | ||
| 477 | ASN1err(ASN1_F_SMIME_READ_ASN1, | ||
| 478 | ASN1_R_MIME_SIG_PARSE_ERROR); | ||
| 479 | sk_BIO_pop_free(parts, BIO_vfree); | ||
| 480 | return NULL; | ||
| 481 | } | ||
| 482 | |||
| 483 | /* Get content type */ | ||
| 484 | |||
| 485 | if (!(hdr = mime_hdr_find(headers, "content-type")) || | ||
| 486 | !hdr->value) { | ||
| 487 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 488 | sk_BIO_pop_free(parts, BIO_vfree); | ||
| 489 | ASN1err(ASN1_F_SMIME_READ_ASN1, | ||
| 490 | ASN1_R_NO_SIG_CONTENT_TYPE); | ||
| 491 | return NULL; | ||
| 492 | } | ||
| 493 | |||
| 494 | if (strcmp(hdr->value, "application/x-pkcs7-signature") && | ||
| 495 | strcmp(hdr->value, "application/pkcs7-signature")) { | ||
| 496 | ASN1err(ASN1_F_SMIME_READ_ASN1, | ||
| 497 | ASN1_R_SIG_INVALID_MIME_TYPE); | ||
| 498 | ERR_asprintf_error_data("type: %s", hdr->value); | ||
| 499 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 500 | sk_BIO_pop_free(parts, BIO_vfree); | ||
| 501 | return NULL; | ||
| 502 | } | ||
| 503 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 504 | /* Read in ASN1 */ | ||
| 505 | if (!(val = b64_read_asn1(asnin, it))) { | ||
| 506 | ASN1err(ASN1_F_SMIME_READ_ASN1, | ||
| 507 | ASN1_R_ASN1_SIG_PARSE_ERROR); | ||
| 508 | sk_BIO_pop_free(parts, BIO_vfree); | ||
| 509 | return NULL; | ||
| 510 | } | ||
| 511 | |||
| 512 | if (bcont) { | ||
| 513 | *bcont = sk_BIO_value(parts, 0); | ||
| 514 | BIO_free(asnin); | ||
| 515 | sk_BIO_free(parts); | ||
| 516 | } else sk_BIO_pop_free(parts, BIO_vfree); | ||
| 517 | return val; | ||
| 518 | } | ||
| 519 | |||
| 520 | /* OK, if not multipart/signed try opaque signature */ | ||
| 521 | |||
| 522 | if (strcmp (hdr->value, "application/x-pkcs7-mime") && | ||
| 523 | strcmp (hdr->value, "application/pkcs7-mime")) { | ||
| 524 | ASN1err(ASN1_F_SMIME_READ_ASN1, ASN1_R_INVALID_MIME_TYPE); | ||
| 525 | ERR_asprintf_error_data("type: %s", hdr->value); | ||
| 526 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 527 | return NULL; | ||
| 528 | } | ||
| 529 | |||
| 530 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 531 | |||
| 532 | if (!(val = b64_read_asn1(bio, it))) { | ||
| 533 | ASN1err(ASN1_F_SMIME_READ_ASN1, ASN1_R_ASN1_PARSE_ERROR); | ||
| 534 | return NULL; | ||
| 535 | } | ||
| 536 | return val; | ||
| 537 | } | ||
| 538 | |||
| 539 | /* Copy text from one BIO to another making the output CRLF at EOL */ | ||
| 540 | int | ||
| 541 | SMIME_crlf_copy(BIO *in, BIO *out, int flags) | ||
| 542 | { | ||
| 543 | BIO *bf; | ||
| 544 | char eol; | ||
| 545 | int len; | ||
| 546 | char linebuf[MAX_SMLEN]; | ||
| 547 | |||
| 548 | /* Buffer output so we don't write one line at a time. This is | ||
| 549 | * useful when streaming as we don't end up with one OCTET STRING | ||
| 550 | * per line. | ||
| 551 | */ | ||
| 552 | bf = BIO_new(BIO_f_buffer()); | ||
| 553 | if (!bf) | ||
| 554 | return 0; | ||
| 555 | out = BIO_push(bf, out); | ||
| 556 | if (flags & SMIME_BINARY) { | ||
| 557 | while ((len = BIO_read(in, linebuf, MAX_SMLEN)) > 0) | ||
| 558 | BIO_write(out, linebuf, len); | ||
| 559 | } else { | ||
| 560 | if (flags & SMIME_TEXT) | ||
| 561 | BIO_printf(out, "Content-Type: text/plain\r\n\r\n"); | ||
| 562 | while ((len = BIO_gets(in, linebuf, MAX_SMLEN)) > 0) { | ||
| 563 | eol = strip_eol(linebuf, &len); | ||
| 564 | if (len) | ||
| 565 | BIO_write(out, linebuf, len); | ||
| 566 | if (eol) | ||
| 567 | BIO_write(out, "\r\n", 2); | ||
| 568 | } | ||
| 569 | } | ||
| 570 | (void)BIO_flush(out); | ||
| 571 | BIO_pop(out); | ||
| 572 | BIO_free(bf); | ||
| 573 | return 1; | ||
| 574 | } | ||
| 575 | |||
| 576 | /* Strip off headers if they are text/plain */ | ||
| 577 | int | ||
| 578 | SMIME_text(BIO *in, BIO *out) | ||
| 579 | { | ||
| 580 | char iobuf[4096]; | ||
| 581 | int len; | ||
| 582 | STACK_OF(MIME_HEADER) *headers; | ||
| 583 | MIME_HEADER *hdr; | ||
| 584 | |||
| 585 | if (!(headers = mime_parse_hdr(in))) { | ||
| 586 | ASN1err(ASN1_F_SMIME_TEXT, ASN1_R_MIME_PARSE_ERROR); | ||
| 587 | return 0; | ||
| 588 | } | ||
| 589 | if (!(hdr = mime_hdr_find(headers, "content-type")) || !hdr->value) { | ||
| 590 | ASN1err(ASN1_F_SMIME_TEXT, ASN1_R_MIME_NO_CONTENT_TYPE); | ||
| 591 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 592 | return 0; | ||
| 593 | } | ||
| 594 | if (strcmp (hdr->value, "text/plain")) { | ||
| 595 | ASN1err(ASN1_F_SMIME_TEXT, ASN1_R_INVALID_MIME_TYPE); | ||
| 596 | ERR_asprintf_error_data("type: %s", hdr->value); | ||
| 597 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 598 | return 0; | ||
| 599 | } | ||
| 600 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 601 | while ((len = BIO_read(in, iobuf, sizeof(iobuf))) > 0) | ||
| 602 | BIO_write(out, iobuf, len); | ||
| 603 | if (len < 0) | ||
| 604 | return 0; | ||
| 605 | return 1; | ||
| 606 | } | ||
| 607 | |||
| 608 | /* | ||
| 609 | * Split a multipart/XXX message body into component parts: result is | ||
| 610 | * canonical parts in a STACK of bios | ||
| 611 | */ | ||
| 612 | static int | ||
| 613 | multi_split(BIO *bio, char *bound, STACK_OF(BIO) **ret) | ||
| 614 | { | ||
| 615 | char linebuf[MAX_SMLEN]; | ||
| 616 | int len, blen; | ||
| 617 | int eol = 0, next_eol = 0; | ||
| 618 | BIO *bpart = NULL; | ||
| 619 | STACK_OF(BIO) *parts; | ||
| 620 | char state, part, first; | ||
| 621 | |||
| 622 | blen = strlen(bound); | ||
| 623 | part = 0; | ||
| 624 | state = 0; | ||
| 625 | first = 1; | ||
| 626 | parts = sk_BIO_new_null(); | ||
| 627 | *ret = parts; | ||
| 628 | if (parts == NULL) | ||
| 629 | return 0; | ||
| 630 | while ((len = BIO_gets(bio, linebuf, MAX_SMLEN)) > 0) { | ||
| 631 | state = mime_bound_check(linebuf, len, bound, blen); | ||
| 632 | if (state == 1) { | ||
| 633 | first = 1; | ||
| 634 | part++; | ||
| 635 | } else if (state == 2) { | ||
| 636 | if (sk_BIO_push(parts, bpart) == 0) | ||
| 637 | return 0; | ||
| 638 | return 1; | ||
| 639 | } else if (part) { | ||
| 640 | /* Strip CR+LF from linebuf */ | ||
| 641 | next_eol = strip_eol(linebuf, &len); | ||
| 642 | if (first) { | ||
| 643 | first = 0; | ||
| 644 | if (bpart != NULL) { | ||
| 645 | if (sk_BIO_push(parts, bpart) == 0) | ||
| 646 | return 0; | ||
| 647 | } | ||
| 648 | bpart = BIO_new(BIO_s_mem()); | ||
| 649 | if (bpart == NULL) | ||
| 650 | return 0; | ||
| 651 | BIO_set_mem_eof_return(bpart, 0); | ||
| 652 | } else if (eol) | ||
| 653 | BIO_write(bpart, "\r\n", 2); | ||
| 654 | eol = next_eol; | ||
| 655 | if (len) | ||
| 656 | BIO_write(bpart, linebuf, len); | ||
| 657 | } | ||
| 658 | } | ||
| 659 | BIO_free(bpart); | ||
| 660 | return 0; | ||
| 661 | } | ||
| 662 | |||
| 663 | /* This is the big one: parse MIME header lines up to message body */ | ||
| 664 | |||
| 665 | #define MIME_INVALID 0 | ||
| 666 | #define MIME_START 1 | ||
| 667 | #define MIME_TYPE 2 | ||
| 668 | #define MIME_NAME 3 | ||
| 669 | #define MIME_VALUE 4 | ||
| 670 | #define MIME_QUOTE 5 | ||
| 671 | #define MIME_COMMENT 6 | ||
| 672 | |||
| 673 | |||
| 674 | static | ||
| 675 | STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio) | ||
| 676 | { | ||
| 677 | char *p, *q, c; | ||
| 678 | char *ntmp; | ||
| 679 | char linebuf[MAX_SMLEN]; | ||
| 680 | MIME_HEADER *mhdr = NULL; | ||
| 681 | STACK_OF(MIME_HEADER) *headers; | ||
| 682 | int len, state, save_state = 0; | ||
| 683 | |||
| 684 | headers = sk_MIME_HEADER_new(mime_hdr_cmp); | ||
| 685 | if (!headers) | ||
| 686 | return NULL; | ||
| 687 | while ((len = BIO_gets(bio, linebuf, MAX_SMLEN)) > 0) { | ||
| 688 | /* If whitespace at line start then continuation line */ | ||
| 689 | if (mhdr && isspace((unsigned char)linebuf[0])) | ||
| 690 | state = MIME_NAME; | ||
| 691 | else | ||
| 692 | state = MIME_START; | ||
| 693 | ntmp = NULL; | ||
| 694 | |||
| 695 | /* Go through all characters */ | ||
| 696 | for (p = linebuf, q = linebuf; | ||
| 697 | (c = *p) && (c != '\r') && (c != '\n'); p++) { | ||
| 698 | |||
| 699 | /* State machine to handle MIME headers | ||
| 700 | * if this looks horrible that's because it *is* | ||
| 701 | */ | ||
| 702 | |||
| 703 | switch (state) { | ||
| 704 | case MIME_START: | ||
| 705 | if (c == ':') { | ||
| 706 | state = MIME_TYPE; | ||
| 707 | *p = 0; | ||
| 708 | ntmp = strip_ends(q); | ||
| 709 | q = p + 1; | ||
| 710 | } | ||
| 711 | break; | ||
| 712 | |||
| 713 | case MIME_TYPE: | ||
| 714 | if (c == ';') { | ||
| 715 | mime_debug("Found End Value\n"); | ||
| 716 | *p = 0; | ||
| 717 | mhdr = mime_hdr_new(ntmp, | ||
| 718 | strip_ends(q)); | ||
| 719 | if (mhdr == NULL) | ||
| 720 | goto merr; | ||
| 721 | if (sk_MIME_HEADER_push(headers, | ||
| 722 | mhdr) == 0) | ||
| 723 | goto merr; | ||
| 724 | ntmp = NULL; | ||
| 725 | q = p + 1; | ||
| 726 | state = MIME_NAME; | ||
| 727 | } else if (c == '(') { | ||
| 728 | save_state = state; | ||
| 729 | state = MIME_COMMENT; | ||
| 730 | } | ||
| 731 | break; | ||
| 732 | |||
| 733 | case MIME_COMMENT: | ||
| 734 | if (c == ')') { | ||
| 735 | state = save_state; | ||
| 736 | } | ||
| 737 | break; | ||
| 738 | |||
| 739 | case MIME_NAME: | ||
| 740 | if (c == '=') { | ||
| 741 | state = MIME_VALUE; | ||
| 742 | *p = 0; | ||
| 743 | ntmp = strip_ends(q); | ||
| 744 | q = p + 1; | ||
| 745 | } | ||
| 746 | break; | ||
| 747 | |||
| 748 | case MIME_VALUE: | ||
| 749 | if (c == ';') { | ||
| 750 | state = MIME_NAME; | ||
| 751 | *p = 0; | ||
| 752 | mime_hdr_addparam(mhdr, ntmp, | ||
| 753 | strip_ends(q)); | ||
| 754 | ntmp = NULL; | ||
| 755 | q = p + 1; | ||
| 756 | } else if (c == '"') { | ||
| 757 | mime_debug("Found Quote\n"); | ||
| 758 | state = MIME_QUOTE; | ||
| 759 | } else if (c == '(') { | ||
| 760 | save_state = state; | ||
| 761 | state = MIME_COMMENT; | ||
| 762 | } | ||
| 763 | break; | ||
| 764 | |||
| 765 | case MIME_QUOTE: | ||
| 766 | if (c == '"') { | ||
| 767 | mime_debug("Found Match Quote\n"); | ||
| 768 | state = MIME_VALUE; | ||
| 769 | } | ||
| 770 | break; | ||
| 771 | } | ||
| 772 | } | ||
| 773 | |||
| 774 | if (state == MIME_TYPE) { | ||
| 775 | mhdr = mime_hdr_new(ntmp, strip_ends(q)); | ||
| 776 | if (mhdr == NULL) | ||
| 777 | goto merr; | ||
| 778 | if (sk_MIME_HEADER_push(headers, mhdr) == 0) | ||
| 779 | goto merr; | ||
| 780 | } else if (state == MIME_VALUE) | ||
| 781 | mime_hdr_addparam(mhdr, ntmp, strip_ends(q)); | ||
| 782 | |||
| 783 | if (p == linebuf) | ||
| 784 | break; /* Blank line means end of headers */ | ||
| 785 | } | ||
| 786 | |||
| 787 | return headers; | ||
| 788 | |||
| 789 | merr: | ||
| 790 | if (mhdr != NULL) | ||
| 791 | mime_hdr_free(mhdr); | ||
| 792 | sk_MIME_HEADER_pop_free(headers, mime_hdr_free); | ||
| 793 | return NULL; | ||
| 794 | } | ||
| 795 | |||
| 796 | static char * | ||
| 797 | strip_ends(char *name) | ||
| 798 | { | ||
| 799 | return strip_end(strip_start(name)); | ||
| 800 | } | ||
| 801 | |||
| 802 | /* Strip a parameter of whitespace from start of param */ | ||
| 803 | static char * | ||
| 804 | strip_start(char *name) | ||
| 805 | { | ||
| 806 | char *p, c; | ||
| 807 | |||
| 808 | /* Look for first non white space or quote */ | ||
| 809 | for (p = name; (c = *p); p++) { | ||
| 810 | if (c == '"') { | ||
| 811 | /* Next char is start of string if non null */ | ||
| 812 | if (p[1]) | ||
| 813 | return p + 1; | ||
| 814 | /* Else null string */ | ||
| 815 | return NULL; | ||
| 816 | } | ||
| 817 | if (!isspace((unsigned char)c)) | ||
| 818 | return p; | ||
| 819 | } | ||
| 820 | return NULL; | ||
| 821 | } | ||
| 822 | |||
| 823 | /* As above but strip from end of string : maybe should handle brackets? */ | ||
| 824 | static char * | ||
| 825 | strip_end(char *name) | ||
| 826 | { | ||
| 827 | char *p, c; | ||
| 828 | |||
| 829 | if (!name) | ||
| 830 | return NULL; | ||
| 831 | |||
| 832 | /* Look for first non white space or quote */ | ||
| 833 | for (p = name + strlen(name) - 1; p >= name; p--) { | ||
| 834 | c = *p; | ||
| 835 | if (c == '"') { | ||
| 836 | if (p - 1 == name) | ||
| 837 | return NULL; | ||
| 838 | *p = 0; | ||
| 839 | return name; | ||
| 840 | } | ||
| 841 | if (isspace((unsigned char)c)) | ||
| 842 | *p = 0; | ||
| 843 | else | ||
| 844 | return name; | ||
| 845 | } | ||
| 846 | return NULL; | ||
| 847 | } | ||
| 848 | |||
| 849 | static MIME_HEADER * | ||
| 850 | mime_hdr_new(char *name, char *value) | ||
| 851 | { | ||
| 852 | MIME_HEADER *mhdr; | ||
| 853 | char *tmpname = NULL, *tmpval = NULL, *p; | ||
| 854 | |||
| 855 | if (name) { | ||
| 856 | if (!(tmpname = strdup(name))) | ||
| 857 | goto err; | ||
| 858 | for (p = tmpname; *p; p++) | ||
| 859 | *p = tolower((unsigned char)*p); | ||
| 860 | } | ||
| 861 | if (value) { | ||
| 862 | if (!(tmpval = strdup(value))) | ||
| 863 | goto err; | ||
| 864 | for (p = tmpval; *p; p++) | ||
| 865 | *p = tolower((unsigned char)*p); | ||
| 866 | } | ||
| 867 | mhdr = malloc(sizeof(MIME_HEADER)); | ||
| 868 | if (!mhdr) | ||
| 869 | goto err; | ||
| 870 | mhdr->name = tmpname; | ||
| 871 | mhdr->value = tmpval; | ||
| 872 | if (!(mhdr->params = sk_MIME_PARAM_new(mime_param_cmp))) { | ||
| 873 | free(mhdr); | ||
| 874 | goto err; | ||
| 875 | } | ||
| 876 | return mhdr; | ||
| 877 | err: | ||
| 878 | free(tmpname); | ||
| 879 | free(tmpval); | ||
| 880 | return NULL; | ||
| 881 | } | ||
| 882 | |||
| 883 | static int | ||
| 884 | mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value) | ||
| 885 | { | ||
| 886 | char *tmpname = NULL, *tmpval = NULL, *p; | ||
| 887 | MIME_PARAM *mparam; | ||
| 888 | |||
| 889 | if (name) { | ||
| 890 | tmpname = strdup(name); | ||
| 891 | if (!tmpname) | ||
| 892 | goto err; | ||
| 893 | for (p = tmpname; *p; p++) | ||
| 894 | *p = tolower((unsigned char)*p); | ||
| 895 | } | ||
| 896 | if (value) { | ||
| 897 | tmpval = strdup(value); | ||
| 898 | if (!tmpval) | ||
| 899 | goto err; | ||
| 900 | } | ||
| 901 | /* Parameter values are case sensitive so leave as is */ | ||
| 902 | mparam = malloc(sizeof(MIME_PARAM)); | ||
| 903 | if (!mparam) | ||
| 904 | goto err; | ||
| 905 | mparam->param_name = tmpname; | ||
| 906 | mparam->param_value = tmpval; | ||
| 907 | if (sk_MIME_PARAM_push(mhdr->params, mparam) == 0) { | ||
| 908 | free(mparam); | ||
| 909 | goto err; | ||
| 910 | } | ||
| 911 | return 1; | ||
| 912 | err: | ||
| 913 | free(tmpname); | ||
| 914 | free(tmpval); | ||
| 915 | return 0; | ||
| 916 | } | ||
| 917 | |||
| 918 | static int | ||
| 919 | mime_hdr_cmp(const MIME_HEADER * const *a, const MIME_HEADER * const *b) | ||
| 920 | { | ||
| 921 | if (!(*a)->name || !(*b)->name) | ||
| 922 | return !!(*a)->name - !!(*b)->name; | ||
| 923 | return (strcmp((*a)->name, (*b)->name)); | ||
| 924 | } | ||
| 925 | |||
| 926 | static int | ||
| 927 | mime_param_cmp(const MIME_PARAM * const *a, const MIME_PARAM * const *b) | ||
| 928 | { | ||
| 929 | if (!(*a)->param_name || !(*b)->param_name) | ||
| 930 | return !!(*a)->param_name - !!(*b)->param_name; | ||
| 931 | return (strcmp((*a)->param_name, (*b)->param_name)); | ||
| 932 | } | ||
| 933 | |||
| 934 | /* Find a header with a given name (if possible) */ | ||
| 935 | |||
| 936 | static MIME_HEADER * | ||
| 937 | mime_hdr_find(STACK_OF(MIME_HEADER) *hdrs, char *name) | ||
| 938 | { | ||
| 939 | MIME_HEADER htmp; | ||
| 940 | int idx; | ||
| 941 | htmp.name = name; | ||
| 942 | idx = sk_MIME_HEADER_find(hdrs, &htmp); | ||
| 943 | if (idx < 0) | ||
| 944 | return NULL; | ||
| 945 | return sk_MIME_HEADER_value(hdrs, idx); | ||
| 946 | } | ||
| 947 | |||
| 948 | static MIME_PARAM * | ||
| 949 | mime_param_find(MIME_HEADER *hdr, char *name) | ||
| 950 | { | ||
| 951 | MIME_PARAM param; | ||
| 952 | int idx; | ||
| 953 | param.param_name = name; | ||
| 954 | idx = sk_MIME_PARAM_find(hdr->params, ¶m); | ||
| 955 | if (idx < 0) | ||
| 956 | return NULL; | ||
| 957 | return sk_MIME_PARAM_value(hdr->params, idx); | ||
| 958 | } | ||
| 959 | |||
| 960 | static void | ||
| 961 | mime_hdr_free(MIME_HEADER *hdr) | ||
| 962 | { | ||
| 963 | free(hdr->name); | ||
| 964 | free(hdr->value); | ||
| 965 | if (hdr->params) | ||
| 966 | sk_MIME_PARAM_pop_free(hdr->params, mime_param_free); | ||
| 967 | free(hdr); | ||
| 968 | } | ||
| 969 | |||
| 970 | static void | ||
| 971 | mime_param_free(MIME_PARAM *param) | ||
| 972 | { | ||
| 973 | free(param->param_name); | ||
| 974 | free(param->param_value); | ||
| 975 | free(param); | ||
| 976 | } | ||
| 977 | |||
| 978 | /* Check for a multipart boundary. Returns: | ||
| 979 | * 0 : no boundary | ||
| 980 | * 1 : part boundary | ||
| 981 | * 2 : final boundary | ||
| 982 | */ | ||
| 983 | static int | ||
| 984 | mime_bound_check(char *line, int linelen, char *bound, int blen) | ||
| 985 | { | ||
| 986 | if (linelen == -1) | ||
| 987 | linelen = strlen(line); | ||
| 988 | if (blen == -1) | ||
| 989 | blen = strlen(bound); | ||
| 990 | /* Quickly eliminate if line length too short */ | ||
| 991 | if (blen + 2 > linelen) | ||
| 992 | return 0; | ||
| 993 | /* Check for part boundary */ | ||
| 994 | if (!strncmp(line, "--", 2) && !strncmp(line + 2, bound, blen)) { | ||
| 995 | if (!strncmp(line + blen + 2, "--", 2)) | ||
| 996 | return 2; | ||
| 997 | else | ||
| 998 | return 1; | ||
| 999 | } | ||
| 1000 | return 0; | ||
| 1001 | } | ||
| 1002 | |||
| 1003 | static int | ||
| 1004 | strip_eol(char *linebuf, int *plen) | ||
| 1005 | { | ||
| 1006 | int len = *plen; | ||
| 1007 | char *p, c; | ||
| 1008 | int is_eol = 0; | ||
| 1009 | |||
| 1010 | for (p = linebuf + len - 1; len > 0; len--, p--) { | ||
| 1011 | c = *p; | ||
| 1012 | if (c == '\n') | ||
| 1013 | is_eol = 1; | ||
| 1014 | else if (c != '\r') | ||
| 1015 | break; | ||
| 1016 | } | ||
| 1017 | *plen = len; | ||
| 1018 | return is_eol; | ||
| 1019 | } | ||
diff --git a/src/lib/libcrypto/asn1/asn_moid.c b/src/lib/libcrypto/asn1/asn_moid.c deleted file mode 100644 index 76b6405212..0000000000 --- a/src/lib/libcrypto/asn1/asn_moid.c +++ /dev/null | |||
| @@ -1,158 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn_moid.c,v 1.12 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Written by Stephen Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2001. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2001-2004 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 | #include <ctype.h> | ||
| 60 | #include <stdio.h> | ||
| 61 | #include <string.h> | ||
| 62 | |||
| 63 | #include <openssl/err.h> | ||
| 64 | #include <openssl/conf.h> | ||
| 65 | #include <openssl/crypto.h> | ||
| 66 | #include <openssl/x509.h> | ||
| 67 | |||
| 68 | /* Simple ASN1 OID module: add all objects in a given section */ | ||
| 69 | |||
| 70 | static int do_create(char *value, char *name); | ||
| 71 | |||
| 72 | static int | ||
| 73 | oid_module_init(CONF_IMODULE *md, const CONF *cnf) | ||
| 74 | { | ||
| 75 | int i; | ||
| 76 | const char *oid_section; | ||
| 77 | STACK_OF(CONF_VALUE) *sktmp; | ||
| 78 | CONF_VALUE *oval; | ||
| 79 | |||
| 80 | oid_section = CONF_imodule_get_value(md); | ||
| 81 | if (!(sktmp = NCONF_get_section(cnf, oid_section))) { | ||
| 82 | ASN1err(ASN1_F_OID_MODULE_INIT, ASN1_R_ERROR_LOADING_SECTION); | ||
| 83 | return 0; | ||
| 84 | } | ||
| 85 | for (i = 0; i < sk_CONF_VALUE_num(sktmp); i++) { | ||
| 86 | oval = sk_CONF_VALUE_value(sktmp, i); | ||
| 87 | if (!do_create(oval->value, oval->name)) { | ||
| 88 | ASN1err(ASN1_F_OID_MODULE_INIT, ASN1_R_ADDING_OBJECT); | ||
| 89 | return 0; | ||
| 90 | } | ||
| 91 | } | ||
| 92 | return 1; | ||
| 93 | } | ||
| 94 | |||
| 95 | static void | ||
| 96 | oid_module_finish(CONF_IMODULE *md) | ||
| 97 | { | ||
| 98 | OBJ_cleanup(); | ||
| 99 | } | ||
| 100 | |||
| 101 | void | ||
| 102 | ASN1_add_oid_module(void) | ||
| 103 | { | ||
| 104 | CONF_module_add("oid_section", oid_module_init, oid_module_finish); | ||
| 105 | } | ||
| 106 | |||
| 107 | /* Create an OID based on a name value pair. Accept two formats. | ||
| 108 | * shortname = 1.2.3.4 | ||
| 109 | * shortname = some long name, 1.2.3.4 | ||
| 110 | */ | ||
| 111 | |||
| 112 | static int | ||
| 113 | do_create(char *value, char *name) | ||
| 114 | { | ||
| 115 | int nid; | ||
| 116 | ASN1_OBJECT *oid; | ||
| 117 | char *ln, *ostr, *p, *lntmp; | ||
| 118 | |||
| 119 | p = strrchr(value, ','); | ||
| 120 | if (!p) { | ||
| 121 | ln = name; | ||
| 122 | ostr = value; | ||
| 123 | } else { | ||
| 124 | ln = NULL; | ||
| 125 | ostr = p + 1; | ||
| 126 | if (!*ostr) | ||
| 127 | return 0; | ||
| 128 | while (isspace((unsigned char)*ostr)) | ||
| 129 | ostr++; | ||
| 130 | } | ||
| 131 | |||
| 132 | nid = OBJ_create(ostr, name, ln); | ||
| 133 | |||
| 134 | if (nid == NID_undef) | ||
| 135 | return 0; | ||
| 136 | |||
| 137 | if (p) { | ||
| 138 | ln = value; | ||
| 139 | while (isspace((unsigned char)*ln)) | ||
| 140 | ln++; | ||
| 141 | p--; | ||
| 142 | while (isspace((unsigned char)*p)) { | ||
| 143 | if (p == ln) | ||
| 144 | return 0; | ||
| 145 | p--; | ||
| 146 | } | ||
| 147 | p++; | ||
| 148 | lntmp = malloc((p - ln) + 1); | ||
| 149 | if (lntmp == NULL) | ||
| 150 | return 0; | ||
| 151 | memcpy(lntmp, ln, p - ln); | ||
| 152 | lntmp[p - ln] = 0; | ||
| 153 | oid = OBJ_nid2obj(nid); | ||
| 154 | oid->ln = lntmp; | ||
| 155 | } | ||
| 156 | |||
| 157 | return 1; | ||
| 158 | } | ||
diff --git a/src/lib/libcrypto/asn1/asn_pack.c b/src/lib/libcrypto/asn1/asn_pack.c deleted file mode 100644 index f010f87bbd..0000000000 --- a/src/lib/libcrypto/asn1/asn_pack.c +++ /dev/null | |||
| @@ -1,217 +0,0 @@ | |||
| 1 | /* $OpenBSD: asn_pack.c,v 1.14 2014/07/11 13:41:59 miod Exp $ */ | ||
| 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 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | |||
| 64 | #ifndef NO_ASN1_OLD | ||
| 65 | |||
| 66 | /* ASN1 packing and unpacking functions */ | ||
| 67 | |||
| 68 | /* Turn an ASN1 encoded SEQUENCE OF into a STACK of structures */ | ||
| 69 | |||
| 70 | STACK_OF(OPENSSL_BLOCK) * | ||
| 71 | ASN1_seq_unpack(const unsigned char *buf, int len, d2i_of_void *d2i, | ||
| 72 | void (*free_func)(OPENSSL_BLOCK)) | ||
| 73 | { | ||
| 74 | STACK_OF(OPENSSL_BLOCK) *sk; | ||
| 75 | const unsigned char *pbuf; | ||
| 76 | |||
| 77 | pbuf = buf; | ||
| 78 | if (!(sk = d2i_ASN1_SET(NULL, &pbuf, len, d2i, free_func, | ||
| 79 | V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL))) | ||
| 80 | ASN1err(ASN1_F_ASN1_SEQ_UNPACK,ASN1_R_DECODE_ERROR); | ||
| 81 | return sk; | ||
| 82 | } | ||
| 83 | |||
| 84 | /* Turn a STACK structures into an ASN1 encoded SEQUENCE OF structure in a | ||
| 85 | * OPENSSL_malloc'ed buffer | ||
| 86 | */ | ||
| 87 | |||
| 88 | unsigned char * | ||
| 89 | ASN1_seq_pack(STACK_OF(OPENSSL_BLOCK) *safes, i2d_of_void *i2d, | ||
| 90 | unsigned char **buf, int *len) | ||
| 91 | { | ||
| 92 | int safelen; | ||
| 93 | unsigned char *safe, *p; | ||
| 94 | |||
| 95 | if (!(safelen = i2d_ASN1_SET(safes, NULL, i2d, V_ASN1_SEQUENCE, | ||
| 96 | V_ASN1_UNIVERSAL, IS_SEQUENCE))) { | ||
| 97 | ASN1err(ASN1_F_ASN1_SEQ_PACK,ASN1_R_ENCODE_ERROR); | ||
| 98 | return NULL; | ||
| 99 | } | ||
| 100 | if (!(safe = malloc(safelen))) { | ||
| 101 | ASN1err(ASN1_F_ASN1_SEQ_PACK,ERR_R_MALLOC_FAILURE); | ||
| 102 | return NULL; | ||
| 103 | } | ||
| 104 | p = safe; | ||
| 105 | i2d_ASN1_SET(safes, &p, i2d, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL, | ||
| 106 | IS_SEQUENCE); | ||
| 107 | if (len) | ||
| 108 | *len = safelen; | ||
| 109 | if (buf) | ||
| 110 | *buf = safe; | ||
| 111 | return safe; | ||
| 112 | } | ||
| 113 | |||
| 114 | /* Extract an ASN1 object from an ASN1_STRING */ | ||
| 115 | |||
| 116 | void * | ||
| 117 | ASN1_unpack_string(ASN1_STRING *oct, d2i_of_void *d2i) | ||
| 118 | { | ||
| 119 | const unsigned char *p; | ||
| 120 | char *ret; | ||
| 121 | |||
| 122 | p = oct->data; | ||
| 123 | if (!(ret = d2i(NULL, &p, oct->length))) | ||
| 124 | ASN1err(ASN1_F_ASN1_UNPACK_STRING,ASN1_R_DECODE_ERROR); | ||
| 125 | return ret; | ||
| 126 | } | ||
| 127 | |||
| 128 | /* Pack an ASN1 object into an ASN1_STRING */ | ||
| 129 | |||
| 130 | ASN1_STRING * | ||
| 131 | ASN1_pack_string(void *obj, i2d_of_void *i2d, ASN1_STRING **oct) | ||
| 132 | { | ||
| 133 | unsigned char *p; | ||
| 134 | ASN1_STRING *octmp; | ||
| 135 | |||
| 136 | if (!oct || !*oct) { | ||
| 137 | if (!(octmp = ASN1_STRING_new())) { | ||
| 138 | ASN1err(ASN1_F_ASN1_PACK_STRING,ERR_R_MALLOC_FAILURE); | ||
| 139 | return NULL; | ||
| 140 | } | ||
| 141 | } else | ||
| 142 | octmp = *oct; | ||
| 143 | |||
| 144 | if (!(octmp->length = i2d(obj, NULL))) { | ||
| 145 | ASN1err(ASN1_F_ASN1_PACK_STRING,ASN1_R_ENCODE_ERROR); | ||
| 146 | goto err; | ||
| 147 | } | ||
| 148 | if (!(p = malloc (octmp->length))) { | ||
| 149 | ASN1err(ASN1_F_ASN1_PACK_STRING,ERR_R_MALLOC_FAILURE); | ||
| 150 | goto err; | ||
| 151 | } | ||
| 152 | octmp->data = p; | ||
| 153 | i2d (obj, &p); | ||
| 154 | if (oct) | ||
| 155 | *oct = octmp; | ||
| 156 | return octmp; | ||
| 157 | err: | ||
| 158 | if (!oct || octmp != *oct) { | ||
| 159 | ASN1_STRING_free(octmp); | ||
| 160 | if (oct) | ||
| 161 | *oct = NULL; | ||
| 162 | } | ||
| 163 | return NULL; | ||
| 164 | } | ||
| 165 | |||
| 166 | #endif | ||
| 167 | |||
| 168 | /* ASN1_ITEM versions of the above */ | ||
| 169 | |||
| 170 | ASN1_STRING * | ||
| 171 | ASN1_item_pack(void *obj, const ASN1_ITEM *it, ASN1_STRING **oct) | ||
| 172 | { | ||
| 173 | ASN1_STRING *octmp; | ||
| 174 | |||
| 175 | if (!oct || !*oct) { | ||
| 176 | if (!(octmp = ASN1_STRING_new ())) { | ||
| 177 | ASN1err(ASN1_F_ASN1_ITEM_PACK, ERR_R_MALLOC_FAILURE); | ||
| 178 | return NULL; | ||
| 179 | } | ||
| 180 | } else | ||
| 181 | octmp = *oct; | ||
| 182 | |||
| 183 | if (octmp->data) { | ||
| 184 | free(octmp->data); | ||
| 185 | octmp->data = NULL; | ||
| 186 | } | ||
| 187 | |||
| 188 | if (!(octmp->length = ASN1_item_i2d(obj, &octmp->data, it))) { | ||
| 189 | ASN1err(ASN1_F_ASN1_ITEM_PACK, ASN1_R_ENCODE_ERROR); | ||
| 190 | goto err; | ||
| 191 | } | ||
| 192 | if (!octmp->data) { | ||
| 193 | ASN1err(ASN1_F_ASN1_ITEM_PACK, ERR_R_MALLOC_FAILURE); | ||
| 194 | goto err; | ||
| 195 | } | ||
| 196 | if (oct) | ||
| 197 | *oct = octmp; | ||
| 198 | return octmp; | ||
| 199 | err: | ||
| 200 | if (!oct || octmp != *oct) | ||
| 201 | ASN1_STRING_free(octmp); | ||
| 202 | return NULL; | ||
| 203 | } | ||
| 204 | |||
| 205 | /* Extract an ASN1 object from an ASN1_STRING */ | ||
| 206 | |||
| 207 | void * | ||
| 208 | ASN1_item_unpack(ASN1_STRING *oct, const ASN1_ITEM *it) | ||
| 209 | { | ||
| 210 | const unsigned char *p; | ||
| 211 | void *ret; | ||
| 212 | |||
| 213 | p = oct->data; | ||
| 214 | if (!(ret = ASN1_item_d2i(NULL, &p, oct->length, it))) | ||
| 215 | ASN1err(ASN1_F_ASN1_ITEM_UNPACK, ASN1_R_DECODE_ERROR); | ||
| 216 | return ret; | ||
| 217 | } | ||
diff --git a/src/lib/libcrypto/asn1/bio_asn1.c b/src/lib/libcrypto/asn1/bio_asn1.c deleted file mode 100644 index 219810db82..0000000000 --- a/src/lib/libcrypto/asn1/bio_asn1.c +++ /dev/null | |||
| @@ -1,496 +0,0 @@ | |||
| 1 | /* $OpenBSD: bio_asn1.c,v 1.11 2015/02/10 09:52:35 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2006 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 | /* Experimental ASN1 BIO. When written through the data is converted | ||
| 60 | * to an ASN1 string type: default is OCTET STRING. Additional functions | ||
| 61 | * can be provided to add prefix and suffix data. | ||
| 62 | */ | ||
| 63 | |||
| 64 | #include <stdlib.h> | ||
| 65 | #include <string.h> | ||
| 66 | |||
| 67 | #include <openssl/bio.h> | ||
| 68 | #include <openssl/asn1.h> | ||
| 69 | |||
| 70 | /* Must be large enough for biggest tag+length */ | ||
| 71 | #define DEFAULT_ASN1_BUF_SIZE 20 | ||
| 72 | |||
| 73 | typedef enum { | ||
| 74 | ASN1_STATE_START, | ||
| 75 | ASN1_STATE_PRE_COPY, | ||
| 76 | ASN1_STATE_HEADER, | ||
| 77 | ASN1_STATE_HEADER_COPY, | ||
| 78 | ASN1_STATE_DATA_COPY, | ||
| 79 | ASN1_STATE_POST_COPY, | ||
| 80 | ASN1_STATE_DONE | ||
| 81 | } asn1_bio_state_t; | ||
| 82 | |||
| 83 | typedef struct BIO_ASN1_EX_FUNCS_st { | ||
| 84 | asn1_ps_func *ex_func; | ||
| 85 | asn1_ps_func *ex_free_func; | ||
| 86 | } BIO_ASN1_EX_FUNCS; | ||
| 87 | |||
| 88 | typedef struct BIO_ASN1_BUF_CTX_t { | ||
| 89 | /* Internal state */ | ||
| 90 | asn1_bio_state_t state; | ||
| 91 | /* Internal buffer */ | ||
| 92 | unsigned char *buf; | ||
| 93 | /* Size of buffer */ | ||
| 94 | int bufsize; | ||
| 95 | /* Current position in buffer */ | ||
| 96 | int bufpos; | ||
| 97 | /* Current buffer length */ | ||
| 98 | int buflen; | ||
| 99 | /* Amount of data to copy */ | ||
| 100 | int copylen; | ||
| 101 | /* Class and tag to use */ | ||
| 102 | int asn1_class, asn1_tag; | ||
| 103 | asn1_ps_func *prefix, *prefix_free, *suffix, *suffix_free; | ||
| 104 | /* Extra buffer for prefix and suffix data */ | ||
| 105 | unsigned char *ex_buf; | ||
| 106 | int ex_len; | ||
| 107 | int ex_pos; | ||
| 108 | void *ex_arg; | ||
| 109 | } BIO_ASN1_BUF_CTX; | ||
| 110 | |||
| 111 | |||
| 112 | static int asn1_bio_write(BIO *h, const char *buf, int num); | ||
| 113 | static int asn1_bio_read(BIO *h, char *buf, int size); | ||
| 114 | static int asn1_bio_puts(BIO *h, const char *str); | ||
| 115 | static int asn1_bio_gets(BIO *h, char *str, int size); | ||
| 116 | static long asn1_bio_ctrl(BIO *h, int cmd, long arg1, void *arg2); | ||
| 117 | static int asn1_bio_new(BIO *h); | ||
| 118 | static int asn1_bio_free(BIO *data); | ||
| 119 | static long asn1_bio_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp); | ||
| 120 | |||
| 121 | static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size); | ||
| 122 | static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx, | ||
| 123 | asn1_ps_func *cleanup, asn1_bio_state_t next); | ||
| 124 | static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx, | ||
| 125 | asn1_ps_func *setup, asn1_bio_state_t ex_state, | ||
| 126 | asn1_bio_state_t other_state); | ||
| 127 | |||
| 128 | static BIO_METHOD methods_asn1 = { | ||
| 129 | .type = BIO_TYPE_ASN1, | ||
| 130 | .name = "asn1", | ||
| 131 | .bwrite = asn1_bio_write, | ||
| 132 | .bread = asn1_bio_read, | ||
| 133 | .bputs = asn1_bio_puts, | ||
| 134 | .bgets = asn1_bio_gets, | ||
| 135 | .ctrl = asn1_bio_ctrl, | ||
| 136 | .create = asn1_bio_new, | ||
| 137 | .destroy = asn1_bio_free, | ||
| 138 | .callback_ctrl = asn1_bio_callback_ctrl | ||
| 139 | }; | ||
| 140 | |||
| 141 | BIO_METHOD * | ||
| 142 | BIO_f_asn1(void) | ||
| 143 | { | ||
| 144 | return (&methods_asn1); | ||
| 145 | } | ||
| 146 | |||
| 147 | static int | ||
| 148 | asn1_bio_new(BIO *b) | ||
| 149 | { | ||
| 150 | BIO_ASN1_BUF_CTX *ctx; | ||
| 151 | ctx = malloc(sizeof(BIO_ASN1_BUF_CTX)); | ||
| 152 | if (!ctx) | ||
| 153 | return 0; | ||
| 154 | if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) { | ||
| 155 | free(ctx); | ||
| 156 | return 0; | ||
| 157 | } | ||
| 158 | b->init = 1; | ||
| 159 | b->ptr = (char *)ctx; | ||
| 160 | b->flags = 0; | ||
| 161 | return 1; | ||
| 162 | } | ||
| 163 | |||
| 164 | static int | ||
| 165 | asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size) | ||
| 166 | { | ||
| 167 | ctx->buf = malloc(size); | ||
| 168 | if (!ctx->buf) | ||
| 169 | return 0; | ||
| 170 | ctx->bufsize = size; | ||
| 171 | ctx->bufpos = 0; | ||
| 172 | ctx->buflen = 0; | ||
| 173 | ctx->copylen = 0; | ||
| 174 | ctx->asn1_class = V_ASN1_UNIVERSAL; | ||
| 175 | ctx->asn1_tag = V_ASN1_OCTET_STRING; | ||
| 176 | ctx->ex_buf = 0; | ||
| 177 | ctx->ex_pos = 0; | ||
| 178 | ctx->ex_len = 0; | ||
| 179 | ctx->state = ASN1_STATE_START; | ||
| 180 | return 1; | ||
| 181 | } | ||
| 182 | |||
| 183 | static int | ||
| 184 | asn1_bio_free(BIO *b) | ||
| 185 | { | ||
| 186 | BIO_ASN1_BUF_CTX *ctx; | ||
| 187 | |||
| 188 | ctx = (BIO_ASN1_BUF_CTX *) b->ptr; | ||
| 189 | if (ctx == NULL) | ||
| 190 | return 0; | ||
| 191 | free(ctx->buf); | ||
| 192 | free(ctx); | ||
| 193 | b->init = 0; | ||
| 194 | b->ptr = NULL; | ||
| 195 | b->flags = 0; | ||
| 196 | return 1; | ||
| 197 | } | ||
| 198 | |||
| 199 | static int | ||
| 200 | asn1_bio_write(BIO *b, const char *in , int inl) | ||
| 201 | { | ||
| 202 | BIO_ASN1_BUF_CTX *ctx; | ||
| 203 | int wrmax, wrlen, ret, buflen; | ||
| 204 | unsigned char *p; | ||
| 205 | |||
| 206 | if (!in || (inl < 0) || (b->next_bio == NULL)) | ||
| 207 | return 0; | ||
| 208 | ctx = (BIO_ASN1_BUF_CTX *) b->ptr; | ||
| 209 | if (ctx == NULL) | ||
| 210 | return 0; | ||
| 211 | |||
| 212 | wrlen = 0; | ||
| 213 | ret = -1; | ||
| 214 | |||
| 215 | for (;;) { | ||
| 216 | switch (ctx->state) { | ||
| 217 | |||
| 218 | /* Setup prefix data, call it */ | ||
| 219 | case ASN1_STATE_START: | ||
| 220 | if (!asn1_bio_setup_ex(b, ctx, ctx->prefix, | ||
| 221 | ASN1_STATE_PRE_COPY, ASN1_STATE_HEADER)) | ||
| 222 | return 0; | ||
| 223 | break; | ||
| 224 | |||
| 225 | /* Copy any pre data first */ | ||
| 226 | case ASN1_STATE_PRE_COPY: | ||
| 227 | ret = asn1_bio_flush_ex(b, ctx, ctx->prefix_free, | ||
| 228 | ASN1_STATE_HEADER); | ||
| 229 | if (ret <= 0) | ||
| 230 | goto done; | ||
| 231 | break; | ||
| 232 | |||
| 233 | case ASN1_STATE_HEADER: | ||
| 234 | buflen = ASN1_object_size(0, inl, ctx->asn1_tag) - inl; | ||
| 235 | if (buflen <= 0 || buflen > ctx->bufsize) | ||
| 236 | return -1; | ||
| 237 | ctx->buflen = buflen; | ||
| 238 | p = ctx->buf; | ||
| 239 | ASN1_put_object(&p, 0, inl, | ||
| 240 | ctx->asn1_tag, ctx->asn1_class); | ||
| 241 | ctx->copylen = inl; | ||
| 242 | ctx->state = ASN1_STATE_HEADER_COPY; | ||
| 243 | break; | ||
| 244 | |||
| 245 | case ASN1_STATE_HEADER_COPY: | ||
| 246 | ret = BIO_write(b->next_bio, | ||
| 247 | ctx->buf + ctx->bufpos, ctx->buflen); | ||
| 248 | if (ret <= 0) | ||
| 249 | goto done; | ||
| 250 | |||
| 251 | ctx->buflen -= ret; | ||
| 252 | if (ctx->buflen) | ||
| 253 | ctx->bufpos += ret; | ||
| 254 | else { | ||
| 255 | ctx->bufpos = 0; | ||
| 256 | ctx->state = ASN1_STATE_DATA_COPY; | ||
| 257 | } | ||
| 258 | break; | ||
| 259 | |||
| 260 | case ASN1_STATE_DATA_COPY: | ||
| 261 | |||
| 262 | if (inl > ctx->copylen) | ||
| 263 | wrmax = ctx->copylen; | ||
| 264 | else | ||
| 265 | wrmax = inl; | ||
| 266 | ret = BIO_write(b->next_bio, in, wrmax); | ||
| 267 | if (ret <= 0) | ||
| 268 | break; | ||
| 269 | wrlen += ret; | ||
| 270 | ctx->copylen -= ret; | ||
| 271 | in += ret; | ||
| 272 | inl -= ret; | ||
| 273 | |||
| 274 | if (ctx->copylen == 0) | ||
| 275 | ctx->state = ASN1_STATE_HEADER; | ||
| 276 | if (inl == 0) | ||
| 277 | goto done; | ||
| 278 | break; | ||
| 279 | |||
| 280 | default: | ||
| 281 | BIO_clear_retry_flags(b); | ||
| 282 | return 0; | ||
| 283 | } | ||
| 284 | |||
| 285 | } | ||
| 286 | |||
| 287 | done: | ||
| 288 | BIO_clear_retry_flags(b); | ||
| 289 | BIO_copy_next_retry(b); | ||
| 290 | |||
| 291 | return (wrlen > 0) ? wrlen : ret; | ||
| 292 | } | ||
| 293 | |||
| 294 | static int | ||
| 295 | asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx, asn1_ps_func *cleanup, | ||
| 296 | asn1_bio_state_t next) | ||
| 297 | { | ||
| 298 | int ret; | ||
| 299 | |||
| 300 | if (ctx->ex_len <= 0) | ||
| 301 | return 1; | ||
| 302 | for (;;) { | ||
| 303 | ret = BIO_write(b->next_bio, ctx->ex_buf + ctx->ex_pos, | ||
| 304 | ctx->ex_len); | ||
| 305 | if (ret <= 0) | ||
| 306 | break; | ||
| 307 | ctx->ex_len -= ret; | ||
| 308 | if (ctx->ex_len > 0) | ||
| 309 | ctx->ex_pos += ret; | ||
| 310 | else { | ||
| 311 | if (cleanup) | ||
| 312 | cleanup(b, &ctx->ex_buf, &ctx->ex_len, | ||
| 313 | &ctx->ex_arg); | ||
| 314 | ctx->state = next; | ||
| 315 | ctx->ex_pos = 0; | ||
| 316 | break; | ||
| 317 | } | ||
| 318 | } | ||
| 319 | return ret; | ||
| 320 | } | ||
| 321 | |||
| 322 | static int | ||
| 323 | asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx, asn1_ps_func *setup, | ||
| 324 | asn1_bio_state_t ex_state, asn1_bio_state_t other_state) | ||
| 325 | { | ||
| 326 | if (setup && !setup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg)) { | ||
| 327 | BIO_clear_retry_flags(b); | ||
| 328 | return 0; | ||
| 329 | } | ||
| 330 | if (ctx->ex_len > 0) | ||
| 331 | ctx->state = ex_state; | ||
| 332 | else | ||
| 333 | ctx->state = other_state; | ||
| 334 | return 1; | ||
| 335 | } | ||
| 336 | |||
| 337 | static int | ||
| 338 | asn1_bio_read(BIO *b, char *in , int inl) | ||
| 339 | { | ||
| 340 | if (!b->next_bio) | ||
| 341 | return 0; | ||
| 342 | return BIO_read(b->next_bio, in , inl); | ||
| 343 | } | ||
| 344 | |||
| 345 | static int | ||
| 346 | asn1_bio_puts(BIO *b, const char *str) | ||
| 347 | { | ||
| 348 | return asn1_bio_write(b, str, strlen(str)); | ||
| 349 | } | ||
| 350 | |||
| 351 | static int | ||
| 352 | asn1_bio_gets(BIO *b, char *str, int size) | ||
| 353 | { | ||
| 354 | if (!b->next_bio) | ||
| 355 | return 0; | ||
| 356 | return BIO_gets(b->next_bio, str , size); | ||
| 357 | } | ||
| 358 | |||
| 359 | static long | ||
| 360 | asn1_bio_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) | ||
| 361 | { | ||
| 362 | if (b->next_bio == NULL) | ||
| 363 | return (0); | ||
| 364 | return BIO_callback_ctrl(b->next_bio, cmd, fp); | ||
| 365 | } | ||
| 366 | |||
| 367 | static long | ||
| 368 | asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2) | ||
| 369 | { | ||
| 370 | BIO_ASN1_BUF_CTX *ctx; | ||
| 371 | BIO_ASN1_EX_FUNCS *ex_func; | ||
| 372 | long ret = 1; | ||
| 373 | |||
| 374 | ctx = (BIO_ASN1_BUF_CTX *) b->ptr; | ||
| 375 | if (ctx == NULL) | ||
| 376 | return 0; | ||
| 377 | switch (cmd) { | ||
| 378 | |||
| 379 | case BIO_C_SET_PREFIX: | ||
| 380 | ex_func = arg2; | ||
| 381 | ctx->prefix = ex_func->ex_func; | ||
| 382 | ctx->prefix_free = ex_func->ex_free_func; | ||
| 383 | break; | ||
| 384 | |||
| 385 | case BIO_C_GET_PREFIX: | ||
| 386 | ex_func = arg2; | ||
| 387 | ex_func->ex_func = ctx->prefix; | ||
| 388 | ex_func->ex_free_func = ctx->prefix_free; | ||
| 389 | break; | ||
| 390 | |||
| 391 | case BIO_C_SET_SUFFIX: | ||
| 392 | ex_func = arg2; | ||
| 393 | ctx->suffix = ex_func->ex_func; | ||
| 394 | ctx->suffix_free = ex_func->ex_free_func; | ||
| 395 | break; | ||
| 396 | |||
| 397 | case BIO_C_GET_SUFFIX: | ||
| 398 | ex_func = arg2; | ||
| 399 | ex_func->ex_func = ctx->suffix; | ||
| 400 | ex_func->ex_free_func = ctx->suffix_free; | ||
| 401 | break; | ||
| 402 | |||
| 403 | case BIO_C_SET_EX_ARG: | ||
| 404 | ctx->ex_arg = arg2; | ||
| 405 | break; | ||
| 406 | |||
| 407 | case BIO_C_GET_EX_ARG: | ||
| 408 | *(void **)arg2 = ctx->ex_arg; | ||
| 409 | break; | ||
| 410 | |||
| 411 | case BIO_CTRL_FLUSH: | ||
| 412 | if (!b->next_bio) | ||
| 413 | return 0; | ||
| 414 | |||
| 415 | /* Call post function if possible */ | ||
| 416 | if (ctx->state == ASN1_STATE_HEADER) { | ||
| 417 | if (!asn1_bio_setup_ex(b, ctx, ctx->suffix, | ||
| 418 | ASN1_STATE_POST_COPY, ASN1_STATE_DONE)) | ||
| 419 | return 0; | ||
| 420 | } | ||
| 421 | |||
| 422 | if (ctx->state == ASN1_STATE_POST_COPY) { | ||
| 423 | ret = asn1_bio_flush_ex(b, ctx, ctx->suffix_free, | ||
| 424 | ASN1_STATE_DONE); | ||
| 425 | if (ret <= 0) | ||
| 426 | return ret; | ||
| 427 | } | ||
| 428 | |||
| 429 | if (ctx->state == ASN1_STATE_DONE) | ||
| 430 | return BIO_ctrl(b->next_bio, cmd, arg1, arg2); | ||
| 431 | else { | ||
| 432 | BIO_clear_retry_flags(b); | ||
| 433 | return 0; | ||
| 434 | } | ||
| 435 | break; | ||
| 436 | |||
| 437 | |||
| 438 | default: | ||
| 439 | if (!b->next_bio) | ||
| 440 | return 0; | ||
| 441 | return BIO_ctrl(b->next_bio, cmd, arg1, arg2); | ||
| 442 | |||
| 443 | } | ||
| 444 | |||
| 445 | return ret; | ||
| 446 | } | ||
| 447 | |||
| 448 | static int | ||
| 449 | asn1_bio_set_ex(BIO *b, int cmd, asn1_ps_func *ex_func, asn1_ps_func | ||
| 450 | *ex_free_func) | ||
| 451 | { | ||
| 452 | BIO_ASN1_EX_FUNCS extmp; | ||
| 453 | |||
| 454 | extmp.ex_func = ex_func; | ||
| 455 | extmp.ex_free_func = ex_free_func; | ||
| 456 | return BIO_ctrl(b, cmd, 0, &extmp); | ||
| 457 | } | ||
| 458 | |||
| 459 | static int | ||
| 460 | asn1_bio_get_ex(BIO *b, int cmd, asn1_ps_func **ex_func, | ||
| 461 | asn1_ps_func **ex_free_func) | ||
| 462 | { | ||
| 463 | BIO_ASN1_EX_FUNCS extmp; | ||
| 464 | int ret; | ||
| 465 | |||
| 466 | ret = BIO_ctrl(b, cmd, 0, &extmp); | ||
| 467 | if (ret > 0) { | ||
| 468 | *ex_func = extmp.ex_func; | ||
| 469 | *ex_free_func = extmp.ex_free_func; | ||
| 470 | } | ||
| 471 | return ret; | ||
| 472 | } | ||
| 473 | |||
| 474 | int | ||
| 475 | BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, asn1_ps_func *prefix_free) | ||
| 476 | { | ||
| 477 | return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free); | ||
| 478 | } | ||
| 479 | |||
| 480 | int | ||
| 481 | BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, asn1_ps_func **pprefix_free) | ||
| 482 | { | ||
| 483 | return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free); | ||
| 484 | } | ||
| 485 | |||
| 486 | int | ||
| 487 | BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, asn1_ps_func *suffix_free) | ||
| 488 | { | ||
| 489 | return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free); | ||
| 490 | } | ||
| 491 | |||
| 492 | int | ||
| 493 | BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, asn1_ps_func **psuffix_free) | ||
| 494 | { | ||
| 495 | return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free); | ||
| 496 | } | ||
diff --git a/src/lib/libcrypto/asn1/bio_ndef.c b/src/lib/libcrypto/asn1/bio_ndef.c deleted file mode 100644 index 1a23c27d04..0000000000 --- a/src/lib/libcrypto/asn1/bio_ndef.c +++ /dev/null | |||
| @@ -1,243 +0,0 @@ | |||
| 1 | /* $OpenBSD: bio_ndef.c,v 1.9 2014/07/25 06:05:32 doug Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2008 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 | */ | ||
| 54 | |||
| 55 | #include <openssl/asn1.h> | ||
| 56 | #include <openssl/asn1t.h> | ||
| 57 | #include <openssl/bio.h> | ||
| 58 | #include <openssl/err.h> | ||
| 59 | |||
| 60 | #include <stdio.h> | ||
| 61 | |||
| 62 | /* Experimental NDEF ASN1 BIO support routines */ | ||
| 63 | |||
| 64 | /* The usage is quite simple, initialize an ASN1 structure, | ||
| 65 | * get a BIO from it then any data written through the BIO | ||
| 66 | * will end up translated to approptiate format on the fly. | ||
| 67 | * The data is streamed out and does *not* need to be | ||
| 68 | * all held in memory at once. | ||
| 69 | * | ||
| 70 | * When the BIO is flushed the output is finalized and any | ||
| 71 | * signatures etc written out. | ||
| 72 | * | ||
| 73 | * The BIO is a 'proper' BIO and can handle non blocking I/O | ||
| 74 | * correctly. | ||
| 75 | * | ||
| 76 | * The usage is simple. The implementation is *not*... | ||
| 77 | */ | ||
| 78 | |||
| 79 | /* BIO support data stored in the ASN1 BIO ex_arg */ | ||
| 80 | |||
| 81 | typedef struct ndef_aux_st { | ||
| 82 | /* ASN1 structure this BIO refers to */ | ||
| 83 | ASN1_VALUE *val; | ||
| 84 | const ASN1_ITEM *it; | ||
| 85 | /* Top of the BIO chain */ | ||
| 86 | BIO *ndef_bio; | ||
| 87 | /* Output BIO */ | ||
| 88 | BIO *out; | ||
| 89 | /* Boundary where content is inserted */ | ||
| 90 | unsigned char **boundary; | ||
| 91 | /* DER buffer start */ | ||
| 92 | unsigned char *derbuf; | ||
| 93 | } NDEF_SUPPORT; | ||
| 94 | |||
| 95 | static int ndef_prefix(BIO *b, unsigned char **pbuf, int *plen, void *parg); | ||
| 96 | static int ndef_prefix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg); | ||
| 97 | static int ndef_suffix(BIO *b, unsigned char **pbuf, int *plen, void *parg); | ||
| 98 | static int ndef_suffix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg); | ||
| 99 | |||
| 100 | BIO * | ||
| 101 | BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it) | ||
| 102 | { | ||
| 103 | NDEF_SUPPORT *ndef_aux = NULL; | ||
| 104 | BIO *asn_bio = NULL; | ||
| 105 | const ASN1_AUX *aux = it->funcs; | ||
| 106 | ASN1_STREAM_ARG sarg; | ||
| 107 | |||
| 108 | if (!aux || !aux->asn1_cb) { | ||
| 109 | ASN1err(ASN1_F_BIO_NEW_NDEF, ASN1_R_STREAMING_NOT_SUPPORTED); | ||
| 110 | return NULL; | ||
| 111 | } | ||
| 112 | ndef_aux = malloc(sizeof(NDEF_SUPPORT)); | ||
| 113 | asn_bio = BIO_new(BIO_f_asn1()); | ||
| 114 | |||
| 115 | /* ASN1 bio needs to be next to output BIO */ | ||
| 116 | |||
| 117 | out = BIO_push(asn_bio, out); | ||
| 118 | |||
| 119 | if (!ndef_aux || !asn_bio || !out) | ||
| 120 | goto err; | ||
| 121 | |||
| 122 | BIO_asn1_set_prefix(asn_bio, ndef_prefix, ndef_prefix_free); | ||
| 123 | BIO_asn1_set_suffix(asn_bio, ndef_suffix, ndef_suffix_free); | ||
| 124 | |||
| 125 | /* Now let callback prepend any digest, cipher etc BIOs | ||
| 126 | * ASN1 structure needs. | ||
| 127 | */ | ||
| 128 | |||
| 129 | sarg.out = out; | ||
| 130 | sarg.ndef_bio = NULL; | ||
| 131 | sarg.boundary = NULL; | ||
| 132 | |||
| 133 | if (aux->asn1_cb(ASN1_OP_STREAM_PRE, &val, it, &sarg) <= 0) | ||
| 134 | goto err; | ||
| 135 | |||
| 136 | ndef_aux->val = val; | ||
| 137 | ndef_aux->it = it; | ||
| 138 | ndef_aux->ndef_bio = sarg.ndef_bio; | ||
| 139 | ndef_aux->boundary = sarg.boundary; | ||
| 140 | ndef_aux->out = out; | ||
| 141 | |||
| 142 | BIO_ctrl(asn_bio, BIO_C_SET_EX_ARG, 0, ndef_aux); | ||
| 143 | |||
| 144 | return sarg.ndef_bio; | ||
| 145 | |||
| 146 | err: | ||
| 147 | BIO_free(asn_bio); | ||
| 148 | free(ndef_aux); | ||
| 149 | return NULL; | ||
| 150 | } | ||
| 151 | |||
| 152 | static int | ||
| 153 | ndef_prefix(BIO *b, unsigned char **pbuf, int *plen, void *parg) | ||
| 154 | { | ||
| 155 | NDEF_SUPPORT *ndef_aux; | ||
| 156 | unsigned char *p; | ||
| 157 | int derlen; | ||
| 158 | |||
| 159 | if (!parg) | ||
| 160 | return 0; | ||
| 161 | |||
| 162 | ndef_aux = *(NDEF_SUPPORT **)parg; | ||
| 163 | |||
| 164 | derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it); | ||
| 165 | p = malloc(derlen); | ||
| 166 | ndef_aux->derbuf = p; | ||
| 167 | *pbuf = p; | ||
| 168 | derlen = ASN1_item_ndef_i2d(ndef_aux->val, &p, ndef_aux->it); | ||
| 169 | |||
| 170 | if (!*ndef_aux->boundary) | ||
| 171 | return 0; | ||
| 172 | |||
| 173 | *plen = *ndef_aux->boundary - *pbuf; | ||
| 174 | |||
| 175 | return 1; | ||
| 176 | } | ||
| 177 | |||
| 178 | static int | ||
| 179 | ndef_prefix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg) | ||
| 180 | { | ||
| 181 | NDEF_SUPPORT *ndef_aux; | ||
| 182 | |||
| 183 | if (!parg) | ||
| 184 | return 0; | ||
| 185 | |||
| 186 | ndef_aux = *(NDEF_SUPPORT **)parg; | ||
| 187 | |||
| 188 | free(ndef_aux->derbuf); | ||
| 189 | |||
| 190 | ndef_aux->derbuf = NULL; | ||
| 191 | *pbuf = NULL; | ||
| 192 | *plen = 0; | ||
| 193 | return 1; | ||
| 194 | } | ||
| 195 | |||
| 196 | static int | ||
| 197 | ndef_suffix_free(BIO *b, unsigned char **pbuf, int *plen, void *parg) | ||
| 198 | { | ||
| 199 | NDEF_SUPPORT **pndef_aux = (NDEF_SUPPORT **)parg; | ||
| 200 | if (!ndef_prefix_free(b, pbuf, plen, parg)) | ||
| 201 | return 0; | ||
| 202 | free(*pndef_aux); | ||
| 203 | *pndef_aux = NULL; | ||
| 204 | return 1; | ||
| 205 | } | ||
| 206 | |||
| 207 | static int | ||
| 208 | ndef_suffix(BIO *b, unsigned char **pbuf, int *plen, void *parg) | ||
| 209 | { | ||
| 210 | NDEF_SUPPORT *ndef_aux; | ||
| 211 | unsigned char *p; | ||
| 212 | int derlen; | ||
| 213 | const ASN1_AUX *aux; | ||
| 214 | ASN1_STREAM_ARG sarg; | ||
| 215 | |||
| 216 | if (!parg) | ||
| 217 | return 0; | ||
| 218 | |||
| 219 | ndef_aux = *(NDEF_SUPPORT **)parg; | ||
| 220 | |||
| 221 | aux = ndef_aux->it->funcs; | ||
| 222 | |||
| 223 | /* Finalize structures */ | ||
| 224 | sarg.ndef_bio = ndef_aux->ndef_bio; | ||
| 225 | sarg.out = ndef_aux->out; | ||
| 226 | sarg.boundary = ndef_aux->boundary; | ||
| 227 | if (aux->asn1_cb(ASN1_OP_STREAM_POST, | ||
| 228 | &ndef_aux->val, ndef_aux->it, &sarg) <= 0) | ||
| 229 | return 0; | ||
| 230 | |||
| 231 | derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it); | ||
| 232 | p = malloc(derlen); | ||
| 233 | ndef_aux->derbuf = p; | ||
| 234 | *pbuf = p; | ||
| 235 | derlen = ASN1_item_ndef_i2d(ndef_aux->val, &p, ndef_aux->it); | ||
| 236 | |||
| 237 | if (!*ndef_aux->boundary) | ||
| 238 | return 0; | ||
| 239 | *pbuf = *ndef_aux->boundary; | ||
| 240 | *plen = derlen - (*ndef_aux->boundary - ndef_aux->derbuf); | ||
| 241 | |||
| 242 | return 1; | ||
| 243 | } | ||
diff --git a/src/lib/libcrypto/asn1/charmap.h b/src/lib/libcrypto/asn1/charmap.h deleted file mode 100644 index d9397bf826..0000000000 --- a/src/lib/libcrypto/asn1/charmap.h +++ /dev/null | |||
| @@ -1,15 +0,0 @@ | |||
| 1 | /* $OpenBSD: charmap.h,v 1.4 2014/06/12 15:49:27 deraadt Exp $ */ | ||
| 2 | /* Auto generated with chartype.pl script. | ||
| 3 | * Mask of various character properties | ||
| 4 | */ | ||
| 5 | |||
| 6 | static const unsigned char char_type[] = { | ||
| 7 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | ||
| 8 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | ||
| 9 | 120, 0, 1, 40, 0, 0, 0, 16, 16, 16, 0, 25, 25, 16, 16, 16, | ||
| 10 | 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 9, 9, 16, 9, 16, | ||
| 11 | 0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, | ||
| 12 | 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 1, 0, 0, 0, | ||
| 13 | 0, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, | ||
| 14 | 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 0, 0, 0, 0, 2 | ||
| 15 | }; | ||
diff --git a/src/lib/libcrypto/asn1/charmap.pl b/src/lib/libcrypto/asn1/charmap.pl deleted file mode 100644 index 2875c59867..0000000000 --- a/src/lib/libcrypto/asn1/charmap.pl +++ /dev/null | |||
| @@ -1,80 +0,0 @@ | |||
| 1 | #!/usr/local/bin/perl -w | ||
| 2 | |||
| 3 | use strict; | ||
| 4 | |||
| 5 | my ($i, @arr); | ||
| 6 | |||
| 7 | # Set up an array with the type of ASCII characters | ||
| 8 | # Each set bit represents a character property. | ||
| 9 | |||
| 10 | # RFC2253 character properties | ||
| 11 | my $RFC2253_ESC = 1; # Character escaped with \ | ||
| 12 | my $ESC_CTRL = 2; # Escaped control character | ||
| 13 | # These are used with RFC1779 quoting using " | ||
| 14 | my $NOESC_QUOTE = 8; # Not escaped if quoted | ||
| 15 | my $PSTRING_CHAR = 0x10; # Valid PrintableString character | ||
| 16 | my $RFC2253_FIRST_ESC = 0x20; # Escaped with \ if first character | ||
| 17 | my $RFC2253_LAST_ESC = 0x40; # Escaped with \ if last character | ||
| 18 | |||
| 19 | for($i = 0; $i < 128; $i++) { | ||
| 20 | # Set the RFC2253 escape characters (control) | ||
| 21 | $arr[$i] = 0; | ||
| 22 | if(($i < 32) || ($i > 126)) { | ||
| 23 | $arr[$i] |= $ESC_CTRL; | ||
| 24 | } | ||
| 25 | |||
| 26 | # Some PrintableString characters | ||
| 27 | if( ( ( $i >= ord("a")) && ( $i <= ord("z")) ) | ||
| 28 | || ( ( $i >= ord("A")) && ( $i <= ord("Z")) ) | ||
| 29 | || ( ( $i >= ord("0")) && ( $i <= ord("9")) ) ) { | ||
| 30 | $arr[$i] |= $PSTRING_CHAR; | ||
| 31 | } | ||
| 32 | } | ||
| 33 | |||
| 34 | # Now setup the rest | ||
| 35 | |||
| 36 | # Remaining RFC2253 escaped characters | ||
| 37 | |||
| 38 | $arr[ord(" ")] |= $NOESC_QUOTE | $RFC2253_FIRST_ESC | $RFC2253_LAST_ESC; | ||
| 39 | $arr[ord("#")] |= $NOESC_QUOTE | $RFC2253_FIRST_ESC; | ||
| 40 | |||
| 41 | $arr[ord(",")] |= $NOESC_QUOTE | $RFC2253_ESC; | ||
| 42 | $arr[ord("+")] |= $NOESC_QUOTE | $RFC2253_ESC; | ||
| 43 | $arr[ord("\"")] |= $RFC2253_ESC; | ||
| 44 | $arr[ord("\\")] |= $RFC2253_ESC; | ||
| 45 | $arr[ord("<")] |= $NOESC_QUOTE | $RFC2253_ESC; | ||
| 46 | $arr[ord(">")] |= $NOESC_QUOTE | $RFC2253_ESC; | ||
| 47 | $arr[ord(";")] |= $NOESC_QUOTE | $RFC2253_ESC; | ||
| 48 | |||
| 49 | # Remaining PrintableString characters | ||
| 50 | |||
| 51 | $arr[ord(" ")] |= $PSTRING_CHAR; | ||
| 52 | $arr[ord("'")] |= $PSTRING_CHAR; | ||
| 53 | $arr[ord("(")] |= $PSTRING_CHAR; | ||
| 54 | $arr[ord(")")] |= $PSTRING_CHAR; | ||
| 55 | $arr[ord("+")] |= $PSTRING_CHAR; | ||
| 56 | $arr[ord(",")] |= $PSTRING_CHAR; | ||
| 57 | $arr[ord("-")] |= $PSTRING_CHAR; | ||
| 58 | $arr[ord(".")] |= $PSTRING_CHAR; | ||
| 59 | $arr[ord("/")] |= $PSTRING_CHAR; | ||
| 60 | $arr[ord(":")] |= $PSTRING_CHAR; | ||
| 61 | $arr[ord("=")] |= $PSTRING_CHAR; | ||
| 62 | $arr[ord("?")] |= $PSTRING_CHAR; | ||
| 63 | |||
| 64 | # Now generate the C code | ||
| 65 | |||
| 66 | print <<EOF; | ||
| 67 | /* Auto generated with chartype.pl script. | ||
| 68 | * Mask of various character properties | ||
| 69 | */ | ||
| 70 | |||
| 71 | static unsigned char char_type[] = { | ||
| 72 | EOF | ||
| 73 | |||
| 74 | for($i = 0; $i < 128; $i++) { | ||
| 75 | print("\n") if($i && (($i % 16) == 0)); | ||
| 76 | printf("%2d", $arr[$i]); | ||
| 77 | print(",") if ($i != 127); | ||
| 78 | } | ||
| 79 | print("\n};\n\n"); | ||
| 80 | |||
diff --git a/src/lib/libcrypto/asn1/d2i_pr.c b/src/lib/libcrypto/asn1/d2i_pr.c deleted file mode 100644 index 68d02177c4..0000000000 --- a/src/lib/libcrypto/asn1/d2i_pr.c +++ /dev/null | |||
| @@ -1,170 +0,0 @@ | |||
| 1 | /* $OpenBSD: d2i_pr.c,v 1.14 2015/03/19 14:00:22 tedu Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1.h> | ||
| 64 | #include <openssl/bn.h> | ||
| 65 | #include <openssl/err.h> | ||
| 66 | #include <openssl/evp.h> | ||
| 67 | #include <openssl/objects.h> | ||
| 68 | #include <openssl/x509.h> | ||
| 69 | |||
| 70 | #ifndef OPENSSL_NO_ENGINE | ||
| 71 | #include <openssl/engine.h> | ||
| 72 | #endif | ||
| 73 | |||
| 74 | #include "asn1_locl.h" | ||
| 75 | |||
| 76 | EVP_PKEY * | ||
| 77 | d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp, long length) | ||
| 78 | { | ||
| 79 | EVP_PKEY *ret; | ||
| 80 | |||
| 81 | if ((a == NULL) || (*a == NULL)) { | ||
| 82 | if ((ret = EVP_PKEY_new()) == NULL) { | ||
| 83 | ASN1err(ASN1_F_D2I_PRIVATEKEY, ERR_R_EVP_LIB); | ||
| 84 | return (NULL); | ||
| 85 | } | ||
| 86 | } else { | ||
| 87 | ret = *a; | ||
| 88 | #ifndef OPENSSL_NO_ENGINE | ||
| 89 | if (ret->engine) { | ||
| 90 | ENGINE_finish(ret->engine); | ||
| 91 | ret->engine = NULL; | ||
| 92 | } | ||
| 93 | #endif | ||
| 94 | } | ||
| 95 | |||
| 96 | if (!EVP_PKEY_set_type(ret, type)) { | ||
| 97 | ASN1err(ASN1_F_D2I_PRIVATEKEY, ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE); | ||
| 98 | goto err; | ||
| 99 | } | ||
| 100 | |||
| 101 | if (!ret->ameth->old_priv_decode || | ||
| 102 | !ret->ameth->old_priv_decode(ret, pp, length)) { | ||
| 103 | if (ret->ameth->priv_decode) { | ||
| 104 | PKCS8_PRIV_KEY_INFO *p8 = NULL; | ||
| 105 | p8 = d2i_PKCS8_PRIV_KEY_INFO(NULL, pp, length); | ||
| 106 | if (!p8) | ||
| 107 | goto err; | ||
| 108 | EVP_PKEY_free(ret); | ||
| 109 | ret = EVP_PKCS82PKEY(p8); | ||
| 110 | PKCS8_PRIV_KEY_INFO_free(p8); | ||
| 111 | } else { | ||
| 112 | ASN1err(ASN1_F_D2I_PRIVATEKEY, ERR_R_ASN1_LIB); | ||
| 113 | goto err; | ||
| 114 | } | ||
| 115 | } | ||
| 116 | if (a != NULL) | ||
| 117 | (*a) = ret; | ||
| 118 | return (ret); | ||
| 119 | |||
| 120 | err: | ||
| 121 | if (a == NULL || *a != ret) | ||
| 122 | EVP_PKEY_free(ret); | ||
| 123 | return (NULL); | ||
| 124 | } | ||
| 125 | |||
| 126 | /* This works like d2i_PrivateKey() except it automatically works out the type */ | ||
| 127 | |||
| 128 | EVP_PKEY * | ||
| 129 | d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp, long length) | ||
| 130 | { | ||
| 131 | STACK_OF(ASN1_TYPE) *inkey; | ||
| 132 | const unsigned char *p; | ||
| 133 | int keytype; | ||
| 134 | |||
| 135 | p = *pp; | ||
| 136 | /* Dirty trick: read in the ASN1 data into a STACK_OF(ASN1_TYPE): | ||
| 137 | * by analyzing it we can determine the passed structure: this | ||
| 138 | * assumes the input is surrounded by an ASN1 SEQUENCE. | ||
| 139 | */ | ||
| 140 | inkey = d2i_ASN1_SEQUENCE_ANY(NULL, &p, length); | ||
| 141 | /* Since we only need to discern "traditional format" RSA and DSA | ||
| 142 | * keys we can just count the elements. | ||
| 143 | */ | ||
| 144 | if (sk_ASN1_TYPE_num(inkey) == 6) | ||
| 145 | keytype = EVP_PKEY_DSA; | ||
| 146 | else if (sk_ASN1_TYPE_num(inkey) == 4) | ||
| 147 | keytype = EVP_PKEY_EC; | ||
| 148 | else if (sk_ASN1_TYPE_num(inkey) == 3) { | ||
| 149 | /* This seems to be PKCS8, not traditional format */ | ||
| 150 | PKCS8_PRIV_KEY_INFO *p8 = d2i_PKCS8_PRIV_KEY_INFO( | ||
| 151 | NULL, pp, length); | ||
| 152 | EVP_PKEY *ret; | ||
| 153 | |||
| 154 | sk_ASN1_TYPE_pop_free(inkey, ASN1_TYPE_free); | ||
| 155 | if (!p8) { | ||
| 156 | ASN1err(ASN1_F_D2I_AUTOPRIVATEKEY, | ||
| 157 | ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE); | ||
| 158 | return NULL; | ||
| 159 | } | ||
| 160 | ret = EVP_PKCS82PKEY(p8); | ||
| 161 | PKCS8_PRIV_KEY_INFO_free(p8); | ||
| 162 | if (a) { | ||
| 163 | *a = ret; | ||
| 164 | } | ||
| 165 | return ret; | ||
| 166 | } else | ||
| 167 | keytype = EVP_PKEY_RSA; | ||
| 168 | sk_ASN1_TYPE_pop_free(inkey, ASN1_TYPE_free); | ||
| 169 | return d2i_PrivateKey(keytype, a, pp, length); | ||
| 170 | } | ||
diff --git a/src/lib/libcrypto/asn1/d2i_pu.c b/src/lib/libcrypto/asn1/d2i_pu.c deleted file mode 100644 index e917356254..0000000000 --- a/src/lib/libcrypto/asn1/d2i_pu.c +++ /dev/null | |||
| @@ -1,136 +0,0 @@ | |||
| 1 | /* $OpenBSD: d2i_pu.c,v 1.13 2015/03/19 14:00:22 tedu Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1.h> | ||
| 64 | #include <openssl/bn.h> | ||
| 65 | #include <openssl/err.h> | ||
| 66 | #include <openssl/evp.h> | ||
| 67 | #include <openssl/objects.h> | ||
| 68 | |||
| 69 | #ifndef OPENSSL_NO_DSA | ||
| 70 | #include <openssl/dsa.h> | ||
| 71 | #endif | ||
| 72 | #ifndef OPENSSL_NO_EC | ||
| 73 | #include <openssl/ec.h> | ||
| 74 | #endif | ||
| 75 | #ifndef OPENSSL_NO_RSA | ||
| 76 | #include <openssl/rsa.h> | ||
| 77 | #endif | ||
| 78 | |||
| 79 | EVP_PKEY * | ||
| 80 | d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp, long length) | ||
| 81 | { | ||
| 82 | EVP_PKEY *ret; | ||
| 83 | |||
| 84 | if ((a == NULL) || (*a == NULL)) { | ||
| 85 | if ((ret = EVP_PKEY_new()) == NULL) { | ||
| 86 | ASN1err(ASN1_F_D2I_PUBLICKEY, ERR_R_EVP_LIB); | ||
| 87 | return (NULL); | ||
| 88 | } | ||
| 89 | } else | ||
| 90 | ret = *a; | ||
| 91 | |||
| 92 | if (!EVP_PKEY_set_type(ret, type)) { | ||
| 93 | ASN1err(ASN1_F_D2I_PUBLICKEY, ERR_R_EVP_LIB); | ||
| 94 | goto err; | ||
| 95 | } | ||
| 96 | |||
| 97 | switch (EVP_PKEY_id(ret)) { | ||
| 98 | #ifndef OPENSSL_NO_RSA | ||
| 99 | case EVP_PKEY_RSA: | ||
| 100 | if ((ret->pkey.rsa = d2i_RSAPublicKey(NULL, pp, length)) == | ||
| 101 | NULL) { | ||
| 102 | ASN1err(ASN1_F_D2I_PUBLICKEY, ERR_R_ASN1_LIB); | ||
| 103 | goto err; | ||
| 104 | } | ||
| 105 | break; | ||
| 106 | #endif | ||
| 107 | #ifndef OPENSSL_NO_DSA | ||
| 108 | case EVP_PKEY_DSA: | ||
| 109 | if (!d2i_DSAPublicKey(&(ret->pkey.dsa), pp, length)) { | ||
| 110 | ASN1err(ASN1_F_D2I_PUBLICKEY, ERR_R_ASN1_LIB); | ||
| 111 | goto err; | ||
| 112 | } | ||
| 113 | break; | ||
| 114 | #endif | ||
| 115 | #ifndef OPENSSL_NO_EC | ||
| 116 | case EVP_PKEY_EC: | ||
| 117 | if (!o2i_ECPublicKey(&(ret->pkey.ec), pp, length)) { | ||
| 118 | ASN1err(ASN1_F_D2I_PUBLICKEY, ERR_R_ASN1_LIB); | ||
| 119 | goto err; | ||
| 120 | } | ||
| 121 | break; | ||
| 122 | #endif | ||
| 123 | default: | ||
| 124 | ASN1err(ASN1_F_D2I_PUBLICKEY, ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE); | ||
| 125 | goto err; | ||
| 126 | /* break; */ | ||
| 127 | } | ||
| 128 | if (a != NULL) | ||
| 129 | (*a) = ret; | ||
| 130 | return (ret); | ||
| 131 | |||
| 132 | err: | ||
| 133 | if (a == NULL || *a != ret) | ||
| 134 | EVP_PKEY_free(ret); | ||
| 135 | return (NULL); | ||
| 136 | } | ||
diff --git a/src/lib/libcrypto/asn1/evp_asn1.c b/src/lib/libcrypto/asn1/evp_asn1.c deleted file mode 100644 index 5ee4751763..0000000000 --- a/src/lib/libcrypto/asn1/evp_asn1.c +++ /dev/null | |||
| @@ -1,199 +0,0 @@ | |||
| 1 | /* $OpenBSD: evp_asn1.c,v 1.14 2015/07/29 14:58:34 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1.h> | ||
| 63 | #include <openssl/asn1_mac.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | |||
| 66 | int | ||
| 67 | ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len) | ||
| 68 | { | ||
| 69 | ASN1_STRING *os; | ||
| 70 | |||
| 71 | if ((os = M_ASN1_OCTET_STRING_new()) == NULL) | ||
| 72 | return (0); | ||
| 73 | if (!ASN1_STRING_set(os, data, len)) { | ||
| 74 | M_ASN1_OCTET_STRING_free(os); | ||
| 75 | return (0); | ||
| 76 | } | ||
| 77 | ASN1_TYPE_set(a, V_ASN1_OCTET_STRING, os); | ||
| 78 | return (1); | ||
| 79 | } | ||
| 80 | |||
| 81 | /* int max_len: for returned value */ | ||
| 82 | int | ||
| 83 | ASN1_TYPE_get_octetstring(ASN1_TYPE *a, unsigned char *data, int max_len) | ||
| 84 | { | ||
| 85 | int ret, num; | ||
| 86 | unsigned char *p; | ||
| 87 | |||
| 88 | if ((a->type != V_ASN1_OCTET_STRING) || | ||
| 89 | (a->value.octet_string == NULL)) { | ||
| 90 | ASN1err(ASN1_F_ASN1_TYPE_GET_OCTETSTRING, ASN1_R_DATA_IS_WRONG); | ||
| 91 | return (-1); | ||
| 92 | } | ||
| 93 | p = M_ASN1_STRING_data(a->value.octet_string); | ||
| 94 | ret = M_ASN1_STRING_length(a->value.octet_string); | ||
| 95 | if (ret < max_len) | ||
| 96 | num = ret; | ||
| 97 | else | ||
| 98 | num = max_len; | ||
| 99 | memcpy(data, p, num); | ||
| 100 | return (ret); | ||
| 101 | } | ||
| 102 | |||
| 103 | int | ||
| 104 | ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, unsigned char *data, | ||
| 105 | int len) | ||
| 106 | { | ||
| 107 | int n, size; | ||
| 108 | ASN1_OCTET_STRING os, *osp; | ||
| 109 | ASN1_INTEGER in; | ||
| 110 | unsigned char *p; | ||
| 111 | unsigned char buf[32]; /* when they have 256bit longs, | ||
| 112 | * I'll be in trouble */ | ||
| 113 | in.data = buf; | ||
| 114 | in.length = 32; | ||
| 115 | os.data = data; | ||
| 116 | os.type = V_ASN1_OCTET_STRING; | ||
| 117 | os.length = len; | ||
| 118 | ASN1_INTEGER_set(&in, num); | ||
| 119 | n = i2d_ASN1_INTEGER(&in, NULL); | ||
| 120 | n += M_i2d_ASN1_OCTET_STRING(&os, NULL); | ||
| 121 | |||
| 122 | size = ASN1_object_size(1, n, V_ASN1_SEQUENCE); | ||
| 123 | |||
| 124 | if ((osp = ASN1_STRING_new()) == NULL) | ||
| 125 | return (0); | ||
| 126 | /* Grow the 'string' */ | ||
| 127 | if (!ASN1_STRING_set(osp, NULL, size)) { | ||
| 128 | ASN1_STRING_free(osp); | ||
| 129 | return (0); | ||
| 130 | } | ||
| 131 | |||
| 132 | M_ASN1_STRING_length_set(osp, size); | ||
| 133 | p = M_ASN1_STRING_data(osp); | ||
| 134 | |||
| 135 | ASN1_put_object(&p, 1,n, V_ASN1_SEQUENCE, V_ASN1_UNIVERSAL); | ||
| 136 | i2d_ASN1_INTEGER(&in, &p); | ||
| 137 | M_i2d_ASN1_OCTET_STRING(&os, &p); | ||
| 138 | |||
| 139 | ASN1_TYPE_set(a, V_ASN1_SEQUENCE, osp); | ||
| 140 | return (1); | ||
| 141 | } | ||
| 142 | |||
| 143 | /* we return the actual length..., num may be missing, in which | ||
| 144 | * case, set it to zero */ | ||
| 145 | /* int max_len: for returned value */ | ||
| 146 | int | ||
| 147 | ASN1_TYPE_get_int_octetstring(ASN1_TYPE *a, long *num, unsigned char *data, | ||
| 148 | int max_len) | ||
| 149 | { | ||
| 150 | int ret = -1, n; | ||
| 151 | ASN1_INTEGER *ai = NULL; | ||
| 152 | ASN1_OCTET_STRING *os = NULL; | ||
| 153 | const unsigned char *p; | ||
| 154 | long length; | ||
| 155 | ASN1_const_CTX c; | ||
| 156 | |||
| 157 | if ((a->type != V_ASN1_SEQUENCE) || (a->value.sequence == NULL)) { | ||
| 158 | goto err; | ||
| 159 | } | ||
| 160 | p = M_ASN1_STRING_data(a->value.sequence); | ||
| 161 | length = M_ASN1_STRING_length(a->value.sequence); | ||
| 162 | |||
| 163 | c.pp = &p; | ||
| 164 | c.p = p; | ||
| 165 | c.max = p + length; | ||
| 166 | c.error = ASN1_R_DATA_IS_WRONG; | ||
| 167 | |||
| 168 | M_ASN1_D2I_start_sequence(); | ||
| 169 | c.q = c.p; | ||
| 170 | if ((ai = d2i_ASN1_INTEGER(NULL, &c.p, c.slen)) == NULL) | ||
| 171 | goto err; | ||
| 172 | c.slen -= (c.p - c.q); | ||
| 173 | c.q = c.p; | ||
| 174 | if ((os = d2i_ASN1_OCTET_STRING(NULL, &c.p, c.slen)) == NULL) | ||
| 175 | goto err; | ||
| 176 | c.slen -= (c.p - c.q); | ||
| 177 | if (!M_ASN1_D2I_end_sequence()) | ||
| 178 | goto err; | ||
| 179 | |||
| 180 | if (num != NULL) | ||
| 181 | *num = ASN1_INTEGER_get(ai); | ||
| 182 | |||
| 183 | ret = M_ASN1_STRING_length(os); | ||
| 184 | if (max_len > ret) | ||
| 185 | n = ret; | ||
| 186 | else | ||
| 187 | n = max_len; | ||
| 188 | |||
| 189 | if (data != NULL) | ||
| 190 | memcpy(data, M_ASN1_STRING_data(os), n); | ||
| 191 | if (0) { | ||
| 192 | err: | ||
| 193 | ASN1err(ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING, | ||
| 194 | ASN1_R_DATA_IS_WRONG); | ||
| 195 | } | ||
| 196 | M_ASN1_OCTET_STRING_free(os); | ||
| 197 | M_ASN1_INTEGER_free(ai); | ||
| 198 | return (ret); | ||
| 199 | } | ||
diff --git a/src/lib/libcrypto/asn1/f_enum.c b/src/lib/libcrypto/asn1/f_enum.c deleted file mode 100644 index 7f064edb04..0000000000 --- a/src/lib/libcrypto/asn1/f_enum.c +++ /dev/null | |||
| @@ -1,201 +0,0 @@ | |||
| 1 | /* $OpenBSD: f_enum.c,v 1.14 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/buffer.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | |||
| 65 | /* Based on a_int.c: equivalent ENUMERATED functions */ | ||
| 66 | |||
| 67 | int | ||
| 68 | i2a_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *a) | ||
| 69 | { | ||
| 70 | int i, n = 0; | ||
| 71 | static const char h[] = "0123456789ABCDEF"; | ||
| 72 | char buf[2]; | ||
| 73 | |||
| 74 | if (a == NULL) | ||
| 75 | return (0); | ||
| 76 | |||
| 77 | if (a->length == 0) { | ||
| 78 | if (BIO_write(bp, "00", 2) != 2) | ||
| 79 | goto err; | ||
| 80 | n = 2; | ||
| 81 | } else { | ||
| 82 | for (i = 0; i < a->length; i++) { | ||
| 83 | if ((i != 0) && (i % 35 == 0)) { | ||
| 84 | if (BIO_write(bp, "\\\n", 2) != 2) | ||
| 85 | goto err; | ||
| 86 | n += 2; | ||
| 87 | } | ||
| 88 | buf[0] = h[((unsigned char)a->data[i] >> 4) & 0x0f]; | ||
| 89 | buf[1] = h[((unsigned char)a->data[i]) & 0x0f]; | ||
| 90 | if (BIO_write(bp, buf, 2) != 2) | ||
| 91 | goto err; | ||
| 92 | n += 2; | ||
| 93 | } | ||
| 94 | } | ||
| 95 | return (n); | ||
| 96 | |||
| 97 | err: | ||
| 98 | return (-1); | ||
| 99 | } | ||
| 100 | |||
| 101 | int | ||
| 102 | a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size) | ||
| 103 | { | ||
| 104 | int ret = 0; | ||
| 105 | int i, j,k, m,n, again, bufsize; | ||
| 106 | unsigned char *s = NULL, *sp; | ||
| 107 | unsigned char *bufp; | ||
| 108 | int first = 1; | ||
| 109 | size_t num = 0, slen = 0; | ||
| 110 | |||
| 111 | bs->type = V_ASN1_ENUMERATED; | ||
| 112 | |||
| 113 | bufsize = BIO_gets(bp, buf, size); | ||
| 114 | for (;;) { | ||
| 115 | if (bufsize < 1) | ||
| 116 | goto err_sl; | ||
| 117 | i = bufsize; | ||
| 118 | if (buf[i-1] == '\n') | ||
| 119 | buf[--i] = '\0'; | ||
| 120 | if (i == 0) | ||
| 121 | goto err_sl; | ||
| 122 | if (buf[i-1] == '\r') | ||
| 123 | buf[--i] = '\0'; | ||
| 124 | if (i == 0) | ||
| 125 | goto err_sl; | ||
| 126 | again = (buf[i - 1] == '\\'); | ||
| 127 | |||
| 128 | for (j = 0; j < i; j++) { | ||
| 129 | if (!(((buf[j] >= '0') && (buf[j] <= '9')) || | ||
| 130 | ((buf[j] >= 'a') && (buf[j] <= 'f')) || | ||
| 131 | ((buf[j] >= 'A') && (buf[j] <= 'F')))) { | ||
| 132 | i = j; | ||
| 133 | break; | ||
| 134 | } | ||
| 135 | } | ||
| 136 | buf[i] = '\0'; | ||
| 137 | /* We have now cleared all the crap off the end of the | ||
| 138 | * line */ | ||
| 139 | if (i < 2) | ||
| 140 | goto err_sl; | ||
| 141 | |||
| 142 | bufp = (unsigned char *)buf; | ||
| 143 | if (first) { | ||
| 144 | first = 0; | ||
| 145 | if ((bufp[0] == '0') && (buf[1] == '0')) { | ||
| 146 | bufp += 2; | ||
| 147 | i -= 2; | ||
| 148 | } | ||
| 149 | } | ||
| 150 | k = 0; | ||
| 151 | i -= again; | ||
| 152 | if (i % 2 != 0) { | ||
| 153 | ASN1err(ASN1_F_A2I_ASN1_ENUMERATED, | ||
| 154 | ASN1_R_ODD_NUMBER_OF_CHARS); | ||
| 155 | goto err; | ||
| 156 | } | ||
| 157 | i /= 2; | ||
| 158 | if (num + i > slen) { | ||
| 159 | sp = realloc(s, num + i); | ||
| 160 | if (sp == NULL) { | ||
| 161 | ASN1err(ASN1_F_A2I_ASN1_ENUMERATED, | ||
| 162 | ERR_R_MALLOC_FAILURE); | ||
| 163 | goto err; | ||
| 164 | } | ||
| 165 | s = sp; | ||
| 166 | slen = num + i; | ||
| 167 | } | ||
| 168 | for (j = 0; j < i; j++, k += 2) { | ||
| 169 | for (n = 0; n < 2; n++) { | ||
| 170 | m = bufp[k + n]; | ||
| 171 | if ((m >= '0') && (m <= '9')) | ||
| 172 | m -= '0'; | ||
| 173 | else if ((m >= 'a') && (m <= 'f')) | ||
| 174 | m = m - 'a' + 10; | ||
| 175 | else if ((m >= 'A') && (m <= 'F')) | ||
| 176 | m = m - 'A' + 10; | ||
| 177 | else { | ||
| 178 | ASN1err(ASN1_F_A2I_ASN1_ENUMERATED, | ||
| 179 | ASN1_R_NON_HEX_CHARACTERS); | ||
| 180 | goto err; | ||
| 181 | } | ||
| 182 | s[num + j] <<= 4; | ||
| 183 | s[num + j] |= m; | ||
| 184 | } | ||
| 185 | } | ||
| 186 | num += i; | ||
| 187 | if (again) | ||
| 188 | bufsize = BIO_gets(bp, buf, size); | ||
| 189 | else | ||
| 190 | break; | ||
| 191 | } | ||
| 192 | bs->length = num; | ||
| 193 | bs->data = s; | ||
| 194 | return (1); | ||
| 195 | |||
| 196 | err_sl: | ||
| 197 | ASN1err(ASN1_F_A2I_ASN1_ENUMERATED, ASN1_R_SHORT_LINE); | ||
| 198 | err: | ||
| 199 | free(s); | ||
| 200 | return (ret); | ||
| 201 | } | ||
diff --git a/src/lib/libcrypto/asn1/f_int.c b/src/lib/libcrypto/asn1/f_int.c deleted file mode 100644 index 0ec29f5769..0000000000 --- a/src/lib/libcrypto/asn1/f_int.c +++ /dev/null | |||
| @@ -1,204 +0,0 @@ | |||
| 1 | /* $OpenBSD: f_int.c,v 1.17 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/buffer.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | |||
| 65 | int | ||
| 66 | i2a_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *a) | ||
| 67 | { | ||
| 68 | int i, n = 0; | ||
| 69 | static const char h[] = "0123456789ABCDEF"; | ||
| 70 | char buf[2]; | ||
| 71 | |||
| 72 | if (a == NULL) | ||
| 73 | return (0); | ||
| 74 | |||
| 75 | if (a->type & V_ASN1_NEG) { | ||
| 76 | if (BIO_write(bp, "-", 1) != 1) | ||
| 77 | goto err; | ||
| 78 | n = 1; | ||
| 79 | } | ||
| 80 | |||
| 81 | if (a->length == 0) { | ||
| 82 | if (BIO_write(bp, "00", 2) != 2) | ||
| 83 | goto err; | ||
| 84 | n += 2; | ||
| 85 | } else { | ||
| 86 | for (i = 0; i < a->length; i++) { | ||
| 87 | if ((i != 0) && (i % 35 == 0)) { | ||
| 88 | if (BIO_write(bp, "\\\n", 2) != 2) | ||
| 89 | goto err; | ||
| 90 | n += 2; | ||
| 91 | } | ||
| 92 | buf[0] = h[((unsigned char)a->data[i] >> 4) & 0x0f]; | ||
| 93 | buf[1] = h[((unsigned char)a->data[i]) & 0x0f]; | ||
| 94 | if (BIO_write(bp, buf, 2) != 2) | ||
| 95 | goto err; | ||
| 96 | n += 2; | ||
| 97 | } | ||
| 98 | } | ||
| 99 | return (n); | ||
| 100 | |||
| 101 | err: | ||
| 102 | return (-1); | ||
| 103 | } | ||
| 104 | |||
| 105 | int | ||
| 106 | a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size) | ||
| 107 | { | ||
| 108 | int ret = 0; | ||
| 109 | int i, j,k, m,n, again, bufsize; | ||
| 110 | unsigned char *s = NULL, *sp; | ||
| 111 | unsigned char *bufp; | ||
| 112 | int num = 0, slen = 0, first = 1; | ||
| 113 | |||
| 114 | bs->type = V_ASN1_INTEGER; | ||
| 115 | |||
| 116 | bufsize = BIO_gets(bp, buf, size); | ||
| 117 | for (;;) { | ||
| 118 | if (bufsize < 1) | ||
| 119 | goto err_sl; | ||
| 120 | i = bufsize; | ||
| 121 | if (buf[i - 1] == '\n') | ||
| 122 | buf[--i] = '\0'; | ||
| 123 | if (i == 0) | ||
| 124 | goto err_sl; | ||
| 125 | if (buf[i - 1] == '\r') | ||
| 126 | buf[--i] = '\0'; | ||
| 127 | if (i == 0) | ||
| 128 | goto err_sl; | ||
| 129 | again = (buf[i - 1] == '\\'); | ||
| 130 | |||
| 131 | for (j = 0; j < i; j++) { | ||
| 132 | if (!(((buf[j] >= '0') && (buf[j] <= '9')) || | ||
| 133 | ((buf[j] >= 'a') && (buf[j] <= 'f')) || | ||
| 134 | ((buf[j] >= 'A') && (buf[j] <= 'F')))) { | ||
| 135 | i = j; | ||
| 136 | break; | ||
| 137 | } | ||
| 138 | } | ||
| 139 | buf[i] = '\0'; | ||
| 140 | /* We have now cleared all the crap off the end of the | ||
| 141 | * line */ | ||
| 142 | if (i < 2) | ||
| 143 | goto err_sl; | ||
| 144 | |||
| 145 | bufp = (unsigned char *)buf; | ||
| 146 | if (first) { | ||
| 147 | first = 0; | ||
| 148 | if ((bufp[0] == '0') && (buf[1] == '0')) { | ||
| 149 | bufp += 2; | ||
| 150 | i -= 2; | ||
| 151 | } | ||
| 152 | } | ||
| 153 | k = 0; | ||
| 154 | i -= again; | ||
| 155 | if (i % 2 != 0) { | ||
| 156 | ASN1err(ASN1_F_A2I_ASN1_INTEGER, | ||
| 157 | ASN1_R_ODD_NUMBER_OF_CHARS); | ||
| 158 | goto err; | ||
| 159 | } | ||
| 160 | i /= 2; | ||
| 161 | if (num + i > slen) { | ||
| 162 | sp = OPENSSL_realloc_clean(s, slen, num + i); | ||
| 163 | if (sp == NULL) { | ||
| 164 | ASN1err(ASN1_F_A2I_ASN1_INTEGER, | ||
| 165 | ERR_R_MALLOC_FAILURE); | ||
| 166 | goto err; | ||
| 167 | } | ||
| 168 | s = sp; | ||
| 169 | slen = num + i; | ||
| 170 | } | ||
| 171 | for (j = 0; j < i; j++, k += 2) { | ||
| 172 | for (n = 0; n < 2; n++) { | ||
| 173 | m = bufp[k + n]; | ||
| 174 | if ((m >= '0') && (m <= '9')) | ||
| 175 | m -= '0'; | ||
| 176 | else if ((m >= 'a') && (m <= 'f')) | ||
| 177 | m = m - 'a' + 10; | ||
| 178 | else if ((m >= 'A') && (m <= 'F')) | ||
| 179 | m = m - 'A' + 10; | ||
| 180 | else { | ||
| 181 | ASN1err(ASN1_F_A2I_ASN1_INTEGER, | ||
| 182 | ASN1_R_NON_HEX_CHARACTERS); | ||
| 183 | goto err; | ||
| 184 | } | ||
| 185 | s[num + j] <<= 4; | ||
| 186 | s[num + j] |= m; | ||
| 187 | } | ||
| 188 | } | ||
| 189 | num += i; | ||
| 190 | if (again) | ||
| 191 | bufsize = BIO_gets(bp, buf, size); | ||
| 192 | else | ||
| 193 | break; | ||
| 194 | } | ||
| 195 | bs->length = num; | ||
| 196 | bs->data = s; | ||
| 197 | return (1); | ||
| 198 | |||
| 199 | err_sl: | ||
| 200 | ASN1err(ASN1_F_A2I_ASN1_INTEGER, ASN1_R_SHORT_LINE); | ||
| 201 | err: | ||
| 202 | free(s); | ||
| 203 | return (ret); | ||
| 204 | } | ||
diff --git a/src/lib/libcrypto/asn1/f_string.c b/src/lib/libcrypto/asn1/f_string.c deleted file mode 100644 index 14cd1a906a..0000000000 --- a/src/lib/libcrypto/asn1/f_string.c +++ /dev/null | |||
| @@ -1,197 +0,0 @@ | |||
| 1 | /* $OpenBSD: f_string.c,v 1.16 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/buffer.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | |||
| 65 | int | ||
| 66 | i2a_ASN1_STRING(BIO *bp, ASN1_STRING *a, int type) | ||
| 67 | { | ||
| 68 | int i, n = 0; | ||
| 69 | static const char h[] = "0123456789ABCDEF"; | ||
| 70 | char buf[2]; | ||
| 71 | |||
| 72 | if (a == NULL) | ||
| 73 | return (0); | ||
| 74 | |||
| 75 | if (a->length == 0) { | ||
| 76 | if (BIO_write(bp, "0", 1) != 1) | ||
| 77 | goto err; | ||
| 78 | n = 1; | ||
| 79 | } else { | ||
| 80 | for (i = 0; i < a->length; i++) { | ||
| 81 | if ((i != 0) && (i % 35 == 0)) { | ||
| 82 | if (BIO_write(bp, "\\\n", 2) != 2) | ||
| 83 | goto err; | ||
| 84 | n += 2; | ||
| 85 | } | ||
| 86 | buf[0] = h[((unsigned char)a->data[i] >> 4) & 0x0f]; | ||
| 87 | buf[1] = h[((unsigned char)a->data[i]) & 0x0f]; | ||
| 88 | if (BIO_write(bp, buf, 2) != 2) | ||
| 89 | goto err; | ||
| 90 | n += 2; | ||
| 91 | } | ||
| 92 | } | ||
| 93 | return (n); | ||
| 94 | |||
| 95 | err: | ||
| 96 | return (-1); | ||
| 97 | } | ||
| 98 | |||
| 99 | int | ||
| 100 | a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size) | ||
| 101 | { | ||
| 102 | int ret = 0; | ||
| 103 | int i, j, k, m, n, again, bufsize; | ||
| 104 | unsigned char *s = NULL, *sp; | ||
| 105 | unsigned char *bufp; | ||
| 106 | int first = 1; | ||
| 107 | size_t num = 0, slen = 0; | ||
| 108 | |||
| 109 | bufsize = BIO_gets(bp, buf, size); | ||
| 110 | for (;;) { | ||
| 111 | if (bufsize < 1) { | ||
| 112 | if (first) | ||
| 113 | break; | ||
| 114 | else | ||
| 115 | goto err_sl; | ||
| 116 | } | ||
| 117 | first = 0; | ||
| 118 | |||
| 119 | i = bufsize; | ||
| 120 | if (buf[i-1] == '\n') | ||
| 121 | buf[--i] = '\0'; | ||
| 122 | if (i == 0) | ||
| 123 | goto err_sl; | ||
| 124 | if (buf[i-1] == '\r') | ||
| 125 | buf[--i] = '\0'; | ||
| 126 | if (i == 0) | ||
| 127 | goto err_sl; | ||
| 128 | again = (buf[i - 1] == '\\'); | ||
| 129 | |||
| 130 | for (j = i - 1; j > 0; j--) { | ||
| 131 | if (!(((buf[j] >= '0') && (buf[j] <= '9')) || | ||
| 132 | ((buf[j] >= 'a') && (buf[j] <= 'f')) || | ||
| 133 | ((buf[j] >= 'A') && (buf[j] <= 'F')))) { | ||
| 134 | i = j; | ||
| 135 | break; | ||
| 136 | } | ||
| 137 | } | ||
| 138 | buf[i] = '\0'; | ||
| 139 | /* We have now cleared all the crap off the end of the | ||
| 140 | * line */ | ||
| 141 | if (i < 2) | ||
| 142 | goto err_sl; | ||
| 143 | |||
| 144 | bufp = (unsigned char *)buf; | ||
| 145 | |||
| 146 | k = 0; | ||
| 147 | i -= again; | ||
| 148 | if (i % 2 != 0) { | ||
| 149 | ASN1err(ASN1_F_A2I_ASN1_STRING, | ||
| 150 | ASN1_R_ODD_NUMBER_OF_CHARS); | ||
| 151 | goto err; | ||
| 152 | } | ||
| 153 | i /= 2; | ||
| 154 | if (num + i > slen) { | ||
| 155 | sp = realloc(s, num + i); | ||
| 156 | if (sp == NULL) { | ||
| 157 | ASN1err(ASN1_F_A2I_ASN1_STRING, | ||
| 158 | ERR_R_MALLOC_FAILURE); | ||
| 159 | goto err; | ||
| 160 | } | ||
| 161 | s = sp; | ||
| 162 | slen = num + i; | ||
| 163 | } | ||
| 164 | for (j = 0; j < i; j++, k += 2) { | ||
| 165 | for (n = 0; n < 2; n++) { | ||
| 166 | m = bufp[k + n]; | ||
| 167 | if ((m >= '0') && (m <= '9')) | ||
| 168 | m -= '0'; | ||
| 169 | else if ((m >= 'a') && (m <= 'f')) | ||
| 170 | m = m - 'a' + 10; | ||
| 171 | else if ((m >= 'A') && (m <= 'F')) | ||
| 172 | m = m - 'A' + 10; | ||
| 173 | else { | ||
| 174 | ASN1err(ASN1_F_A2I_ASN1_STRING, | ||
| 175 | ASN1_R_NON_HEX_CHARACTERS); | ||
| 176 | goto err; | ||
| 177 | } | ||
| 178 | s[num + j] <<= 4; | ||
| 179 | s[num + j] |= m; | ||
| 180 | } | ||
| 181 | } | ||
| 182 | num += i; | ||
| 183 | if (again) | ||
| 184 | bufsize = BIO_gets(bp, buf, size); | ||
| 185 | else | ||
| 186 | break; | ||
| 187 | } | ||
| 188 | bs->length = num; | ||
| 189 | bs->data = s; | ||
| 190 | return (1); | ||
| 191 | |||
| 192 | err_sl: | ||
| 193 | ASN1err(ASN1_F_A2I_ASN1_STRING, ASN1_R_SHORT_LINE); | ||
| 194 | err: | ||
| 195 | free(s); | ||
| 196 | return (ret); | ||
| 197 | } | ||
diff --git a/src/lib/libcrypto/asn1/i2d_pr.c b/src/lib/libcrypto/asn1/i2d_pr.c deleted file mode 100644 index 5fa34678b6..0000000000 --- a/src/lib/libcrypto/asn1/i2d_pr.c +++ /dev/null | |||
| @@ -1,81 +0,0 @@ | |||
| 1 | /* $OpenBSD: i2d_pr.c,v 1.10 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/err.h> | ||
| 62 | #include <openssl/evp.h> | ||
| 63 | #include <openssl/x509.h> | ||
| 64 | |||
| 65 | #include "asn1_locl.h" | ||
| 66 | |||
| 67 | int | ||
| 68 | i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp) | ||
| 69 | { | ||
| 70 | if (a->ameth && a->ameth->old_priv_encode) { | ||
| 71 | return a->ameth->old_priv_encode(a, pp); | ||
| 72 | } | ||
| 73 | if (a->ameth && a->ameth->priv_encode) { | ||
| 74 | PKCS8_PRIV_KEY_INFO *p8 = EVP_PKEY2PKCS8(a); | ||
| 75 | int ret = i2d_PKCS8_PRIV_KEY_INFO(p8, pp); | ||
| 76 | PKCS8_PRIV_KEY_INFO_free(p8); | ||
| 77 | return ret; | ||
| 78 | } | ||
| 79 | ASN1err(ASN1_F_I2D_PRIVATEKEY, ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE); | ||
| 80 | return (-1); | ||
| 81 | } | ||
diff --git a/src/lib/libcrypto/asn1/i2d_pu.c b/src/lib/libcrypto/asn1/i2d_pu.c deleted file mode 100644 index 6e485ea325..0000000000 --- a/src/lib/libcrypto/asn1/i2d_pu.c +++ /dev/null | |||
| @@ -1,98 +0,0 @@ | |||
| 1 | /* $OpenBSD: i2d_pu.c,v 1.10 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/bn.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/evp.h> | ||
| 66 | #include <openssl/objects.h> | ||
| 67 | |||
| 68 | #ifndef OPENSSL_NO_DSA | ||
| 69 | #include <openssl/dsa.h> | ||
| 70 | #endif | ||
| 71 | #ifndef OPENSSL_NO_EC | ||
| 72 | #include <openssl/ec.h> | ||
| 73 | #endif | ||
| 74 | #ifndef OPENSSL_NO_RSA | ||
| 75 | #include <openssl/rsa.h> | ||
| 76 | #endif | ||
| 77 | |||
| 78 | int | ||
| 79 | i2d_PublicKey(EVP_PKEY *a, unsigned char **pp) | ||
| 80 | { | ||
| 81 | switch (a->type) { | ||
| 82 | #ifndef OPENSSL_NO_RSA | ||
| 83 | case EVP_PKEY_RSA: | ||
| 84 | return (i2d_RSAPublicKey(a->pkey.rsa, pp)); | ||
| 85 | #endif | ||
| 86 | #ifndef OPENSSL_NO_DSA | ||
| 87 | case EVP_PKEY_DSA: | ||
| 88 | return (i2d_DSAPublicKey(a->pkey.dsa, pp)); | ||
| 89 | #endif | ||
| 90 | #ifndef OPENSSL_NO_EC | ||
| 91 | case EVP_PKEY_EC: | ||
| 92 | return (i2o_ECPublicKey(a->pkey.ec, pp)); | ||
| 93 | #endif | ||
| 94 | default: | ||
| 95 | ASN1err(ASN1_F_I2D_PUBLICKEY, ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE); | ||
| 96 | return (-1); | ||
| 97 | } | ||
| 98 | } | ||
diff --git a/src/lib/libcrypto/asn1/n_pkey.c b/src/lib/libcrypto/asn1/n_pkey.c deleted file mode 100644 index d3a7431356..0000000000 --- a/src/lib/libcrypto/asn1/n_pkey.c +++ /dev/null | |||
| @@ -1,430 +0,0 @@ | |||
| 1 | /* $OpenBSD: n_pkey.c,v 1.26 2015/03/19 14:00:22 tedu Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/opensslconf.h> | ||
| 63 | |||
| 64 | #ifndef OPENSSL_NO_RSA | ||
| 65 | #include <openssl/asn1t.h> | ||
| 66 | #include <openssl/err.h> | ||
| 67 | #include <openssl/evp.h> | ||
| 68 | #include <openssl/objects.h> | ||
| 69 | #include <openssl/rsa.h> | ||
| 70 | #include <openssl/x509.h> | ||
| 71 | |||
| 72 | #ifndef OPENSSL_NO_RC4 | ||
| 73 | |||
| 74 | typedef struct netscape_pkey_st { | ||
| 75 | long version; | ||
| 76 | X509_ALGOR *algor; | ||
| 77 | ASN1_OCTET_STRING *private_key; | ||
| 78 | } NETSCAPE_PKEY; | ||
| 79 | |||
| 80 | typedef struct netscape_encrypted_pkey_st { | ||
| 81 | ASN1_OCTET_STRING *os; | ||
| 82 | /* This is the same structure as DigestInfo so use it: | ||
| 83 | * although this isn't really anything to do with | ||
| 84 | * digests. | ||
| 85 | */ | ||
| 86 | X509_SIG *enckey; | ||
| 87 | } NETSCAPE_ENCRYPTED_PKEY; | ||
| 88 | |||
| 89 | |||
| 90 | static const ASN1_AUX NETSCAPE_ENCRYPTED_PKEY_aux = { | ||
| 91 | .flags = ASN1_AFLG_BROKEN, | ||
| 92 | }; | ||
| 93 | static const ASN1_TEMPLATE NETSCAPE_ENCRYPTED_PKEY_seq_tt[] = { | ||
| 94 | { | ||
| 95 | .offset = offsetof(NETSCAPE_ENCRYPTED_PKEY, os), | ||
| 96 | .field_name = "os", | ||
| 97 | .item = &ASN1_OCTET_STRING_it, | ||
| 98 | }, | ||
| 99 | { | ||
| 100 | .offset = offsetof(NETSCAPE_ENCRYPTED_PKEY, enckey), | ||
| 101 | .field_name = "enckey", | ||
| 102 | .item = &X509_SIG_it, | ||
| 103 | }, | ||
| 104 | }; | ||
| 105 | |||
| 106 | const ASN1_ITEM NETSCAPE_ENCRYPTED_PKEY_it = { | ||
| 107 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 108 | .utype = V_ASN1_SEQUENCE, | ||
| 109 | .templates = NETSCAPE_ENCRYPTED_PKEY_seq_tt, | ||
| 110 | .tcount = sizeof(NETSCAPE_ENCRYPTED_PKEY_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 111 | .funcs = &NETSCAPE_ENCRYPTED_PKEY_aux, | ||
| 112 | .size = sizeof(NETSCAPE_ENCRYPTED_PKEY), | ||
| 113 | .sname = "NETSCAPE_ENCRYPTED_PKEY", | ||
| 114 | }; | ||
| 115 | |||
| 116 | DECLARE_ASN1_FUNCTIONS_const(NETSCAPE_ENCRYPTED_PKEY) | ||
| 117 | DECLARE_ASN1_ENCODE_FUNCTIONS_const(NETSCAPE_ENCRYPTED_PKEY, NETSCAPE_ENCRYPTED_PKEY) | ||
| 118 | |||
| 119 | NETSCAPE_ENCRYPTED_PKEY * | ||
| 120 | d2i_NETSCAPE_ENCRYPTED_PKEY(NETSCAPE_ENCRYPTED_PKEY **a, const unsigned char **in, long len) | ||
| 121 | { | ||
| 122 | return (NETSCAPE_ENCRYPTED_PKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 123 | &NETSCAPE_ENCRYPTED_PKEY_it); | ||
| 124 | } | ||
| 125 | |||
| 126 | int | ||
| 127 | i2d_NETSCAPE_ENCRYPTED_PKEY(const NETSCAPE_ENCRYPTED_PKEY *a, unsigned char **out) | ||
| 128 | { | ||
| 129 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_ENCRYPTED_PKEY_it); | ||
| 130 | } | ||
| 131 | |||
| 132 | NETSCAPE_ENCRYPTED_PKEY * | ||
| 133 | NETSCAPE_ENCRYPTED_PKEY_new(void) | ||
| 134 | { | ||
| 135 | return (NETSCAPE_ENCRYPTED_PKEY *)ASN1_item_new(&NETSCAPE_ENCRYPTED_PKEY_it); | ||
| 136 | } | ||
| 137 | |||
| 138 | void | ||
| 139 | NETSCAPE_ENCRYPTED_PKEY_free(NETSCAPE_ENCRYPTED_PKEY *a) | ||
| 140 | { | ||
| 141 | ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_ENCRYPTED_PKEY_it); | ||
| 142 | } | ||
| 143 | |||
| 144 | static const ASN1_TEMPLATE NETSCAPE_PKEY_seq_tt[] = { | ||
| 145 | { | ||
| 146 | .offset = offsetof(NETSCAPE_PKEY, version), | ||
| 147 | .field_name = "version", | ||
| 148 | .item = &LONG_it, | ||
| 149 | }, | ||
| 150 | { | ||
| 151 | .offset = offsetof(NETSCAPE_PKEY, algor), | ||
| 152 | .field_name = "algor", | ||
| 153 | .item = &X509_ALGOR_it, | ||
| 154 | }, | ||
| 155 | { | ||
| 156 | .offset = offsetof(NETSCAPE_PKEY, private_key), | ||
| 157 | .field_name = "private_key", | ||
| 158 | .item = &ASN1_OCTET_STRING_it, | ||
| 159 | }, | ||
| 160 | }; | ||
| 161 | |||
| 162 | const ASN1_ITEM NETSCAPE_PKEY_it = { | ||
| 163 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 164 | .utype = V_ASN1_SEQUENCE, | ||
| 165 | .templates = NETSCAPE_PKEY_seq_tt, | ||
| 166 | .tcount = sizeof(NETSCAPE_PKEY_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 167 | .size = sizeof(NETSCAPE_PKEY), | ||
| 168 | .sname = "NETSCAPE_PKEY", | ||
| 169 | }; | ||
| 170 | |||
| 171 | DECLARE_ASN1_FUNCTIONS_const(NETSCAPE_PKEY) | ||
| 172 | DECLARE_ASN1_ENCODE_FUNCTIONS_const(NETSCAPE_PKEY, NETSCAPE_PKEY) | ||
| 173 | |||
| 174 | NETSCAPE_PKEY * | ||
| 175 | d2i_NETSCAPE_PKEY(NETSCAPE_PKEY **a, const unsigned char **in, long len) | ||
| 176 | { | ||
| 177 | return (NETSCAPE_PKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 178 | &NETSCAPE_PKEY_it); | ||
| 179 | } | ||
| 180 | |||
| 181 | int | ||
| 182 | i2d_NETSCAPE_PKEY(const NETSCAPE_PKEY *a, unsigned char **out) | ||
| 183 | { | ||
| 184 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_PKEY_it); | ||
| 185 | } | ||
| 186 | |||
| 187 | NETSCAPE_PKEY * | ||
| 188 | NETSCAPE_PKEY_new(void) | ||
| 189 | { | ||
| 190 | return (NETSCAPE_PKEY *)ASN1_item_new(&NETSCAPE_PKEY_it); | ||
| 191 | } | ||
| 192 | |||
| 193 | void | ||
| 194 | NETSCAPE_PKEY_free(NETSCAPE_PKEY *a) | ||
| 195 | { | ||
| 196 | ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_PKEY_it); | ||
| 197 | } | ||
| 198 | |||
| 199 | static RSA *d2i_RSA_NET_2(RSA **a, ASN1_OCTET_STRING *os, | ||
| 200 | int (*cb)(char *buf, int len, const char *prompt, int verify), int sgckey); | ||
| 201 | |||
| 202 | int | ||
| 203 | i2d_Netscape_RSA(const RSA *a, unsigned char **pp, | ||
| 204 | int (*cb)(char *buf, int len, const char *prompt, int verify)) | ||
| 205 | { | ||
| 206 | return i2d_RSA_NET(a, pp, cb, 0); | ||
| 207 | } | ||
| 208 | |||
| 209 | int | ||
| 210 | i2d_RSA_NET(const RSA *a, unsigned char **pp, | ||
| 211 | int (*cb)(char *buf, int len, const char *prompt, int verify), int sgckey) | ||
| 212 | { | ||
| 213 | int i, j, ret = 0; | ||
| 214 | int rsalen, pkeylen, olen; | ||
| 215 | NETSCAPE_PKEY *pkey = NULL; | ||
| 216 | NETSCAPE_ENCRYPTED_PKEY *enckey = NULL; | ||
| 217 | unsigned char buf[256], *zz; | ||
| 218 | unsigned char key[EVP_MAX_KEY_LENGTH]; | ||
| 219 | EVP_CIPHER_CTX ctx; | ||
| 220 | EVP_CIPHER_CTX_init(&ctx); | ||
| 221 | |||
| 222 | if (a == NULL) | ||
| 223 | return (0); | ||
| 224 | |||
| 225 | if ((pkey = NETSCAPE_PKEY_new()) == NULL) | ||
| 226 | goto err; | ||
| 227 | if ((enckey = NETSCAPE_ENCRYPTED_PKEY_new()) == NULL) | ||
| 228 | goto err; | ||
| 229 | pkey->version = 0; | ||
| 230 | |||
| 231 | pkey->algor->algorithm = OBJ_nid2obj(NID_rsaEncryption); | ||
| 232 | if ((pkey->algor->parameter = ASN1_TYPE_new()) == NULL) | ||
| 233 | goto err; | ||
| 234 | pkey->algor->parameter->type = V_ASN1_NULL; | ||
| 235 | |||
| 236 | rsalen = i2d_RSAPrivateKey(a, NULL); | ||
| 237 | |||
| 238 | /* Fake some octet strings just for the initial length | ||
| 239 | * calculation. | ||
| 240 | */ | ||
| 241 | pkey->private_key->length = rsalen; | ||
| 242 | pkeylen = i2d_NETSCAPE_PKEY(pkey, NULL); | ||
| 243 | enckey->enckey->digest->length = pkeylen; | ||
| 244 | enckey->os->length = 11; /* "private-key" */ | ||
| 245 | enckey->enckey->algor->algorithm = OBJ_nid2obj(NID_rc4); | ||
| 246 | if ((enckey->enckey->algor->parameter = ASN1_TYPE_new()) == NULL) | ||
| 247 | goto err; | ||
| 248 | enckey->enckey->algor->parameter->type = V_ASN1_NULL; | ||
| 249 | |||
| 250 | if (pp == NULL) { | ||
| 251 | olen = i2d_NETSCAPE_ENCRYPTED_PKEY(enckey, NULL); | ||
| 252 | NETSCAPE_PKEY_free(pkey); | ||
| 253 | NETSCAPE_ENCRYPTED_PKEY_free(enckey); | ||
| 254 | return olen; | ||
| 255 | } | ||
| 256 | |||
| 257 | /* Since its RC4 encrypted length is actual length */ | ||
| 258 | if ((zz = malloc(rsalen)) == NULL) { | ||
| 259 | ASN1err(ASN1_F_I2D_RSA_NET, ERR_R_MALLOC_FAILURE); | ||
| 260 | goto err; | ||
| 261 | } | ||
| 262 | |||
| 263 | pkey->private_key->data = zz; | ||
| 264 | /* Write out private key encoding */ | ||
| 265 | i2d_RSAPrivateKey(a, &zz); | ||
| 266 | |||
| 267 | if ((zz = malloc(pkeylen)) == NULL) { | ||
| 268 | ASN1err(ASN1_F_I2D_RSA_NET, ERR_R_MALLOC_FAILURE); | ||
| 269 | goto err; | ||
| 270 | } | ||
| 271 | |||
| 272 | if (!ASN1_STRING_set(enckey->os, "private-key", -1)) { | ||
| 273 | ASN1err(ASN1_F_I2D_RSA_NET, ERR_R_MALLOC_FAILURE); | ||
| 274 | goto err; | ||
| 275 | } | ||
| 276 | enckey->enckey->digest->data = zz; | ||
| 277 | i2d_NETSCAPE_PKEY(pkey, &zz); | ||
| 278 | |||
| 279 | /* Wipe the private key encoding */ | ||
| 280 | OPENSSL_cleanse(pkey->private_key->data, rsalen); | ||
| 281 | |||
| 282 | if (cb == NULL) | ||
| 283 | cb = EVP_read_pw_string; | ||
| 284 | i = cb((char *)buf, sizeof(buf), "Enter Private Key password:", 1); | ||
| 285 | if (i != 0) { | ||
| 286 | ASN1err(ASN1_F_I2D_RSA_NET, ASN1_R_BAD_PASSWORD_READ); | ||
| 287 | goto err; | ||
| 288 | } | ||
| 289 | i = strlen((char *)buf); | ||
| 290 | /* If the key is used for SGC the algorithm is modified a little. */ | ||
| 291 | if (sgckey) { | ||
| 292 | if (!EVP_Digest(buf, i, buf, NULL, EVP_md5(), NULL)) | ||
| 293 | goto err; | ||
| 294 | memcpy(buf + 16, "SGCKEYSALT", 10); | ||
| 295 | i = 26; | ||
| 296 | } | ||
| 297 | |||
| 298 | if (!EVP_BytesToKey(EVP_rc4(), EVP_md5(), NULL, buf, i,1, key, NULL)) | ||
| 299 | goto err; | ||
| 300 | OPENSSL_cleanse(buf, sizeof(buf)); | ||
| 301 | |||
| 302 | /* Encrypt private key in place */ | ||
| 303 | zz = enckey->enckey->digest->data; | ||
| 304 | if (!EVP_EncryptInit_ex(&ctx, EVP_rc4(), NULL, key, NULL)) | ||
| 305 | goto err; | ||
| 306 | if (!EVP_EncryptUpdate(&ctx, zz, &i, zz, pkeylen)) | ||
| 307 | goto err; | ||
| 308 | if (!EVP_EncryptFinal_ex(&ctx, zz + i, &j)) | ||
| 309 | goto err; | ||
| 310 | |||
| 311 | ret = i2d_NETSCAPE_ENCRYPTED_PKEY(enckey, pp); | ||
| 312 | err: | ||
| 313 | EVP_CIPHER_CTX_cleanup(&ctx); | ||
| 314 | NETSCAPE_ENCRYPTED_PKEY_free(enckey); | ||
| 315 | NETSCAPE_PKEY_free(pkey); | ||
| 316 | return (ret); | ||
| 317 | } | ||
| 318 | |||
| 319 | |||
| 320 | RSA * | ||
| 321 | d2i_Netscape_RSA(RSA **a, const unsigned char **pp, long length, | ||
| 322 | int (*cb)(char *buf, int len, const char *prompt, int verify)) | ||
| 323 | { | ||
| 324 | return d2i_RSA_NET(a, pp, length, cb, 0); | ||
| 325 | } | ||
| 326 | |||
| 327 | RSA * | ||
| 328 | d2i_RSA_NET(RSA **a, const unsigned char **pp, long length, | ||
| 329 | int (*cb)(char *buf, int len, const char *prompt, int verify), int sgckey) | ||
| 330 | { | ||
| 331 | RSA *ret = NULL; | ||
| 332 | const unsigned char *p; | ||
| 333 | NETSCAPE_ENCRYPTED_PKEY *enckey = NULL; | ||
| 334 | |||
| 335 | p = *pp; | ||
| 336 | |||
| 337 | enckey = d2i_NETSCAPE_ENCRYPTED_PKEY(NULL, &p, length); | ||
| 338 | if (!enckey) { | ||
| 339 | ASN1err(ASN1_F_D2I_RSA_NET, ASN1_R_DECODING_ERROR); | ||
| 340 | return NULL; | ||
| 341 | } | ||
| 342 | |||
| 343 | /* XXX 11 == strlen("private-key") */ | ||
| 344 | if (enckey->os->length != 11 || | ||
| 345 | memcmp("private-key", enckey->os->data, 11) != 0) { | ||
| 346 | ASN1err(ASN1_F_D2I_RSA_NET, ASN1_R_PRIVATE_KEY_HEADER_MISSING); | ||
| 347 | goto err; | ||
| 348 | } | ||
| 349 | if (OBJ_obj2nid(enckey->enckey->algor->algorithm) != NID_rc4) { | ||
| 350 | ASN1err(ASN1_F_D2I_RSA_NET, | ||
| 351 | ASN1_R_UNSUPPORTED_ENCRYPTION_ALGORITHM); | ||
| 352 | goto err; | ||
| 353 | } | ||
| 354 | if (cb == NULL) | ||
| 355 | cb = EVP_read_pw_string; | ||
| 356 | if ((ret = d2i_RSA_NET_2(a, enckey->enckey->digest, cb, | ||
| 357 | sgckey)) == NULL) | ||
| 358 | goto err; | ||
| 359 | |||
| 360 | *pp = p; | ||
| 361 | |||
| 362 | err: | ||
| 363 | NETSCAPE_ENCRYPTED_PKEY_free(enckey); | ||
| 364 | return ret; | ||
| 365 | |||
| 366 | } | ||
| 367 | |||
| 368 | static RSA * | ||
| 369 | d2i_RSA_NET_2(RSA **a, ASN1_OCTET_STRING *os, | ||
| 370 | int (*cb)(char *buf, int len, const char *prompt, int verify), int sgckey) | ||
| 371 | { | ||
| 372 | NETSCAPE_PKEY *pkey = NULL; | ||
| 373 | RSA *ret = NULL; | ||
| 374 | int i, j; | ||
| 375 | unsigned char buf[256]; | ||
| 376 | const unsigned char *zz; | ||
| 377 | unsigned char key[EVP_MAX_KEY_LENGTH]; | ||
| 378 | EVP_CIPHER_CTX ctx; | ||
| 379 | EVP_CIPHER_CTX_init(&ctx); | ||
| 380 | |||
| 381 | i=cb((char *)buf, sizeof(buf), "Enter Private Key password:",0); | ||
| 382 | if (i != 0) { | ||
| 383 | ASN1err(ASN1_F_D2I_RSA_NET_2, ASN1_R_BAD_PASSWORD_READ); | ||
| 384 | goto err; | ||
| 385 | } | ||
| 386 | |||
| 387 | i = strlen((char *)buf); | ||
| 388 | if (sgckey){ | ||
| 389 | if (!EVP_Digest(buf, i, buf, NULL, EVP_md5(), NULL)) | ||
| 390 | goto err; | ||
| 391 | memcpy(buf + 16, "SGCKEYSALT", 10); | ||
| 392 | i = 26; | ||
| 393 | } | ||
| 394 | |||
| 395 | if (!EVP_BytesToKey(EVP_rc4(), EVP_md5(), NULL, buf, i,1, key, NULL)) | ||
| 396 | goto err; | ||
| 397 | OPENSSL_cleanse(buf, sizeof(buf)); | ||
| 398 | |||
| 399 | if (!EVP_DecryptInit_ex(&ctx, EVP_rc4(), NULL, key, NULL)) | ||
| 400 | goto err; | ||
| 401 | if (!EVP_DecryptUpdate(&ctx, os->data, &i, os->data, os->length)) | ||
| 402 | goto err; | ||
| 403 | if (!EVP_DecryptFinal_ex(&ctx, &(os->data[i]), &j)) | ||
| 404 | goto err; | ||
| 405 | os->length = i + j; | ||
| 406 | |||
| 407 | zz = os->data; | ||
| 408 | |||
| 409 | if ((pkey = d2i_NETSCAPE_PKEY(NULL, &zz, os->length)) == NULL) { | ||
| 410 | ASN1err(ASN1_F_D2I_RSA_NET_2, | ||
| 411 | ASN1_R_UNABLE_TO_DECODE_RSA_PRIVATE_KEY); | ||
| 412 | goto err; | ||
| 413 | } | ||
| 414 | |||
| 415 | zz = pkey->private_key->data; | ||
| 416 | if ((ret = d2i_RSAPrivateKey(a, &zz, | ||
| 417 | pkey->private_key->length)) == NULL) { | ||
| 418 | ASN1err(ASN1_F_D2I_RSA_NET_2, ASN1_R_UNABLE_TO_DECODE_RSA_KEY); | ||
| 419 | goto err; | ||
| 420 | } | ||
| 421 | |||
| 422 | err: | ||
| 423 | EVP_CIPHER_CTX_cleanup(&ctx); | ||
| 424 | NETSCAPE_PKEY_free(pkey); | ||
| 425 | return (ret); | ||
| 426 | } | ||
| 427 | |||
| 428 | #endif /* OPENSSL_NO_RC4 */ | ||
| 429 | |||
| 430 | #endif | ||
diff --git a/src/lib/libcrypto/asn1/nsseq.c b/src/lib/libcrypto/asn1/nsseq.c deleted file mode 100644 index 8b39278692..0000000000 --- a/src/lib/libcrypto/asn1/nsseq.c +++ /dev/null | |||
| @@ -1,129 +0,0 @@ | |||
| 1 | /* $OpenBSD: nsseq.c,v 1.10 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 1999. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 1999-2005 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 | #include <stdio.h> | ||
| 60 | #include <stdlib.h> | ||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/x509.h> | ||
| 63 | #include <openssl/objects.h> | ||
| 64 | |||
| 65 | static int | ||
| 66 | nsseq_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) | ||
| 67 | { | ||
| 68 | if (operation == ASN1_OP_NEW_POST) { | ||
| 69 | NETSCAPE_CERT_SEQUENCE *nsseq; | ||
| 70 | nsseq = (NETSCAPE_CERT_SEQUENCE *)*pval; | ||
| 71 | nsseq->type = OBJ_nid2obj(NID_netscape_cert_sequence); | ||
| 72 | } | ||
| 73 | return 1; | ||
| 74 | } | ||
| 75 | |||
| 76 | /* Netscape certificate sequence structure */ | ||
| 77 | |||
| 78 | static const ASN1_AUX NETSCAPE_CERT_SEQUENCE_aux = { | ||
| 79 | .asn1_cb = nsseq_cb, | ||
| 80 | }; | ||
| 81 | static const ASN1_TEMPLATE NETSCAPE_CERT_SEQUENCE_seq_tt[] = { | ||
| 82 | { | ||
| 83 | .offset = offsetof(NETSCAPE_CERT_SEQUENCE, type), | ||
| 84 | .field_name = "type", | ||
| 85 | .item = &ASN1_OBJECT_it, | ||
| 86 | }, | ||
| 87 | { | ||
| 88 | .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL, | ||
| 89 | .offset = offsetof(NETSCAPE_CERT_SEQUENCE, certs), | ||
| 90 | .field_name = "certs", | ||
| 91 | .item = &X509_it, | ||
| 92 | }, | ||
| 93 | }; | ||
| 94 | |||
| 95 | const ASN1_ITEM NETSCAPE_CERT_SEQUENCE_it = { | ||
| 96 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 97 | .utype = V_ASN1_SEQUENCE, | ||
| 98 | .templates = NETSCAPE_CERT_SEQUENCE_seq_tt, | ||
| 99 | .tcount = sizeof(NETSCAPE_CERT_SEQUENCE_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 100 | .funcs = &NETSCAPE_CERT_SEQUENCE_aux, | ||
| 101 | .size = sizeof(NETSCAPE_CERT_SEQUENCE), | ||
| 102 | .sname = "NETSCAPE_CERT_SEQUENCE", | ||
| 103 | }; | ||
| 104 | |||
| 105 | |||
| 106 | NETSCAPE_CERT_SEQUENCE * | ||
| 107 | d2i_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE **a, const unsigned char **in, long len) | ||
| 108 | { | ||
| 109 | return (NETSCAPE_CERT_SEQUENCE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 110 | &NETSCAPE_CERT_SEQUENCE_it); | ||
| 111 | } | ||
| 112 | |||
| 113 | int | ||
| 114 | i2d_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE *a, unsigned char **out) | ||
| 115 | { | ||
| 116 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_CERT_SEQUENCE_it); | ||
| 117 | } | ||
| 118 | |||
| 119 | NETSCAPE_CERT_SEQUENCE * | ||
| 120 | NETSCAPE_CERT_SEQUENCE_new(void) | ||
| 121 | { | ||
| 122 | return (NETSCAPE_CERT_SEQUENCE *)ASN1_item_new(&NETSCAPE_CERT_SEQUENCE_it); | ||
| 123 | } | ||
| 124 | |||
| 125 | void | ||
| 126 | NETSCAPE_CERT_SEQUENCE_free(NETSCAPE_CERT_SEQUENCE *a) | ||
| 127 | { | ||
| 128 | ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_CERT_SEQUENCE_it); | ||
| 129 | } | ||
diff --git a/src/lib/libcrypto/asn1/p5_pbe.c b/src/lib/libcrypto/asn1/p5_pbe.c deleted file mode 100644 index 3e7057bb24..0000000000 --- a/src/lib/libcrypto/asn1/p5_pbe.c +++ /dev/null | |||
| @@ -1,186 +0,0 @@ | |||
| 1 | /* $OpenBSD: p5_pbe.c,v 1.20 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 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 | #include <stdio.h> | ||
| 60 | #include <stdlib.h> | ||
| 61 | #include <string.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1t.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | |||
| 67 | /* PKCS#5 password based encryption structure */ | ||
| 68 | |||
| 69 | static const ASN1_TEMPLATE PBEPARAM_seq_tt[] = { | ||
| 70 | { | ||
| 71 | .offset = offsetof(PBEPARAM, salt), | ||
| 72 | .field_name = "salt", | ||
| 73 | .item = &ASN1_OCTET_STRING_it, | ||
| 74 | }, | ||
| 75 | { | ||
| 76 | .offset = offsetof(PBEPARAM, iter), | ||
| 77 | .field_name = "iter", | ||
| 78 | .item = &ASN1_INTEGER_it, | ||
| 79 | }, | ||
| 80 | }; | ||
| 81 | |||
| 82 | const ASN1_ITEM PBEPARAM_it = { | ||
| 83 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 84 | .utype = V_ASN1_SEQUENCE, | ||
| 85 | .templates = PBEPARAM_seq_tt, | ||
| 86 | .tcount = sizeof(PBEPARAM_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 87 | .size = sizeof(PBEPARAM), | ||
| 88 | .sname = "PBEPARAM", | ||
| 89 | }; | ||
| 90 | |||
| 91 | |||
| 92 | PBEPARAM * | ||
| 93 | d2i_PBEPARAM(PBEPARAM **a, const unsigned char **in, long len) | ||
| 94 | { | ||
| 95 | return (PBEPARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 96 | &PBEPARAM_it); | ||
| 97 | } | ||
| 98 | |||
| 99 | int | ||
| 100 | i2d_PBEPARAM(PBEPARAM *a, unsigned char **out) | ||
| 101 | { | ||
| 102 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBEPARAM_it); | ||
| 103 | } | ||
| 104 | |||
| 105 | PBEPARAM * | ||
| 106 | PBEPARAM_new(void) | ||
| 107 | { | ||
| 108 | return (PBEPARAM *)ASN1_item_new(&PBEPARAM_it); | ||
| 109 | } | ||
| 110 | |||
| 111 | void | ||
| 112 | PBEPARAM_free(PBEPARAM *a) | ||
| 113 | { | ||
| 114 | ASN1_item_free((ASN1_VALUE *)a, &PBEPARAM_it); | ||
| 115 | } | ||
| 116 | |||
| 117 | |||
| 118 | /* Set an algorithm identifier for a PKCS#5 PBE algorithm */ | ||
| 119 | |||
| 120 | int | ||
| 121 | PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter, | ||
| 122 | const unsigned char *salt, int saltlen) | ||
| 123 | { | ||
| 124 | PBEPARAM *pbe = NULL; | ||
| 125 | ASN1_STRING *pbe_str = NULL; | ||
| 126 | unsigned char *sstr; | ||
| 127 | |||
| 128 | pbe = PBEPARAM_new(); | ||
| 129 | if (!pbe) { | ||
| 130 | ASN1err(ASN1_F_PKCS5_PBE_SET0_ALGOR, ERR_R_MALLOC_FAILURE); | ||
| 131 | goto err; | ||
| 132 | } | ||
| 133 | if (iter <= 0) | ||
| 134 | iter = PKCS5_DEFAULT_ITER; | ||
| 135 | if (!ASN1_INTEGER_set(pbe->iter, iter)) { | ||
| 136 | ASN1err(ASN1_F_PKCS5_PBE_SET0_ALGOR, ERR_R_MALLOC_FAILURE); | ||
| 137 | goto err; | ||
| 138 | } | ||
| 139 | if (!saltlen) | ||
| 140 | saltlen = PKCS5_SALT_LEN; | ||
| 141 | if (!ASN1_STRING_set(pbe->salt, NULL, saltlen)) { | ||
| 142 | ASN1err(ASN1_F_PKCS5_PBE_SET0_ALGOR, ERR_R_MALLOC_FAILURE); | ||
| 143 | goto err; | ||
| 144 | } | ||
| 145 | sstr = ASN1_STRING_data(pbe->salt); | ||
| 146 | if (salt) | ||
| 147 | memcpy(sstr, salt, saltlen); | ||
| 148 | else | ||
| 149 | arc4random_buf(sstr, saltlen); | ||
| 150 | |||
| 151 | if (!ASN1_item_pack(pbe, ASN1_ITEM_rptr(PBEPARAM), &pbe_str)) { | ||
| 152 | ASN1err(ASN1_F_PKCS5_PBE_SET0_ALGOR, ERR_R_MALLOC_FAILURE); | ||
| 153 | goto err; | ||
| 154 | } | ||
| 155 | |||
| 156 | PBEPARAM_free(pbe); | ||
| 157 | pbe = NULL; | ||
| 158 | |||
| 159 | if (X509_ALGOR_set0(algor, OBJ_nid2obj(alg), V_ASN1_SEQUENCE, pbe_str)) | ||
| 160 | return 1; | ||
| 161 | |||
| 162 | err: | ||
| 163 | if (pbe != NULL) | ||
| 164 | PBEPARAM_free(pbe); | ||
| 165 | ASN1_STRING_free(pbe_str); | ||
| 166 | return 0; | ||
| 167 | } | ||
| 168 | |||
| 169 | /* Return an algorithm identifier for a PKCS#5 PBE algorithm */ | ||
| 170 | |||
| 171 | X509_ALGOR * | ||
| 172 | PKCS5_pbe_set(int alg, int iter, const unsigned char *salt, int saltlen) | ||
| 173 | { | ||
| 174 | X509_ALGOR *ret; | ||
| 175 | ret = X509_ALGOR_new(); | ||
| 176 | if (!ret) { | ||
| 177 | ASN1err(ASN1_F_PKCS5_PBE_SET, ERR_R_MALLOC_FAILURE); | ||
| 178 | return NULL; | ||
| 179 | } | ||
| 180 | |||
| 181 | if (PKCS5_pbe_set0_algor(ret, alg, iter, salt, saltlen)) | ||
| 182 | return ret; | ||
| 183 | |||
| 184 | X509_ALGOR_free(ret); | ||
| 185 | return NULL; | ||
| 186 | } | ||
diff --git a/src/lib/libcrypto/asn1/p5_pbev2.c b/src/lib/libcrypto/asn1/p5_pbev2.c deleted file mode 100644 index 795721fad2..0000000000 --- a/src/lib/libcrypto/asn1/p5_pbev2.c +++ /dev/null | |||
| @@ -1,374 +0,0 @@ | |||
| 1 | /* $OpenBSD: p5_pbev2.c,v 1.21 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 1999-2004. | ||
| 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 | #include <stdio.h> | ||
| 60 | #include <stdlib.h> | ||
| 61 | #include <string.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1t.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | |||
| 67 | /* PKCS#5 v2.0 password based encryption structures */ | ||
| 68 | |||
| 69 | static const ASN1_TEMPLATE PBE2PARAM_seq_tt[] = { | ||
| 70 | { | ||
| 71 | .offset = offsetof(PBE2PARAM, keyfunc), | ||
| 72 | .field_name = "keyfunc", | ||
| 73 | .item = &X509_ALGOR_it, | ||
| 74 | }, | ||
| 75 | { | ||
| 76 | .offset = offsetof(PBE2PARAM, encryption), | ||
| 77 | .field_name = "encryption", | ||
| 78 | .item = &X509_ALGOR_it, | ||
| 79 | }, | ||
| 80 | }; | ||
| 81 | |||
| 82 | const ASN1_ITEM PBE2PARAM_it = { | ||
| 83 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 84 | .utype = V_ASN1_SEQUENCE, | ||
| 85 | .templates = PBE2PARAM_seq_tt, | ||
| 86 | .tcount = sizeof(PBE2PARAM_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 87 | .size = sizeof(PBE2PARAM), | ||
| 88 | .sname = "PBE2PARAM", | ||
| 89 | }; | ||
| 90 | |||
| 91 | |||
| 92 | PBE2PARAM * | ||
| 93 | d2i_PBE2PARAM(PBE2PARAM **a, const unsigned char **in, long len) | ||
| 94 | { | ||
| 95 | return (PBE2PARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 96 | &PBE2PARAM_it); | ||
| 97 | } | ||
| 98 | |||
| 99 | int | ||
| 100 | i2d_PBE2PARAM(PBE2PARAM *a, unsigned char **out) | ||
| 101 | { | ||
| 102 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBE2PARAM_it); | ||
| 103 | } | ||
| 104 | |||
| 105 | PBE2PARAM * | ||
| 106 | PBE2PARAM_new(void) | ||
| 107 | { | ||
| 108 | return (PBE2PARAM *)ASN1_item_new(&PBE2PARAM_it); | ||
| 109 | } | ||
| 110 | |||
| 111 | void | ||
| 112 | PBE2PARAM_free(PBE2PARAM *a) | ||
| 113 | { | ||
| 114 | ASN1_item_free((ASN1_VALUE *)a, &PBE2PARAM_it); | ||
| 115 | } | ||
| 116 | |||
| 117 | static const ASN1_TEMPLATE PBKDF2PARAM_seq_tt[] = { | ||
| 118 | { | ||
| 119 | .offset = offsetof(PBKDF2PARAM, salt), | ||
| 120 | .field_name = "salt", | ||
| 121 | .item = &ASN1_ANY_it, | ||
| 122 | }, | ||
| 123 | { | ||
| 124 | .offset = offsetof(PBKDF2PARAM, iter), | ||
| 125 | .field_name = "iter", | ||
| 126 | .item = &ASN1_INTEGER_it, | ||
| 127 | }, | ||
| 128 | { | ||
| 129 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 130 | .offset = offsetof(PBKDF2PARAM, keylength), | ||
| 131 | .field_name = "keylength", | ||
| 132 | .item = &ASN1_INTEGER_it, | ||
| 133 | }, | ||
| 134 | { | ||
| 135 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 136 | .offset = offsetof(PBKDF2PARAM, prf), | ||
| 137 | .field_name = "prf", | ||
| 138 | .item = &X509_ALGOR_it, | ||
| 139 | }, | ||
| 140 | }; | ||
| 141 | |||
| 142 | const ASN1_ITEM PBKDF2PARAM_it = { | ||
| 143 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 144 | .utype = V_ASN1_SEQUENCE, | ||
| 145 | .templates = PBKDF2PARAM_seq_tt, | ||
| 146 | .tcount = sizeof(PBKDF2PARAM_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 147 | .size = sizeof(PBKDF2PARAM), | ||
| 148 | .sname = "PBKDF2PARAM", | ||
| 149 | }; | ||
| 150 | |||
| 151 | |||
| 152 | PBKDF2PARAM * | ||
| 153 | d2i_PBKDF2PARAM(PBKDF2PARAM **a, const unsigned char **in, long len) | ||
| 154 | { | ||
| 155 | return (PBKDF2PARAM *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 156 | &PBKDF2PARAM_it); | ||
| 157 | } | ||
| 158 | |||
| 159 | int | ||
| 160 | i2d_PBKDF2PARAM(PBKDF2PARAM *a, unsigned char **out) | ||
| 161 | { | ||
| 162 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &PBKDF2PARAM_it); | ||
| 163 | } | ||
| 164 | |||
| 165 | PBKDF2PARAM * | ||
| 166 | PBKDF2PARAM_new(void) | ||
| 167 | { | ||
| 168 | return (PBKDF2PARAM *)ASN1_item_new(&PBKDF2PARAM_it); | ||
| 169 | } | ||
| 170 | |||
| 171 | void | ||
| 172 | PBKDF2PARAM_free(PBKDF2PARAM *a) | ||
| 173 | { | ||
| 174 | ASN1_item_free((ASN1_VALUE *)a, &PBKDF2PARAM_it); | ||
| 175 | } | ||
| 176 | |||
| 177 | /* Return an algorithm identifier for a PKCS#5 v2.0 PBE algorithm: | ||
| 178 | * yes I know this is horrible! | ||
| 179 | * | ||
| 180 | * Extended version to allow application supplied PRF NID and IV. | ||
| 181 | */ | ||
| 182 | |||
| 183 | X509_ALGOR * | ||
| 184 | PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter, unsigned char *salt, | ||
| 185 | int saltlen, unsigned char *aiv, int prf_nid) | ||
| 186 | { | ||
| 187 | X509_ALGOR *scheme = NULL, *kalg = NULL, *ret = NULL; | ||
| 188 | int alg_nid, keylen; | ||
| 189 | EVP_CIPHER_CTX ctx; | ||
| 190 | unsigned char iv[EVP_MAX_IV_LENGTH]; | ||
| 191 | PBE2PARAM *pbe2 = NULL; | ||
| 192 | ASN1_OBJECT *obj; | ||
| 193 | |||
| 194 | alg_nid = EVP_CIPHER_type(cipher); | ||
| 195 | if (alg_nid == NID_undef) { | ||
| 196 | ASN1err(ASN1_F_PKCS5_PBE2_SET_IV, | ||
| 197 | ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER); | ||
| 198 | goto err; | ||
| 199 | } | ||
| 200 | obj = OBJ_nid2obj(alg_nid); | ||
| 201 | |||
| 202 | if (!(pbe2 = PBE2PARAM_new())) | ||
| 203 | goto merr; | ||
| 204 | |||
| 205 | /* Setup the AlgorithmIdentifier for the encryption scheme */ | ||
| 206 | scheme = pbe2->encryption; | ||
| 207 | |||
| 208 | scheme->algorithm = obj; | ||
| 209 | if (!(scheme->parameter = ASN1_TYPE_new())) | ||
| 210 | goto merr; | ||
| 211 | |||
| 212 | /* Create random IV */ | ||
| 213 | if (EVP_CIPHER_iv_length(cipher)) { | ||
| 214 | if (aiv) | ||
| 215 | memcpy(iv, aiv, EVP_CIPHER_iv_length(cipher)); | ||
| 216 | else | ||
| 217 | arc4random_buf(iv, EVP_CIPHER_iv_length(cipher)); | ||
| 218 | } | ||
| 219 | |||
| 220 | EVP_CIPHER_CTX_init(&ctx); | ||
| 221 | |||
| 222 | /* Dummy cipherinit to just setup the IV, and PRF */ | ||
| 223 | if (!EVP_CipherInit_ex(&ctx, cipher, NULL, NULL, iv, 0)) | ||
| 224 | goto err; | ||
| 225 | if (EVP_CIPHER_param_to_asn1(&ctx, scheme->parameter) < 0) { | ||
| 226 | ASN1err(ASN1_F_PKCS5_PBE2_SET_IV, | ||
| 227 | ASN1_R_ERROR_SETTING_CIPHER_PARAMS); | ||
| 228 | EVP_CIPHER_CTX_cleanup(&ctx); | ||
| 229 | goto err; | ||
| 230 | } | ||
| 231 | /* If prf NID unspecified see if cipher has a preference. | ||
| 232 | * An error is OK here: just means use default PRF. | ||
| 233 | */ | ||
| 234 | if ((prf_nid == -1) && | ||
| 235 | EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_PBE_PRF_NID, 0, &prf_nid) <= 0) { | ||
| 236 | ERR_clear_error(); | ||
| 237 | prf_nid = NID_hmacWithSHA1; | ||
| 238 | } | ||
| 239 | EVP_CIPHER_CTX_cleanup(&ctx); | ||
| 240 | |||
| 241 | /* If its RC2 then we'd better setup the key length */ | ||
| 242 | |||
| 243 | if (alg_nid == NID_rc2_cbc) | ||
| 244 | keylen = EVP_CIPHER_key_length(cipher); | ||
| 245 | else | ||
| 246 | keylen = -1; | ||
| 247 | |||
| 248 | /* Setup keyfunc */ | ||
| 249 | |||
| 250 | X509_ALGOR_free(pbe2->keyfunc); | ||
| 251 | |||
| 252 | pbe2->keyfunc = PKCS5_pbkdf2_set(iter, salt, saltlen, prf_nid, keylen); | ||
| 253 | |||
| 254 | if (!pbe2->keyfunc) | ||
| 255 | goto merr; | ||
| 256 | |||
| 257 | /* Now set up top level AlgorithmIdentifier */ | ||
| 258 | |||
| 259 | if (!(ret = X509_ALGOR_new())) | ||
| 260 | goto merr; | ||
| 261 | if (!(ret->parameter = ASN1_TYPE_new())) | ||
| 262 | goto merr; | ||
| 263 | |||
| 264 | ret->algorithm = OBJ_nid2obj(NID_pbes2); | ||
| 265 | |||
| 266 | /* Encode PBE2PARAM into parameter */ | ||
| 267 | |||
| 268 | if (!ASN1_item_pack(pbe2, ASN1_ITEM_rptr(PBE2PARAM), | ||
| 269 | &ret->parameter->value.sequence)) goto merr; | ||
| 270 | ret->parameter->type = V_ASN1_SEQUENCE; | ||
| 271 | |||
| 272 | PBE2PARAM_free(pbe2); | ||
| 273 | pbe2 = NULL; | ||
| 274 | |||
| 275 | return ret; | ||
| 276 | |||
| 277 | merr: | ||
| 278 | ASN1err(ASN1_F_PKCS5_PBE2_SET_IV, ERR_R_MALLOC_FAILURE); | ||
| 279 | |||
| 280 | err: | ||
| 281 | PBE2PARAM_free(pbe2); | ||
| 282 | /* Note 'scheme' is freed as part of pbe2 */ | ||
| 283 | X509_ALGOR_free(kalg); | ||
| 284 | X509_ALGOR_free(ret); | ||
| 285 | |||
| 286 | return NULL; | ||
| 287 | } | ||
| 288 | |||
| 289 | X509_ALGOR * | ||
| 290 | PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter, unsigned char *salt, | ||
| 291 | int saltlen) | ||
| 292 | { | ||
| 293 | return PKCS5_pbe2_set_iv(cipher, iter, salt, saltlen, NULL, -1); | ||
| 294 | } | ||
| 295 | |||
| 296 | X509_ALGOR * | ||
| 297 | PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen, int prf_nid, | ||
| 298 | int keylen) | ||
| 299 | { | ||
| 300 | X509_ALGOR *keyfunc = NULL; | ||
| 301 | PBKDF2PARAM *kdf = NULL; | ||
| 302 | ASN1_OCTET_STRING *osalt = NULL; | ||
| 303 | |||
| 304 | if (!(kdf = PBKDF2PARAM_new())) | ||
| 305 | goto merr; | ||
| 306 | if (!(osalt = M_ASN1_OCTET_STRING_new())) | ||
| 307 | goto merr; | ||
| 308 | |||
| 309 | kdf->salt->value.octet_string = osalt; | ||
| 310 | kdf->salt->type = V_ASN1_OCTET_STRING; | ||
| 311 | |||
| 312 | if (!saltlen) | ||
| 313 | saltlen = PKCS5_SALT_LEN; | ||
| 314 | if (!(osalt->data = malloc (saltlen))) | ||
| 315 | goto merr; | ||
| 316 | |||
| 317 | osalt->length = saltlen; | ||
| 318 | |||
| 319 | if (salt) | ||
| 320 | memcpy (osalt->data, salt, saltlen); | ||
| 321 | else | ||
| 322 | arc4random_buf(osalt->data, saltlen); | ||
| 323 | |||
| 324 | if (iter <= 0) | ||
| 325 | iter = PKCS5_DEFAULT_ITER; | ||
| 326 | |||
| 327 | if (!ASN1_INTEGER_set(kdf->iter, iter)) | ||
| 328 | goto merr; | ||
| 329 | |||
| 330 | /* If have a key len set it up */ | ||
| 331 | |||
| 332 | if (keylen > 0) { | ||
| 333 | if (!(kdf->keylength = M_ASN1_INTEGER_new())) | ||
| 334 | goto merr; | ||
| 335 | if (!ASN1_INTEGER_set (kdf->keylength, keylen)) | ||
| 336 | goto merr; | ||
| 337 | } | ||
| 338 | |||
| 339 | /* prf can stay NULL if we are using hmacWithSHA1 */ | ||
| 340 | if (prf_nid > 0 && prf_nid != NID_hmacWithSHA1) { | ||
| 341 | kdf->prf = X509_ALGOR_new(); | ||
| 342 | if (!kdf->prf) | ||
| 343 | goto merr; | ||
| 344 | X509_ALGOR_set0(kdf->prf, OBJ_nid2obj(prf_nid), | ||
| 345 | V_ASN1_NULL, NULL); | ||
| 346 | } | ||
| 347 | |||
| 348 | /* Finally setup the keyfunc structure */ | ||
| 349 | |||
| 350 | keyfunc = X509_ALGOR_new(); | ||
| 351 | if (!keyfunc) | ||
| 352 | goto merr; | ||
| 353 | |||
| 354 | keyfunc->algorithm = OBJ_nid2obj(NID_id_pbkdf2); | ||
| 355 | |||
| 356 | /* Encode PBKDF2PARAM into parameter of pbe2 */ | ||
| 357 | |||
| 358 | if (!(keyfunc->parameter = ASN1_TYPE_new())) | ||
| 359 | goto merr; | ||
| 360 | |||
| 361 | if (!ASN1_item_pack(kdf, ASN1_ITEM_rptr(PBKDF2PARAM), | ||
| 362 | &keyfunc->parameter->value.sequence)) | ||
| 363 | goto merr; | ||
| 364 | keyfunc->parameter->type = V_ASN1_SEQUENCE; | ||
| 365 | |||
| 366 | PBKDF2PARAM_free(kdf); | ||
| 367 | return keyfunc; | ||
| 368 | |||
| 369 | merr: | ||
| 370 | ASN1err(ASN1_F_PKCS5_PBKDF2_SET, ERR_R_MALLOC_FAILURE); | ||
| 371 | PBKDF2PARAM_free(kdf); | ||
| 372 | X509_ALGOR_free(keyfunc); | ||
| 373 | return NULL; | ||
| 374 | } | ||
diff --git a/src/lib/libcrypto/asn1/p8_pkey.c b/src/lib/libcrypto/asn1/p8_pkey.c deleted file mode 100644 index 2f7a469673..0000000000 --- a/src/lib/libcrypto/asn1/p8_pkey.c +++ /dev/null | |||
| @@ -1,200 +0,0 @@ | |||
| 1 | /* $OpenBSD: p8_pkey.c,v 1.16 2015/07/16 18:21:57 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 1999. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 1999-2005 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 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/x509.h> | ||
| 63 | |||
| 64 | /* Minor tweak to operation: zero private key data */ | ||
| 65 | static int | ||
| 66 | pkey_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) | ||
| 67 | { | ||
| 68 | /* Since the structure must still be valid use ASN1_OP_FREE_PRE */ | ||
| 69 | if (operation == ASN1_OP_FREE_PRE) { | ||
| 70 | PKCS8_PRIV_KEY_INFO *key = (PKCS8_PRIV_KEY_INFO *)*pval; | ||
| 71 | if (key->pkey != NULL && | ||
| 72 | key->pkey->type == V_ASN1_OCTET_STRING && | ||
| 73 | key->pkey->value.octet_string != NULL) | ||
| 74 | OPENSSL_cleanse(key->pkey->value.octet_string->data, | ||
| 75 | key->pkey->value.octet_string->length); | ||
| 76 | } | ||
| 77 | return 1; | ||
| 78 | } | ||
| 79 | |||
| 80 | static const ASN1_AUX PKCS8_PRIV_KEY_INFO_aux = { | ||
| 81 | .asn1_cb = pkey_cb, | ||
| 82 | }; | ||
| 83 | static const ASN1_TEMPLATE PKCS8_PRIV_KEY_INFO_seq_tt[] = { | ||
| 84 | { | ||
| 85 | .offset = offsetof(PKCS8_PRIV_KEY_INFO, version), | ||
| 86 | .field_name = "version", | ||
| 87 | .item = &ASN1_INTEGER_it, | ||
| 88 | }, | ||
| 89 | { | ||
| 90 | .offset = offsetof(PKCS8_PRIV_KEY_INFO, pkeyalg), | ||
| 91 | .field_name = "pkeyalg", | ||
| 92 | .item = &X509_ALGOR_it, | ||
| 93 | }, | ||
| 94 | { | ||
| 95 | .offset = offsetof(PKCS8_PRIV_KEY_INFO, pkey), | ||
| 96 | .field_name = "pkey", | ||
| 97 | .item = &ASN1_ANY_it, | ||
| 98 | }, | ||
| 99 | { | ||
| 100 | .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL, | ||
| 101 | .offset = offsetof(PKCS8_PRIV_KEY_INFO, attributes), | ||
| 102 | .field_name = "attributes", | ||
| 103 | .item = &X509_ATTRIBUTE_it, | ||
| 104 | }, | ||
| 105 | }; | ||
| 106 | |||
| 107 | const ASN1_ITEM PKCS8_PRIV_KEY_INFO_it = { | ||
| 108 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 109 | .utype = V_ASN1_SEQUENCE, | ||
| 110 | .templates = PKCS8_PRIV_KEY_INFO_seq_tt, | ||
| 111 | .tcount = sizeof(PKCS8_PRIV_KEY_INFO_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 112 | .funcs = &PKCS8_PRIV_KEY_INFO_aux, | ||
| 113 | .size = sizeof(PKCS8_PRIV_KEY_INFO), | ||
| 114 | .sname = "PKCS8_PRIV_KEY_INFO", | ||
| 115 | }; | ||
| 116 | |||
| 117 | |||
| 118 | PKCS8_PRIV_KEY_INFO * | ||
| 119 | d2i_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO **a, const unsigned char **in, long len) | ||
| 120 | { | ||
| 121 | return (PKCS8_PRIV_KEY_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 122 | &PKCS8_PRIV_KEY_INFO_it); | ||
| 123 | } | ||
| 124 | |||
| 125 | int | ||
| 126 | i2d_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO *a, unsigned char **out) | ||
| 127 | { | ||
| 128 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS8_PRIV_KEY_INFO_it); | ||
| 129 | } | ||
| 130 | |||
| 131 | PKCS8_PRIV_KEY_INFO * | ||
| 132 | PKCS8_PRIV_KEY_INFO_new(void) | ||
| 133 | { | ||
| 134 | return (PKCS8_PRIV_KEY_INFO *)ASN1_item_new(&PKCS8_PRIV_KEY_INFO_it); | ||
| 135 | } | ||
| 136 | |||
| 137 | void | ||
| 138 | PKCS8_PRIV_KEY_INFO_free(PKCS8_PRIV_KEY_INFO *a) | ||
| 139 | { | ||
| 140 | ASN1_item_free((ASN1_VALUE *)a, &PKCS8_PRIV_KEY_INFO_it); | ||
| 141 | } | ||
| 142 | |||
| 143 | int | ||
| 144 | PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, int version, | ||
| 145 | int ptype, void *pval, unsigned char *penc, int penclen) | ||
| 146 | { | ||
| 147 | unsigned char **ppenc = NULL; | ||
| 148 | |||
| 149 | if (version >= 0) { | ||
| 150 | if (!ASN1_INTEGER_set(priv->version, version)) | ||
| 151 | return 0; | ||
| 152 | } | ||
| 153 | if (penc) { | ||
| 154 | int pmtype; | ||
| 155 | ASN1_OCTET_STRING *oct; | ||
| 156 | oct = ASN1_OCTET_STRING_new(); | ||
| 157 | if (!oct) | ||
| 158 | return 0; | ||
| 159 | oct->data = penc; | ||
| 160 | ppenc = &oct->data; | ||
| 161 | oct->length = penclen; | ||
| 162 | if (priv->broken == PKCS8_NO_OCTET) | ||
| 163 | pmtype = V_ASN1_SEQUENCE; | ||
| 164 | else | ||
| 165 | pmtype = V_ASN1_OCTET_STRING; | ||
| 166 | ASN1_TYPE_set(priv->pkey, pmtype, oct); | ||
| 167 | } | ||
| 168 | if (!X509_ALGOR_set0(priv->pkeyalg, aobj, ptype, pval)) { | ||
| 169 | /* If call fails do not swallow 'enc' */ | ||
| 170 | if (ppenc) | ||
| 171 | *ppenc = NULL; | ||
| 172 | return 0; | ||
| 173 | } | ||
| 174 | return 1; | ||
| 175 | } | ||
| 176 | |||
| 177 | int | ||
| 178 | PKCS8_pkey_get0(ASN1_OBJECT **ppkalg, const unsigned char **pk, int *ppklen, | ||
| 179 | X509_ALGOR **pa, PKCS8_PRIV_KEY_INFO *p8) | ||
| 180 | { | ||
| 181 | if (ppkalg) | ||
| 182 | *ppkalg = p8->pkeyalg->algorithm; | ||
| 183 | if (p8->pkey->type == V_ASN1_OCTET_STRING) { | ||
| 184 | p8->broken = PKCS8_OK; | ||
| 185 | if (pk) { | ||
| 186 | *pk = p8->pkey->value.octet_string->data; | ||
| 187 | *ppklen = p8->pkey->value.octet_string->length; | ||
| 188 | } | ||
| 189 | } else if (p8->pkey->type == V_ASN1_SEQUENCE) { | ||
| 190 | p8->broken = PKCS8_NO_OCTET; | ||
| 191 | if (pk) { | ||
| 192 | *pk = p8->pkey->value.sequence->data; | ||
| 193 | *ppklen = p8->pkey->value.sequence->length; | ||
| 194 | } | ||
| 195 | } else | ||
| 196 | return 0; | ||
| 197 | if (pa) | ||
| 198 | *pa = p8->pkeyalg; | ||
| 199 | return 1; | ||
| 200 | } | ||
diff --git a/src/lib/libcrypto/asn1/t_bitst.c b/src/lib/libcrypto/asn1/t_bitst.c deleted file mode 100644 index ea4138e0fb..0000000000 --- a/src/lib/libcrypto/asn1/t_bitst.c +++ /dev/null | |||
| @@ -1,112 +0,0 @@ | |||
| 1 | /* $OpenBSD: t_bitst.c,v 1.7 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 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 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/conf.h> | ||
| 63 | #include <openssl/x509v3.h> | ||
| 64 | |||
| 65 | int | ||
| 66 | ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs, | ||
| 67 | BIT_STRING_BITNAME *tbl, int indent) | ||
| 68 | { | ||
| 69 | BIT_STRING_BITNAME *bnam; | ||
| 70 | char first = 1; | ||
| 71 | |||
| 72 | BIO_printf(out, "%*s", indent, ""); | ||
| 73 | for (bnam = tbl; bnam->lname; bnam++) { | ||
| 74 | if (ASN1_BIT_STRING_get_bit(bs, bnam->bitnum)) { | ||
| 75 | if (!first) | ||
| 76 | BIO_puts(out, ", "); | ||
| 77 | BIO_puts(out, bnam->lname); | ||
| 78 | first = 0; | ||
| 79 | } | ||
| 80 | } | ||
| 81 | BIO_puts(out, "\n"); | ||
| 82 | return 1; | ||
| 83 | } | ||
| 84 | |||
| 85 | int | ||
| 86 | ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, char *name, int value, | ||
| 87 | BIT_STRING_BITNAME *tbl) | ||
| 88 | { | ||
| 89 | int bitnum; | ||
| 90 | |||
| 91 | bitnum = ASN1_BIT_STRING_num_asc(name, tbl); | ||
| 92 | if (bitnum < 0) | ||
| 93 | return 0; | ||
| 94 | if (bs) { | ||
| 95 | if (!ASN1_BIT_STRING_set_bit(bs, bitnum, value)) | ||
| 96 | return 0; | ||
| 97 | } | ||
| 98 | return 1; | ||
| 99 | } | ||
| 100 | |||
| 101 | int | ||
| 102 | ASN1_BIT_STRING_num_asc(char *name, BIT_STRING_BITNAME *tbl) | ||
| 103 | { | ||
| 104 | BIT_STRING_BITNAME *bnam; | ||
| 105 | |||
| 106 | for (bnam = tbl; bnam->lname; bnam++) { | ||
| 107 | if (!strcmp(bnam->sname, name) || | ||
| 108 | !strcmp(bnam->lname, name)) | ||
| 109 | return bnam->bitnum; | ||
| 110 | } | ||
| 111 | return -1; | ||
| 112 | } | ||
diff --git a/src/lib/libcrypto/asn1/t_crl.c b/src/lib/libcrypto/asn1/t_crl.c deleted file mode 100644 index 67116361a5..0000000000 --- a/src/lib/libcrypto/asn1/t_crl.c +++ /dev/null | |||
| @@ -1,140 +0,0 @@ | |||
| 1 | /* $OpenBSD: t_crl.c,v 1.16 2014/07/12 16:33:25 miod Exp $ */ | ||
| 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 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/bn.h> | ||
| 62 | #include <openssl/buffer.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | #include <openssl/objects.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | #include <openssl/x509v3.h> | ||
| 67 | |||
| 68 | int | ||
| 69 | X509_CRL_print_fp(FILE *fp, X509_CRL *x) | ||
| 70 | { | ||
| 71 | BIO *b; | ||
| 72 | int ret; | ||
| 73 | |||
| 74 | if ((b = BIO_new(BIO_s_file())) == NULL) { | ||
| 75 | X509err(X509_F_X509_CRL_PRINT_FP, ERR_R_BUF_LIB); | ||
| 76 | return (0); | ||
| 77 | } | ||
| 78 | BIO_set_fp(b, fp, BIO_NOCLOSE); | ||
| 79 | ret = X509_CRL_print(b, x); | ||
| 80 | BIO_free(b); | ||
| 81 | return (ret); | ||
| 82 | } | ||
| 83 | |||
| 84 | int | ||
| 85 | X509_CRL_print(BIO *out, X509_CRL *x) | ||
| 86 | { | ||
| 87 | STACK_OF(X509_REVOKED) *rev; | ||
| 88 | X509_REVOKED *r; | ||
| 89 | long l; | ||
| 90 | int i; | ||
| 91 | char *p; | ||
| 92 | |||
| 93 | BIO_printf(out, "Certificate Revocation List (CRL):\n"); | ||
| 94 | l = X509_CRL_get_version(x); | ||
| 95 | BIO_printf(out, "%8sVersion %lu (0x%lx)\n", "", l + 1, l); | ||
| 96 | i = OBJ_obj2nid(x->sig_alg->algorithm); | ||
| 97 | if (X509_signature_print(out, x->sig_alg, NULL) == 0) | ||
| 98 | goto err; | ||
| 99 | p = X509_NAME_oneline(X509_CRL_get_issuer(x), NULL, 0); | ||
| 100 | if (p == NULL) | ||
| 101 | goto err; | ||
| 102 | BIO_printf(out, "%8sIssuer: %s\n", "", p); | ||
| 103 | free(p); | ||
| 104 | BIO_printf(out, "%8sLast Update: ", ""); | ||
| 105 | ASN1_TIME_print(out, X509_CRL_get_lastUpdate(x)); | ||
| 106 | BIO_printf(out, "\n%8sNext Update: ", ""); | ||
| 107 | if (X509_CRL_get_nextUpdate(x)) | ||
| 108 | ASN1_TIME_print(out, X509_CRL_get_nextUpdate(x)); | ||
| 109 | else | ||
| 110 | BIO_printf(out, "NONE"); | ||
| 111 | BIO_printf(out, "\n"); | ||
| 112 | |||
| 113 | X509V3_extensions_print(out, "CRL extensions", | ||
| 114 | x->crl->extensions, 0, 8); | ||
| 115 | |||
| 116 | rev = X509_CRL_get_REVOKED(x); | ||
| 117 | |||
| 118 | if (sk_X509_REVOKED_num(rev) > 0) | ||
| 119 | BIO_printf(out, "Revoked Certificates:\n"); | ||
| 120 | else | ||
| 121 | BIO_printf(out, "No Revoked Certificates.\n"); | ||
| 122 | |||
| 123 | for (i = 0; i < sk_X509_REVOKED_num(rev); i++) { | ||
| 124 | r = sk_X509_REVOKED_value(rev, i); | ||
| 125 | BIO_printf(out, " Serial Number: "); | ||
| 126 | i2a_ASN1_INTEGER(out, r->serialNumber); | ||
| 127 | BIO_printf(out, "\n Revocation Date: "); | ||
| 128 | ASN1_TIME_print(out, r->revocationDate); | ||
| 129 | BIO_printf(out, "\n"); | ||
| 130 | X509V3_extensions_print(out, "CRL entry extensions", | ||
| 131 | r->extensions, 0, 8); | ||
| 132 | } | ||
| 133 | if (X509_signature_print(out, x->sig_alg, x->signature) == 0) | ||
| 134 | goto err; | ||
| 135 | |||
| 136 | return 1; | ||
| 137 | |||
| 138 | err: | ||
| 139 | return 0; | ||
| 140 | } | ||
diff --git a/src/lib/libcrypto/asn1/t_pkey.c b/src/lib/libcrypto/asn1/t_pkey.c deleted file mode 100644 index b3f7d084c5..0000000000 --- a/src/lib/libcrypto/asn1/t_pkey.c +++ /dev/null | |||
| @@ -1,114 +0,0 @@ | |||
| 1 | /* $OpenBSD: t_pkey.c,v 1.16 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/bn.h> | ||
| 62 | #include <openssl/buffer.h> | ||
| 63 | #include <openssl/objects.h> | ||
| 64 | |||
| 65 | int | ||
| 66 | ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num, | ||
| 67 | unsigned char *buf, int off) | ||
| 68 | { | ||
| 69 | int n, i; | ||
| 70 | const char *neg; | ||
| 71 | |||
| 72 | if (num == NULL) | ||
| 73 | return (1); | ||
| 74 | neg = (BN_is_negative(num)) ? "-" : ""; | ||
| 75 | if (!BIO_indent(bp, off, 128)) | ||
| 76 | return 0; | ||
| 77 | if (BN_is_zero(num)) { | ||
| 78 | if (BIO_printf(bp, "%s 0\n", number) <= 0) | ||
| 79 | return 0; | ||
| 80 | return 1; | ||
| 81 | } | ||
| 82 | |||
| 83 | if (BN_num_bytes(num) <= BN_BYTES) { | ||
| 84 | if (BIO_printf(bp, "%s %s%lu (%s0x%lx)\n", number, neg, | ||
| 85 | (unsigned long)num->d[0], neg, | ||
| 86 | (unsigned long)num->d[0]) <= 0) | ||
| 87 | return (0); | ||
| 88 | } else { | ||
| 89 | buf[0] = 0; | ||
| 90 | if (BIO_printf(bp, "%s%s", number, | ||
| 91 | (neg[0] == '-') ? " (Negative)" : "") <= 0) | ||
| 92 | return (0); | ||
| 93 | n = BN_bn2bin(num, &buf[1]); | ||
| 94 | |||
| 95 | if (buf[1] & 0x80) | ||
| 96 | n++; | ||
| 97 | else | ||
| 98 | buf++; | ||
| 99 | |||
| 100 | for (i = 0; i < n; i++) { | ||
| 101 | if ((i % 15) == 0) { | ||
| 102 | if (BIO_puts(bp, "\n") <= 0 || | ||
| 103 | !BIO_indent(bp, off + 4, 128)) | ||
| 104 | return 0; | ||
| 105 | } | ||
| 106 | if (BIO_printf(bp, "%02x%s", buf[i], | ||
| 107 | ((i + 1) == n) ? "" : ":") <= 0) | ||
| 108 | return (0); | ||
| 109 | } | ||
| 110 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 111 | return (0); | ||
| 112 | } | ||
| 113 | return (1); | ||
| 114 | } | ||
diff --git a/src/lib/libcrypto/asn1/t_req.c b/src/lib/libcrypto/asn1/t_req.c deleted file mode 100644 index 8db456708a..0000000000 --- a/src/lib/libcrypto/asn1/t_req.c +++ /dev/null | |||
| @@ -1,267 +0,0 @@ | |||
| 1 | /* $OpenBSD: t_req.c,v 1.18 2015/07/29 14:58:34 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/bn.h> | ||
| 64 | #include <openssl/buffer.h> | ||
| 65 | #include <openssl/err.h> | ||
| 66 | #include <openssl/objects.h> | ||
| 67 | #include <openssl/x509.h> | ||
| 68 | #include <openssl/x509v3.h> | ||
| 69 | |||
| 70 | #ifndef OPENSSL_NO_DSA | ||
| 71 | #include <openssl/dsa.h> | ||
| 72 | #endif | ||
| 73 | #ifndef OPENSSL_NO_RSA | ||
| 74 | #include <openssl/rsa.h> | ||
| 75 | #endif | ||
| 76 | |||
| 77 | int | ||
| 78 | X509_REQ_print_fp(FILE *fp, X509_REQ *x) | ||
| 79 | { | ||
| 80 | BIO *b; | ||
| 81 | int ret; | ||
| 82 | |||
| 83 | if ((b = BIO_new(BIO_s_file())) == NULL) { | ||
| 84 | X509err(X509_F_X509_REQ_PRINT_FP, ERR_R_BUF_LIB); | ||
| 85 | return (0); | ||
| 86 | } | ||
| 87 | BIO_set_fp(b, fp, BIO_NOCLOSE); | ||
| 88 | ret = X509_REQ_print(b, x); | ||
| 89 | BIO_free(b); | ||
| 90 | return (ret); | ||
| 91 | } | ||
| 92 | |||
| 93 | int | ||
| 94 | X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflags, | ||
| 95 | unsigned long cflag) | ||
| 96 | { | ||
| 97 | unsigned long l; | ||
| 98 | int i; | ||
| 99 | const char *neg; | ||
| 100 | X509_REQ_INFO *ri; | ||
| 101 | EVP_PKEY *pkey; | ||
| 102 | STACK_OF(X509_ATTRIBUTE) *sk; | ||
| 103 | STACK_OF(X509_EXTENSION) *exts; | ||
| 104 | char mlch = ' '; | ||
| 105 | int nmindent = 0; | ||
| 106 | |||
| 107 | if ((nmflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) { | ||
| 108 | mlch = '\n'; | ||
| 109 | nmindent = 12; | ||
| 110 | } | ||
| 111 | |||
| 112 | if (nmflags == X509_FLAG_COMPAT) | ||
| 113 | nmindent = 16; | ||
| 114 | |||
| 115 | ri = x->req_info; | ||
| 116 | if (!(cflag & X509_FLAG_NO_HEADER)) { | ||
| 117 | if (BIO_write(bp, "Certificate Request:\n", 21) <= 0) | ||
| 118 | goto err; | ||
| 119 | if (BIO_write(bp, " Data:\n", 10) <= 0) | ||
| 120 | |||
| 121 | goto err; | ||
| 122 | } | ||
| 123 | if (!(cflag & X509_FLAG_NO_VERSION)) { | ||
| 124 | neg = (ri->version->type == V_ASN1_NEG_INTEGER) ? "-" : ""; | ||
| 125 | l = 0; | ||
| 126 | for (i = 0; i < ri->version->length; i++) { | ||
| 127 | l <<= 8; | ||
| 128 | l += ri->version->data[i]; | ||
| 129 | } | ||
| 130 | if (BIO_printf(bp, "%8sVersion: %s%lu (%s0x%lx)\n", "", neg, | ||
| 131 | l, neg, l) <= 0) | ||
| 132 | goto err; | ||
| 133 | } | ||
| 134 | if (!(cflag & X509_FLAG_NO_SUBJECT)) { | ||
| 135 | if (BIO_printf(bp, " Subject:%c", mlch) <= 0) | ||
| 136 | goto err; | ||
| 137 | if (X509_NAME_print_ex(bp, ri->subject, nmindent, nmflags) < 0) | ||
| 138 | goto err; | ||
| 139 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 140 | goto err; | ||
| 141 | } | ||
| 142 | if (!(cflag & X509_FLAG_NO_PUBKEY)) { | ||
| 143 | if (BIO_write(bp, " Subject Public Key Info:\n", | ||
| 144 | 33) <= 0) | ||
| 145 | goto err; | ||
| 146 | if (BIO_printf(bp, "%12sPublic Key Algorithm: ", "") <= 0) | ||
| 147 | goto err; | ||
| 148 | if (i2a_ASN1_OBJECT(bp, ri->pubkey->algor->algorithm) <= 0) | ||
| 149 | goto err; | ||
| 150 | if (BIO_puts(bp, "\n") <= 0) | ||
| 151 | goto err; | ||
| 152 | |||
| 153 | pkey = X509_REQ_get_pubkey(x); | ||
| 154 | if (pkey == NULL) { | ||
| 155 | BIO_printf(bp, "%12sUnable to load Public Key\n", ""); | ||
| 156 | ERR_print_errors(bp); | ||
| 157 | } else { | ||
| 158 | EVP_PKEY_print_public(bp, pkey, 16, NULL); | ||
| 159 | EVP_PKEY_free(pkey); | ||
| 160 | } | ||
| 161 | } | ||
| 162 | |||
| 163 | if (!(cflag & X509_FLAG_NO_ATTRIBUTES)) { | ||
| 164 | /* may not be */ | ||
| 165 | if (BIO_printf(bp, "%8sAttributes:\n", "") <= 0) | ||
| 166 | goto err; | ||
| 167 | |||
| 168 | sk = x->req_info->attributes; | ||
| 169 | if (sk_X509_ATTRIBUTE_num(sk) == 0) { | ||
| 170 | if (BIO_printf(bp, "%12sa0:00\n", "") <= 0) | ||
| 171 | goto err; | ||
| 172 | } else { | ||
| 173 | for (i = 0; i < sk_X509_ATTRIBUTE_num(sk); i++) { | ||
| 174 | ASN1_TYPE *at; | ||
| 175 | X509_ATTRIBUTE *a; | ||
| 176 | ASN1_BIT_STRING *bs = NULL; | ||
| 177 | ASN1_TYPE *t; | ||
| 178 | int j, type = 0, count = 1, ii = 0; | ||
| 179 | |||
| 180 | a = sk_X509_ATTRIBUTE_value(sk, i); | ||
| 181 | if (X509_REQ_extension_nid( | ||
| 182 | OBJ_obj2nid(a->object))) | ||
| 183 | continue; | ||
| 184 | if (BIO_printf(bp, "%12s", "") <= 0) | ||
| 185 | goto err; | ||
| 186 | if ((j = i2a_ASN1_OBJECT(bp, a->object)) > 0) { | ||
| 187 | if (a->single) { | ||
| 188 | t = a->value.single; | ||
| 189 | type = t->type; | ||
| 190 | bs = t->value.bit_string; | ||
| 191 | } else { | ||
| 192 | ii = 0; | ||
| 193 | count = sk_ASN1_TYPE_num( | ||
| 194 | a->value.set); | ||
| 195 | get_next: | ||
| 196 | at = sk_ASN1_TYPE_value( | ||
| 197 | a->value.set, ii); | ||
| 198 | type = at->type; | ||
| 199 | bs = at->value.asn1_string; | ||
| 200 | } | ||
| 201 | } | ||
| 202 | for (j = 25 - j; j > 0; j--) | ||
| 203 | if (BIO_write(bp, " ", 1) != 1) | ||
| 204 | goto err; | ||
| 205 | if (BIO_puts(bp, ":") <= 0) | ||
| 206 | goto err; | ||
| 207 | if ((type == V_ASN1_PRINTABLESTRING) || | ||
| 208 | (type == V_ASN1_T61STRING) || | ||
| 209 | (type == V_ASN1_IA5STRING)) { | ||
| 210 | if (BIO_write(bp, (char *)bs->data, | ||
| 211 | bs->length) != bs->length) | ||
| 212 | goto err; | ||
| 213 | BIO_puts(bp, "\n"); | ||
| 214 | } else { | ||
| 215 | BIO_puts(bp, | ||
| 216 | "unable to print attribute\n"); | ||
| 217 | } | ||
| 218 | if (++ii < count) | ||
| 219 | goto get_next; | ||
| 220 | } | ||
| 221 | } | ||
| 222 | } | ||
| 223 | if (!(cflag & X509_FLAG_NO_EXTENSIONS)) { | ||
| 224 | exts = X509_REQ_get_extensions(x); | ||
| 225 | if (exts) { | ||
| 226 | BIO_printf(bp, "%8sRequested Extensions:\n", ""); | ||
| 227 | for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) { | ||
| 228 | ASN1_OBJECT *obj; | ||
| 229 | X509_EXTENSION *ex; | ||
| 230 | int j; | ||
| 231 | ex = sk_X509_EXTENSION_value(exts, i); | ||
| 232 | if (BIO_printf(bp, "%12s", "") <= 0) | ||
| 233 | goto err; | ||
| 234 | obj = X509_EXTENSION_get_object(ex); | ||
| 235 | i2a_ASN1_OBJECT(bp, obj); | ||
| 236 | j = X509_EXTENSION_get_critical(ex); | ||
| 237 | if (BIO_printf(bp, ": %s\n", | ||
| 238 | j ? "critical" : "") <= 0) | ||
| 239 | goto err; | ||
| 240 | if (!X509V3_EXT_print(bp, ex, cflag, 16)) { | ||
| 241 | BIO_printf(bp, "%16s", ""); | ||
| 242 | ASN1_STRING_print(bp, ex->value); | ||
| 243 | } | ||
| 244 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 245 | goto err; | ||
| 246 | } | ||
| 247 | sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free); | ||
| 248 | } | ||
| 249 | } | ||
| 250 | |||
| 251 | if (!(cflag & X509_FLAG_NO_SIGDUMP)) { | ||
| 252 | if (!X509_signature_print(bp, x->sig_alg, x->signature)) | ||
| 253 | goto err; | ||
| 254 | } | ||
| 255 | |||
| 256 | return (1); | ||
| 257 | |||
| 258 | err: | ||
| 259 | X509err(X509_F_X509_REQ_PRINT_EX, ERR_R_BUF_LIB); | ||
| 260 | return (0); | ||
| 261 | } | ||
| 262 | |||
| 263 | int | ||
| 264 | X509_REQ_print(BIO *bp, X509_REQ *x) | ||
| 265 | { | ||
| 266 | return X509_REQ_print_ex(bp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT); | ||
| 267 | } | ||
diff --git a/src/lib/libcrypto/asn1/t_spki.c b/src/lib/libcrypto/asn1/t_spki.c deleted file mode 100644 index 39ff0670b6..0000000000 --- a/src/lib/libcrypto/asn1/t_spki.c +++ /dev/null | |||
| @@ -1,112 +0,0 @@ | |||
| 1 | /* $OpenBSD: t_spki.c,v 1.11 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 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 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1.h> | ||
| 64 | #include <openssl/bn.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | |||
| 67 | #ifndef OPENSSL_NO_DSA | ||
| 68 | #include <openssl/dsa.h> | ||
| 69 | #endif | ||
| 70 | #ifndef OPENSSL_NO_RSA | ||
| 71 | #include <openssl/rsa.h> | ||
| 72 | #endif | ||
| 73 | |||
| 74 | /* Print out an SPKI */ | ||
| 75 | |||
| 76 | int | ||
| 77 | NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki) | ||
| 78 | { | ||
| 79 | EVP_PKEY *pkey; | ||
| 80 | ASN1_IA5STRING *chal; | ||
| 81 | int i, n; | ||
| 82 | char *s; | ||
| 83 | |||
| 84 | BIO_printf(out, "Netscape SPKI:\n"); | ||
| 85 | i = OBJ_obj2nid(spki->spkac->pubkey->algor->algorithm); | ||
| 86 | BIO_printf(out, " Public Key Algorithm: %s\n", | ||
| 87 | (i == NID_undef) ? "UNKNOWN" : OBJ_nid2ln(i)); | ||
| 88 | pkey = X509_PUBKEY_get(spki->spkac->pubkey); | ||
| 89 | if (!pkey) | ||
| 90 | BIO_printf(out, " Unable to load public key\n"); | ||
| 91 | else { | ||
| 92 | EVP_PKEY_print_public(out, pkey, 4, NULL); | ||
| 93 | EVP_PKEY_free(pkey); | ||
| 94 | } | ||
| 95 | chal = spki->spkac->challenge; | ||
| 96 | if (chal->length) | ||
| 97 | BIO_printf(out, " Challenge String: %s\n", chal->data); | ||
| 98 | i = OBJ_obj2nid(spki->sig_algor->algorithm); | ||
| 99 | BIO_printf(out, " Signature Algorithm: %s", | ||
| 100 | (i == NID_undef) ? "UNKNOWN" : OBJ_nid2ln(i)); | ||
| 101 | |||
| 102 | n = spki->signature->length; | ||
| 103 | s = (char *)spki->signature->data; | ||
| 104 | for (i = 0; i < n; i++) { | ||
| 105 | if ((i % 18) == 0) | ||
| 106 | BIO_write(out, "\n ", 7); | ||
| 107 | BIO_printf(out, "%02x%s", (unsigned char)s[i], | ||
| 108 | ((i + 1) == n) ? "" : ":"); | ||
| 109 | } | ||
| 110 | BIO_write(out, "\n", 1); | ||
| 111 | return 1; | ||
| 112 | } | ||
diff --git a/src/lib/libcrypto/asn1/t_x509.c b/src/lib/libcrypto/asn1/t_x509.c deleted file mode 100644 index 1c83fc5608..0000000000 --- a/src/lib/libcrypto/asn1/t_x509.c +++ /dev/null | |||
| @@ -1,537 +0,0 @@ | |||
| 1 | /* $OpenBSD: t_x509.c,v 1.26 2015/02/07 13:19:15 doug Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/bn.h> | ||
| 64 | #include <openssl/buffer.h> | ||
| 65 | #include <openssl/err.h> | ||
| 66 | #include <openssl/objects.h> | ||
| 67 | #include <openssl/x509.h> | ||
| 68 | #include <openssl/x509v3.h> | ||
| 69 | |||
| 70 | #ifndef OPENSSL_NO_DSA | ||
| 71 | #include <openssl/dsa.h> | ||
| 72 | #endif | ||
| 73 | #ifndef OPENSSL_NO_EC | ||
| 74 | #include <openssl/ec.h> | ||
| 75 | #endif | ||
| 76 | #ifndef OPENSSL_NO_RSA | ||
| 77 | #include <openssl/rsa.h> | ||
| 78 | #endif | ||
| 79 | |||
| 80 | #include "asn1_locl.h" | ||
| 81 | |||
| 82 | int | ||
| 83 | X509_print_fp(FILE *fp, X509 *x) | ||
| 84 | { | ||
| 85 | return X509_print_ex_fp(fp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT); | ||
| 86 | } | ||
| 87 | |||
| 88 | int | ||
| 89 | X509_print_ex_fp(FILE *fp, X509 *x, unsigned long nmflag, unsigned long cflag) | ||
| 90 | { | ||
| 91 | BIO *b; | ||
| 92 | int ret; | ||
| 93 | |||
| 94 | if ((b = BIO_new(BIO_s_file())) == NULL) { | ||
| 95 | X509err(X509_F_X509_PRINT_EX_FP, ERR_R_BUF_LIB); | ||
| 96 | return (0); | ||
| 97 | } | ||
| 98 | BIO_set_fp(b, fp, BIO_NOCLOSE); | ||
| 99 | ret = X509_print_ex(b, x, nmflag, cflag); | ||
| 100 | BIO_free(b); | ||
| 101 | return (ret); | ||
| 102 | } | ||
| 103 | |||
| 104 | int | ||
| 105 | X509_print(BIO *bp, X509 *x) | ||
| 106 | { | ||
| 107 | return X509_print_ex(bp, x, XN_FLAG_COMPAT, X509_FLAG_COMPAT); | ||
| 108 | } | ||
| 109 | |||
| 110 | int | ||
| 111 | X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags, unsigned long cflag) | ||
| 112 | { | ||
| 113 | long l; | ||
| 114 | int ret = 0, i; | ||
| 115 | char *m = NULL, mlch = ' '; | ||
| 116 | int nmindent = 0; | ||
| 117 | X509_CINF *ci; | ||
| 118 | ASN1_INTEGER *bs; | ||
| 119 | EVP_PKEY *pkey = NULL; | ||
| 120 | const char *neg; | ||
| 121 | |||
| 122 | if ((nmflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) { | ||
| 123 | mlch = '\n'; | ||
| 124 | nmindent = 12; | ||
| 125 | } | ||
| 126 | |||
| 127 | if (nmflags == X509_FLAG_COMPAT) | ||
| 128 | nmindent = 16; | ||
| 129 | |||
| 130 | ci = x->cert_info; | ||
| 131 | if (!(cflag & X509_FLAG_NO_HEADER)) { | ||
| 132 | if (BIO_write(bp, "Certificate:\n", 13) <= 0) | ||
| 133 | goto err; | ||
| 134 | if (BIO_write(bp, " Data:\n", 10) <= 0) | ||
| 135 | goto err; | ||
| 136 | } | ||
| 137 | if (!(cflag & X509_FLAG_NO_VERSION)) { | ||
| 138 | l = X509_get_version(x); | ||
| 139 | if (BIO_printf(bp, "%8sVersion: %lu (0x%lx)\n", | ||
| 140 | "", l + 1, l) <= 0) | ||
| 141 | goto err; | ||
| 142 | } | ||
| 143 | if (!(cflag & X509_FLAG_NO_SERIAL)) { | ||
| 144 | if (BIO_write(bp, " Serial Number:", 22) <= 0) | ||
| 145 | goto err; | ||
| 146 | |||
| 147 | bs = X509_get_serialNumber(x); | ||
| 148 | if (bs->length <= (int)sizeof(long)) { | ||
| 149 | l = ASN1_INTEGER_get(bs); | ||
| 150 | if (bs->type == V_ASN1_NEG_INTEGER) { | ||
| 151 | l = -l; | ||
| 152 | neg = "-"; | ||
| 153 | } else | ||
| 154 | neg = ""; | ||
| 155 | if (BIO_printf(bp, " %s%lu (%s0x%lx)\n", | ||
| 156 | neg, l, neg, l) <= 0) | ||
| 157 | goto err; | ||
| 158 | } else { | ||
| 159 | neg = (bs->type == V_ASN1_NEG_INTEGER) ? | ||
| 160 | " (Negative)" : ""; | ||
| 161 | if (BIO_printf(bp, "\n%12s%s", "", neg) <= 0) | ||
| 162 | goto err; | ||
| 163 | for (i = 0; i < bs->length; i++) { | ||
| 164 | if (BIO_printf(bp, "%02x%c", bs->data[i], | ||
| 165 | ((i + 1 == bs->length) ? '\n' : ':')) <= 0) | ||
| 166 | goto err; | ||
| 167 | } | ||
| 168 | } | ||
| 169 | |||
| 170 | } | ||
| 171 | |||
| 172 | if (!(cflag & X509_FLAG_NO_SIGNAME)) { | ||
| 173 | if (X509_signature_print(bp, x->sig_alg, NULL) <= 0) | ||
| 174 | goto err; | ||
| 175 | } | ||
| 176 | |||
| 177 | if (!(cflag & X509_FLAG_NO_ISSUER)) { | ||
| 178 | if (BIO_printf(bp, " Issuer:%c", mlch) <= 0) | ||
| 179 | goto err; | ||
| 180 | if (X509_NAME_print_ex(bp, X509_get_issuer_name(x), | ||
| 181 | nmindent, nmflags) < 0) | ||
| 182 | goto err; | ||
| 183 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 184 | goto err; | ||
| 185 | } | ||
| 186 | if (!(cflag & X509_FLAG_NO_VALIDITY)) { | ||
| 187 | if (BIO_write(bp, " Validity\n", 17) <= 0) | ||
| 188 | goto err; | ||
| 189 | if (BIO_write(bp, " Not Before: ", 24) <= 0) | ||
| 190 | goto err; | ||
| 191 | if (!ASN1_TIME_print(bp, X509_get_notBefore(x))) | ||
| 192 | goto err; | ||
| 193 | if (BIO_write(bp, "\n Not After : ", 25) <= 0) | ||
| 194 | goto err; | ||
| 195 | if (!ASN1_TIME_print(bp, X509_get_notAfter(x))) | ||
| 196 | goto err; | ||
| 197 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 198 | goto err; | ||
| 199 | } | ||
| 200 | if (!(cflag & X509_FLAG_NO_SUBJECT)) { | ||
| 201 | if (BIO_printf(bp, " Subject:%c", mlch) <= 0) | ||
| 202 | goto err; | ||
| 203 | if (X509_NAME_print_ex(bp, X509_get_subject_name(x), | ||
| 204 | nmindent, nmflags) < 0) | ||
| 205 | goto err; | ||
| 206 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 207 | goto err; | ||
| 208 | } | ||
| 209 | if (!(cflag & X509_FLAG_NO_PUBKEY)) { | ||
| 210 | if (BIO_write(bp, " Subject Public Key Info:\n", | ||
| 211 | 33) <= 0) | ||
| 212 | goto err; | ||
| 213 | if (BIO_printf(bp, "%12sPublic Key Algorithm: ", "") <= 0) | ||
| 214 | goto err; | ||
| 215 | if (i2a_ASN1_OBJECT(bp, ci->key->algor->algorithm) <= 0) | ||
| 216 | goto err; | ||
| 217 | if (BIO_puts(bp, "\n") <= 0) | ||
| 218 | goto err; | ||
| 219 | |||
| 220 | pkey = X509_get_pubkey(x); | ||
| 221 | if (pkey == NULL) { | ||
| 222 | BIO_printf(bp, "%12sUnable to load Public Key\n", ""); | ||
| 223 | ERR_print_errors(bp); | ||
| 224 | } else { | ||
| 225 | EVP_PKEY_print_public(bp, pkey, 16, NULL); | ||
| 226 | EVP_PKEY_free(pkey); | ||
| 227 | } | ||
| 228 | } | ||
| 229 | |||
| 230 | if (!(cflag & X509_FLAG_NO_EXTENSIONS)) | ||
| 231 | X509V3_extensions_print(bp, "X509v3 extensions", | ||
| 232 | ci->extensions, cflag, 8); | ||
| 233 | |||
| 234 | if (!(cflag & X509_FLAG_NO_SIGDUMP)) { | ||
| 235 | if (X509_signature_print(bp, x->sig_alg, x->signature) <= 0) | ||
| 236 | goto err; | ||
| 237 | } | ||
| 238 | if (!(cflag & X509_FLAG_NO_AUX)) { | ||
| 239 | if (!X509_CERT_AUX_print(bp, x->aux, 0)) | ||
| 240 | goto err; | ||
| 241 | } | ||
| 242 | ret = 1; | ||
| 243 | |||
| 244 | err: | ||
| 245 | free(m); | ||
| 246 | return (ret); | ||
| 247 | } | ||
| 248 | |||
| 249 | int X509_ocspid_print (BIO *bp, X509 *x) | ||
| 250 | { | ||
| 251 | unsigned char *der = NULL; | ||
| 252 | unsigned char *dertmp; | ||
| 253 | int derlen; | ||
| 254 | int i; | ||
| 255 | unsigned char SHA1md[SHA_DIGEST_LENGTH]; | ||
| 256 | |||
| 257 | /* display the hash of the subject as it would appear | ||
| 258 | in OCSP requests */ | ||
| 259 | if (BIO_printf(bp, " Subject OCSP hash: ") <= 0) | ||
| 260 | goto err; | ||
| 261 | derlen = i2d_X509_NAME(x->cert_info->subject, NULL); | ||
| 262 | if ((der = dertmp = malloc(derlen)) == NULL) | ||
| 263 | goto err; | ||
| 264 | i2d_X509_NAME(x->cert_info->subject, &dertmp); | ||
| 265 | |||
| 266 | if (!EVP_Digest(der, derlen, SHA1md, NULL, EVP_sha1(), NULL)) | ||
| 267 | goto err; | ||
| 268 | for (i = 0; i < SHA_DIGEST_LENGTH; i++) { | ||
| 269 | if (BIO_printf(bp, "%02X", SHA1md[i]) <= 0) | ||
| 270 | goto err; | ||
| 271 | } | ||
| 272 | free (der); | ||
| 273 | der = NULL; | ||
| 274 | |||
| 275 | /* display the hash of the public key as it would appear | ||
| 276 | in OCSP requests */ | ||
| 277 | if (BIO_printf(bp, "\n Public key OCSP hash: ") <= 0) | ||
| 278 | goto err; | ||
| 279 | |||
| 280 | if (!EVP_Digest(x->cert_info->key->public_key->data, | ||
| 281 | x->cert_info->key->public_key->length, | ||
| 282 | SHA1md, NULL, EVP_sha1(), NULL)) | ||
| 283 | goto err; | ||
| 284 | for (i = 0; i < SHA_DIGEST_LENGTH; i++) { | ||
| 285 | if (BIO_printf(bp, "%02X", SHA1md[i]) <= 0) | ||
| 286 | goto err; | ||
| 287 | } | ||
| 288 | BIO_printf(bp, "\n"); | ||
| 289 | |||
| 290 | return (1); | ||
| 291 | |||
| 292 | err: | ||
| 293 | free(der); | ||
| 294 | return (0); | ||
| 295 | } | ||
| 296 | |||
| 297 | int | ||
| 298 | X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent) | ||
| 299 | { | ||
| 300 | const unsigned char *s; | ||
| 301 | int i, n; | ||
| 302 | |||
| 303 | n = sig->length; | ||
| 304 | s = sig->data; | ||
| 305 | for (i = 0; i < n; i++) { | ||
| 306 | if ((i % 18) == 0) { | ||
| 307 | if (BIO_write(bp, "\n", 1) <= 0) | ||
| 308 | return 0; | ||
| 309 | if (BIO_indent(bp, indent, indent) <= 0) | ||
| 310 | return 0; | ||
| 311 | } | ||
| 312 | if (BIO_printf(bp, "%02x%s", s[i], | ||
| 313 | ((i + 1) == n) ? "" : ":") <= 0) | ||
| 314 | return 0; | ||
| 315 | } | ||
| 316 | if (BIO_write(bp, "\n", 1) != 1) | ||
| 317 | return 0; | ||
| 318 | |||
| 319 | return 1; | ||
| 320 | } | ||
| 321 | |||
| 322 | int | ||
| 323 | X509_signature_print(BIO *bp, X509_ALGOR *sigalg, ASN1_STRING *sig) | ||
| 324 | { | ||
| 325 | int sig_nid; | ||
| 326 | if (BIO_puts(bp, " Signature Algorithm: ") <= 0) | ||
| 327 | return 0; | ||
| 328 | if (i2a_ASN1_OBJECT(bp, sigalg->algorithm) <= 0) | ||
| 329 | return 0; | ||
| 330 | |||
| 331 | sig_nid = OBJ_obj2nid(sigalg->algorithm); | ||
| 332 | if (sig_nid != NID_undef) { | ||
| 333 | int pkey_nid, dig_nid; | ||
| 334 | const EVP_PKEY_ASN1_METHOD *ameth; | ||
| 335 | if (OBJ_find_sigid_algs(sig_nid, &dig_nid, &pkey_nid)) { | ||
| 336 | ameth = EVP_PKEY_asn1_find(NULL, pkey_nid); | ||
| 337 | if (ameth && ameth->sig_print) | ||
| 338 | return ameth->sig_print(bp, sigalg, sig, 9, 0); | ||
| 339 | } | ||
| 340 | } | ||
| 341 | if (sig) | ||
| 342 | return X509_signature_dump(bp, sig, 9); | ||
| 343 | else if (BIO_puts(bp, "\n") <= 0) | ||
| 344 | return 0; | ||
| 345 | return 1; | ||
| 346 | } | ||
| 347 | |||
| 348 | int | ||
| 349 | ASN1_STRING_print(BIO *bp, const ASN1_STRING *v) | ||
| 350 | { | ||
| 351 | int i, n; | ||
| 352 | char buf[80]; | ||
| 353 | const char *p; | ||
| 354 | |||
| 355 | if (v == NULL) | ||
| 356 | return (0); | ||
| 357 | n = 0; | ||
| 358 | p = (const char *)v->data; | ||
| 359 | for (i = 0; i < v->length; i++) { | ||
| 360 | if ((p[i] > '~') || ((p[i] < ' ') && | ||
| 361 | (p[i] != '\n') && (p[i] != '\r'))) | ||
| 362 | buf[n] = '.'; | ||
| 363 | else | ||
| 364 | buf[n] = p[i]; | ||
| 365 | n++; | ||
| 366 | if (n >= 80) { | ||
| 367 | if (BIO_write(bp, buf, n) <= 0) | ||
| 368 | return (0); | ||
| 369 | n = 0; | ||
| 370 | } | ||
| 371 | } | ||
| 372 | if (n > 0) | ||
| 373 | if (BIO_write(bp, buf, n) <= 0) | ||
| 374 | return (0); | ||
| 375 | return (1); | ||
| 376 | } | ||
| 377 | |||
| 378 | int | ||
| 379 | ASN1_TIME_print(BIO *bp, const ASN1_TIME *tm) | ||
| 380 | { | ||
| 381 | if (tm->type == V_ASN1_UTCTIME) | ||
| 382 | return ASN1_UTCTIME_print(bp, tm); | ||
| 383 | if (tm->type == V_ASN1_GENERALIZEDTIME) | ||
| 384 | return ASN1_GENERALIZEDTIME_print(bp, tm); | ||
| 385 | BIO_write(bp, "Bad time value", 14); | ||
| 386 | return (0); | ||
| 387 | } | ||
| 388 | |||
| 389 | static const char *mon[12] = { | ||
| 390 | "Jan", "Feb", "Mar", "Apr", "May", "Jun", | ||
| 391 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" | ||
| 392 | }; | ||
| 393 | |||
| 394 | int | ||
| 395 | ASN1_GENERALIZEDTIME_print(BIO *bp, const ASN1_GENERALIZEDTIME *tm) | ||
| 396 | { | ||
| 397 | char *v; | ||
| 398 | int gmt = 0; | ||
| 399 | int i; | ||
| 400 | int y = 0, M = 0, d = 0, h = 0, m = 0, s = 0; | ||
| 401 | char *f = NULL; | ||
| 402 | int f_len = 0; | ||
| 403 | |||
| 404 | i = tm->length; | ||
| 405 | v = (char *)tm->data; | ||
| 406 | |||
| 407 | if (i < 12) | ||
| 408 | goto err; | ||
| 409 | if (v[i-1] == 'Z') | ||
| 410 | gmt = 1; | ||
| 411 | for (i = 0; i < 12; i++) | ||
| 412 | if ((v[i] > '9') || (v[i] < '0')) | ||
| 413 | goto err; | ||
| 414 | y = (v[0] - '0') * 1000 + (v[1] - '0') * 100 + | ||
| 415 | (v[2] - '0') * 10 + (v[3] - '0'); | ||
| 416 | M = (v[4] - '0') * 10 + (v[5] - '0'); | ||
| 417 | if ((M > 12) || (M < 1)) | ||
| 418 | goto err; | ||
| 419 | d = (v[6] - '0') * 10 + (v[7] - '0'); | ||
| 420 | h = (v[8] - '0') * 10 + (v[9] - '0'); | ||
| 421 | m = (v[10] - '0') * 10 + (v[11] - '0'); | ||
| 422 | if (tm->length >= 14 && | ||
| 423 | (v[12] >= '0') && (v[12] <= '9') && | ||
| 424 | (v[13] >= '0') && (v[13] <= '9')) { | ||
| 425 | s = (v[12] - '0') * 10 + (v[13] - '0'); | ||
| 426 | /* Check for fractions of seconds. */ | ||
| 427 | if (tm->length >= 15 && v[14] == '.') { | ||
| 428 | int l = tm->length; | ||
| 429 | f = &v[14]; /* The decimal point. */ | ||
| 430 | f_len = 1; | ||
| 431 | while (14 + f_len < l && f[f_len] >= '0' && | ||
| 432 | f[f_len] <= '9') | ||
| 433 | ++f_len; | ||
| 434 | } | ||
| 435 | } | ||
| 436 | |||
| 437 | if (BIO_printf(bp, "%s %2d %02d:%02d:%02d%.*s %d%s", | ||
| 438 | mon[M - 1], d, h, m, s, f_len, f, y, (gmt) ? " GMT" : "") <= 0) | ||
| 439 | return (0); | ||
| 440 | else | ||
| 441 | return (1); | ||
| 442 | |||
| 443 | err: | ||
| 444 | BIO_write(bp, "Bad time value", 14); | ||
| 445 | return (0); | ||
| 446 | } | ||
| 447 | |||
| 448 | int | ||
| 449 | ASN1_UTCTIME_print(BIO *bp, const ASN1_UTCTIME *tm) | ||
| 450 | { | ||
| 451 | const char *v; | ||
| 452 | int gmt = 0; | ||
| 453 | int i; | ||
| 454 | int y = 0, M = 0, d = 0, h = 0, m = 0, s = 0; | ||
| 455 | |||
| 456 | i = tm->length; | ||
| 457 | v = (const char *)tm->data; | ||
| 458 | |||
| 459 | if (i < 10) | ||
| 460 | goto err; | ||
| 461 | if (v[i-1] == 'Z') | ||
| 462 | gmt = 1; | ||
| 463 | for (i = 0; i < 10; i++) | ||
| 464 | if ((v[i] > '9') || (v[i] < '0')) | ||
| 465 | goto err; | ||
| 466 | y = (v[0] - '0') * 10 + (v[1] - '0'); | ||
| 467 | if (y < 50) | ||
| 468 | y += 100; | ||
| 469 | M = (v[2] - '0') * 10 + (v[3] - '0'); | ||
| 470 | if ((M > 12) || (M < 1)) | ||
| 471 | goto err; | ||
| 472 | d = (v[4] - '0') * 10 + (v[5] - '0'); | ||
| 473 | h = (v[6] - '0') * 10 + (v[7] - '0'); | ||
| 474 | m = (v[8] - '0') * 10 + (v[9] - '0'); | ||
| 475 | if (tm->length >=12 && | ||
| 476 | (v[10] >= '0') && (v[10] <= '9') && | ||
| 477 | (v[11] >= '0') && (v[11] <= '9')) | ||
| 478 | s = (v[10] - '0') * 10 + (v[11] - '0'); | ||
| 479 | |||
| 480 | if (BIO_printf(bp, "%s %2d %02d:%02d:%02d %d%s", | ||
| 481 | mon[M - 1], d, h, m, s, y + 1900, (gmt) ? " GMT" : "") <= 0) | ||
| 482 | return (0); | ||
| 483 | else | ||
| 484 | return (1); | ||
| 485 | |||
| 486 | err: | ||
| 487 | BIO_write(bp, "Bad time value", 14); | ||
| 488 | return (0); | ||
| 489 | } | ||
| 490 | |||
| 491 | int | ||
| 492 | X509_NAME_print(BIO *bp, X509_NAME *name, int obase) | ||
| 493 | { | ||
| 494 | char *s, *c, *b; | ||
| 495 | int ret = 0, l, i; | ||
| 496 | |||
| 497 | l = 80 - 2 - obase; | ||
| 498 | |||
| 499 | b = X509_NAME_oneline(name, NULL, 0); | ||
| 500 | if (b == NULL) | ||
| 501 | return 0; | ||
| 502 | if (*b == '\0') { | ||
| 503 | free(b); | ||
| 504 | return 1; | ||
| 505 | } | ||
| 506 | s = b + 1; /* skip the first slash */ | ||
| 507 | |||
| 508 | c = s; | ||
| 509 | for (;;) { | ||
| 510 | if (((*s == '/') && | ||
| 511 | ((s[1] >= 'A') && (s[1] <= 'Z') && | ||
| 512 | ((s[2] == '=') || ((s[2] >= 'A') && (s[2] <= 'Z') && | ||
| 513 | (s[3] == '='))))) || (*s == '\0')) { | ||
| 514 | i = s - c; | ||
| 515 | if (BIO_write(bp, c, i) != i) | ||
| 516 | goto err; | ||
| 517 | c = s + 1; /* skip following slash */ | ||
| 518 | if (*s != '\0') { | ||
| 519 | if (BIO_write(bp, ", ", 2) != 2) | ||
| 520 | goto err; | ||
| 521 | } | ||
| 522 | l--; | ||
| 523 | } | ||
| 524 | if (*s == '\0') | ||
| 525 | break; | ||
| 526 | s++; | ||
| 527 | l--; | ||
| 528 | } | ||
| 529 | |||
| 530 | ret = 1; | ||
| 531 | if (0) { | ||
| 532 | err: | ||
| 533 | X509err(X509_F_X509_NAME_PRINT, ERR_R_BUF_LIB); | ||
| 534 | } | ||
| 535 | free(b); | ||
| 536 | return (ret); | ||
| 537 | } | ||
diff --git a/src/lib/libcrypto/asn1/t_x509a.c b/src/lib/libcrypto/asn1/t_x509a.c deleted file mode 100644 index fd68211b84..0000000000 --- a/src/lib/libcrypto/asn1/t_x509a.c +++ /dev/null | |||
| @@ -1,118 +0,0 @@ | |||
| 1 | /* $OpenBSD: t_x509a.c,v 1.8 2014/07/11 08:44:47 jsing Exp $ */ | ||
| 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 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/evp.h> | ||
| 63 | #include <openssl/x509.h> | ||
| 64 | |||
| 65 | /* X509_CERT_AUX and string set routines | ||
| 66 | */ | ||
| 67 | |||
| 68 | int | ||
| 69 | X509_CERT_AUX_print(BIO *out, X509_CERT_AUX *aux, int indent) | ||
| 70 | { | ||
| 71 | char oidstr[80], first; | ||
| 72 | int i; | ||
| 73 | if (!aux) | ||
| 74 | return 1; | ||
| 75 | if (aux->trust) { | ||
| 76 | first = 1; | ||
| 77 | BIO_printf(out, "%*sTrusted Uses:\n%*s", | ||
| 78 | indent, "", indent + 2, ""); | ||
| 79 | for (i = 0; i < sk_ASN1_OBJECT_num(aux->trust); i++) { | ||
| 80 | if (!first) | ||
| 81 | BIO_puts(out, ", "); | ||
| 82 | else | ||
| 83 | first = 0; | ||
| 84 | OBJ_obj2txt(oidstr, sizeof oidstr, | ||
| 85 | sk_ASN1_OBJECT_value(aux->trust, i), 0); | ||
| 86 | BIO_puts(out, oidstr); | ||
| 87 | } | ||
| 88 | BIO_puts(out, "\n"); | ||
| 89 | } else | ||
| 90 | BIO_printf(out, "%*sNo Trusted Uses.\n", indent, ""); | ||
| 91 | if (aux->reject) { | ||
| 92 | first = 1; | ||
| 93 | BIO_printf(out, "%*sRejected Uses:\n%*s", | ||
| 94 | indent, "", indent + 2, ""); | ||
| 95 | for (i = 0; i < sk_ASN1_OBJECT_num(aux->reject); i++) { | ||
| 96 | if (!first) | ||
| 97 | BIO_puts(out, ", "); | ||
| 98 | else | ||
| 99 | first = 0; | ||
| 100 | OBJ_obj2txt(oidstr, sizeof oidstr, | ||
| 101 | sk_ASN1_OBJECT_value(aux->reject, i), 0); | ||
| 102 | BIO_puts(out, oidstr); | ||
| 103 | } | ||
| 104 | BIO_puts(out, "\n"); | ||
| 105 | } else | ||
| 106 | BIO_printf(out, "%*sNo Rejected Uses.\n", indent, ""); | ||
| 107 | if (aux->alias) | ||
| 108 | BIO_printf(out, "%*sAlias: %s\n", indent, "", | ||
| 109 | aux->alias->data); | ||
| 110 | if (aux->keyid) { | ||
| 111 | BIO_printf(out, "%*sKey Id: ", indent, ""); | ||
| 112 | for (i = 0; i < aux->keyid->length; i++) | ||
| 113 | BIO_printf(out, "%s%02X", i ? ":" : "", | ||
| 114 | aux->keyid->data[i]); | ||
| 115 | BIO_write(out, "\n", 1); | ||
| 116 | } | ||
| 117 | return 1; | ||
| 118 | } | ||
diff --git a/src/lib/libcrypto/asn1/tasn_dec.c b/src/lib/libcrypto/asn1/tasn_dec.c deleted file mode 100644 index f08514dc83..0000000000 --- a/src/lib/libcrypto/asn1/tasn_dec.c +++ /dev/null | |||
| @@ -1,1184 +0,0 @@ | |||
| 1 | /* $OpenBSD: tasn_dec.c,v 1.27 2015/07/20 15:41:48 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000-2005 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 | |||
| 60 | #include <stddef.h> | ||
| 61 | #include <string.h> | ||
| 62 | #include <openssl/asn1.h> | ||
| 63 | #include <openssl/asn1t.h> | ||
| 64 | #include <openssl/objects.h> | ||
| 65 | #include <openssl/buffer.h> | ||
| 66 | #include <openssl/err.h> | ||
| 67 | |||
| 68 | static int asn1_check_eoc(const unsigned char **in, long len); | ||
| 69 | static int asn1_find_end(const unsigned char **in, long len, char inf); | ||
| 70 | |||
| 71 | static int asn1_collect(BUF_MEM *buf, const unsigned char **in, long len, | ||
| 72 | char inf, int tag, int aclass, int depth); | ||
| 73 | |||
| 74 | static int collect_data(BUF_MEM *buf, const unsigned char **p, long plen); | ||
| 75 | |||
| 76 | static int asn1_check_tlen(long *olen, int *otag, unsigned char *oclass, | ||
| 77 | char *inf, char *cst, const unsigned char **in, long len, int exptag, | ||
| 78 | int expclass, char opt, ASN1_TLC *ctx); | ||
| 79 | |||
| 80 | static int asn1_template_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, | ||
| 81 | long len, const ASN1_TEMPLATE *tt, char opt, ASN1_TLC *ctx); | ||
| 82 | static int asn1_template_noexp_d2i(ASN1_VALUE **val, const unsigned char **in, | ||
| 83 | long len, const ASN1_TEMPLATE *tt, char opt, ASN1_TLC *ctx); | ||
| 84 | static int asn1_d2i_ex_primitive(ASN1_VALUE **pval, const unsigned char **in, | ||
| 85 | long len, const ASN1_ITEM *it, int tag, int aclass, char opt, | ||
| 86 | ASN1_TLC *ctx); | ||
| 87 | |||
| 88 | /* Table to convert tags to bit values, used for MSTRING type */ | ||
| 89 | static const unsigned long tag2bit[32] = { | ||
| 90 | 0, 0, 0, B_ASN1_BIT_STRING, /* tags 0 - 3 */ | ||
| 91 | B_ASN1_OCTET_STRING, 0, 0, B_ASN1_UNKNOWN,/* tags 4- 7 */ | ||
| 92 | B_ASN1_UNKNOWN, B_ASN1_UNKNOWN, B_ASN1_UNKNOWN, B_ASN1_UNKNOWN,/* tags 8-11 */ | ||
| 93 | B_ASN1_UTF8STRING,B_ASN1_UNKNOWN,B_ASN1_UNKNOWN,B_ASN1_UNKNOWN,/* tags 12-15 */ | ||
| 94 | B_ASN1_SEQUENCE,0,B_ASN1_NUMERICSTRING,B_ASN1_PRINTABLESTRING, /* tags 16-19 */ | ||
| 95 | B_ASN1_T61STRING,B_ASN1_VIDEOTEXSTRING,B_ASN1_IA5STRING, /* tags 20-22 */ | ||
| 96 | B_ASN1_UTCTIME, B_ASN1_GENERALIZEDTIME, /* tags 23-24 */ | ||
| 97 | B_ASN1_GRAPHICSTRING,B_ASN1_ISO64STRING,B_ASN1_GENERALSTRING, /* tags 25-27 */ | ||
| 98 | B_ASN1_UNIVERSALSTRING,B_ASN1_UNKNOWN,B_ASN1_BMPSTRING,B_ASN1_UNKNOWN, /* tags 28-31 */ | ||
| 99 | }; | ||
| 100 | |||
| 101 | unsigned long | ||
| 102 | ASN1_tag2bit(int tag) | ||
| 103 | { | ||
| 104 | if ((tag < 0) || (tag > 30)) | ||
| 105 | return 0; | ||
| 106 | return tag2bit[tag]; | ||
| 107 | } | ||
| 108 | |||
| 109 | /* Macro to initialize and invalidate the cache */ | ||
| 110 | |||
| 111 | #define asn1_tlc_clear(c) if (c) (c)->valid = 0 | ||
| 112 | /* Version to avoid compiler warning about 'c' always non-NULL */ | ||
| 113 | #define asn1_tlc_clear_nc(c) (c)->valid = 0 | ||
| 114 | |||
| 115 | /* Decode an ASN1 item, this currently behaves just | ||
| 116 | * like a standard 'd2i' function. 'in' points to | ||
| 117 | * a buffer to read the data from, in future we will | ||
| 118 | * have more advanced versions that can input data | ||
| 119 | * a piece at a time and this will simply be a special | ||
| 120 | * case. | ||
| 121 | */ | ||
| 122 | |||
| 123 | ASN1_VALUE * | ||
| 124 | ASN1_item_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, | ||
| 125 | const ASN1_ITEM *it) | ||
| 126 | { | ||
| 127 | ASN1_TLC c; | ||
| 128 | ASN1_VALUE *ptmpval = NULL; | ||
| 129 | |||
| 130 | if (!pval) | ||
| 131 | pval = &ptmpval; | ||
| 132 | asn1_tlc_clear_nc(&c); | ||
| 133 | if (ASN1_item_ex_d2i(pval, in, len, it, -1, 0, 0, &c) > 0) | ||
| 134 | return *pval; | ||
| 135 | return NULL; | ||
| 136 | } | ||
| 137 | |||
| 138 | int | ||
| 139 | ASN1_template_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, | ||
| 140 | const ASN1_TEMPLATE *tt) | ||
| 141 | { | ||
| 142 | ASN1_TLC c; | ||
| 143 | |||
| 144 | asn1_tlc_clear_nc(&c); | ||
| 145 | return asn1_template_ex_d2i(pval, in, len, tt, 0, &c); | ||
| 146 | } | ||
| 147 | |||
| 148 | |||
| 149 | /* Decode an item, taking care of IMPLICIT tagging, if any. | ||
| 150 | * If 'opt' set and tag mismatch return -1 to handle OPTIONAL | ||
| 151 | */ | ||
| 152 | |||
| 153 | int | ||
| 154 | ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, | ||
| 155 | const ASN1_ITEM *it, int tag, int aclass, char opt, ASN1_TLC *ctx) | ||
| 156 | { | ||
| 157 | const ASN1_TEMPLATE *tt, *errtt = NULL; | ||
| 158 | const ASN1_EXTERN_FUNCS *ef; | ||
| 159 | const ASN1_AUX *aux = it->funcs; | ||
| 160 | ASN1_aux_cb *asn1_cb; | ||
| 161 | const unsigned char *p = NULL, *q; | ||
| 162 | unsigned char oclass; | ||
| 163 | char seq_eoc, seq_nolen, cst, isopt; | ||
| 164 | long tmplen; | ||
| 165 | int i; | ||
| 166 | int otag; | ||
| 167 | int ret = 0; | ||
| 168 | ASN1_VALUE **pchptr; | ||
| 169 | |||
| 170 | if (!pval) | ||
| 171 | return 0; | ||
| 172 | |||
| 173 | if (aux && aux->asn1_cb) | ||
| 174 | asn1_cb = aux->asn1_cb; | ||
| 175 | else | ||
| 176 | asn1_cb = 0; | ||
| 177 | |||
| 178 | switch (it->itype) { | ||
| 179 | case ASN1_ITYPE_PRIMITIVE: | ||
| 180 | if (it->templates) { | ||
| 181 | /* tagging or OPTIONAL is currently illegal on an item | ||
| 182 | * template because the flags can't get passed down. | ||
| 183 | * In practice this isn't a problem: we include the | ||
| 184 | * relevant flags from the item template in the | ||
| 185 | * template itself. | ||
| 186 | */ | ||
| 187 | if ((tag != -1) || opt) { | ||
| 188 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 189 | ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE); | ||
| 190 | goto err; | ||
| 191 | } | ||
| 192 | return asn1_template_ex_d2i(pval, in, len, | ||
| 193 | it->templates, opt, ctx); | ||
| 194 | } | ||
| 195 | return asn1_d2i_ex_primitive(pval, in, len, it, | ||
| 196 | tag, aclass, opt, ctx); | ||
| 197 | break; | ||
| 198 | |||
| 199 | case ASN1_ITYPE_MSTRING: | ||
| 200 | p = *in; | ||
| 201 | /* Just read in tag and class */ | ||
| 202 | ret = asn1_check_tlen(NULL, &otag, &oclass, NULL, NULL, | ||
| 203 | &p, len, -1, 0, 1, ctx); | ||
| 204 | if (!ret) { | ||
| 205 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 206 | ERR_R_NESTED_ASN1_ERROR); | ||
| 207 | goto err; | ||
| 208 | } | ||
| 209 | |||
| 210 | /* Must be UNIVERSAL class */ | ||
| 211 | if (oclass != V_ASN1_UNIVERSAL) { | ||
| 212 | /* If OPTIONAL, assume this is OK */ | ||
| 213 | if (opt) | ||
| 214 | return -1; | ||
| 215 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 216 | ASN1_R_MSTRING_NOT_UNIVERSAL); | ||
| 217 | goto err; | ||
| 218 | } | ||
| 219 | /* Check tag matches bit map */ | ||
| 220 | if (!(ASN1_tag2bit(otag) & it->utype)) { | ||
| 221 | /* If OPTIONAL, assume this is OK */ | ||
| 222 | if (opt) | ||
| 223 | return -1; | ||
| 224 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 225 | ASN1_R_MSTRING_WRONG_TAG); | ||
| 226 | goto err; | ||
| 227 | } | ||
| 228 | return asn1_d2i_ex_primitive(pval, in, len, | ||
| 229 | it, otag, 0, 0, ctx); | ||
| 230 | |||
| 231 | case ASN1_ITYPE_EXTERN: | ||
| 232 | /* Use new style d2i */ | ||
| 233 | ef = it->funcs; | ||
| 234 | return ef->asn1_ex_d2i(pval, in, len, | ||
| 235 | it, tag, aclass, opt, ctx); | ||
| 236 | |||
| 237 | case ASN1_ITYPE_CHOICE: | ||
| 238 | if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL)) | ||
| 239 | goto auxerr; | ||
| 240 | |||
| 241 | if (*pval) { | ||
| 242 | /* Free up and zero CHOICE value if initialised */ | ||
| 243 | i = asn1_get_choice_selector(pval, it); | ||
| 244 | if ((i >= 0) && (i < it->tcount)) { | ||
| 245 | tt = it->templates + i; | ||
| 246 | pchptr = asn1_get_field_ptr(pval, tt); | ||
| 247 | ASN1_template_free(pchptr, tt); | ||
| 248 | asn1_set_choice_selector(pval, -1, it); | ||
| 249 | } | ||
| 250 | } else if (!ASN1_item_ex_new(pval, it)) { | ||
| 251 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 252 | ERR_R_NESTED_ASN1_ERROR); | ||
| 253 | goto err; | ||
| 254 | } | ||
| 255 | /* CHOICE type, try each possibility in turn */ | ||
| 256 | p = *in; | ||
| 257 | for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) { | ||
| 258 | pchptr = asn1_get_field_ptr(pval, tt); | ||
| 259 | /* We mark field as OPTIONAL so its absence | ||
| 260 | * can be recognised. | ||
| 261 | */ | ||
| 262 | ret = asn1_template_ex_d2i(pchptr, &p, len, tt, 1, ctx); | ||
| 263 | /* If field not present, try the next one */ | ||
| 264 | if (ret == -1) | ||
| 265 | continue; | ||
| 266 | /* If positive return, read OK, break loop */ | ||
| 267 | if (ret > 0) | ||
| 268 | break; | ||
| 269 | /* Otherwise must be an ASN1 parsing error */ | ||
| 270 | errtt = tt; | ||
| 271 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 272 | ERR_R_NESTED_ASN1_ERROR); | ||
| 273 | goto err; | ||
| 274 | } | ||
| 275 | |||
| 276 | /* Did we fall off the end without reading anything? */ | ||
| 277 | if (i == it->tcount) { | ||
| 278 | /* If OPTIONAL, this is OK */ | ||
| 279 | if (opt) { | ||
| 280 | /* Free and zero it */ | ||
| 281 | ASN1_item_ex_free(pval, it); | ||
| 282 | return -1; | ||
| 283 | } | ||
| 284 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 285 | ASN1_R_NO_MATCHING_CHOICE_TYPE); | ||
| 286 | goto err; | ||
| 287 | } | ||
| 288 | |||
| 289 | asn1_set_choice_selector(pval, i, it); | ||
| 290 | *in = p; | ||
| 291 | if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL)) | ||
| 292 | goto auxerr; | ||
| 293 | return 1; | ||
| 294 | |||
| 295 | case ASN1_ITYPE_NDEF_SEQUENCE: | ||
| 296 | case ASN1_ITYPE_SEQUENCE: | ||
| 297 | p = *in; | ||
| 298 | tmplen = len; | ||
| 299 | |||
| 300 | /* If no IMPLICIT tagging set to SEQUENCE, UNIVERSAL */ | ||
| 301 | if (tag == -1) { | ||
| 302 | tag = V_ASN1_SEQUENCE; | ||
| 303 | aclass = V_ASN1_UNIVERSAL; | ||
| 304 | } | ||
| 305 | /* Get SEQUENCE length and update len, p */ | ||
| 306 | ret = asn1_check_tlen(&len, NULL, NULL, &seq_eoc, &cst, | ||
| 307 | &p, len, tag, aclass, opt, ctx); | ||
| 308 | if (!ret) { | ||
| 309 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 310 | ERR_R_NESTED_ASN1_ERROR); | ||
| 311 | goto err; | ||
| 312 | } else if (ret == -1) | ||
| 313 | return -1; | ||
| 314 | if (aux && (aux->flags & ASN1_AFLG_BROKEN)) { | ||
| 315 | len = tmplen - (p - *in); | ||
| 316 | seq_nolen = 1; | ||
| 317 | } | ||
| 318 | /* If indefinite we don't do a length check */ | ||
| 319 | else | ||
| 320 | seq_nolen = seq_eoc; | ||
| 321 | if (!cst) { | ||
| 322 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 323 | ASN1_R_SEQUENCE_NOT_CONSTRUCTED); | ||
| 324 | goto err; | ||
| 325 | } | ||
| 326 | |||
| 327 | if (!*pval && !ASN1_item_ex_new(pval, it)) { | ||
| 328 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 329 | ERR_R_NESTED_ASN1_ERROR); | ||
| 330 | goto err; | ||
| 331 | } | ||
| 332 | |||
| 333 | if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL)) | ||
| 334 | goto auxerr; | ||
| 335 | |||
| 336 | /* Free up and zero any ADB found */ | ||
| 337 | for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) { | ||
| 338 | if (tt->flags & ASN1_TFLG_ADB_MASK) { | ||
| 339 | const ASN1_TEMPLATE *seqtt; | ||
| 340 | ASN1_VALUE **pseqval; | ||
| 341 | seqtt = asn1_do_adb(pval, tt, 1); | ||
| 342 | if (!seqtt) | ||
| 343 | goto err; | ||
| 344 | pseqval = asn1_get_field_ptr(pval, seqtt); | ||
| 345 | ASN1_template_free(pseqval, seqtt); | ||
| 346 | } | ||
| 347 | } | ||
| 348 | |||
| 349 | /* Get each field entry */ | ||
| 350 | for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) { | ||
| 351 | const ASN1_TEMPLATE *seqtt; | ||
| 352 | ASN1_VALUE **pseqval; | ||
| 353 | seqtt = asn1_do_adb(pval, tt, 1); | ||
| 354 | if (!seqtt) | ||
| 355 | goto err; | ||
| 356 | pseqval = asn1_get_field_ptr(pval, seqtt); | ||
| 357 | /* Have we ran out of data? */ | ||
| 358 | if (!len) | ||
| 359 | break; | ||
| 360 | q = p; | ||
| 361 | if (asn1_check_eoc(&p, len)) { | ||
| 362 | if (!seq_eoc) { | ||
| 363 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 364 | ASN1_R_UNEXPECTED_EOC); | ||
| 365 | goto err; | ||
| 366 | } | ||
| 367 | len -= p - q; | ||
| 368 | seq_eoc = 0; | ||
| 369 | q = p; | ||
| 370 | break; | ||
| 371 | } | ||
| 372 | /* This determines the OPTIONAL flag value. The field | ||
| 373 | * cannot be omitted if it is the last of a SEQUENCE | ||
| 374 | * and there is still data to be read. This isn't | ||
| 375 | * strictly necessary but it increases efficiency in | ||
| 376 | * some cases. | ||
| 377 | */ | ||
| 378 | if (i == (it->tcount - 1)) | ||
| 379 | isopt = 0; | ||
| 380 | else | ||
| 381 | isopt = (char)(seqtt->flags & ASN1_TFLG_OPTIONAL); | ||
| 382 | /* attempt to read in field, allowing each to be | ||
| 383 | * OPTIONAL */ | ||
| 384 | |||
| 385 | ret = asn1_template_ex_d2i(pseqval, &p, len, | ||
| 386 | seqtt, isopt, ctx); | ||
| 387 | if (!ret) { | ||
| 388 | errtt = seqtt; | ||
| 389 | goto err; | ||
| 390 | } else if (ret == -1) { | ||
| 391 | /* OPTIONAL component absent. | ||
| 392 | * Free and zero the field. | ||
| 393 | */ | ||
| 394 | ASN1_template_free(pseqval, seqtt); | ||
| 395 | continue; | ||
| 396 | } | ||
| 397 | /* Update length */ | ||
| 398 | len -= p - q; | ||
| 399 | } | ||
| 400 | |||
| 401 | /* Check for EOC if expecting one */ | ||
| 402 | if (seq_eoc && !asn1_check_eoc(&p, len)) { | ||
| 403 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_MISSING_EOC); | ||
| 404 | goto err; | ||
| 405 | } | ||
| 406 | /* Check all data read */ | ||
| 407 | if (!seq_nolen && len) { | ||
| 408 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 409 | ASN1_R_SEQUENCE_LENGTH_MISMATCH); | ||
| 410 | goto err; | ||
| 411 | } | ||
| 412 | |||
| 413 | /* If we get here we've got no more data in the SEQUENCE, | ||
| 414 | * however we may not have read all fields so check all | ||
| 415 | * remaining are OPTIONAL and clear any that are. | ||
| 416 | */ | ||
| 417 | for (; i < it->tcount; tt++, i++) { | ||
| 418 | const ASN1_TEMPLATE *seqtt; | ||
| 419 | seqtt = asn1_do_adb(pval, tt, 1); | ||
| 420 | if (!seqtt) | ||
| 421 | goto err; | ||
| 422 | if (seqtt->flags & ASN1_TFLG_OPTIONAL) { | ||
| 423 | ASN1_VALUE **pseqval; | ||
| 424 | pseqval = asn1_get_field_ptr(pval, seqtt); | ||
| 425 | ASN1_template_free(pseqval, seqtt); | ||
| 426 | } else { | ||
| 427 | errtt = seqtt; | ||
| 428 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, | ||
| 429 | ASN1_R_FIELD_MISSING); | ||
| 430 | goto err; | ||
| 431 | } | ||
| 432 | } | ||
| 433 | /* Save encoding */ | ||
| 434 | if (!asn1_enc_save(pval, *in, p - *in, it)) { | ||
| 435 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ERR_R_MALLOC_FAILURE); | ||
| 436 | goto auxerr; | ||
| 437 | } | ||
| 438 | *in = p; | ||
| 439 | if (asn1_cb && !asn1_cb(ASN1_OP_D2I_POST, pval, it, NULL)) | ||
| 440 | goto auxerr; | ||
| 441 | return 1; | ||
| 442 | |||
| 443 | default: | ||
| 444 | return 0; | ||
| 445 | } | ||
| 446 | |||
| 447 | auxerr: | ||
| 448 | ASN1err(ASN1_F_ASN1_ITEM_EX_D2I, ASN1_R_AUX_ERROR); | ||
| 449 | err: | ||
| 450 | ASN1_item_ex_free(pval, it); | ||
| 451 | if (errtt) | ||
| 452 | ERR_asprintf_error_data("Field=%s, Type=%s", errtt->field_name, | ||
| 453 | it->sname); | ||
| 454 | else | ||
| 455 | ERR_asprintf_error_data("Type=%s", it->sname); | ||
| 456 | return 0; | ||
| 457 | } | ||
| 458 | |||
| 459 | /* Templates are handled with two separate functions. | ||
| 460 | * One handles any EXPLICIT tag and the other handles the rest. | ||
| 461 | */ | ||
| 462 | |||
| 463 | static int | ||
| 464 | asn1_template_ex_d2i(ASN1_VALUE **val, const unsigned char **in, long inlen, | ||
| 465 | const ASN1_TEMPLATE *tt, char opt, ASN1_TLC *ctx) | ||
| 466 | { | ||
| 467 | int flags, aclass; | ||
| 468 | int ret; | ||
| 469 | long len; | ||
| 470 | const unsigned char *p, *q; | ||
| 471 | char exp_eoc; | ||
| 472 | |||
| 473 | if (!val) | ||
| 474 | return 0; | ||
| 475 | flags = tt->flags; | ||
| 476 | aclass = flags & ASN1_TFLG_TAG_CLASS; | ||
| 477 | |||
| 478 | p = *in; | ||
| 479 | |||
| 480 | /* Check if EXPLICIT tag expected */ | ||
| 481 | if (flags & ASN1_TFLG_EXPTAG) { | ||
| 482 | char cst; | ||
| 483 | /* Need to work out amount of data available to the inner | ||
| 484 | * content and where it starts: so read in EXPLICIT header to | ||
| 485 | * get the info. | ||
| 486 | */ | ||
| 487 | ret = asn1_check_tlen(&len, NULL, NULL, &exp_eoc, &cst, | ||
| 488 | &p, inlen, tt->tag, aclass, opt, ctx); | ||
| 489 | q = p; | ||
| 490 | if (!ret) { | ||
| 491 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, | ||
| 492 | ERR_R_NESTED_ASN1_ERROR); | ||
| 493 | return 0; | ||
| 494 | } else if (ret == -1) | ||
| 495 | return -1; | ||
| 496 | if (!cst) { | ||
| 497 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, | ||
| 498 | ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED); | ||
| 499 | return 0; | ||
| 500 | } | ||
| 501 | /* We've found the field so it can't be OPTIONAL now */ | ||
| 502 | ret = asn1_template_noexp_d2i(val, &p, len, tt, 0, ctx); | ||
| 503 | if (!ret) { | ||
| 504 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, | ||
| 505 | ERR_R_NESTED_ASN1_ERROR); | ||
| 506 | return 0; | ||
| 507 | } | ||
| 508 | /* We read the field in OK so update length */ | ||
| 509 | len -= p - q; | ||
| 510 | if (exp_eoc) { | ||
| 511 | /* If NDEF we must have an EOC here */ | ||
| 512 | if (!asn1_check_eoc(&p, len)) { | ||
| 513 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, | ||
| 514 | ASN1_R_MISSING_EOC); | ||
| 515 | goto err; | ||
| 516 | } | ||
| 517 | } else { | ||
| 518 | /* Otherwise we must hit the EXPLICIT tag end or its | ||
| 519 | * an error */ | ||
| 520 | if (len) { | ||
| 521 | ASN1err(ASN1_F_ASN1_TEMPLATE_EX_D2I, | ||
| 522 | ASN1_R_EXPLICIT_LENGTH_MISMATCH); | ||
| 523 | goto err; | ||
| 524 | } | ||
| 525 | } | ||
| 526 | } else | ||
| 527 | return asn1_template_noexp_d2i(val, in, inlen, tt, opt, ctx); | ||
| 528 | |||
| 529 | *in = p; | ||
| 530 | return 1; | ||
| 531 | |||
| 532 | err: | ||
| 533 | ASN1_template_free(val, tt); | ||
| 534 | return 0; | ||
| 535 | } | ||
| 536 | |||
| 537 | static int | ||
| 538 | asn1_template_noexp_d2i(ASN1_VALUE **val, const unsigned char **in, long len, | ||
| 539 | const ASN1_TEMPLATE *tt, char opt, ASN1_TLC *ctx) | ||
| 540 | { | ||
| 541 | int flags, aclass; | ||
| 542 | int ret; | ||
| 543 | const unsigned char *p, *q; | ||
| 544 | |||
| 545 | if (!val) | ||
| 546 | return 0; | ||
| 547 | flags = tt->flags; | ||
| 548 | aclass = flags & ASN1_TFLG_TAG_CLASS; | ||
| 549 | |||
| 550 | p = *in; | ||
| 551 | q = p; | ||
| 552 | |||
| 553 | if (flags & ASN1_TFLG_SK_MASK) { | ||
| 554 | /* SET OF, SEQUENCE OF */ | ||
| 555 | int sktag, skaclass; | ||
| 556 | char sk_eoc; | ||
| 557 | /* First work out expected inner tag value */ | ||
| 558 | if (flags & ASN1_TFLG_IMPTAG) { | ||
| 559 | sktag = tt->tag; | ||
| 560 | skaclass = aclass; | ||
| 561 | } else { | ||
| 562 | skaclass = V_ASN1_UNIVERSAL; | ||
| 563 | if (flags & ASN1_TFLG_SET_OF) | ||
| 564 | sktag = V_ASN1_SET; | ||
| 565 | else | ||
| 566 | sktag = V_ASN1_SEQUENCE; | ||
| 567 | } | ||
| 568 | /* Get the tag */ | ||
| 569 | ret = asn1_check_tlen(&len, NULL, NULL, &sk_eoc, NULL, | ||
| 570 | &p, len, sktag, skaclass, opt, ctx); | ||
| 571 | if (!ret) { | ||
| 572 | ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, | ||
| 573 | ERR_R_NESTED_ASN1_ERROR); | ||
| 574 | return 0; | ||
| 575 | } else if (ret == -1) | ||
| 576 | return -1; | ||
| 577 | if (!*val) | ||
| 578 | *val = (ASN1_VALUE *)sk_new_null(); | ||
| 579 | else { | ||
| 580 | /* We've got a valid STACK: free up any items present */ | ||
| 581 | STACK_OF(ASN1_VALUE) *sktmp = | ||
| 582 | (STACK_OF(ASN1_VALUE) *)*val; | ||
| 583 | ASN1_VALUE *vtmp; | ||
| 584 | while (sk_ASN1_VALUE_num(sktmp) > 0) { | ||
| 585 | vtmp = sk_ASN1_VALUE_pop(sktmp); | ||
| 586 | ASN1_item_ex_free(&vtmp, | ||
| 587 | ASN1_ITEM_ptr(tt->item)); | ||
| 588 | } | ||
| 589 | } | ||
| 590 | |||
| 591 | if (!*val) { | ||
| 592 | ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, | ||
| 593 | ERR_R_MALLOC_FAILURE); | ||
| 594 | goto err; | ||
| 595 | } | ||
| 596 | |||
| 597 | /* Read as many items as we can */ | ||
| 598 | while (len > 0) { | ||
| 599 | ASN1_VALUE *skfield; | ||
| 600 | q = p; | ||
| 601 | /* See if EOC found */ | ||
| 602 | if (asn1_check_eoc(&p, len)) { | ||
| 603 | if (!sk_eoc) { | ||
| 604 | ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, | ||
| 605 | ASN1_R_UNEXPECTED_EOC); | ||
| 606 | goto err; | ||
| 607 | } | ||
| 608 | len -= p - q; | ||
| 609 | sk_eoc = 0; | ||
| 610 | break; | ||
| 611 | } | ||
| 612 | skfield = NULL; | ||
| 613 | if (!ASN1_item_ex_d2i(&skfield, &p, len, | ||
| 614 | ASN1_ITEM_ptr(tt->item), -1, 0, 0, ctx)) { | ||
| 615 | ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, | ||
| 616 | ERR_R_NESTED_ASN1_ERROR); | ||
| 617 | goto err; | ||
| 618 | } | ||
| 619 | len -= p - q; | ||
| 620 | if (!sk_ASN1_VALUE_push((STACK_OF(ASN1_VALUE) *)*val, | ||
| 621 | skfield)) { | ||
| 622 | ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, | ||
| 623 | ERR_R_MALLOC_FAILURE); | ||
| 624 | goto err; | ||
| 625 | } | ||
| 626 | } | ||
| 627 | if (sk_eoc) { | ||
| 628 | ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, | ||
| 629 | ASN1_R_MISSING_EOC); | ||
| 630 | goto err; | ||
| 631 | } | ||
| 632 | } else if (flags & ASN1_TFLG_IMPTAG) { | ||
| 633 | /* IMPLICIT tagging */ | ||
| 634 | ret = ASN1_item_ex_d2i(val, &p, len, | ||
| 635 | ASN1_ITEM_ptr(tt->item), tt->tag, aclass, opt, ctx); | ||
| 636 | if (!ret) { | ||
| 637 | ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, | ||
| 638 | ERR_R_NESTED_ASN1_ERROR); | ||
| 639 | goto err; | ||
| 640 | } else if (ret == -1) | ||
| 641 | return -1; | ||
| 642 | } else { | ||
| 643 | /* Nothing special */ | ||
| 644 | ret = ASN1_item_ex_d2i(val, &p, len, ASN1_ITEM_ptr(tt->item), | ||
| 645 | -1, 0, opt, ctx); | ||
| 646 | if (!ret) { | ||
| 647 | ASN1err(ASN1_F_ASN1_TEMPLATE_NOEXP_D2I, | ||
| 648 | ERR_R_NESTED_ASN1_ERROR); | ||
| 649 | goto err; | ||
| 650 | } else if (ret == -1) | ||
| 651 | return -1; | ||
| 652 | } | ||
| 653 | |||
| 654 | *in = p; | ||
| 655 | return 1; | ||
| 656 | |||
| 657 | err: | ||
| 658 | ASN1_template_free(val, tt); | ||
| 659 | return 0; | ||
| 660 | } | ||
| 661 | |||
| 662 | static int | ||
| 663 | asn1_d2i_ex_primitive(ASN1_VALUE **pval, const unsigned char **in, long inlen, | ||
| 664 | const ASN1_ITEM *it, int tag, int aclass, char opt, ASN1_TLC *ctx) | ||
| 665 | { | ||
| 666 | int ret = 0, utype; | ||
| 667 | long plen; | ||
| 668 | char cst, inf, free_cont = 0; | ||
| 669 | const unsigned char *p; | ||
| 670 | BUF_MEM buf; | ||
| 671 | const unsigned char *cont = NULL; | ||
| 672 | long len; | ||
| 673 | |||
| 674 | if (!pval) { | ||
| 675 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ASN1_R_ILLEGAL_NULL); | ||
| 676 | return 0; /* Should never happen */ | ||
| 677 | } | ||
| 678 | |||
| 679 | if (it->itype == ASN1_ITYPE_MSTRING) { | ||
| 680 | utype = tag; | ||
| 681 | tag = -1; | ||
| 682 | } else | ||
| 683 | utype = it->utype; | ||
| 684 | |||
| 685 | if (utype == V_ASN1_ANY) { | ||
| 686 | /* If type is ANY need to figure out type from tag */ | ||
| 687 | unsigned char oclass; | ||
| 688 | if (tag >= 0) { | ||
| 689 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, | ||
| 690 | ASN1_R_ILLEGAL_TAGGED_ANY); | ||
| 691 | return 0; | ||
| 692 | } | ||
| 693 | if (opt) { | ||
| 694 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, | ||
| 695 | ASN1_R_ILLEGAL_OPTIONAL_ANY); | ||
| 696 | return 0; | ||
| 697 | } | ||
| 698 | p = *in; | ||
| 699 | ret = asn1_check_tlen(NULL, &utype, &oclass, NULL, NULL, | ||
| 700 | &p, inlen, -1, 0, 0, ctx); | ||
| 701 | if (!ret) { | ||
| 702 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, | ||
| 703 | ERR_R_NESTED_ASN1_ERROR); | ||
| 704 | return 0; | ||
| 705 | } | ||
| 706 | if (oclass != V_ASN1_UNIVERSAL) | ||
| 707 | utype = V_ASN1_OTHER; | ||
| 708 | } | ||
| 709 | if (tag == -1) { | ||
| 710 | tag = utype; | ||
| 711 | aclass = V_ASN1_UNIVERSAL; | ||
| 712 | } | ||
| 713 | p = *in; | ||
| 714 | /* Check header */ | ||
| 715 | ret = asn1_check_tlen(&plen, NULL, NULL, &inf, &cst, | ||
| 716 | &p, inlen, tag, aclass, opt, ctx); | ||
| 717 | if (!ret) { | ||
| 718 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, ERR_R_NESTED_ASN1_ERROR); | ||
| 719 | return 0; | ||
| 720 | } else if (ret == -1) | ||
| 721 | return -1; | ||
| 722 | ret = 0; | ||
| 723 | /* SEQUENCE, SET and "OTHER" are left in encoded form */ | ||
| 724 | if ((utype == V_ASN1_SEQUENCE) || (utype == V_ASN1_SET) || | ||
| 725 | (utype == V_ASN1_OTHER)) { | ||
| 726 | /* Clear context cache for type OTHER because the auto clear | ||
| 727 | * when we have a exact match wont work | ||
| 728 | */ | ||
| 729 | if (utype == V_ASN1_OTHER) { | ||
| 730 | asn1_tlc_clear(ctx); | ||
| 731 | } | ||
| 732 | /* SEQUENCE and SET must be constructed */ | ||
| 733 | else if (!cst) { | ||
| 734 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, | ||
| 735 | ASN1_R_TYPE_NOT_CONSTRUCTED); | ||
| 736 | return 0; | ||
| 737 | } | ||
| 738 | |||
| 739 | cont = *in; | ||
| 740 | /* If indefinite length constructed find the real end */ | ||
| 741 | if (inf) { | ||
| 742 | if (!asn1_find_end(&p, plen, inf)) | ||
| 743 | goto err; | ||
| 744 | len = p - cont; | ||
| 745 | } else { | ||
| 746 | len = p - cont + plen; | ||
| 747 | p += plen; | ||
| 748 | buf.data = NULL; | ||
| 749 | } | ||
| 750 | } else if (cst) { | ||
| 751 | buf.length = 0; | ||
| 752 | buf.max = 0; | ||
| 753 | buf.data = NULL; | ||
| 754 | /* Should really check the internal tags are correct but | ||
| 755 | * some things may get this wrong. The relevant specs | ||
| 756 | * say that constructed string types should be OCTET STRINGs | ||
| 757 | * internally irrespective of the type. So instead just check | ||
| 758 | * for UNIVERSAL class and ignore the tag. | ||
| 759 | */ | ||
| 760 | if (!asn1_collect(&buf, &p, plen, inf, -1, V_ASN1_UNIVERSAL, 0)) { | ||
| 761 | free_cont = 1; | ||
| 762 | goto err; | ||
| 763 | } | ||
| 764 | len = buf.length; | ||
| 765 | /* Append a final null to string */ | ||
| 766 | if (!BUF_MEM_grow_clean(&buf, len + 1)) { | ||
| 767 | ASN1err(ASN1_F_ASN1_D2I_EX_PRIMITIVE, | ||
| 768 | ERR_R_MALLOC_FAILURE); | ||
| 769 | return 0; | ||
| 770 | } | ||
| 771 | buf.data[len] = 0; | ||
| 772 | cont = (const unsigned char *)buf.data; | ||
| 773 | free_cont = 1; | ||
| 774 | } else { | ||
| 775 | cont = p; | ||
| 776 | len = plen; | ||
| 777 | p += plen; | ||
| 778 | } | ||
| 779 | |||
| 780 | /* We now have content length and type: translate into a structure */ | ||
| 781 | if (!asn1_ex_c2i(pval, cont, len, utype, &free_cont, it)) | ||
| 782 | goto err; | ||
| 783 | |||
| 784 | *in = p; | ||
| 785 | ret = 1; | ||
| 786 | |||
| 787 | err: | ||
| 788 | if (free_cont && buf.data) | ||
| 789 | free(buf.data); | ||
| 790 | return ret; | ||
| 791 | } | ||
| 792 | |||
| 793 | /* Translate ASN1 content octets into a structure */ | ||
| 794 | |||
| 795 | int | ||
| 796 | asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, | ||
| 797 | char *free_cont, const ASN1_ITEM *it) | ||
| 798 | { | ||
| 799 | ASN1_VALUE **opval = NULL; | ||
| 800 | ASN1_STRING *stmp; | ||
| 801 | ASN1_TYPE *typ = NULL; | ||
| 802 | int ret = 0; | ||
| 803 | const ASN1_PRIMITIVE_FUNCS *pf; | ||
| 804 | ASN1_INTEGER **tint; | ||
| 805 | |||
| 806 | pf = it->funcs; | ||
| 807 | |||
| 808 | if (pf && pf->prim_c2i) | ||
| 809 | return pf->prim_c2i(pval, cont, len, utype, free_cont, it); | ||
| 810 | /* If ANY type clear type and set pointer to internal value */ | ||
| 811 | if (it->utype == V_ASN1_ANY) { | ||
| 812 | if (!*pval) { | ||
| 813 | typ = ASN1_TYPE_new(); | ||
| 814 | if (typ == NULL) | ||
| 815 | goto err; | ||
| 816 | *pval = (ASN1_VALUE *)typ; | ||
| 817 | } else | ||
| 818 | typ = (ASN1_TYPE *)*pval; | ||
| 819 | |||
| 820 | if (utype != typ->type) | ||
| 821 | ASN1_TYPE_set(typ, utype, NULL); | ||
| 822 | opval = pval; | ||
| 823 | pval = &typ->value.asn1_value; | ||
| 824 | } | ||
| 825 | switch (utype) { | ||
| 826 | case V_ASN1_OBJECT: | ||
| 827 | if (!c2i_ASN1_OBJECT((ASN1_OBJECT **)pval, &cont, len)) | ||
| 828 | goto err; | ||
| 829 | break; | ||
| 830 | |||
| 831 | case V_ASN1_NULL: | ||
| 832 | if (len) { | ||
| 833 | ASN1err(ASN1_F_ASN1_EX_C2I, | ||
| 834 | ASN1_R_NULL_IS_WRONG_LENGTH); | ||
| 835 | goto err; | ||
| 836 | } | ||
| 837 | *pval = (ASN1_VALUE *)1; | ||
| 838 | break; | ||
| 839 | |||
| 840 | case V_ASN1_BOOLEAN: | ||
| 841 | if (len != 1) { | ||
| 842 | ASN1err(ASN1_F_ASN1_EX_C2I, | ||
| 843 | ASN1_R_BOOLEAN_IS_WRONG_LENGTH); | ||
| 844 | goto err; | ||
| 845 | } else { | ||
| 846 | ASN1_BOOLEAN *tbool; | ||
| 847 | tbool = (ASN1_BOOLEAN *)pval; | ||
| 848 | *tbool = *cont; | ||
| 849 | } | ||
| 850 | break; | ||
| 851 | |||
| 852 | case V_ASN1_BIT_STRING: | ||
| 853 | if (!c2i_ASN1_BIT_STRING((ASN1_BIT_STRING **)pval, &cont, len)) | ||
| 854 | goto err; | ||
| 855 | break; | ||
| 856 | |||
| 857 | case V_ASN1_INTEGER: | ||
| 858 | case V_ASN1_NEG_INTEGER: | ||
| 859 | case V_ASN1_ENUMERATED: | ||
| 860 | case V_ASN1_NEG_ENUMERATED: | ||
| 861 | tint = (ASN1_INTEGER **)pval; | ||
| 862 | if (!c2i_ASN1_INTEGER(tint, &cont, len)) | ||
| 863 | goto err; | ||
| 864 | /* Fixup type to match the expected form */ | ||
| 865 | (*tint)->type = utype | ((*tint)->type & V_ASN1_NEG); | ||
| 866 | break; | ||
| 867 | |||
| 868 | case V_ASN1_OCTET_STRING: | ||
| 869 | case V_ASN1_NUMERICSTRING: | ||
| 870 | case V_ASN1_PRINTABLESTRING: | ||
| 871 | case V_ASN1_T61STRING: | ||
| 872 | case V_ASN1_VIDEOTEXSTRING: | ||
| 873 | case V_ASN1_IA5STRING: | ||
| 874 | case V_ASN1_UTCTIME: | ||
| 875 | case V_ASN1_GENERALIZEDTIME: | ||
| 876 | case V_ASN1_GRAPHICSTRING: | ||
| 877 | case V_ASN1_VISIBLESTRING: | ||
| 878 | case V_ASN1_GENERALSTRING: | ||
| 879 | case V_ASN1_UNIVERSALSTRING: | ||
| 880 | case V_ASN1_BMPSTRING: | ||
| 881 | case V_ASN1_UTF8STRING: | ||
| 882 | case V_ASN1_OTHER: | ||
| 883 | case V_ASN1_SET: | ||
| 884 | case V_ASN1_SEQUENCE: | ||
| 885 | default: | ||
| 886 | if (utype == V_ASN1_BMPSTRING && (len & 1)) { | ||
| 887 | ASN1err(ASN1_F_ASN1_EX_C2I, | ||
| 888 | ASN1_R_BMPSTRING_IS_WRONG_LENGTH); | ||
| 889 | goto err; | ||
| 890 | } | ||
| 891 | if (utype == V_ASN1_UNIVERSALSTRING && (len & 3)) { | ||
| 892 | ASN1err(ASN1_F_ASN1_EX_C2I, | ||
| 893 | ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH); | ||
| 894 | goto err; | ||
| 895 | } | ||
| 896 | /* All based on ASN1_STRING and handled the same */ | ||
| 897 | if (!*pval) { | ||
| 898 | stmp = ASN1_STRING_type_new(utype); | ||
| 899 | if (!stmp) { | ||
| 900 | ASN1err(ASN1_F_ASN1_EX_C2I, | ||
| 901 | ERR_R_MALLOC_FAILURE); | ||
| 902 | goto err; | ||
| 903 | } | ||
| 904 | *pval = (ASN1_VALUE *)stmp; | ||
| 905 | } else { | ||
| 906 | stmp = (ASN1_STRING *)*pval; | ||
| 907 | stmp->type = utype; | ||
| 908 | } | ||
| 909 | /* If we've already allocated a buffer use it */ | ||
| 910 | if (*free_cont) { | ||
| 911 | free(stmp->data); | ||
| 912 | stmp->data = (unsigned char *)cont; /* UGLY CAST! RL */ | ||
| 913 | stmp->length = len; | ||
| 914 | *free_cont = 0; | ||
| 915 | } else { | ||
| 916 | if (!ASN1_STRING_set(stmp, cont, len)) { | ||
| 917 | ASN1err(ASN1_F_ASN1_EX_C2I, | ||
| 918 | ERR_R_MALLOC_FAILURE); | ||
| 919 | ASN1_STRING_free(stmp); | ||
| 920 | *pval = NULL; | ||
| 921 | goto err; | ||
| 922 | } | ||
| 923 | } | ||
| 924 | break; | ||
| 925 | } | ||
| 926 | /* If ASN1_ANY and NULL type fix up value */ | ||
| 927 | if (typ && (utype == V_ASN1_NULL)) | ||
| 928 | typ->value.ptr = NULL; | ||
| 929 | |||
| 930 | ret = 1; | ||
| 931 | |||
| 932 | err: | ||
| 933 | if (!ret) { | ||
| 934 | ASN1_TYPE_free(typ); | ||
| 935 | if (opval) | ||
| 936 | *opval = NULL; | ||
| 937 | } | ||
| 938 | return ret; | ||
| 939 | } | ||
| 940 | |||
| 941 | |||
| 942 | /* This function finds the end of an ASN1 structure when passed its maximum | ||
| 943 | * length, whether it is indefinite length and a pointer to the content. | ||
| 944 | * This is more efficient than calling asn1_collect because it does not | ||
| 945 | * recurse on each indefinite length header. | ||
| 946 | */ | ||
| 947 | |||
| 948 | static int | ||
| 949 | asn1_find_end(const unsigned char **in, long len, char inf) | ||
| 950 | { | ||
| 951 | int expected_eoc; | ||
| 952 | long plen; | ||
| 953 | const unsigned char *p = *in, *q; | ||
| 954 | |||
| 955 | /* If not indefinite length constructed just add length */ | ||
| 956 | if (inf == 0) { | ||
| 957 | *in += len; | ||
| 958 | return 1; | ||
| 959 | } | ||
| 960 | expected_eoc = 1; | ||
| 961 | /* Indefinite length constructed form. Find the end when enough EOCs | ||
| 962 | * are found. If more indefinite length constructed headers | ||
| 963 | * are encountered increment the expected eoc count otherwise just | ||
| 964 | * skip to the end of the data. | ||
| 965 | */ | ||
| 966 | while (len > 0) { | ||
| 967 | if (asn1_check_eoc(&p, len)) { | ||
| 968 | expected_eoc--; | ||
| 969 | if (expected_eoc == 0) | ||
| 970 | break; | ||
| 971 | len -= 2; | ||
| 972 | continue; | ||
| 973 | } | ||
| 974 | q = p; | ||
| 975 | /* Just read in a header: only care about the length */ | ||
| 976 | if (!asn1_check_tlen(&plen, NULL, NULL, &inf, NULL, &p, len, | ||
| 977 | -1, 0, 0, NULL)) { | ||
| 978 | ASN1err(ASN1_F_ASN1_FIND_END, ERR_R_NESTED_ASN1_ERROR); | ||
| 979 | return 0; | ||
| 980 | } | ||
| 981 | if (inf) | ||
| 982 | expected_eoc++; | ||
| 983 | else | ||
| 984 | p += plen; | ||
| 985 | len -= p - q; | ||
| 986 | } | ||
| 987 | if (expected_eoc) { | ||
| 988 | ASN1err(ASN1_F_ASN1_FIND_END, ASN1_R_MISSING_EOC); | ||
| 989 | return 0; | ||
| 990 | } | ||
| 991 | *in = p; | ||
| 992 | return 1; | ||
| 993 | } | ||
| 994 | /* This function collects the asn1 data from a constructred string | ||
| 995 | * type into a buffer. The values of 'in' and 'len' should refer | ||
| 996 | * to the contents of the constructed type and 'inf' should be set | ||
| 997 | * if it is indefinite length. | ||
| 998 | */ | ||
| 999 | |||
| 1000 | #ifndef ASN1_MAX_STRING_NEST | ||
| 1001 | /* This determines how many levels of recursion are permitted in ASN1 | ||
| 1002 | * string types. If it is not limited stack overflows can occur. If set | ||
| 1003 | * to zero no recursion is allowed at all. Although zero should be adequate | ||
| 1004 | * examples exist that require a value of 1. So 5 should be more than enough. | ||
| 1005 | */ | ||
| 1006 | #define ASN1_MAX_STRING_NEST 5 | ||
| 1007 | #endif | ||
| 1008 | |||
| 1009 | static int | ||
| 1010 | asn1_collect(BUF_MEM *buf, const unsigned char **in, long len, char inf, | ||
| 1011 | int tag, int aclass, int depth) | ||
| 1012 | { | ||
| 1013 | const unsigned char *p, *q; | ||
| 1014 | long plen; | ||
| 1015 | char cst, ininf; | ||
| 1016 | |||
| 1017 | p = *in; | ||
| 1018 | inf &= 1; | ||
| 1019 | /* If no buffer and not indefinite length constructed just pass over | ||
| 1020 | * the encoded data */ | ||
| 1021 | if (!buf && !inf) { | ||
| 1022 | *in += len; | ||
| 1023 | return 1; | ||
| 1024 | } | ||
| 1025 | while (len > 0) { | ||
| 1026 | q = p; | ||
| 1027 | /* Check for EOC */ | ||
| 1028 | if (asn1_check_eoc(&p, len)) { | ||
| 1029 | /* EOC is illegal outside indefinite length | ||
| 1030 | * constructed form */ | ||
| 1031 | if (!inf) { | ||
| 1032 | ASN1err(ASN1_F_ASN1_COLLECT, | ||
| 1033 | ASN1_R_UNEXPECTED_EOC); | ||
| 1034 | return 0; | ||
| 1035 | } | ||
| 1036 | inf = 0; | ||
| 1037 | break; | ||
| 1038 | } | ||
| 1039 | |||
| 1040 | if (!asn1_check_tlen(&plen, NULL, NULL, &ininf, &cst, &p, | ||
| 1041 | len, tag, aclass, 0, NULL)) { | ||
| 1042 | ASN1err(ASN1_F_ASN1_COLLECT, ERR_R_NESTED_ASN1_ERROR); | ||
| 1043 | return 0; | ||
| 1044 | } | ||
| 1045 | |||
| 1046 | /* If indefinite length constructed update max length */ | ||
| 1047 | if (cst) { | ||
| 1048 | if (depth >= ASN1_MAX_STRING_NEST) { | ||
| 1049 | ASN1err(ASN1_F_ASN1_COLLECT, | ||
| 1050 | ASN1_R_NESTED_ASN1_STRING); | ||
| 1051 | return 0; | ||
| 1052 | } | ||
| 1053 | if (!asn1_collect(buf, &p, plen, ininf, tag, aclass, | ||
| 1054 | depth + 1)) | ||
| 1055 | return 0; | ||
| 1056 | } else if (plen && !collect_data(buf, &p, plen)) | ||
| 1057 | return 0; | ||
| 1058 | len -= p - q; | ||
| 1059 | } | ||
| 1060 | if (inf) { | ||
| 1061 | ASN1err(ASN1_F_ASN1_COLLECT, ASN1_R_MISSING_EOC); | ||
| 1062 | return 0; | ||
| 1063 | } | ||
| 1064 | *in = p; | ||
| 1065 | return 1; | ||
| 1066 | } | ||
| 1067 | |||
| 1068 | static int | ||
| 1069 | collect_data(BUF_MEM *buf, const unsigned char **p, long plen) | ||
| 1070 | { | ||
| 1071 | int len; | ||
| 1072 | if (buf) { | ||
| 1073 | len = buf->length; | ||
| 1074 | if (!BUF_MEM_grow_clean(buf, len + plen)) { | ||
| 1075 | ASN1err(ASN1_F_COLLECT_DATA, ERR_R_MALLOC_FAILURE); | ||
| 1076 | return 0; | ||
| 1077 | } | ||
| 1078 | memcpy(buf->data + len, *p, plen); | ||
| 1079 | } | ||
| 1080 | *p += plen; | ||
| 1081 | return 1; | ||
| 1082 | } | ||
| 1083 | |||
| 1084 | /* Check for ASN1 EOC and swallow it if found */ | ||
| 1085 | |||
| 1086 | static int | ||
| 1087 | asn1_check_eoc(const unsigned char **in, long len) | ||
| 1088 | { | ||
| 1089 | const unsigned char *p; | ||
| 1090 | |||
| 1091 | if (len < 2) | ||
| 1092 | return 0; | ||
| 1093 | p = *in; | ||
| 1094 | if (!p[0] && !p[1]) { | ||
| 1095 | *in += 2; | ||
| 1096 | return 1; | ||
| 1097 | } | ||
| 1098 | return 0; | ||
| 1099 | } | ||
| 1100 | |||
| 1101 | /* Check an ASN1 tag and length: a bit like ASN1_get_object | ||
| 1102 | * but it sets the length for indefinite length constructed | ||
| 1103 | * form, we don't know the exact length but we can set an | ||
| 1104 | * upper bound to the amount of data available minus the | ||
| 1105 | * header length just read. | ||
| 1106 | */ | ||
| 1107 | |||
| 1108 | static int | ||
| 1109 | asn1_check_tlen(long *olen, int *otag, unsigned char *oclass, char *inf, | ||
| 1110 | char *cst, const unsigned char **in, long len, int exptag, int expclass, | ||
| 1111 | char opt, ASN1_TLC *ctx) | ||
| 1112 | { | ||
| 1113 | int i; | ||
| 1114 | int ptag, pclass; | ||
| 1115 | long plen; | ||
| 1116 | const unsigned char *p, *q; | ||
| 1117 | |||
| 1118 | p = *in; | ||
| 1119 | q = p; | ||
| 1120 | |||
| 1121 | if (ctx && ctx->valid) { | ||
| 1122 | i = ctx->ret; | ||
| 1123 | plen = ctx->plen; | ||
| 1124 | pclass = ctx->pclass; | ||
| 1125 | ptag = ctx->ptag; | ||
| 1126 | p += ctx->hdrlen; | ||
| 1127 | } else { | ||
| 1128 | i = ASN1_get_object(&p, &plen, &ptag, &pclass, len); | ||
| 1129 | if (ctx) { | ||
| 1130 | ctx->ret = i; | ||
| 1131 | ctx->plen = plen; | ||
| 1132 | ctx->pclass = pclass; | ||
| 1133 | ctx->ptag = ptag; | ||
| 1134 | ctx->hdrlen = p - q; | ||
| 1135 | ctx->valid = 1; | ||
| 1136 | /* If definite length, and no error, length + | ||
| 1137 | * header can't exceed total amount of data available. | ||
| 1138 | */ | ||
| 1139 | if (!(i & 0x81) && ((plen + ctx->hdrlen) > len)) { | ||
| 1140 | ASN1err(ASN1_F_ASN1_CHECK_TLEN, | ||
| 1141 | ASN1_R_TOO_LONG); | ||
| 1142 | asn1_tlc_clear(ctx); | ||
| 1143 | return 0; | ||
| 1144 | } | ||
| 1145 | } | ||
| 1146 | } | ||
| 1147 | |||
| 1148 | if (i & 0x80) { | ||
| 1149 | ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_BAD_OBJECT_HEADER); | ||
| 1150 | asn1_tlc_clear(ctx); | ||
| 1151 | return 0; | ||
| 1152 | } | ||
| 1153 | if (exptag >= 0) { | ||
| 1154 | if ((exptag != ptag) || (expclass != pclass)) { | ||
| 1155 | /* If type is OPTIONAL, not an error: | ||
| 1156 | * indicate missing type. | ||
| 1157 | */ | ||
| 1158 | if (opt) | ||
| 1159 | return -1; | ||
| 1160 | asn1_tlc_clear(ctx); | ||
| 1161 | ASN1err(ASN1_F_ASN1_CHECK_TLEN, ASN1_R_WRONG_TAG); | ||
| 1162 | return 0; | ||
| 1163 | } | ||
| 1164 | /* We have a tag and class match: | ||
| 1165 | * assume we are going to do something with it */ | ||
| 1166 | asn1_tlc_clear(ctx); | ||
| 1167 | } | ||
| 1168 | |||
| 1169 | if (i & 1) | ||
| 1170 | plen = len - (p - q); | ||
| 1171 | if (inf) | ||
| 1172 | *inf = i & 1; | ||
| 1173 | if (cst) | ||
| 1174 | *cst = i & V_ASN1_CONSTRUCTED; | ||
| 1175 | if (olen) | ||
| 1176 | *olen = plen; | ||
| 1177 | if (oclass) | ||
| 1178 | *oclass = pclass; | ||
| 1179 | if (otag) | ||
| 1180 | *otag = ptag; | ||
| 1181 | |||
| 1182 | *in = p; | ||
| 1183 | return 1; | ||
| 1184 | } | ||
diff --git a/src/lib/libcrypto/asn1/tasn_enc.c b/src/lib/libcrypto/asn1/tasn_enc.c deleted file mode 100644 index c59033e54d..0000000000 --- a/src/lib/libcrypto/asn1/tasn_enc.c +++ /dev/null | |||
| @@ -1,654 +0,0 @@ | |||
| 1 | /* $OpenBSD: tasn_enc.c,v 1.16 2015/02/14 15:23:57 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000-2004 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 | #include <stddef.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1.h> | ||
| 63 | #include <openssl/asn1t.h> | ||
| 64 | #include <openssl/objects.h> | ||
| 65 | |||
| 66 | static int asn1_i2d_ex_primitive(ASN1_VALUE **pval, unsigned char **out, | ||
| 67 | const ASN1_ITEM *it, int tag, int aclass); | ||
| 68 | static int asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out, | ||
| 69 | int skcontlen, const ASN1_ITEM *item, int do_sort, int iclass); | ||
| 70 | static int asn1_template_ex_i2d(ASN1_VALUE **pval, unsigned char **out, | ||
| 71 | const ASN1_TEMPLATE *tt, int tag, int aclass); | ||
| 72 | static int asn1_item_flags_i2d(ASN1_VALUE *val, unsigned char **out, | ||
| 73 | const ASN1_ITEM *it, int flags); | ||
| 74 | static int asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cout, int *putype, | ||
| 75 | const ASN1_ITEM *it); | ||
| 76 | |||
| 77 | /* Top level i2d equivalents: the 'ndef' variant instructs the encoder | ||
| 78 | * to use indefinite length constructed encoding, where appropriate | ||
| 79 | */ | ||
| 80 | |||
| 81 | int | ||
| 82 | ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it) | ||
| 83 | { | ||
| 84 | return asn1_item_flags_i2d(val, out, it, ASN1_TFLG_NDEF); | ||
| 85 | } | ||
| 86 | |||
| 87 | int | ||
| 88 | ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it) | ||
| 89 | { | ||
| 90 | return asn1_item_flags_i2d(val, out, it, 0); | ||
| 91 | } | ||
| 92 | |||
| 93 | /* Encode an ASN1 item, this is use by the | ||
| 94 | * standard 'i2d' function. 'out' points to | ||
| 95 | * a buffer to output the data to. | ||
| 96 | * | ||
| 97 | * The new i2d has one additional feature. If the output | ||
| 98 | * buffer is NULL (i.e. *out == NULL) then a buffer is | ||
| 99 | * allocated and populated with the encoding. | ||
| 100 | */ | ||
| 101 | |||
| 102 | static int | ||
| 103 | asn1_item_flags_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it, | ||
| 104 | int flags) | ||
| 105 | { | ||
| 106 | if (out && !*out) { | ||
| 107 | unsigned char *p, *buf; | ||
| 108 | int len; | ||
| 109 | len = ASN1_item_ex_i2d(&val, NULL, it, -1, flags); | ||
| 110 | if (len <= 0) | ||
| 111 | return len; | ||
| 112 | buf = malloc(len); | ||
| 113 | if (!buf) | ||
| 114 | return -1; | ||
| 115 | p = buf; | ||
| 116 | ASN1_item_ex_i2d(&val, &p, it, -1, flags); | ||
| 117 | *out = buf; | ||
| 118 | return len; | ||
| 119 | } | ||
| 120 | |||
| 121 | return ASN1_item_ex_i2d(&val, out, it, -1, flags); | ||
| 122 | } | ||
| 123 | |||
| 124 | /* Encode an item, taking care of IMPLICIT tagging (if any). | ||
| 125 | * This function performs the normal item handling: it can be | ||
| 126 | * used in external types. | ||
| 127 | */ | ||
| 128 | |||
| 129 | int | ||
| 130 | ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, const ASN1_ITEM *it, | ||
| 131 | int tag, int aclass) | ||
| 132 | { | ||
| 133 | const ASN1_TEMPLATE *tt = NULL; | ||
| 134 | int i, seqcontlen, seqlen, ndef = 1; | ||
| 135 | const ASN1_EXTERN_FUNCS *ef; | ||
| 136 | const ASN1_AUX *aux = it->funcs; | ||
| 137 | ASN1_aux_cb *asn1_cb = 0; | ||
| 138 | |||
| 139 | if ((it->itype != ASN1_ITYPE_PRIMITIVE) && !*pval) | ||
| 140 | return 0; | ||
| 141 | |||
| 142 | if (aux && aux->asn1_cb) | ||
| 143 | asn1_cb = aux->asn1_cb; | ||
| 144 | |||
| 145 | switch (it->itype) { | ||
| 146 | |||
| 147 | case ASN1_ITYPE_PRIMITIVE: | ||
| 148 | if (it->templates) | ||
| 149 | return asn1_template_ex_i2d(pval, out, it->templates, | ||
| 150 | tag, aclass); | ||
| 151 | return asn1_i2d_ex_primitive(pval, out, it, tag, aclass); | ||
| 152 | break; | ||
| 153 | |||
| 154 | case ASN1_ITYPE_MSTRING: | ||
| 155 | return asn1_i2d_ex_primitive(pval, out, it, -1, aclass); | ||
| 156 | |||
| 157 | case ASN1_ITYPE_CHOICE: | ||
| 158 | if (asn1_cb && !asn1_cb(ASN1_OP_I2D_PRE, pval, it, NULL)) | ||
| 159 | return 0; | ||
| 160 | i = asn1_get_choice_selector(pval, it); | ||
| 161 | if ((i >= 0) && (i < it->tcount)) { | ||
| 162 | ASN1_VALUE **pchval; | ||
| 163 | const ASN1_TEMPLATE *chtt; | ||
| 164 | chtt = it->templates + i; | ||
| 165 | pchval = asn1_get_field_ptr(pval, chtt); | ||
| 166 | return asn1_template_ex_i2d(pchval, out, chtt, | ||
| 167 | -1, aclass); | ||
| 168 | } | ||
| 169 | /* Fixme: error condition if selector out of range */ | ||
| 170 | if (asn1_cb && !asn1_cb(ASN1_OP_I2D_POST, pval, it, NULL)) | ||
| 171 | return 0; | ||
| 172 | break; | ||
| 173 | |||
| 174 | case ASN1_ITYPE_EXTERN: | ||
| 175 | /* If new style i2d it does all the work */ | ||
| 176 | ef = it->funcs; | ||
| 177 | return ef->asn1_ex_i2d(pval, out, it, tag, aclass); | ||
| 178 | |||
| 179 | case ASN1_ITYPE_NDEF_SEQUENCE: | ||
| 180 | /* Use indefinite length constructed if requested */ | ||
| 181 | if (aclass & ASN1_TFLG_NDEF) | ||
| 182 | ndef = 2; | ||
| 183 | /* fall through */ | ||
| 184 | |||
| 185 | case ASN1_ITYPE_SEQUENCE: | ||
| 186 | i = asn1_enc_restore(&seqcontlen, out, pval, it); | ||
| 187 | /* An error occurred */ | ||
| 188 | if (i < 0) | ||
| 189 | return 0; | ||
| 190 | /* We have a valid cached encoding... */ | ||
| 191 | if (i > 0) | ||
| 192 | return seqcontlen; | ||
| 193 | /* Otherwise carry on */ | ||
| 194 | seqcontlen = 0; | ||
| 195 | /* If no IMPLICIT tagging set to SEQUENCE, UNIVERSAL */ | ||
| 196 | if (tag == -1) { | ||
| 197 | tag = V_ASN1_SEQUENCE; | ||
| 198 | /* Retain any other flags in aclass */ | ||
| 199 | aclass = (aclass & ~ASN1_TFLG_TAG_CLASS) | | ||
| 200 | V_ASN1_UNIVERSAL; | ||
| 201 | } | ||
| 202 | if (asn1_cb && !asn1_cb(ASN1_OP_I2D_PRE, pval, it, NULL)) | ||
| 203 | return 0; | ||
| 204 | /* First work out sequence content length */ | ||
| 205 | for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) { | ||
| 206 | const ASN1_TEMPLATE *seqtt; | ||
| 207 | ASN1_VALUE **pseqval; | ||
| 208 | seqtt = asn1_do_adb(pval, tt, 1); | ||
| 209 | if (!seqtt) | ||
| 210 | return 0; | ||
| 211 | pseqval = asn1_get_field_ptr(pval, seqtt); | ||
| 212 | /* FIXME: check for errors in enhanced version */ | ||
| 213 | seqcontlen += asn1_template_ex_i2d(pseqval, NULL, seqtt, | ||
| 214 | -1, aclass); | ||
| 215 | } | ||
| 216 | |||
| 217 | seqlen = ASN1_object_size(ndef, seqcontlen, tag); | ||
| 218 | if (!out) | ||
| 219 | return seqlen; | ||
| 220 | /* Output SEQUENCE header */ | ||
| 221 | ASN1_put_object(out, ndef, seqcontlen, tag, aclass); | ||
| 222 | for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) { | ||
| 223 | const ASN1_TEMPLATE *seqtt; | ||
| 224 | ASN1_VALUE **pseqval; | ||
| 225 | seqtt = asn1_do_adb(pval, tt, 1); | ||
| 226 | if (!seqtt) | ||
| 227 | return 0; | ||
| 228 | pseqval = asn1_get_field_ptr(pval, seqtt); | ||
| 229 | /* FIXME: check for errors in enhanced version */ | ||
| 230 | asn1_template_ex_i2d(pseqval, out, seqtt, -1, aclass); | ||
| 231 | } | ||
| 232 | if (ndef == 2) | ||
| 233 | ASN1_put_eoc(out); | ||
| 234 | if (asn1_cb && !asn1_cb(ASN1_OP_I2D_POST, pval, it, NULL)) | ||
| 235 | return 0; | ||
| 236 | return seqlen; | ||
| 237 | |||
| 238 | default: | ||
| 239 | return 0; | ||
| 240 | |||
| 241 | } | ||
| 242 | return 0; | ||
| 243 | } | ||
| 244 | |||
| 245 | int | ||
| 246 | ASN1_template_i2d(ASN1_VALUE **pval, unsigned char **out, | ||
| 247 | const ASN1_TEMPLATE *tt) | ||
| 248 | { | ||
| 249 | return asn1_template_ex_i2d(pval, out, tt, -1, 0); | ||
| 250 | } | ||
| 251 | |||
| 252 | static int | ||
| 253 | asn1_template_ex_i2d(ASN1_VALUE **pval, unsigned char **out, | ||
| 254 | const ASN1_TEMPLATE *tt, int tag, int iclass) | ||
| 255 | { | ||
| 256 | int i, ret, flags, ttag, tclass, ndef; | ||
| 257 | flags = tt->flags; | ||
| 258 | /* Work out tag and class to use: tagging may come | ||
| 259 | * either from the template or the arguments, not both | ||
| 260 | * because this would create ambiguity. Additionally | ||
| 261 | * the iclass argument may contain some additional flags | ||
| 262 | * which should be noted and passed down to other levels. | ||
| 263 | */ | ||
| 264 | if (flags & ASN1_TFLG_TAG_MASK) { | ||
| 265 | /* Error if argument and template tagging */ | ||
| 266 | if (tag != -1) | ||
| 267 | /* FIXME: error code here */ | ||
| 268 | return -1; | ||
| 269 | /* Get tagging from template */ | ||
| 270 | ttag = tt->tag; | ||
| 271 | tclass = flags & ASN1_TFLG_TAG_CLASS; | ||
| 272 | } else if (tag != -1) { | ||
| 273 | /* No template tagging, get from arguments */ | ||
| 274 | ttag = tag; | ||
| 275 | tclass = iclass & ASN1_TFLG_TAG_CLASS; | ||
| 276 | } else { | ||
| 277 | ttag = -1; | ||
| 278 | tclass = 0; | ||
| 279 | } | ||
| 280 | /* | ||
| 281 | * Remove any class mask from iflag. | ||
| 282 | */ | ||
| 283 | iclass &= ~ASN1_TFLG_TAG_CLASS; | ||
| 284 | |||
| 285 | /* At this point 'ttag' contains the outer tag to use, | ||
| 286 | * 'tclass' is the class and iclass is any flags passed | ||
| 287 | * to this function. | ||
| 288 | */ | ||
| 289 | |||
| 290 | /* if template and arguments require ndef, use it */ | ||
| 291 | if ((flags & ASN1_TFLG_NDEF) && (iclass & ASN1_TFLG_NDEF)) | ||
| 292 | ndef = 2; | ||
| 293 | else | ||
| 294 | ndef = 1; | ||
| 295 | |||
| 296 | if (flags & ASN1_TFLG_SK_MASK) { | ||
| 297 | /* SET OF, SEQUENCE OF */ | ||
| 298 | STACK_OF(ASN1_VALUE) *sk = (STACK_OF(ASN1_VALUE) *)*pval; | ||
| 299 | int isset, sktag, skaclass; | ||
| 300 | int skcontlen, sklen; | ||
| 301 | ASN1_VALUE *skitem; | ||
| 302 | |||
| 303 | if (!*pval) | ||
| 304 | return 0; | ||
| 305 | |||
| 306 | if (flags & ASN1_TFLG_SET_OF) { | ||
| 307 | isset = 1; | ||
| 308 | /* 2 means we reorder */ | ||
| 309 | if (flags & ASN1_TFLG_SEQUENCE_OF) | ||
| 310 | isset = 2; | ||
| 311 | } else | ||
| 312 | isset = 0; | ||
| 313 | |||
| 314 | /* Work out inner tag value: if EXPLICIT | ||
| 315 | * or no tagging use underlying type. | ||
| 316 | */ | ||
| 317 | if ((ttag != -1) && !(flags & ASN1_TFLG_EXPTAG)) { | ||
| 318 | sktag = ttag; | ||
| 319 | skaclass = tclass; | ||
| 320 | } else { | ||
| 321 | skaclass = V_ASN1_UNIVERSAL; | ||
| 322 | if (isset) | ||
| 323 | sktag = V_ASN1_SET; | ||
| 324 | else | ||
| 325 | sktag = V_ASN1_SEQUENCE; | ||
| 326 | } | ||
| 327 | |||
| 328 | /* Determine total length of items */ | ||
| 329 | skcontlen = 0; | ||
| 330 | for (i = 0; i < sk_ASN1_VALUE_num(sk); i++) { | ||
| 331 | skitem = sk_ASN1_VALUE_value(sk, i); | ||
| 332 | skcontlen += ASN1_item_ex_i2d(&skitem, NULL, | ||
| 333 | ASN1_ITEM_ptr(tt->item), -1, iclass); | ||
| 334 | } | ||
| 335 | sklen = ASN1_object_size(ndef, skcontlen, sktag); | ||
| 336 | /* If EXPLICIT need length of surrounding tag */ | ||
| 337 | if (flags & ASN1_TFLG_EXPTAG) | ||
| 338 | ret = ASN1_object_size(ndef, sklen, ttag); | ||
| 339 | else | ||
| 340 | ret = sklen; | ||
| 341 | |||
| 342 | if (!out) | ||
| 343 | return ret; | ||
| 344 | |||
| 345 | /* Now encode this lot... */ | ||
| 346 | /* EXPLICIT tag */ | ||
| 347 | if (flags & ASN1_TFLG_EXPTAG) | ||
| 348 | ASN1_put_object(out, ndef, sklen, ttag, tclass); | ||
| 349 | /* SET or SEQUENCE and IMPLICIT tag */ | ||
| 350 | ASN1_put_object(out, ndef, skcontlen, sktag, skaclass); | ||
| 351 | /* And the stuff itself */ | ||
| 352 | asn1_set_seq_out(sk, out, skcontlen, ASN1_ITEM_ptr(tt->item), | ||
| 353 | isset, iclass); | ||
| 354 | if (ndef == 2) { | ||
| 355 | ASN1_put_eoc(out); | ||
| 356 | if (flags & ASN1_TFLG_EXPTAG) | ||
| 357 | ASN1_put_eoc(out); | ||
| 358 | } | ||
| 359 | |||
| 360 | return ret; | ||
| 361 | } | ||
| 362 | |||
| 363 | if (flags & ASN1_TFLG_EXPTAG) { | ||
| 364 | /* EXPLICIT tagging */ | ||
| 365 | /* Find length of tagged item */ | ||
| 366 | i = ASN1_item_ex_i2d(pval, NULL, ASN1_ITEM_ptr(tt->item), | ||
| 367 | -1, iclass); | ||
| 368 | if (!i) | ||
| 369 | return 0; | ||
| 370 | /* Find length of EXPLICIT tag */ | ||
| 371 | ret = ASN1_object_size(ndef, i, ttag); | ||
| 372 | if (out) { | ||
| 373 | /* Output tag and item */ | ||
| 374 | ASN1_put_object(out, ndef, i, ttag, tclass); | ||
| 375 | ASN1_item_ex_i2d(pval, out, ASN1_ITEM_ptr(tt->item), | ||
| 376 | -1, iclass); | ||
| 377 | if (ndef == 2) | ||
| 378 | ASN1_put_eoc(out); | ||
| 379 | } | ||
| 380 | return ret; | ||
| 381 | } | ||
| 382 | |||
| 383 | /* Either normal or IMPLICIT tagging: combine class and flags */ | ||
| 384 | return ASN1_item_ex_i2d(pval, out, ASN1_ITEM_ptr(tt->item), | ||
| 385 | ttag, tclass | iclass); | ||
| 386 | } | ||
| 387 | |||
| 388 | /* Temporary structure used to hold DER encoding of items for SET OF */ | ||
| 389 | |||
| 390 | typedef struct { | ||
| 391 | unsigned char *data; | ||
| 392 | int length; | ||
| 393 | ASN1_VALUE *field; | ||
| 394 | } DER_ENC; | ||
| 395 | |||
| 396 | static int | ||
| 397 | der_cmp(const void *a, const void *b) | ||
| 398 | { | ||
| 399 | const DER_ENC *d1 = a, *d2 = b; | ||
| 400 | int cmplen, i; | ||
| 401 | |||
| 402 | cmplen = (d1->length < d2->length) ? d1->length : d2->length; | ||
| 403 | i = memcmp(d1->data, d2->data, cmplen); | ||
| 404 | if (i) | ||
| 405 | return i; | ||
| 406 | return d1->length - d2->length; | ||
| 407 | } | ||
| 408 | |||
| 409 | /* Output the content octets of SET OF or SEQUENCE OF */ | ||
| 410 | |||
| 411 | static int | ||
| 412 | asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out, int skcontlen, | ||
| 413 | const ASN1_ITEM *item, int do_sort, int iclass) | ||
| 414 | { | ||
| 415 | int i; | ||
| 416 | ASN1_VALUE *skitem; | ||
| 417 | unsigned char *tmpdat = NULL, *p = NULL; | ||
| 418 | DER_ENC *derlst = NULL, *tder; | ||
| 419 | |||
| 420 | if (do_sort) { | ||
| 421 | /* Don't need to sort less than 2 items */ | ||
| 422 | if (sk_ASN1_VALUE_num(sk) < 2) | ||
| 423 | do_sort = 0; | ||
| 424 | else { | ||
| 425 | derlst = reallocarray(NULL, sk_ASN1_VALUE_num(sk), | ||
| 426 | sizeof(*derlst)); | ||
| 427 | tmpdat = malloc(skcontlen); | ||
| 428 | if (!derlst || !tmpdat) { | ||
| 429 | free(derlst); | ||
| 430 | free(tmpdat); | ||
| 431 | return 0; | ||
| 432 | } | ||
| 433 | } | ||
| 434 | } | ||
| 435 | /* If not sorting just output each item */ | ||
| 436 | if (!do_sort) { | ||
| 437 | for (i = 0; i < sk_ASN1_VALUE_num(sk); i++) { | ||
| 438 | skitem = sk_ASN1_VALUE_value(sk, i); | ||
| 439 | ASN1_item_ex_i2d(&skitem, out, item, -1, iclass); | ||
| 440 | } | ||
| 441 | return 1; | ||
| 442 | } | ||
| 443 | p = tmpdat; | ||
| 444 | |||
| 445 | /* Doing sort: build up a list of each member's DER encoding */ | ||
| 446 | for (i = 0, tder = derlst; i < sk_ASN1_VALUE_num(sk); i++, tder++) { | ||
| 447 | skitem = sk_ASN1_VALUE_value(sk, i); | ||
| 448 | tder->data = p; | ||
| 449 | tder->length = ASN1_item_ex_i2d(&skitem, &p, item, -1, iclass); | ||
| 450 | tder->field = skitem; | ||
| 451 | } | ||
| 452 | |||
| 453 | /* Now sort them */ | ||
| 454 | qsort(derlst, sk_ASN1_VALUE_num(sk), sizeof(*derlst), der_cmp); | ||
| 455 | /* Output sorted DER encoding */ | ||
| 456 | p = *out; | ||
| 457 | for (i = 0, tder = derlst; i < sk_ASN1_VALUE_num(sk); i++, tder++) { | ||
| 458 | memcpy(p, tder->data, tder->length); | ||
| 459 | p += tder->length; | ||
| 460 | } | ||
| 461 | *out = p; | ||
| 462 | /* If do_sort is 2 then reorder the STACK */ | ||
| 463 | if (do_sort == 2) { | ||
| 464 | for (i = 0, tder = derlst; i < sk_ASN1_VALUE_num(sk); i++, tder++) | ||
| 465 | (void)sk_ASN1_VALUE_set(sk, i, tder->field); | ||
| 466 | } | ||
| 467 | free(derlst); | ||
| 468 | free(tmpdat); | ||
| 469 | return 1; | ||
| 470 | } | ||
| 471 | |||
| 472 | static int | ||
| 473 | asn1_i2d_ex_primitive(ASN1_VALUE **pval, unsigned char **out, | ||
| 474 | const ASN1_ITEM *it, int tag, int aclass) | ||
| 475 | { | ||
| 476 | int len; | ||
| 477 | int utype; | ||
| 478 | int usetag; | ||
| 479 | int ndef = 0; | ||
| 480 | |||
| 481 | utype = it->utype; | ||
| 482 | |||
| 483 | /* Get length of content octets and maybe find | ||
| 484 | * out the underlying type. | ||
| 485 | */ | ||
| 486 | |||
| 487 | len = asn1_ex_i2c(pval, NULL, &utype, it); | ||
| 488 | |||
| 489 | /* If SEQUENCE, SET or OTHER then header is | ||
| 490 | * included in pseudo content octets so don't | ||
| 491 | * include tag+length. We need to check here | ||
| 492 | * because the call to asn1_ex_i2c() could change | ||
| 493 | * utype. | ||
| 494 | */ | ||
| 495 | if ((utype == V_ASN1_SEQUENCE) || (utype == V_ASN1_SET) || | ||
| 496 | (utype == V_ASN1_OTHER)) | ||
| 497 | usetag = 0; | ||
| 498 | else | ||
| 499 | usetag = 1; | ||
| 500 | |||
| 501 | /* -1 means omit type */ | ||
| 502 | if (len == -1) | ||
| 503 | return 0; | ||
| 504 | |||
| 505 | /* -2 return is special meaning use ndef */ | ||
| 506 | if (len == -2) { | ||
| 507 | ndef = 2; | ||
| 508 | len = 0; | ||
| 509 | } | ||
| 510 | |||
| 511 | /* If not implicitly tagged get tag from underlying type */ | ||
| 512 | if (tag == -1) | ||
| 513 | tag = utype; | ||
| 514 | |||
| 515 | /* Output tag+length followed by content octets */ | ||
| 516 | if (out) { | ||
| 517 | if (usetag) | ||
| 518 | ASN1_put_object(out, ndef, len, tag, aclass); | ||
| 519 | asn1_ex_i2c(pval, *out, &utype, it); | ||
| 520 | if (ndef) | ||
| 521 | ASN1_put_eoc(out); | ||
| 522 | else | ||
| 523 | *out += len; | ||
| 524 | } | ||
| 525 | |||
| 526 | if (usetag) | ||
| 527 | return ASN1_object_size(ndef, len, tag); | ||
| 528 | return len; | ||
| 529 | } | ||
| 530 | |||
| 531 | /* Produce content octets from a structure */ | ||
| 532 | |||
| 533 | static int | ||
| 534 | asn1_ex_i2c(ASN1_VALUE **pval, unsigned char *cout, int *putype, | ||
| 535 | const ASN1_ITEM *it) | ||
| 536 | { | ||
| 537 | ASN1_BOOLEAN *tbool = NULL; | ||
| 538 | ASN1_STRING *strtmp; | ||
| 539 | ASN1_OBJECT *otmp; | ||
| 540 | int utype; | ||
| 541 | const unsigned char *cont; | ||
| 542 | unsigned char c; | ||
| 543 | int len; | ||
| 544 | const ASN1_PRIMITIVE_FUNCS *pf; | ||
| 545 | |||
| 546 | pf = it->funcs; | ||
| 547 | if (pf && pf->prim_i2c) | ||
| 548 | return pf->prim_i2c(pval, cout, putype, it); | ||
| 549 | |||
| 550 | /* Should type be omitted? */ | ||
| 551 | if ((it->itype != ASN1_ITYPE_PRIMITIVE) || | ||
| 552 | (it->utype != V_ASN1_BOOLEAN)) { | ||
| 553 | if (!*pval) | ||
| 554 | return -1; | ||
| 555 | } | ||
| 556 | |||
| 557 | if (it->itype == ASN1_ITYPE_MSTRING) { | ||
| 558 | /* If MSTRING type set the underlying type */ | ||
| 559 | strtmp = (ASN1_STRING *)*pval; | ||
| 560 | utype = strtmp->type; | ||
| 561 | *putype = utype; | ||
| 562 | } else if (it->utype == V_ASN1_ANY) { | ||
| 563 | /* If ANY set type and pointer to value */ | ||
| 564 | ASN1_TYPE *typ; | ||
| 565 | typ = (ASN1_TYPE *)*pval; | ||
| 566 | utype = typ->type; | ||
| 567 | *putype = utype; | ||
| 568 | pval = &typ->value.asn1_value; | ||
| 569 | } else | ||
| 570 | utype = *putype; | ||
| 571 | |||
| 572 | switch (utype) { | ||
| 573 | case V_ASN1_OBJECT: | ||
| 574 | otmp = (ASN1_OBJECT *)*pval; | ||
| 575 | cont = otmp->data; | ||
| 576 | len = otmp->length; | ||
| 577 | break; | ||
| 578 | |||
| 579 | case V_ASN1_NULL: | ||
| 580 | cont = NULL; | ||
| 581 | len = 0; | ||
| 582 | break; | ||
| 583 | |||
| 584 | case V_ASN1_BOOLEAN: | ||
| 585 | tbool = (ASN1_BOOLEAN *)pval; | ||
| 586 | if (*tbool == -1) | ||
| 587 | return -1; | ||
| 588 | if (it->utype != V_ASN1_ANY) { | ||
| 589 | /* Default handling if value == size field then omit */ | ||
| 590 | if (*tbool && (it->size > 0)) | ||
| 591 | return -1; | ||
| 592 | if (!*tbool && !it->size) | ||
| 593 | return -1; | ||
| 594 | } | ||
| 595 | c = (unsigned char)*tbool; | ||
| 596 | cont = &c; | ||
| 597 | len = 1; | ||
| 598 | break; | ||
| 599 | |||
| 600 | case V_ASN1_BIT_STRING: | ||
| 601 | return i2c_ASN1_BIT_STRING((ASN1_BIT_STRING *)*pval, | ||
| 602 | cout ? &cout : NULL); | ||
| 603 | break; | ||
| 604 | |||
| 605 | case V_ASN1_INTEGER: | ||
| 606 | case V_ASN1_NEG_INTEGER: | ||
| 607 | case V_ASN1_ENUMERATED: | ||
| 608 | case V_ASN1_NEG_ENUMERATED: | ||
| 609 | /* These are all have the same content format | ||
| 610 | * as ASN1_INTEGER | ||
| 611 | */ | ||
| 612 | return i2c_ASN1_INTEGER((ASN1_INTEGER *)*pval, | ||
| 613 | cout ? &cout : NULL); | ||
| 614 | break; | ||
| 615 | |||
| 616 | case V_ASN1_OCTET_STRING: | ||
| 617 | case V_ASN1_NUMERICSTRING: | ||
| 618 | case V_ASN1_PRINTABLESTRING: | ||
| 619 | case V_ASN1_T61STRING: | ||
| 620 | case V_ASN1_VIDEOTEXSTRING: | ||
| 621 | case V_ASN1_IA5STRING: | ||
| 622 | case V_ASN1_UTCTIME: | ||
| 623 | case V_ASN1_GENERALIZEDTIME: | ||
| 624 | case V_ASN1_GRAPHICSTRING: | ||
| 625 | case V_ASN1_VISIBLESTRING: | ||
| 626 | case V_ASN1_GENERALSTRING: | ||
| 627 | case V_ASN1_UNIVERSALSTRING: | ||
| 628 | case V_ASN1_BMPSTRING: | ||
| 629 | case V_ASN1_UTF8STRING: | ||
| 630 | case V_ASN1_SEQUENCE: | ||
| 631 | case V_ASN1_SET: | ||
| 632 | default: | ||
| 633 | /* All based on ASN1_STRING and handled the same */ | ||
| 634 | strtmp = (ASN1_STRING *)*pval; | ||
| 635 | /* Special handling for NDEF */ | ||
| 636 | if ((it->size == ASN1_TFLG_NDEF) && | ||
| 637 | (strtmp->flags & ASN1_STRING_FLAG_NDEF)) { | ||
| 638 | if (cout) { | ||
| 639 | strtmp->data = cout; | ||
| 640 | strtmp->length = 0; | ||
| 641 | } | ||
| 642 | /* Special return code */ | ||
| 643 | return -2; | ||
| 644 | } | ||
| 645 | cont = strtmp->data; | ||
| 646 | len = strtmp->length; | ||
| 647 | |||
| 648 | break; | ||
| 649 | |||
| 650 | } | ||
| 651 | if (cout && len) | ||
| 652 | memcpy(cout, cont, len); | ||
| 653 | return len; | ||
| 654 | } | ||
diff --git a/src/lib/libcrypto/asn1/tasn_fre.c b/src/lib/libcrypto/asn1/tasn_fre.c deleted file mode 100644 index 30d68786b1..0000000000 --- a/src/lib/libcrypto/asn1/tasn_fre.c +++ /dev/null | |||
| @@ -1,243 +0,0 @@ | |||
| 1 | /* $OpenBSD: tasn_fre.c,v 1.14 2015/02/14 15:23:57 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000 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 | |||
| 60 | #include <stddef.h> | ||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/asn1t.h> | ||
| 63 | #include <openssl/objects.h> | ||
| 64 | |||
| 65 | static void asn1_item_combine_free(ASN1_VALUE **pval, const ASN1_ITEM *it, | ||
| 66 | int combine); | ||
| 67 | |||
| 68 | /* Free up an ASN1 structure */ | ||
| 69 | |||
| 70 | void | ||
| 71 | ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it) | ||
| 72 | { | ||
| 73 | asn1_item_combine_free(&val, it, 0); | ||
| 74 | } | ||
| 75 | |||
| 76 | void | ||
| 77 | ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 78 | { | ||
| 79 | asn1_item_combine_free(pval, it, 0); | ||
| 80 | } | ||
| 81 | |||
| 82 | static void | ||
| 83 | asn1_item_combine_free(ASN1_VALUE **pval, const ASN1_ITEM *it, int combine) | ||
| 84 | { | ||
| 85 | const ASN1_TEMPLATE *tt = NULL, *seqtt; | ||
| 86 | const ASN1_EXTERN_FUNCS *ef; | ||
| 87 | const ASN1_AUX *aux = it->funcs; | ||
| 88 | ASN1_aux_cb *asn1_cb = NULL; | ||
| 89 | int i; | ||
| 90 | |||
| 91 | if (pval == NULL || *pval == NULL) | ||
| 92 | return; | ||
| 93 | |||
| 94 | if (aux != NULL && aux->asn1_cb != NULL) | ||
| 95 | asn1_cb = aux->asn1_cb; | ||
| 96 | |||
| 97 | switch (it->itype) { | ||
| 98 | case ASN1_ITYPE_PRIMITIVE: | ||
| 99 | if (it->templates) | ||
| 100 | ASN1_template_free(pval, it->templates); | ||
| 101 | else | ||
| 102 | ASN1_primitive_free(pval, it); | ||
| 103 | break; | ||
| 104 | |||
| 105 | case ASN1_ITYPE_MSTRING: | ||
| 106 | ASN1_primitive_free(pval, it); | ||
| 107 | break; | ||
| 108 | |||
| 109 | case ASN1_ITYPE_CHOICE: | ||
| 110 | if (asn1_cb) { | ||
| 111 | i = asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL); | ||
| 112 | if (i == 2) | ||
| 113 | return; | ||
| 114 | } | ||
| 115 | i = asn1_get_choice_selector(pval, it); | ||
| 116 | if ((i >= 0) && (i < it->tcount)) { | ||
| 117 | ASN1_VALUE **pchval; | ||
| 118 | tt = it->templates + i; | ||
| 119 | pchval = asn1_get_field_ptr(pval, tt); | ||
| 120 | ASN1_template_free(pchval, tt); | ||
| 121 | } | ||
| 122 | if (asn1_cb) | ||
| 123 | asn1_cb(ASN1_OP_FREE_POST, pval, it, NULL); | ||
| 124 | if (!combine) { | ||
| 125 | free(*pval); | ||
| 126 | *pval = NULL; | ||
| 127 | } | ||
| 128 | break; | ||
| 129 | |||
| 130 | case ASN1_ITYPE_EXTERN: | ||
| 131 | ef = it->funcs; | ||
| 132 | if (ef && ef->asn1_ex_free) | ||
| 133 | ef->asn1_ex_free(pval, it); | ||
| 134 | break; | ||
| 135 | |||
| 136 | case ASN1_ITYPE_NDEF_SEQUENCE: | ||
| 137 | case ASN1_ITYPE_SEQUENCE: | ||
| 138 | if (asn1_do_lock(pval, -1, it) > 0) | ||
| 139 | return; | ||
| 140 | if (asn1_cb) { | ||
| 141 | i = asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL); | ||
| 142 | if (i == 2) | ||
| 143 | return; | ||
| 144 | } | ||
| 145 | asn1_enc_free(pval, it); | ||
| 146 | /* If we free up as normal we will invalidate any | ||
| 147 | * ANY DEFINED BY field and we wont be able to | ||
| 148 | * determine the type of the field it defines. So | ||
| 149 | * free up in reverse order. | ||
| 150 | */ | ||
| 151 | tt = it->templates + it->tcount - 1; | ||
| 152 | for (i = 0; i < it->tcount; tt--, i++) { | ||
| 153 | ASN1_VALUE **pseqval; | ||
| 154 | seqtt = asn1_do_adb(pval, tt, 0); | ||
| 155 | if (!seqtt) | ||
| 156 | continue; | ||
| 157 | pseqval = asn1_get_field_ptr(pval, seqtt); | ||
| 158 | ASN1_template_free(pseqval, seqtt); | ||
| 159 | } | ||
| 160 | if (asn1_cb) | ||
| 161 | asn1_cb(ASN1_OP_FREE_POST, pval, it, NULL); | ||
| 162 | if (!combine) { | ||
| 163 | free(*pval); | ||
| 164 | *pval = NULL; | ||
| 165 | } | ||
| 166 | break; | ||
| 167 | } | ||
| 168 | } | ||
| 169 | |||
| 170 | void | ||
| 171 | ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) | ||
| 172 | { | ||
| 173 | int i; | ||
| 174 | if (tt->flags & ASN1_TFLG_SK_MASK) { | ||
| 175 | STACK_OF(ASN1_VALUE) *sk = (STACK_OF(ASN1_VALUE) *)*pval; | ||
| 176 | for (i = 0; i < sk_ASN1_VALUE_num(sk); i++) { | ||
| 177 | ASN1_VALUE *vtmp; | ||
| 178 | vtmp = sk_ASN1_VALUE_value(sk, i); | ||
| 179 | asn1_item_combine_free(&vtmp, ASN1_ITEM_ptr(tt->item), | ||
| 180 | 0); | ||
| 181 | } | ||
| 182 | sk_ASN1_VALUE_free(sk); | ||
| 183 | *pval = NULL; | ||
| 184 | } else | ||
| 185 | asn1_item_combine_free(pval, ASN1_ITEM_ptr(tt->item), | ||
| 186 | tt->flags & ASN1_TFLG_COMBINE); | ||
| 187 | } | ||
| 188 | |||
| 189 | void | ||
| 190 | ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 191 | { | ||
| 192 | int utype; | ||
| 193 | if (it) { | ||
| 194 | const ASN1_PRIMITIVE_FUNCS *pf; | ||
| 195 | pf = it->funcs; | ||
| 196 | if (pf && pf->prim_free) { | ||
| 197 | pf->prim_free(pval, it); | ||
| 198 | return; | ||
| 199 | } | ||
| 200 | } | ||
| 201 | /* Special case: if 'it' is NULL free contents of ASN1_TYPE */ | ||
| 202 | if (!it) { | ||
| 203 | ASN1_TYPE *typ = (ASN1_TYPE *)*pval; | ||
| 204 | utype = typ->type; | ||
| 205 | pval = &typ->value.asn1_value; | ||
| 206 | if (!*pval) | ||
| 207 | return; | ||
| 208 | } else if (it->itype == ASN1_ITYPE_MSTRING) { | ||
| 209 | utype = -1; | ||
| 210 | if (!*pval) | ||
| 211 | return; | ||
| 212 | } else { | ||
| 213 | utype = it->utype; | ||
| 214 | if ((utype != V_ASN1_BOOLEAN) && !*pval) | ||
| 215 | return; | ||
| 216 | } | ||
| 217 | |||
| 218 | switch (utype) { | ||
| 219 | case V_ASN1_OBJECT: | ||
| 220 | ASN1_OBJECT_free((ASN1_OBJECT *)*pval); | ||
| 221 | break; | ||
| 222 | |||
| 223 | case V_ASN1_BOOLEAN: | ||
| 224 | if (it) | ||
| 225 | *(ASN1_BOOLEAN *)pval = it->size; | ||
| 226 | else | ||
| 227 | *(ASN1_BOOLEAN *)pval = -1; | ||
| 228 | return; | ||
| 229 | |||
| 230 | case V_ASN1_NULL: | ||
| 231 | break; | ||
| 232 | |||
| 233 | case V_ASN1_ANY: | ||
| 234 | ASN1_primitive_free(pval, NULL); | ||
| 235 | free(*pval); | ||
| 236 | break; | ||
| 237 | |||
| 238 | default: | ||
| 239 | ASN1_STRING_free((ASN1_STRING *)*pval); | ||
| 240 | break; | ||
| 241 | } | ||
| 242 | *pval = NULL; | ||
| 243 | } | ||
diff --git a/src/lib/libcrypto/asn1/tasn_new.c b/src/lib/libcrypto/asn1/tasn_new.c deleted file mode 100644 index 986e5811b6..0000000000 --- a/src/lib/libcrypto/asn1/tasn_new.c +++ /dev/null | |||
| @@ -1,374 +0,0 @@ | |||
| 1 | /* $OpenBSD: tasn_new.c,v 1.15 2015/07/20 15:43:23 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000-2004 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 | |||
| 60 | #include <stddef.h> | ||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/objects.h> | ||
| 63 | #include <openssl/err.h> | ||
| 64 | #include <openssl/asn1t.h> | ||
| 65 | #include <string.h> | ||
| 66 | |||
| 67 | static int asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it, | ||
| 68 | int combine); | ||
| 69 | static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 70 | static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt); | ||
| 71 | static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 72 | |||
| 73 | ASN1_VALUE * | ||
| 74 | ASN1_item_new(const ASN1_ITEM *it) | ||
| 75 | { | ||
| 76 | ASN1_VALUE *ret = NULL; | ||
| 77 | if (ASN1_item_ex_new(&ret, it) > 0) | ||
| 78 | return ret; | ||
| 79 | return NULL; | ||
| 80 | } | ||
| 81 | |||
| 82 | /* Allocate an ASN1 structure */ | ||
| 83 | |||
| 84 | int | ||
| 85 | ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 86 | { | ||
| 87 | return asn1_item_ex_combine_new(pval, it, 0); | ||
| 88 | } | ||
| 89 | |||
| 90 | static int | ||
| 91 | asn1_item_ex_combine_new(ASN1_VALUE **pval, const ASN1_ITEM *it, int combine) | ||
| 92 | { | ||
| 93 | const ASN1_TEMPLATE *tt = NULL; | ||
| 94 | const ASN1_EXTERN_FUNCS *ef; | ||
| 95 | const ASN1_AUX *aux = it->funcs; | ||
| 96 | ASN1_aux_cb *asn1_cb = NULL; | ||
| 97 | ASN1_VALUE **pseqval; | ||
| 98 | int i; | ||
| 99 | |||
| 100 | if (aux != NULL && aux->asn1_cb != NULL) | ||
| 101 | asn1_cb = aux->asn1_cb; | ||
| 102 | |||
| 103 | if (!combine) | ||
| 104 | *pval = NULL; | ||
| 105 | |||
| 106 | #ifdef CRYPTO_MDEBUG | ||
| 107 | if (it->sname) | ||
| 108 | CRYPTO_push_info(it->sname); | ||
| 109 | #endif | ||
| 110 | |||
| 111 | switch (it->itype) { | ||
| 112 | case ASN1_ITYPE_EXTERN: | ||
| 113 | ef = it->funcs; | ||
| 114 | if (ef && ef->asn1_ex_new) { | ||
| 115 | if (!ef->asn1_ex_new(pval, it)) | ||
| 116 | goto memerr; | ||
| 117 | } | ||
| 118 | break; | ||
| 119 | |||
| 120 | case ASN1_ITYPE_PRIMITIVE: | ||
| 121 | if (it->templates) { | ||
| 122 | if (!ASN1_template_new(pval, it->templates)) | ||
| 123 | goto memerr; | ||
| 124 | } else if (!ASN1_primitive_new(pval, it)) | ||
| 125 | goto memerr; | ||
| 126 | break; | ||
| 127 | |||
| 128 | case ASN1_ITYPE_MSTRING: | ||
| 129 | if (!ASN1_primitive_new(pval, it)) | ||
| 130 | goto memerr; | ||
| 131 | break; | ||
| 132 | |||
| 133 | case ASN1_ITYPE_CHOICE: | ||
| 134 | if (asn1_cb) { | ||
| 135 | i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL); | ||
| 136 | if (!i) | ||
| 137 | goto auxerr; | ||
| 138 | if (i == 2) { | ||
| 139 | #ifdef CRYPTO_MDEBUG | ||
| 140 | if (it->sname) | ||
| 141 | CRYPTO_pop_info(); | ||
| 142 | #endif | ||
| 143 | return 1; | ||
| 144 | } | ||
| 145 | } | ||
| 146 | if (!combine) { | ||
| 147 | *pval = calloc(1, it->size); | ||
| 148 | if (!*pval) | ||
| 149 | goto memerr; | ||
| 150 | } | ||
| 151 | asn1_set_choice_selector(pval, -1, it); | ||
| 152 | if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL)) | ||
| 153 | goto auxerr; | ||
| 154 | break; | ||
| 155 | |||
| 156 | case ASN1_ITYPE_NDEF_SEQUENCE: | ||
| 157 | case ASN1_ITYPE_SEQUENCE: | ||
| 158 | if (asn1_cb) { | ||
| 159 | i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL); | ||
| 160 | if (!i) | ||
| 161 | goto auxerr; | ||
| 162 | if (i == 2) { | ||
| 163 | #ifdef CRYPTO_MDEBUG | ||
| 164 | if (it->sname) | ||
| 165 | CRYPTO_pop_info(); | ||
| 166 | #endif | ||
| 167 | return 1; | ||
| 168 | } | ||
| 169 | } | ||
| 170 | if (!combine) { | ||
| 171 | *pval = calloc(1, it->size); | ||
| 172 | if (!*pval) | ||
| 173 | goto memerr; | ||
| 174 | asn1_do_lock(pval, 0, it); | ||
| 175 | asn1_enc_init(pval, it); | ||
| 176 | } | ||
| 177 | for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) { | ||
| 178 | pseqval = asn1_get_field_ptr(pval, tt); | ||
| 179 | if (!ASN1_template_new(pseqval, tt)) | ||
| 180 | goto memerr; | ||
| 181 | } | ||
| 182 | if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL)) | ||
| 183 | goto auxerr; | ||
| 184 | break; | ||
| 185 | } | ||
| 186 | #ifdef CRYPTO_MDEBUG | ||
| 187 | if (it->sname) | ||
| 188 | CRYPTO_pop_info(); | ||
| 189 | #endif | ||
| 190 | return 1; | ||
| 191 | |||
| 192 | memerr: | ||
| 193 | ASN1err(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW, ERR_R_MALLOC_FAILURE); | ||
| 194 | #ifdef CRYPTO_MDEBUG | ||
| 195 | if (it->sname) | ||
| 196 | CRYPTO_pop_info(); | ||
| 197 | #endif | ||
| 198 | return 0; | ||
| 199 | |||
| 200 | auxerr: | ||
| 201 | ASN1err(ASN1_F_ASN1_ITEM_EX_COMBINE_NEW, ASN1_R_AUX_ERROR); | ||
| 202 | ASN1_item_ex_free(pval, it); | ||
| 203 | #ifdef CRYPTO_MDEBUG | ||
| 204 | if (it->sname) | ||
| 205 | CRYPTO_pop_info(); | ||
| 206 | #endif | ||
| 207 | return 0; | ||
| 208 | |||
| 209 | } | ||
| 210 | |||
| 211 | static void | ||
| 212 | asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 213 | { | ||
| 214 | const ASN1_EXTERN_FUNCS *ef; | ||
| 215 | |||
| 216 | switch (it->itype) { | ||
| 217 | case ASN1_ITYPE_EXTERN: | ||
| 218 | ef = it->funcs; | ||
| 219 | if (ef && ef->asn1_ex_clear) | ||
| 220 | ef->asn1_ex_clear(pval, it); | ||
| 221 | else | ||
| 222 | *pval = NULL; | ||
| 223 | break; | ||
| 224 | |||
| 225 | case ASN1_ITYPE_PRIMITIVE: | ||
| 226 | if (it->templates) | ||
| 227 | asn1_template_clear(pval, it->templates); | ||
| 228 | else | ||
| 229 | asn1_primitive_clear(pval, it); | ||
| 230 | break; | ||
| 231 | |||
| 232 | case ASN1_ITYPE_MSTRING: | ||
| 233 | asn1_primitive_clear(pval, it); | ||
| 234 | break; | ||
| 235 | |||
| 236 | case ASN1_ITYPE_CHOICE: | ||
| 237 | case ASN1_ITYPE_SEQUENCE: | ||
| 238 | case ASN1_ITYPE_NDEF_SEQUENCE: | ||
| 239 | *pval = NULL; | ||
| 240 | break; | ||
| 241 | } | ||
| 242 | } | ||
| 243 | |||
| 244 | int | ||
| 245 | ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) | ||
| 246 | { | ||
| 247 | const ASN1_ITEM *it = ASN1_ITEM_ptr(tt->item); | ||
| 248 | int ret; | ||
| 249 | |||
| 250 | if (tt->flags & ASN1_TFLG_OPTIONAL) { | ||
| 251 | asn1_template_clear(pval, tt); | ||
| 252 | return 1; | ||
| 253 | } | ||
| 254 | /* If ANY DEFINED BY nothing to do */ | ||
| 255 | |||
| 256 | if (tt->flags & ASN1_TFLG_ADB_MASK) { | ||
| 257 | *pval = NULL; | ||
| 258 | return 1; | ||
| 259 | } | ||
| 260 | #ifdef CRYPTO_MDEBUG | ||
| 261 | if (tt->field_name) | ||
| 262 | CRYPTO_push_info(tt->field_name); | ||
| 263 | #endif | ||
| 264 | /* If SET OF or SEQUENCE OF, its a STACK */ | ||
| 265 | if (tt->flags & ASN1_TFLG_SK_MASK) { | ||
| 266 | STACK_OF(ASN1_VALUE) *skval; | ||
| 267 | skval = sk_ASN1_VALUE_new_null(); | ||
| 268 | if (!skval) { | ||
| 269 | ASN1err(ASN1_F_ASN1_TEMPLATE_NEW, ERR_R_MALLOC_FAILURE); | ||
| 270 | ret = 0; | ||
| 271 | goto done; | ||
| 272 | } | ||
| 273 | *pval = (ASN1_VALUE *)skval; | ||
| 274 | ret = 1; | ||
| 275 | goto done; | ||
| 276 | } | ||
| 277 | /* Otherwise pass it back to the item routine */ | ||
| 278 | ret = asn1_item_ex_combine_new(pval, it, tt->flags & ASN1_TFLG_COMBINE); | ||
| 279 | done: | ||
| 280 | #ifdef CRYPTO_MDEBUG | ||
| 281 | if (it->sname) | ||
| 282 | CRYPTO_pop_info(); | ||
| 283 | #endif | ||
| 284 | return ret; | ||
| 285 | } | ||
| 286 | |||
| 287 | static void | ||
| 288 | asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) | ||
| 289 | { | ||
| 290 | /* If ADB or STACK just NULL the field */ | ||
| 291 | if (tt->flags & (ASN1_TFLG_ADB_MASK|ASN1_TFLG_SK_MASK)) | ||
| 292 | *pval = NULL; | ||
| 293 | else | ||
| 294 | asn1_item_clear(pval, ASN1_ITEM_ptr(tt->item)); | ||
| 295 | } | ||
| 296 | |||
| 297 | |||
| 298 | /* NB: could probably combine most of the real XXX_new() behaviour and junk | ||
| 299 | * all the old functions. | ||
| 300 | */ | ||
| 301 | |||
| 302 | int | ||
| 303 | ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 304 | { | ||
| 305 | ASN1_TYPE *typ; | ||
| 306 | ASN1_STRING *str; | ||
| 307 | int utype; | ||
| 308 | |||
| 309 | if (it && it->funcs) { | ||
| 310 | const ASN1_PRIMITIVE_FUNCS *pf = it->funcs; | ||
| 311 | if (pf->prim_new) | ||
| 312 | return pf->prim_new(pval, it); | ||
| 313 | } | ||
| 314 | |||
| 315 | if (!it || (it->itype == ASN1_ITYPE_MSTRING)) | ||
| 316 | utype = V_ASN1_UNDEF; | ||
| 317 | else | ||
| 318 | utype = it->utype; | ||
| 319 | switch (utype) { | ||
| 320 | case V_ASN1_OBJECT: | ||
| 321 | *pval = (ASN1_VALUE *)OBJ_nid2obj(NID_undef); | ||
| 322 | return 1; | ||
| 323 | |||
| 324 | case V_ASN1_BOOLEAN: | ||
| 325 | *(ASN1_BOOLEAN *)pval = it->size; | ||
| 326 | return 1; | ||
| 327 | |||
| 328 | case V_ASN1_NULL: | ||
| 329 | *pval = (ASN1_VALUE *)1; | ||
| 330 | return 1; | ||
| 331 | |||
| 332 | case V_ASN1_ANY: | ||
| 333 | typ = malloc(sizeof(ASN1_TYPE)); | ||
| 334 | if (typ != NULL) { | ||
| 335 | typ->value.ptr = NULL; | ||
| 336 | typ->type = V_ASN1_UNDEF; | ||
| 337 | } | ||
| 338 | *pval = (ASN1_VALUE *)typ; | ||
| 339 | break; | ||
| 340 | |||
| 341 | default: | ||
| 342 | str = ASN1_STRING_type_new(utype); | ||
| 343 | if (it != NULL && it->itype == ASN1_ITYPE_MSTRING && | ||
| 344 | str != NULL) | ||
| 345 | str->flags |= ASN1_STRING_FLAG_MSTRING; | ||
| 346 | *pval = (ASN1_VALUE *)str; | ||
| 347 | break; | ||
| 348 | } | ||
| 349 | if (*pval) | ||
| 350 | return 1; | ||
| 351 | return 0; | ||
| 352 | } | ||
| 353 | |||
| 354 | static void | ||
| 355 | asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 356 | { | ||
| 357 | int utype; | ||
| 358 | if (it && it->funcs) { | ||
| 359 | const ASN1_PRIMITIVE_FUNCS *pf = it->funcs; | ||
| 360 | if (pf->prim_clear) | ||
| 361 | pf->prim_clear(pval, it); | ||
| 362 | else | ||
| 363 | *pval = NULL; | ||
| 364 | return; | ||
| 365 | } | ||
| 366 | if (!it || (it->itype == ASN1_ITYPE_MSTRING)) | ||
| 367 | utype = V_ASN1_UNDEF; | ||
| 368 | else | ||
| 369 | utype = it->utype; | ||
| 370 | if (utype == V_ASN1_BOOLEAN) | ||
| 371 | *(ASN1_BOOLEAN *)pval = it->size; | ||
| 372 | else | ||
| 373 | *pval = NULL; | ||
| 374 | } | ||
diff --git a/src/lib/libcrypto/asn1/tasn_prn.c b/src/lib/libcrypto/asn1/tasn_prn.c deleted file mode 100644 index c9fde96789..0000000000 --- a/src/lib/libcrypto/asn1/tasn_prn.c +++ /dev/null | |||
| @@ -1,596 +0,0 @@ | |||
| 1 | /* $OpenBSD: tasn_prn.c,v 1.13 2015/02/14 15:15:27 miod Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000,2005 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 | #include <stddef.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/asn1t.h> | ||
| 63 | #include <openssl/buffer.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/objects.h> | ||
| 66 | #include <openssl/x509v3.h> | ||
| 67 | |||
| 68 | #include "asn1_locl.h" | ||
| 69 | |||
| 70 | /* Print routines. | ||
| 71 | */ | ||
| 72 | |||
| 73 | /* ASN1_PCTX routines */ | ||
| 74 | |||
| 75 | ASN1_PCTX default_pctx = { | ||
| 76 | ASN1_PCTX_FLAGS_SHOW_ABSENT, /* flags */ | ||
| 77 | 0, /* nm_flags */ | ||
| 78 | 0, /* cert_flags */ | ||
| 79 | 0, /* oid_flags */ | ||
| 80 | 0 /* str_flags */ | ||
| 81 | }; | ||
| 82 | |||
| 83 | |||
| 84 | ASN1_PCTX * | ||
| 85 | ASN1_PCTX_new(void) | ||
| 86 | { | ||
| 87 | ASN1_PCTX *ret; | ||
| 88 | ret = malloc(sizeof(ASN1_PCTX)); | ||
| 89 | if (ret == NULL) { | ||
| 90 | ASN1err(ASN1_F_ASN1_PCTX_NEW, ERR_R_MALLOC_FAILURE); | ||
| 91 | return NULL; | ||
| 92 | } | ||
| 93 | ret->flags = 0; | ||
| 94 | ret->nm_flags = 0; | ||
| 95 | ret->cert_flags = 0; | ||
| 96 | ret->oid_flags = 0; | ||
| 97 | ret->str_flags = 0; | ||
| 98 | return ret; | ||
| 99 | } | ||
| 100 | |||
| 101 | void | ||
| 102 | ASN1_PCTX_free(ASN1_PCTX *p) | ||
| 103 | { | ||
| 104 | free(p); | ||
| 105 | } | ||
| 106 | |||
| 107 | unsigned long | ||
| 108 | ASN1_PCTX_get_flags(ASN1_PCTX *p) | ||
| 109 | { | ||
| 110 | return p->flags; | ||
| 111 | } | ||
| 112 | |||
| 113 | void | ||
| 114 | ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags) | ||
| 115 | { | ||
| 116 | p->flags = flags; | ||
| 117 | } | ||
| 118 | |||
| 119 | unsigned long | ||
| 120 | ASN1_PCTX_get_nm_flags(ASN1_PCTX *p) | ||
| 121 | { | ||
| 122 | return p->nm_flags; | ||
| 123 | } | ||
| 124 | |||
| 125 | void | ||
| 126 | ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags) | ||
| 127 | { | ||
| 128 | p->nm_flags = flags; | ||
| 129 | } | ||
| 130 | |||
| 131 | unsigned long | ||
| 132 | ASN1_PCTX_get_cert_flags(ASN1_PCTX *p) | ||
| 133 | { | ||
| 134 | return p->cert_flags; | ||
| 135 | } | ||
| 136 | |||
| 137 | void | ||
| 138 | ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags) | ||
| 139 | { | ||
| 140 | p->cert_flags = flags; | ||
| 141 | } | ||
| 142 | |||
| 143 | unsigned long | ||
| 144 | ASN1_PCTX_get_oid_flags(ASN1_PCTX *p) | ||
| 145 | { | ||
| 146 | return p->oid_flags; | ||
| 147 | } | ||
| 148 | |||
| 149 | void | ||
| 150 | ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags) | ||
| 151 | { | ||
| 152 | p->oid_flags = flags; | ||
| 153 | } | ||
| 154 | |||
| 155 | unsigned long | ||
| 156 | ASN1_PCTX_get_str_flags(ASN1_PCTX *p) | ||
| 157 | { | ||
| 158 | return p->str_flags; | ||
| 159 | } | ||
| 160 | |||
| 161 | void | ||
| 162 | ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags) | ||
| 163 | { | ||
| 164 | p->str_flags = flags; | ||
| 165 | } | ||
| 166 | |||
| 167 | /* Main print routines */ | ||
| 168 | |||
| 169 | static int asn1_item_print_ctx(BIO *out, ASN1_VALUE **fld, int indent, | ||
| 170 | const ASN1_ITEM *it, const char *fname, const char *sname, int nohdr, | ||
| 171 | const ASN1_PCTX *pctx); | ||
| 172 | |||
| 173 | int asn1_template_print_ctx(BIO *out, ASN1_VALUE **fld, int indent, | ||
| 174 | const ASN1_TEMPLATE *tt, const ASN1_PCTX *pctx); | ||
| 175 | |||
| 176 | static int asn1_primitive_print(BIO *out, ASN1_VALUE **fld, | ||
| 177 | const ASN1_ITEM *it, int indent, const char *fname, const char *sname, | ||
| 178 | const ASN1_PCTX *pctx); | ||
| 179 | |||
| 180 | static int asn1_print_fsname(BIO *out, int indent, const char *fname, | ||
| 181 | const char *sname, const ASN1_PCTX *pctx); | ||
| 182 | |||
| 183 | int | ||
| 184 | ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent, const ASN1_ITEM *it, | ||
| 185 | const ASN1_PCTX *pctx) | ||
| 186 | { | ||
| 187 | const char *sname; | ||
| 188 | |||
| 189 | if (pctx == NULL) | ||
| 190 | pctx = &default_pctx; | ||
| 191 | if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME) | ||
| 192 | sname = NULL; | ||
| 193 | else | ||
| 194 | sname = it->sname; | ||
| 195 | return asn1_item_print_ctx(out, &ifld, indent, it, NULL, sname, | ||
| 196 | 0, pctx); | ||
| 197 | } | ||
| 198 | |||
| 199 | static int | ||
| 200 | asn1_item_print_ctx(BIO *out, ASN1_VALUE **fld, int indent, const ASN1_ITEM *it, | ||
| 201 | const char *fname, const char *sname, int nohdr, const ASN1_PCTX *pctx) | ||
| 202 | { | ||
| 203 | const ASN1_TEMPLATE *tt; | ||
| 204 | const ASN1_EXTERN_FUNCS *ef; | ||
| 205 | ASN1_VALUE **tmpfld; | ||
| 206 | const ASN1_AUX *aux = it->funcs; | ||
| 207 | ASN1_aux_cb *asn1_cb; | ||
| 208 | ASN1_PRINT_ARG parg; | ||
| 209 | int i; | ||
| 210 | |||
| 211 | if (aux && aux->asn1_cb) { | ||
| 212 | parg.out = out; | ||
| 213 | parg.indent = indent; | ||
| 214 | parg.pctx = pctx; | ||
| 215 | asn1_cb = aux->asn1_cb; | ||
| 216 | } else | ||
| 217 | asn1_cb = 0; | ||
| 218 | |||
| 219 | if (*fld == NULL) { | ||
| 220 | if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_ABSENT) { | ||
| 221 | if (!nohdr && | ||
| 222 | !asn1_print_fsname(out, indent, fname, sname, pctx)) | ||
| 223 | return 0; | ||
| 224 | if (BIO_puts(out, "<ABSENT>\n") <= 0) | ||
| 225 | return 0; | ||
| 226 | } | ||
| 227 | return 1; | ||
| 228 | } | ||
| 229 | |||
| 230 | switch (it->itype) { | ||
| 231 | case ASN1_ITYPE_PRIMITIVE: | ||
| 232 | if (it->templates) { | ||
| 233 | if (!asn1_template_print_ctx(out, fld, indent, | ||
| 234 | it->templates, pctx)) | ||
| 235 | return 0; | ||
| 236 | } | ||
| 237 | /* fall thru */ | ||
| 238 | case ASN1_ITYPE_MSTRING: | ||
| 239 | if (!asn1_primitive_print(out, fld, it, | ||
| 240 | indent, fname, sname, pctx)) | ||
| 241 | return 0; | ||
| 242 | break; | ||
| 243 | |||
| 244 | case ASN1_ITYPE_EXTERN: | ||
| 245 | if (!nohdr && | ||
| 246 | !asn1_print_fsname(out, indent, fname, sname, pctx)) | ||
| 247 | return 0; | ||
| 248 | /* Use new style print routine if possible */ | ||
| 249 | ef = it->funcs; | ||
| 250 | if (ef && ef->asn1_ex_print) { | ||
| 251 | i = ef->asn1_ex_print(out, fld, indent, "", pctx); | ||
| 252 | if (!i) | ||
| 253 | return 0; | ||
| 254 | if ((i == 2) && (BIO_puts(out, "\n") <= 0)) | ||
| 255 | return 0; | ||
| 256 | return 1; | ||
| 257 | } else if (sname && | ||
| 258 | BIO_printf(out, ":EXTERNAL TYPE %s\n", sname) <= 0) | ||
| 259 | return 0; | ||
| 260 | break; | ||
| 261 | |||
| 262 | case ASN1_ITYPE_CHOICE: | ||
| 263 | /* CHOICE type, get selector */ | ||
| 264 | i = asn1_get_choice_selector(fld, it); | ||
| 265 | /* This should never happen... */ | ||
| 266 | if ((i < 0) || (i >= it->tcount)) { | ||
| 267 | if (BIO_printf(out, | ||
| 268 | "ERROR: selector [%d] invalid\n", i) <= 0) | ||
| 269 | return 0; | ||
| 270 | return 1; | ||
| 271 | } | ||
| 272 | tt = it->templates + i; | ||
| 273 | tmpfld = asn1_get_field_ptr(fld, tt); | ||
| 274 | if (!asn1_template_print_ctx(out, tmpfld, indent, tt, pctx)) | ||
| 275 | return 0; | ||
| 276 | break; | ||
| 277 | |||
| 278 | case ASN1_ITYPE_SEQUENCE: | ||
| 279 | case ASN1_ITYPE_NDEF_SEQUENCE: | ||
| 280 | if (!nohdr && | ||
| 281 | !asn1_print_fsname(out, indent, fname, sname, pctx)) | ||
| 282 | return 0; | ||
| 283 | if (fname || sname) { | ||
| 284 | if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) { | ||
| 285 | if (BIO_puts(out, " {\n") <= 0) | ||
| 286 | return 0; | ||
| 287 | } else { | ||
| 288 | if (BIO_puts(out, "\n") <= 0) | ||
| 289 | return 0; | ||
| 290 | } | ||
| 291 | } | ||
| 292 | |||
| 293 | if (asn1_cb) { | ||
| 294 | i = asn1_cb(ASN1_OP_PRINT_PRE, fld, it, &parg); | ||
| 295 | if (i == 0) | ||
| 296 | return 0; | ||
| 297 | if (i == 2) | ||
| 298 | return 1; | ||
| 299 | } | ||
| 300 | |||
| 301 | /* Print each field entry */ | ||
| 302 | for (i = 0, tt = it->templates; i < it->tcount; i++, tt++) { | ||
| 303 | const ASN1_TEMPLATE *seqtt; | ||
| 304 | |||
| 305 | seqtt = asn1_do_adb(fld, tt, 1); | ||
| 306 | if (seqtt == NULL) | ||
| 307 | return 0; | ||
| 308 | tmpfld = asn1_get_field_ptr(fld, seqtt); | ||
| 309 | if (!asn1_template_print_ctx(out, tmpfld, indent + 2, | ||
| 310 | seqtt, pctx)) | ||
| 311 | return 0; | ||
| 312 | } | ||
| 313 | if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) { | ||
| 314 | if (BIO_printf(out, "%*s}\n", indent, "") < 0) | ||
| 315 | return 0; | ||
| 316 | } | ||
| 317 | |||
| 318 | if (asn1_cb) { | ||
| 319 | i = asn1_cb(ASN1_OP_PRINT_POST, fld, it, &parg); | ||
| 320 | if (i == 0) | ||
| 321 | return 0; | ||
| 322 | } | ||
| 323 | break; | ||
| 324 | |||
| 325 | default: | ||
| 326 | BIO_printf(out, "Unprocessed type %d\n", it->itype); | ||
| 327 | return 0; | ||
| 328 | } | ||
| 329 | |||
| 330 | return 1; | ||
| 331 | } | ||
| 332 | |||
| 333 | int | ||
| 334 | asn1_template_print_ctx(BIO *out, ASN1_VALUE **fld, int indent, | ||
| 335 | const ASN1_TEMPLATE *tt, const ASN1_PCTX *pctx) | ||
| 336 | { | ||
| 337 | int i, flags; | ||
| 338 | const char *sname, *fname; | ||
| 339 | |||
| 340 | flags = tt->flags; | ||
| 341 | if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME) | ||
| 342 | sname = ASN1_ITEM_ptr(tt->item)->sname; | ||
| 343 | else | ||
| 344 | sname = NULL; | ||
| 345 | if (pctx->flags & ASN1_PCTX_FLAGS_NO_FIELD_NAME) | ||
| 346 | fname = NULL; | ||
| 347 | else | ||
| 348 | fname = tt->field_name; | ||
| 349 | if (flags & ASN1_TFLG_SK_MASK) { | ||
| 350 | char *tname; | ||
| 351 | ASN1_VALUE *skitem; | ||
| 352 | STACK_OF(ASN1_VALUE) *stack; | ||
| 353 | |||
| 354 | /* SET OF, SEQUENCE OF */ | ||
| 355 | if (fname) { | ||
| 356 | if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SSOF) { | ||
| 357 | if (flags & ASN1_TFLG_SET_OF) | ||
| 358 | tname = "SET"; | ||
| 359 | else | ||
| 360 | tname = "SEQUENCE"; | ||
| 361 | if (BIO_printf(out, "%*s%s OF %s {\n", | ||
| 362 | indent, "", tname, tt->field_name) <= 0) | ||
| 363 | return 0; | ||
| 364 | } else if (BIO_printf(out, "%*s%s:\n", indent, "", | ||
| 365 | fname) <= 0) | ||
| 366 | return 0; | ||
| 367 | } | ||
| 368 | stack = (STACK_OF(ASN1_VALUE) *)*fld; | ||
| 369 | for (i = 0; i < sk_ASN1_VALUE_num(stack); i++) { | ||
| 370 | if ((i > 0) && (BIO_puts(out, "\n") <= 0)) | ||
| 371 | return 0; | ||
| 372 | skitem = sk_ASN1_VALUE_value(stack, i); | ||
| 373 | if (!asn1_item_print_ctx(out, &skitem, indent + 2, | ||
| 374 | ASN1_ITEM_ptr(tt->item), NULL, NULL, 1, pctx)) | ||
| 375 | return 0; | ||
| 376 | } | ||
| 377 | if (!i && BIO_printf(out, "%*s<EMPTY>\n", indent + 2, "") <= 0) | ||
| 378 | return 0; | ||
| 379 | if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_SEQUENCE) { | ||
| 380 | if (BIO_printf(out, "%*s}\n", indent, "") <= 0) | ||
| 381 | return 0; | ||
| 382 | } | ||
| 383 | return 1; | ||
| 384 | } | ||
| 385 | return asn1_item_print_ctx(out, fld, indent, ASN1_ITEM_ptr(tt->item), | ||
| 386 | fname, sname, 0, pctx); | ||
| 387 | } | ||
| 388 | |||
| 389 | static int | ||
| 390 | asn1_print_fsname(BIO *out, int indent, const char *fname, const char *sname, | ||
| 391 | const ASN1_PCTX *pctx) | ||
| 392 | { | ||
| 393 | static char spaces[] = " "; | ||
| 394 | const int nspaces = sizeof(spaces) - 1; | ||
| 395 | |||
| 396 | while (indent > nspaces) { | ||
| 397 | if (BIO_write(out, spaces, nspaces) != nspaces) | ||
| 398 | return 0; | ||
| 399 | indent -= nspaces; | ||
| 400 | } | ||
| 401 | if (BIO_write(out, spaces, indent) != indent) | ||
| 402 | return 0; | ||
| 403 | if (pctx->flags & ASN1_PCTX_FLAGS_NO_STRUCT_NAME) | ||
| 404 | sname = NULL; | ||
| 405 | if (pctx->flags & ASN1_PCTX_FLAGS_NO_FIELD_NAME) | ||
| 406 | fname = NULL; | ||
| 407 | if (!sname && !fname) | ||
| 408 | return 1; | ||
| 409 | if (fname) { | ||
| 410 | if (BIO_puts(out, fname) <= 0) | ||
| 411 | return 0; | ||
| 412 | } | ||
| 413 | if (sname) { | ||
| 414 | if (fname) { | ||
| 415 | if (BIO_printf(out, " (%s)", sname) <= 0) | ||
| 416 | return 0; | ||
| 417 | } else { | ||
| 418 | if (BIO_puts(out, sname) <= 0) | ||
| 419 | return 0; | ||
| 420 | } | ||
| 421 | } | ||
| 422 | if (BIO_write(out, ": ", 2) != 2) | ||
| 423 | return 0; | ||
| 424 | return 1; | ||
| 425 | } | ||
| 426 | |||
| 427 | static int | ||
| 428 | asn1_print_boolean_ctx(BIO *out, int boolval, const ASN1_PCTX *pctx) | ||
| 429 | { | ||
| 430 | const char *str; | ||
| 431 | switch (boolval) { | ||
| 432 | case -1: | ||
| 433 | str = "BOOL ABSENT"; | ||
| 434 | break; | ||
| 435 | |||
| 436 | case 0: | ||
| 437 | str = "FALSE"; | ||
| 438 | break; | ||
| 439 | |||
| 440 | default: | ||
| 441 | str = "TRUE"; | ||
| 442 | break; | ||
| 443 | |||
| 444 | } | ||
| 445 | |||
| 446 | if (BIO_puts(out, str) <= 0) | ||
| 447 | return 0; | ||
| 448 | return 1; | ||
| 449 | |||
| 450 | } | ||
| 451 | |||
| 452 | static int | ||
| 453 | asn1_print_integer_ctx(BIO *out, ASN1_INTEGER *str, const ASN1_PCTX *pctx) | ||
| 454 | { | ||
| 455 | char *s; | ||
| 456 | int ret = 1; | ||
| 457 | s = i2s_ASN1_INTEGER(NULL, str); | ||
| 458 | if (BIO_puts(out, s) <= 0) | ||
| 459 | ret = 0; | ||
| 460 | free(s); | ||
| 461 | return ret; | ||
| 462 | } | ||
| 463 | |||
| 464 | static int | ||
| 465 | asn1_print_oid_ctx(BIO *out, const ASN1_OBJECT *oid, const ASN1_PCTX *pctx) | ||
| 466 | { | ||
| 467 | char objbuf[80]; | ||
| 468 | const char *ln; | ||
| 469 | ln = OBJ_nid2ln(OBJ_obj2nid(oid)); | ||
| 470 | if (!ln) | ||
| 471 | ln = ""; | ||
| 472 | OBJ_obj2txt(objbuf, sizeof objbuf, oid, 1); | ||
| 473 | if (BIO_printf(out, "%s (%s)", ln, objbuf) <= 0) | ||
| 474 | return 0; | ||
| 475 | return 1; | ||
| 476 | } | ||
| 477 | |||
| 478 | static int | ||
| 479 | asn1_print_obstring_ctx(BIO *out, ASN1_STRING *str, int indent, | ||
| 480 | const ASN1_PCTX *pctx) | ||
| 481 | { | ||
| 482 | if (str->type == V_ASN1_BIT_STRING) { | ||
| 483 | if (BIO_printf(out, " (%ld unused bits)\n", | ||
| 484 | str->flags & 0x7) <= 0) | ||
| 485 | return 0; | ||
| 486 | } else if (BIO_puts(out, "\n") <= 0) | ||
| 487 | return 0; | ||
| 488 | if ((str->length > 0) && | ||
| 489 | BIO_dump_indent(out, (char *)str->data, str->length, | ||
| 490 | indent + 2) <= 0) | ||
| 491 | return 0; | ||
| 492 | return 1; | ||
| 493 | } | ||
| 494 | |||
| 495 | static int | ||
| 496 | asn1_primitive_print(BIO *out, ASN1_VALUE **fld, const ASN1_ITEM *it, | ||
| 497 | int indent, const char *fname, const char *sname, const ASN1_PCTX *pctx) | ||
| 498 | { | ||
| 499 | long utype; | ||
| 500 | ASN1_STRING *str; | ||
| 501 | int ret = 1, needlf = 1; | ||
| 502 | const char *pname; | ||
| 503 | const ASN1_PRIMITIVE_FUNCS *pf; | ||
| 504 | |||
| 505 | pf = it->funcs; | ||
| 506 | if (!asn1_print_fsname(out, indent, fname, sname, pctx)) | ||
| 507 | return 0; | ||
| 508 | if (pf && pf->prim_print) | ||
| 509 | return pf->prim_print(out, fld, it, indent, pctx); | ||
| 510 | str = (ASN1_STRING *)*fld; | ||
| 511 | if (it->itype == ASN1_ITYPE_MSTRING) | ||
| 512 | utype = str->type & ~V_ASN1_NEG; | ||
| 513 | else | ||
| 514 | utype = it->utype; | ||
| 515 | if (utype == V_ASN1_ANY) { | ||
| 516 | ASN1_TYPE *atype = (ASN1_TYPE *)*fld; | ||
| 517 | utype = atype->type; | ||
| 518 | fld = &atype->value.asn1_value; | ||
| 519 | str = (ASN1_STRING *)*fld; | ||
| 520 | if (pctx->flags & ASN1_PCTX_FLAGS_NO_ANY_TYPE) | ||
| 521 | pname = NULL; | ||
| 522 | else | ||
| 523 | pname = ASN1_tag2str(utype); | ||
| 524 | } else { | ||
| 525 | if (pctx->flags & ASN1_PCTX_FLAGS_SHOW_TYPE) | ||
| 526 | pname = ASN1_tag2str(utype); | ||
| 527 | else | ||
| 528 | pname = NULL; | ||
| 529 | } | ||
| 530 | |||
| 531 | if (utype == V_ASN1_NULL) { | ||
| 532 | if (BIO_puts(out, "NULL\n") <= 0) | ||
| 533 | return 0; | ||
| 534 | return 1; | ||
| 535 | } | ||
| 536 | |||
| 537 | if (pname) { | ||
| 538 | if (BIO_puts(out, pname) <= 0) | ||
| 539 | return 0; | ||
| 540 | if (BIO_puts(out, ":") <= 0) | ||
| 541 | return 0; | ||
| 542 | } | ||
| 543 | |||
| 544 | switch (utype) { | ||
| 545 | case V_ASN1_BOOLEAN: | ||
| 546 | { | ||
| 547 | int boolval = *(int *)fld; | ||
| 548 | if (boolval == -1) | ||
| 549 | boolval = it->size; | ||
| 550 | ret = asn1_print_boolean_ctx(out, boolval, pctx); | ||
| 551 | } | ||
| 552 | break; | ||
| 553 | |||
| 554 | case V_ASN1_INTEGER: | ||
| 555 | case V_ASN1_ENUMERATED: | ||
| 556 | ret = asn1_print_integer_ctx(out, str, pctx); | ||
| 557 | break; | ||
| 558 | |||
| 559 | case V_ASN1_UTCTIME: | ||
| 560 | ret = ASN1_UTCTIME_print(out, str); | ||
| 561 | break; | ||
| 562 | |||
| 563 | case V_ASN1_GENERALIZEDTIME: | ||
| 564 | ret = ASN1_GENERALIZEDTIME_print(out, str); | ||
| 565 | break; | ||
| 566 | |||
| 567 | case V_ASN1_OBJECT: | ||
| 568 | ret = asn1_print_oid_ctx(out, (const ASN1_OBJECT *)*fld, pctx); | ||
| 569 | break; | ||
| 570 | |||
| 571 | case V_ASN1_OCTET_STRING: | ||
| 572 | case V_ASN1_BIT_STRING: | ||
| 573 | ret = asn1_print_obstring_ctx(out, str, indent, pctx); | ||
| 574 | needlf = 0; | ||
| 575 | break; | ||
| 576 | |||
| 577 | case V_ASN1_SEQUENCE: | ||
| 578 | case V_ASN1_SET: | ||
| 579 | case V_ASN1_OTHER: | ||
| 580 | if (BIO_puts(out, "\n") <= 0) | ||
| 581 | return 0; | ||
| 582 | if (ASN1_parse_dump(out, str->data, str->length, | ||
| 583 | indent, 0) <= 0) | ||
| 584 | ret = 0; | ||
| 585 | needlf = 0; | ||
| 586 | break; | ||
| 587 | |||
| 588 | default: | ||
| 589 | ret = ASN1_STRING_print_ex(out, str, pctx->str_flags); | ||
| 590 | } | ||
| 591 | if (!ret) | ||
| 592 | return 0; | ||
| 593 | if (needlf && BIO_puts(out, "\n") <= 0) | ||
| 594 | return 0; | ||
| 595 | return 1; | ||
| 596 | } | ||
diff --git a/src/lib/libcrypto/asn1/tasn_typ.c b/src/lib/libcrypto/asn1/tasn_typ.c deleted file mode 100644 index 542713aa09..0000000000 --- a/src/lib/libcrypto/asn1/tasn_typ.c +++ /dev/null | |||
| @@ -1,799 +0,0 @@ | |||
| 1 | /* $OpenBSD: tasn_typ.c,v 1.13 2015/07/24 15:09:52 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000 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 | #include <stdio.h> | ||
| 59 | #include <openssl/asn1.h> | ||
| 60 | #include <openssl/asn1t.h> | ||
| 61 | |||
| 62 | /* Declarations for string types */ | ||
| 63 | |||
| 64 | const ASN1_ITEM ASN1_INTEGER_it = { | ||
| 65 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 66 | .utype = V_ASN1_INTEGER, | ||
| 67 | .sname = "ASN1_INTEGER", | ||
| 68 | }; | ||
| 69 | |||
| 70 | ASN1_INTEGER * | ||
| 71 | d2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **in, long len) | ||
| 72 | { | ||
| 73 | return (ASN1_INTEGER *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 74 | &ASN1_INTEGER_it); | ||
| 75 | } | ||
| 76 | |||
| 77 | int | ||
| 78 | i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **out) | ||
| 79 | { | ||
| 80 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_INTEGER_it); | ||
| 81 | } | ||
| 82 | |||
| 83 | ASN1_INTEGER * | ||
| 84 | ASN1_INTEGER_new(void) | ||
| 85 | { | ||
| 86 | return (ASN1_INTEGER *)ASN1_item_new(&ASN1_INTEGER_it); | ||
| 87 | } | ||
| 88 | |||
| 89 | void | ||
| 90 | ASN1_INTEGER_free(ASN1_INTEGER *a) | ||
| 91 | { | ||
| 92 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_INTEGER_it); | ||
| 93 | } | ||
| 94 | |||
| 95 | |||
| 96 | const ASN1_ITEM ASN1_ENUMERATED_it = { | ||
| 97 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 98 | .utype = V_ASN1_ENUMERATED, | ||
| 99 | .sname = "ASN1_ENUMERATED", | ||
| 100 | }; | ||
| 101 | |||
| 102 | ASN1_ENUMERATED * | ||
| 103 | d2i_ASN1_ENUMERATED(ASN1_ENUMERATED **a, const unsigned char **in, long len) | ||
| 104 | { | ||
| 105 | return (ASN1_ENUMERATED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 106 | &ASN1_ENUMERATED_it); | ||
| 107 | } | ||
| 108 | |||
| 109 | int | ||
| 110 | i2d_ASN1_ENUMERATED(ASN1_ENUMERATED *a, unsigned char **out) | ||
| 111 | { | ||
| 112 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_ENUMERATED_it); | ||
| 113 | } | ||
| 114 | |||
| 115 | ASN1_ENUMERATED * | ||
| 116 | ASN1_ENUMERATED_new(void) | ||
| 117 | { | ||
| 118 | return (ASN1_ENUMERATED *)ASN1_item_new(&ASN1_ENUMERATED_it); | ||
| 119 | } | ||
| 120 | |||
| 121 | void | ||
| 122 | ASN1_ENUMERATED_free(ASN1_ENUMERATED *a) | ||
| 123 | { | ||
| 124 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_ENUMERATED_it); | ||
| 125 | } | ||
| 126 | |||
| 127 | |||
| 128 | const ASN1_ITEM ASN1_BIT_STRING_it = { | ||
| 129 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 130 | .utype = V_ASN1_BIT_STRING, | ||
| 131 | .sname = "ASN1_BIT_STRING", | ||
| 132 | }; | ||
| 133 | |||
| 134 | ASN1_BIT_STRING * | ||
| 135 | d2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, const unsigned char **in, long len) | ||
| 136 | { | ||
| 137 | return (ASN1_BIT_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 138 | &ASN1_BIT_STRING_it); | ||
| 139 | } | ||
| 140 | |||
| 141 | int | ||
| 142 | i2d_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **out) | ||
| 143 | { | ||
| 144 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_BIT_STRING_it); | ||
| 145 | } | ||
| 146 | |||
| 147 | ASN1_BIT_STRING * | ||
| 148 | ASN1_BIT_STRING_new(void) | ||
| 149 | { | ||
| 150 | return (ASN1_BIT_STRING *)ASN1_item_new(&ASN1_BIT_STRING_it); | ||
| 151 | } | ||
| 152 | |||
| 153 | void | ||
| 154 | ASN1_BIT_STRING_free(ASN1_BIT_STRING *a) | ||
| 155 | { | ||
| 156 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_BIT_STRING_it); | ||
| 157 | } | ||
| 158 | |||
| 159 | |||
| 160 | const ASN1_ITEM ASN1_OCTET_STRING_it = { | ||
| 161 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 162 | .utype = V_ASN1_OCTET_STRING, | ||
| 163 | .sname = "ASN1_OCTET_STRING", | ||
| 164 | }; | ||
| 165 | |||
| 166 | ASN1_OCTET_STRING * | ||
| 167 | d2i_ASN1_OCTET_STRING(ASN1_OCTET_STRING **a, const unsigned char **in, long len) | ||
| 168 | { | ||
| 169 | return (ASN1_OCTET_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 170 | &ASN1_OCTET_STRING_it); | ||
| 171 | } | ||
| 172 | |||
| 173 | int | ||
| 174 | i2d_ASN1_OCTET_STRING(ASN1_OCTET_STRING *a, unsigned char **out) | ||
| 175 | { | ||
| 176 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_OCTET_STRING_it); | ||
| 177 | } | ||
| 178 | |||
| 179 | ASN1_OCTET_STRING * | ||
| 180 | ASN1_OCTET_STRING_new(void) | ||
| 181 | { | ||
| 182 | return (ASN1_OCTET_STRING *)ASN1_item_new(&ASN1_OCTET_STRING_it); | ||
| 183 | } | ||
| 184 | |||
| 185 | void | ||
| 186 | ASN1_OCTET_STRING_free(ASN1_OCTET_STRING *a) | ||
| 187 | { | ||
| 188 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_OCTET_STRING_it); | ||
| 189 | } | ||
| 190 | |||
| 191 | |||
| 192 | const ASN1_ITEM ASN1_NULL_it = { | ||
| 193 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 194 | .utype = V_ASN1_NULL, | ||
| 195 | .sname = "ASN1_NULL", | ||
| 196 | }; | ||
| 197 | |||
| 198 | ASN1_NULL * | ||
| 199 | d2i_ASN1_NULL(ASN1_NULL **a, const unsigned char **in, long len) | ||
| 200 | { | ||
| 201 | return (ASN1_NULL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 202 | &ASN1_NULL_it); | ||
| 203 | } | ||
| 204 | |||
| 205 | int | ||
| 206 | i2d_ASN1_NULL(ASN1_NULL *a, unsigned char **out) | ||
| 207 | { | ||
| 208 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_NULL_it); | ||
| 209 | } | ||
| 210 | |||
| 211 | ASN1_NULL * | ||
| 212 | ASN1_NULL_new(void) | ||
| 213 | { | ||
| 214 | return (ASN1_NULL *)ASN1_item_new(&ASN1_NULL_it); | ||
| 215 | } | ||
| 216 | |||
| 217 | void | ||
| 218 | ASN1_NULL_free(ASN1_NULL *a) | ||
| 219 | { | ||
| 220 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_NULL_it); | ||
| 221 | } | ||
| 222 | |||
| 223 | |||
| 224 | const ASN1_ITEM ASN1_OBJECT_it = { | ||
| 225 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 226 | .utype = V_ASN1_OBJECT, | ||
| 227 | .sname = "ASN1_OBJECT", | ||
| 228 | }; | ||
| 229 | |||
| 230 | |||
| 231 | const ASN1_ITEM ASN1_UTF8STRING_it = { | ||
| 232 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 233 | .utype = V_ASN1_UTF8STRING, | ||
| 234 | .sname = "ASN1_UTF8STRING", | ||
| 235 | }; | ||
| 236 | |||
| 237 | ASN1_UTF8STRING * | ||
| 238 | d2i_ASN1_UTF8STRING(ASN1_UTF8STRING **a, const unsigned char **in, long len) | ||
| 239 | { | ||
| 240 | return (ASN1_UTF8STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 241 | &ASN1_UTF8STRING_it); | ||
| 242 | } | ||
| 243 | |||
| 244 | int | ||
| 245 | i2d_ASN1_UTF8STRING(ASN1_UTF8STRING *a, unsigned char **out) | ||
| 246 | { | ||
| 247 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_UTF8STRING_it); | ||
| 248 | } | ||
| 249 | |||
| 250 | ASN1_UTF8STRING * | ||
| 251 | ASN1_UTF8STRING_new(void) | ||
| 252 | { | ||
| 253 | return (ASN1_UTF8STRING *)ASN1_item_new(&ASN1_UTF8STRING_it); | ||
| 254 | } | ||
| 255 | |||
| 256 | void | ||
| 257 | ASN1_UTF8STRING_free(ASN1_UTF8STRING *a) | ||
| 258 | { | ||
| 259 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_UTF8STRING_it); | ||
| 260 | } | ||
| 261 | |||
| 262 | |||
| 263 | const ASN1_ITEM ASN1_PRINTABLESTRING_it = { | ||
| 264 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 265 | .utype = V_ASN1_PRINTABLESTRING, | ||
| 266 | .sname = "ASN1_PRINTABLESTRING", | ||
| 267 | }; | ||
| 268 | |||
| 269 | ASN1_PRINTABLESTRING * | ||
| 270 | d2i_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING **a, const unsigned char **in, | ||
| 271 | long len) | ||
| 272 | { | ||
| 273 | return (ASN1_PRINTABLESTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 274 | &ASN1_PRINTABLESTRING_it); | ||
| 275 | } | ||
| 276 | |||
| 277 | int | ||
| 278 | i2d_ASN1_PRINTABLESTRING(ASN1_PRINTABLESTRING *a, unsigned char **out) | ||
| 279 | { | ||
| 280 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_PRINTABLESTRING_it); | ||
| 281 | } | ||
| 282 | |||
| 283 | ASN1_PRINTABLESTRING * | ||
| 284 | ASN1_PRINTABLESTRING_new(void) | ||
| 285 | { | ||
| 286 | return (ASN1_PRINTABLESTRING *)ASN1_item_new(&ASN1_PRINTABLESTRING_it); | ||
| 287 | } | ||
| 288 | |||
| 289 | void | ||
| 290 | ASN1_PRINTABLESTRING_free(ASN1_PRINTABLESTRING *a) | ||
| 291 | { | ||
| 292 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_PRINTABLESTRING_it); | ||
| 293 | } | ||
| 294 | |||
| 295 | |||
| 296 | const ASN1_ITEM ASN1_T61STRING_it = { | ||
| 297 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 298 | .utype = V_ASN1_T61STRING, | ||
| 299 | .sname = "ASN1_T61STRING", | ||
| 300 | }; | ||
| 301 | |||
| 302 | ASN1_T61STRING * | ||
| 303 | d2i_ASN1_T61STRING(ASN1_T61STRING **a, const unsigned char **in, long len) | ||
| 304 | { | ||
| 305 | return (ASN1_T61STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 306 | &ASN1_T61STRING_it); | ||
| 307 | } | ||
| 308 | |||
| 309 | int | ||
| 310 | i2d_ASN1_T61STRING(ASN1_T61STRING *a, unsigned char **out) | ||
| 311 | { | ||
| 312 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_T61STRING_it); | ||
| 313 | } | ||
| 314 | |||
| 315 | ASN1_T61STRING * | ||
| 316 | ASN1_T61STRING_new(void) | ||
| 317 | { | ||
| 318 | return (ASN1_T61STRING *)ASN1_item_new(&ASN1_T61STRING_it); | ||
| 319 | } | ||
| 320 | |||
| 321 | void | ||
| 322 | ASN1_T61STRING_free(ASN1_T61STRING *a) | ||
| 323 | { | ||
| 324 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_T61STRING_it); | ||
| 325 | } | ||
| 326 | |||
| 327 | |||
| 328 | const ASN1_ITEM ASN1_IA5STRING_it = { | ||
| 329 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 330 | .utype = V_ASN1_IA5STRING, | ||
| 331 | .sname = "ASN1_IA5STRING", | ||
| 332 | }; | ||
| 333 | |||
| 334 | ASN1_IA5STRING * | ||
| 335 | d2i_ASN1_IA5STRING(ASN1_IA5STRING **a, const unsigned char **in, long len) | ||
| 336 | { | ||
| 337 | return (ASN1_IA5STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 338 | &ASN1_IA5STRING_it); | ||
| 339 | } | ||
| 340 | |||
| 341 | int | ||
| 342 | i2d_ASN1_IA5STRING(ASN1_IA5STRING *a, unsigned char **out) | ||
| 343 | { | ||
| 344 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_IA5STRING_it); | ||
| 345 | } | ||
| 346 | |||
| 347 | ASN1_IA5STRING * | ||
| 348 | ASN1_IA5STRING_new(void) | ||
| 349 | { | ||
| 350 | return (ASN1_IA5STRING *)ASN1_item_new(&ASN1_IA5STRING_it); | ||
| 351 | } | ||
| 352 | |||
| 353 | void | ||
| 354 | ASN1_IA5STRING_free(ASN1_IA5STRING *a) | ||
| 355 | { | ||
| 356 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_IA5STRING_it); | ||
| 357 | } | ||
| 358 | |||
| 359 | |||
| 360 | const ASN1_ITEM ASN1_GENERALSTRING_it = { | ||
| 361 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 362 | .utype = V_ASN1_GENERALSTRING, | ||
| 363 | .sname = "ASN1_GENERALSTRING", | ||
| 364 | }; | ||
| 365 | |||
| 366 | ASN1_GENERALSTRING * | ||
| 367 | d2i_ASN1_GENERALSTRING(ASN1_GENERALSTRING **a, const unsigned char **in, | ||
| 368 | long len) | ||
| 369 | { | ||
| 370 | return (ASN1_GENERALSTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 371 | &ASN1_GENERALSTRING_it); | ||
| 372 | } | ||
| 373 | |||
| 374 | int | ||
| 375 | i2d_ASN1_GENERALSTRING(ASN1_GENERALSTRING *a, unsigned char **out) | ||
| 376 | { | ||
| 377 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_GENERALSTRING_it); | ||
| 378 | } | ||
| 379 | |||
| 380 | ASN1_GENERALSTRING * | ||
| 381 | ASN1_GENERALSTRING_new(void) | ||
| 382 | { | ||
| 383 | return (ASN1_GENERALSTRING *)ASN1_item_new(&ASN1_GENERALSTRING_it); | ||
| 384 | } | ||
| 385 | |||
| 386 | void | ||
| 387 | ASN1_GENERALSTRING_free(ASN1_GENERALSTRING *a) | ||
| 388 | { | ||
| 389 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_GENERALSTRING_it); | ||
| 390 | } | ||
| 391 | |||
| 392 | |||
| 393 | const ASN1_ITEM ASN1_UTCTIME_it = { | ||
| 394 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 395 | .utype = V_ASN1_UTCTIME, | ||
| 396 | .sname = "ASN1_UTCTIME", | ||
| 397 | }; | ||
| 398 | |||
| 399 | ASN1_UTCTIME * | ||
| 400 | d2i_ASN1_UTCTIME(ASN1_UTCTIME **a, const unsigned char **in, long len) | ||
| 401 | { | ||
| 402 | return (ASN1_UTCTIME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 403 | &ASN1_UTCTIME_it); | ||
| 404 | } | ||
| 405 | |||
| 406 | int | ||
| 407 | i2d_ASN1_UTCTIME(ASN1_UTCTIME *a, unsigned char **out) | ||
| 408 | { | ||
| 409 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_UTCTIME_it); | ||
| 410 | } | ||
| 411 | |||
| 412 | ASN1_UTCTIME * | ||
| 413 | ASN1_UTCTIME_new(void) | ||
| 414 | { | ||
| 415 | return (ASN1_UTCTIME *)ASN1_item_new(&ASN1_UTCTIME_it); | ||
| 416 | } | ||
| 417 | |||
| 418 | void | ||
| 419 | ASN1_UTCTIME_free(ASN1_UTCTIME *a) | ||
| 420 | { | ||
| 421 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_UTCTIME_it); | ||
| 422 | } | ||
| 423 | |||
| 424 | |||
| 425 | const ASN1_ITEM ASN1_GENERALIZEDTIME_it = { | ||
| 426 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 427 | .utype = V_ASN1_GENERALIZEDTIME, | ||
| 428 | .sname = "ASN1_GENERALIZEDTIME", | ||
| 429 | }; | ||
| 430 | |||
| 431 | ASN1_GENERALIZEDTIME * | ||
| 432 | d2i_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME **a, const unsigned char **in, | ||
| 433 | long len) | ||
| 434 | { | ||
| 435 | return (ASN1_GENERALIZEDTIME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 436 | &ASN1_GENERALIZEDTIME_it); | ||
| 437 | } | ||
| 438 | |||
| 439 | int | ||
| 440 | i2d_ASN1_GENERALIZEDTIME(ASN1_GENERALIZEDTIME *a, unsigned char **out) | ||
| 441 | { | ||
| 442 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_GENERALIZEDTIME_it); | ||
| 443 | } | ||
| 444 | |||
| 445 | ASN1_GENERALIZEDTIME * | ||
| 446 | ASN1_GENERALIZEDTIME_new(void) | ||
| 447 | { | ||
| 448 | return (ASN1_GENERALIZEDTIME *)ASN1_item_new(&ASN1_GENERALIZEDTIME_it); | ||
| 449 | } | ||
| 450 | |||
| 451 | void | ||
| 452 | ASN1_GENERALIZEDTIME_free(ASN1_GENERALIZEDTIME *a) | ||
| 453 | { | ||
| 454 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_GENERALIZEDTIME_it); | ||
| 455 | } | ||
| 456 | |||
| 457 | |||
| 458 | const ASN1_ITEM ASN1_VISIBLESTRING_it = { | ||
| 459 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 460 | .utype = V_ASN1_VISIBLESTRING, | ||
| 461 | .sname = "ASN1_VISIBLESTRING", | ||
| 462 | }; | ||
| 463 | |||
| 464 | ASN1_VISIBLESTRING * | ||
| 465 | d2i_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING **a, const unsigned char **in, | ||
| 466 | long len) | ||
| 467 | { | ||
| 468 | return (ASN1_VISIBLESTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 469 | &ASN1_VISIBLESTRING_it); | ||
| 470 | } | ||
| 471 | |||
| 472 | int | ||
| 473 | i2d_ASN1_VISIBLESTRING(ASN1_VISIBLESTRING *a, unsigned char **out) | ||
| 474 | { | ||
| 475 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_VISIBLESTRING_it); | ||
| 476 | } | ||
| 477 | |||
| 478 | ASN1_VISIBLESTRING * | ||
| 479 | ASN1_VISIBLESTRING_new(void) | ||
| 480 | { | ||
| 481 | return (ASN1_VISIBLESTRING *)ASN1_item_new(&ASN1_VISIBLESTRING_it); | ||
| 482 | } | ||
| 483 | |||
| 484 | void | ||
| 485 | ASN1_VISIBLESTRING_free(ASN1_VISIBLESTRING *a) | ||
| 486 | { | ||
| 487 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_VISIBLESTRING_it); | ||
| 488 | } | ||
| 489 | |||
| 490 | |||
| 491 | const ASN1_ITEM ASN1_UNIVERSALSTRING_it = { | ||
| 492 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 493 | .utype = V_ASN1_UNIVERSALSTRING, | ||
| 494 | .sname = "ASN1_UNIVERSALSTRING", | ||
| 495 | }; | ||
| 496 | |||
| 497 | ASN1_UNIVERSALSTRING * | ||
| 498 | d2i_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING **a, const unsigned char **in, | ||
| 499 | long len) | ||
| 500 | { | ||
| 501 | return (ASN1_UNIVERSALSTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 502 | &ASN1_UNIVERSALSTRING_it); | ||
| 503 | } | ||
| 504 | |||
| 505 | int | ||
| 506 | i2d_ASN1_UNIVERSALSTRING(ASN1_UNIVERSALSTRING *a, unsigned char **out) | ||
| 507 | { | ||
| 508 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_UNIVERSALSTRING_it); | ||
| 509 | } | ||
| 510 | |||
| 511 | ASN1_UNIVERSALSTRING * | ||
| 512 | ASN1_UNIVERSALSTRING_new(void) | ||
| 513 | { | ||
| 514 | return (ASN1_UNIVERSALSTRING *)ASN1_item_new(&ASN1_UNIVERSALSTRING_it); | ||
| 515 | } | ||
| 516 | |||
| 517 | void | ||
| 518 | ASN1_UNIVERSALSTRING_free(ASN1_UNIVERSALSTRING *a) | ||
| 519 | { | ||
| 520 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_UNIVERSALSTRING_it); | ||
| 521 | } | ||
| 522 | |||
| 523 | |||
| 524 | const ASN1_ITEM ASN1_BMPSTRING_it = { | ||
| 525 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 526 | .utype = V_ASN1_BMPSTRING, | ||
| 527 | .sname = "ASN1_BMPSTRING", | ||
| 528 | }; | ||
| 529 | |||
| 530 | ASN1_BMPSTRING * | ||
| 531 | d2i_ASN1_BMPSTRING(ASN1_BMPSTRING **a, const unsigned char **in, long len) | ||
| 532 | { | ||
| 533 | return (ASN1_BMPSTRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 534 | &ASN1_BMPSTRING_it); | ||
| 535 | } | ||
| 536 | |||
| 537 | int | ||
| 538 | i2d_ASN1_BMPSTRING(ASN1_BMPSTRING *a, unsigned char **out) | ||
| 539 | { | ||
| 540 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_BMPSTRING_it); | ||
| 541 | } | ||
| 542 | |||
| 543 | ASN1_BMPSTRING * | ||
| 544 | ASN1_BMPSTRING_new(void) | ||
| 545 | { | ||
| 546 | return (ASN1_BMPSTRING *)ASN1_item_new(&ASN1_BMPSTRING_it); | ||
| 547 | } | ||
| 548 | |||
| 549 | void | ||
| 550 | ASN1_BMPSTRING_free(ASN1_BMPSTRING *a) | ||
| 551 | { | ||
| 552 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_BMPSTRING_it); | ||
| 553 | } | ||
| 554 | |||
| 555 | |||
| 556 | const ASN1_ITEM ASN1_ANY_it = { | ||
| 557 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 558 | .utype = V_ASN1_ANY, | ||
| 559 | .sname = "ASN1_ANY", | ||
| 560 | }; | ||
| 561 | |||
| 562 | /* Just swallow an ASN1_SEQUENCE in an ASN1_STRING */ | ||
| 563 | |||
| 564 | const ASN1_ITEM ASN1_SEQUENCE_it = { | ||
| 565 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 566 | .utype = V_ASN1_SEQUENCE, | ||
| 567 | .sname = "ASN1_SEQUENCE", | ||
| 568 | }; | ||
| 569 | |||
| 570 | |||
| 571 | ASN1_TYPE * | ||
| 572 | d2i_ASN1_TYPE(ASN1_TYPE **a, const unsigned char **in, long len) | ||
| 573 | { | ||
| 574 | return (ASN1_TYPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 575 | &ASN1_ANY_it); | ||
| 576 | } | ||
| 577 | |||
| 578 | int | ||
| 579 | i2d_ASN1_TYPE(ASN1_TYPE *a, unsigned char **out) | ||
| 580 | { | ||
| 581 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_ANY_it); | ||
| 582 | } | ||
| 583 | |||
| 584 | ASN1_TYPE * | ||
| 585 | ASN1_TYPE_new(void) | ||
| 586 | { | ||
| 587 | return (ASN1_TYPE *)ASN1_item_new(&ASN1_ANY_it); | ||
| 588 | } | ||
| 589 | |||
| 590 | void | ||
| 591 | ASN1_TYPE_free(ASN1_TYPE *a) | ||
| 592 | { | ||
| 593 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_ANY_it); | ||
| 594 | } | ||
| 595 | |||
| 596 | /* Multistring types */ | ||
| 597 | |||
| 598 | |||
| 599 | const ASN1_ITEM ASN1_PRINTABLE_it = { | ||
| 600 | .itype = ASN1_ITYPE_MSTRING, | ||
| 601 | .utype = B_ASN1_PRINTABLE, | ||
| 602 | .templates = NULL, | ||
| 603 | .tcount = 0, | ||
| 604 | .funcs = NULL, | ||
| 605 | .size = sizeof(ASN1_STRING), | ||
| 606 | .sname = "ASN1_PRINTABLE", | ||
| 607 | }; | ||
| 608 | |||
| 609 | ASN1_STRING * | ||
| 610 | d2i_ASN1_PRINTABLE(ASN1_STRING **a, const unsigned char **in, long len) | ||
| 611 | { | ||
| 612 | return (ASN1_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 613 | &ASN1_PRINTABLE_it); | ||
| 614 | } | ||
| 615 | |||
| 616 | int | ||
| 617 | i2d_ASN1_PRINTABLE(ASN1_STRING *a, unsigned char **out) | ||
| 618 | { | ||
| 619 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_PRINTABLE_it); | ||
| 620 | } | ||
| 621 | |||
| 622 | ASN1_STRING * | ||
| 623 | ASN1_PRINTABLE_new(void) | ||
| 624 | { | ||
| 625 | return (ASN1_STRING *)ASN1_item_new(&ASN1_PRINTABLE_it); | ||
| 626 | } | ||
| 627 | |||
| 628 | void | ||
| 629 | ASN1_PRINTABLE_free(ASN1_STRING *a) | ||
| 630 | { | ||
| 631 | ASN1_item_free((ASN1_VALUE *)a, &ASN1_PRINTABLE_it); | ||
| 632 | } | ||
| 633 | |||
| 634 | |||
| 635 | const ASN1_ITEM DISPLAYTEXT_it = { | ||
| 636 | .itype = ASN1_ITYPE_MSTRING, | ||
| 637 | .utype = B_ASN1_DISPLAYTEXT, | ||
| 638 | .templates = NULL, | ||
| 639 | .tcount = 0, | ||
| 640 | .funcs = NULL, | ||
| 641 | .size = sizeof(ASN1_STRING), | ||
| 642 | .sname = "DISPLAYTEXT", | ||
| 643 | }; | ||
| 644 | |||
| 645 | ASN1_STRING * | ||
| 646 | d2i_DISPLAYTEXT(ASN1_STRING **a, const unsigned char **in, long len) | ||
| 647 | { | ||
| 648 | return (ASN1_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 649 | &DISPLAYTEXT_it); | ||
| 650 | } | ||
| 651 | |||
| 652 | int | ||
| 653 | i2d_DISPLAYTEXT(ASN1_STRING *a, unsigned char **out) | ||
| 654 | { | ||
| 655 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &DISPLAYTEXT_it); | ||
| 656 | } | ||
| 657 | |||
| 658 | ASN1_STRING * | ||
| 659 | DISPLAYTEXT_new(void) | ||
| 660 | { | ||
| 661 | return (ASN1_STRING *)ASN1_item_new(&DISPLAYTEXT_it); | ||
| 662 | } | ||
| 663 | |||
| 664 | void | ||
| 665 | DISPLAYTEXT_free(ASN1_STRING *a) | ||
| 666 | { | ||
| 667 | ASN1_item_free((ASN1_VALUE *)a, &DISPLAYTEXT_it); | ||
| 668 | } | ||
| 669 | |||
| 670 | |||
| 671 | const ASN1_ITEM DIRECTORYSTRING_it = { | ||
| 672 | .itype = ASN1_ITYPE_MSTRING, | ||
| 673 | .utype = B_ASN1_DIRECTORYSTRING, | ||
| 674 | .templates = NULL, | ||
| 675 | .tcount = 0, | ||
| 676 | .funcs = NULL, | ||
| 677 | .size = sizeof(ASN1_STRING), | ||
| 678 | .sname = "DIRECTORYSTRING", | ||
| 679 | }; | ||
| 680 | |||
| 681 | ASN1_STRING * | ||
| 682 | d2i_DIRECTORYSTRING(ASN1_STRING **a, const unsigned char **in, long len) | ||
| 683 | { | ||
| 684 | return (ASN1_STRING *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 685 | &DIRECTORYSTRING_it); | ||
| 686 | } | ||
| 687 | |||
| 688 | int | ||
| 689 | i2d_DIRECTORYSTRING(ASN1_STRING *a, unsigned char **out) | ||
| 690 | { | ||
| 691 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIRECTORYSTRING_it); | ||
| 692 | } | ||
| 693 | |||
| 694 | ASN1_STRING * | ||
| 695 | DIRECTORYSTRING_new(void) | ||
| 696 | { | ||
| 697 | return (ASN1_STRING *)ASN1_item_new(&DIRECTORYSTRING_it); | ||
| 698 | } | ||
| 699 | |||
| 700 | void | ||
| 701 | DIRECTORYSTRING_free(ASN1_STRING *a) | ||
| 702 | { | ||
| 703 | ASN1_item_free((ASN1_VALUE *)a, &DIRECTORYSTRING_it); | ||
| 704 | } | ||
| 705 | |||
| 706 | /* Three separate BOOLEAN type: normal, DEFAULT TRUE and DEFAULT FALSE */ | ||
| 707 | |||
| 708 | const ASN1_ITEM ASN1_BOOLEAN_it = { | ||
| 709 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 710 | .utype = V_ASN1_BOOLEAN, | ||
| 711 | .size = -1, | ||
| 712 | .sname = "ASN1_BOOLEAN", | ||
| 713 | }; | ||
| 714 | |||
| 715 | const ASN1_ITEM ASN1_TBOOLEAN_it = { | ||
| 716 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 717 | .utype = V_ASN1_BOOLEAN, | ||
| 718 | .size = 1, | ||
| 719 | .sname = "ASN1_TBOOLEAN", | ||
| 720 | }; | ||
| 721 | |||
| 722 | const ASN1_ITEM ASN1_FBOOLEAN_it = { | ||
| 723 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 724 | .utype = V_ASN1_BOOLEAN, | ||
| 725 | .size = 0, | ||
| 726 | .sname = "ASN1_FBOOLEAN", | ||
| 727 | }; | ||
| 728 | |||
| 729 | /* Special, OCTET STRING with indefinite length constructed support */ | ||
| 730 | |||
| 731 | const ASN1_ITEM ASN1_OCTET_STRING_NDEF_it = { | ||
| 732 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 733 | .utype = V_ASN1_OCTET_STRING, | ||
| 734 | .size = ASN1_TFLG_NDEF, | ||
| 735 | .sname = "ASN1_OCTET_STRING_NDEF", | ||
| 736 | }; | ||
| 737 | |||
| 738 | static const ASN1_TEMPLATE ASN1_SEQUENCE_ANY_item_tt = { | ||
| 739 | .flags = ASN1_TFLG_SEQUENCE_OF, | ||
| 740 | .tag = 0, | ||
| 741 | .offset = 0, | ||
| 742 | .field_name = "ASN1_SEQUENCE_ANY", | ||
| 743 | .item = &ASN1_ANY_it, | ||
| 744 | }; | ||
| 745 | |||
| 746 | const ASN1_ITEM ASN1_SEQUENCE_ANY_it = { | ||
| 747 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 748 | .utype = -1, | ||
| 749 | .templates = &ASN1_SEQUENCE_ANY_item_tt, | ||
| 750 | .tcount = 0, | ||
| 751 | .funcs = NULL, | ||
| 752 | .size = 0, | ||
| 753 | .sname = "ASN1_SEQUENCE_ANY", | ||
| 754 | }; | ||
| 755 | |||
| 756 | static const ASN1_TEMPLATE ASN1_SET_ANY_item_tt = { | ||
| 757 | .flags = ASN1_TFLG_SET_OF, | ||
| 758 | .tag = 0, | ||
| 759 | .offset = 0, | ||
| 760 | .field_name = "ASN1_SET_ANY", | ||
| 761 | .item = &ASN1_ANY_it, | ||
| 762 | }; | ||
| 763 | |||
| 764 | const ASN1_ITEM ASN1_SET_ANY_it = { | ||
| 765 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 766 | .utype = -1, | ||
| 767 | .templates = &ASN1_SET_ANY_item_tt, | ||
| 768 | .tcount = 0, | ||
| 769 | .funcs = NULL, | ||
| 770 | .size = 0, | ||
| 771 | .sname = "ASN1_SET_ANY", | ||
| 772 | }; | ||
| 773 | |||
| 774 | |||
| 775 | ASN1_SEQUENCE_ANY * | ||
| 776 | d2i_ASN1_SEQUENCE_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len) | ||
| 777 | { | ||
| 778 | return (ASN1_SEQUENCE_ANY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 779 | &ASN1_SEQUENCE_ANY_it); | ||
| 780 | } | ||
| 781 | |||
| 782 | int | ||
| 783 | i2d_ASN1_SEQUENCE_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out) | ||
| 784 | { | ||
| 785 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_SEQUENCE_ANY_it); | ||
| 786 | } | ||
| 787 | |||
| 788 | ASN1_SEQUENCE_ANY * | ||
| 789 | d2i_ASN1_SET_ANY(ASN1_SEQUENCE_ANY **a, const unsigned char **in, long len) | ||
| 790 | { | ||
| 791 | return (ASN1_SEQUENCE_ANY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 792 | &ASN1_SET_ANY_it); | ||
| 793 | } | ||
| 794 | |||
| 795 | int | ||
| 796 | i2d_ASN1_SET_ANY(const ASN1_SEQUENCE_ANY *a, unsigned char **out) | ||
| 797 | { | ||
| 798 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASN1_SET_ANY_it); | ||
| 799 | } | ||
diff --git a/src/lib/libcrypto/asn1/tasn_utl.c b/src/lib/libcrypto/asn1/tasn_utl.c deleted file mode 100644 index 529aaf6116..0000000000 --- a/src/lib/libcrypto/asn1/tasn_utl.c +++ /dev/null | |||
| @@ -1,281 +0,0 @@ | |||
| 1 | /* $OpenBSD: tasn_utl.c,v 1.11 2015/07/25 17:07:17 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000-2004 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 | #include <stddef.h> | ||
| 60 | #include <string.h> | ||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/asn1t.h> | ||
| 63 | #include <openssl/objects.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | |||
| 66 | /* Utility functions for manipulating fields and offsets */ | ||
| 67 | |||
| 68 | /* Add 'offset' to 'addr' */ | ||
| 69 | #define offset2ptr(addr, offset) (void *)(((char *) addr) + offset) | ||
| 70 | |||
| 71 | /* Given an ASN1_ITEM CHOICE type return | ||
| 72 | * the selector value | ||
| 73 | */ | ||
| 74 | |||
| 75 | int | ||
| 76 | asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 77 | { | ||
| 78 | int *sel = offset2ptr(*pval, it->utype); | ||
| 79 | return *sel; | ||
| 80 | } | ||
| 81 | |||
| 82 | /* Given an ASN1_ITEM CHOICE type set | ||
| 83 | * the selector value, return old value. | ||
| 84 | */ | ||
| 85 | |||
| 86 | int | ||
| 87 | asn1_set_choice_selector(ASN1_VALUE **pval, int value, const ASN1_ITEM *it) | ||
| 88 | { | ||
| 89 | int *sel, ret; | ||
| 90 | sel = offset2ptr(*pval, it->utype); | ||
| 91 | ret = *sel; | ||
| 92 | *sel = value; | ||
| 93 | return ret; | ||
| 94 | } | ||
| 95 | |||
| 96 | /* Do reference counting. The value 'op' decides what to do. | ||
| 97 | * if it is +1 then the count is incremented. If op is 0 count is | ||
| 98 | * set to 1. If op is -1 count is decremented and the return value | ||
| 99 | * is the current refrence count or 0 if no reference count exists. | ||
| 100 | */ | ||
| 101 | |||
| 102 | int | ||
| 103 | asn1_do_lock(ASN1_VALUE **pval, int op, const ASN1_ITEM *it) | ||
| 104 | { | ||
| 105 | const ASN1_AUX *aux; | ||
| 106 | int *lck, ret; | ||
| 107 | |||
| 108 | if ((it->itype != ASN1_ITYPE_SEQUENCE) && | ||
| 109 | (it->itype != ASN1_ITYPE_NDEF_SEQUENCE)) | ||
| 110 | return 0; | ||
| 111 | aux = it->funcs; | ||
| 112 | if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT)) | ||
| 113 | return 0; | ||
| 114 | lck = offset2ptr(*pval, aux->ref_offset); | ||
| 115 | if (op == 0) { | ||
| 116 | *lck = 1; | ||
| 117 | return 1; | ||
| 118 | } | ||
| 119 | ret = CRYPTO_add(lck, op, aux->ref_lock); | ||
| 120 | return ret; | ||
| 121 | } | ||
| 122 | |||
| 123 | static ASN1_ENCODING * | ||
| 124 | asn1_get_enc_ptr(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 125 | { | ||
| 126 | const ASN1_AUX *aux; | ||
| 127 | |||
| 128 | if (!pval || !*pval) | ||
| 129 | return NULL; | ||
| 130 | aux = it->funcs; | ||
| 131 | if (!aux || !(aux->flags & ASN1_AFLG_ENCODING)) | ||
| 132 | return NULL; | ||
| 133 | return offset2ptr(*pval, aux->enc_offset); | ||
| 134 | } | ||
| 135 | |||
| 136 | void | ||
| 137 | asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 138 | { | ||
| 139 | ASN1_ENCODING *enc; | ||
| 140 | |||
| 141 | enc = asn1_get_enc_ptr(pval, it); | ||
| 142 | if (enc) { | ||
| 143 | enc->enc = NULL; | ||
| 144 | enc->len = 0; | ||
| 145 | enc->modified = 1; | ||
| 146 | } | ||
| 147 | } | ||
| 148 | |||
| 149 | void | ||
| 150 | asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 151 | { | ||
| 152 | ASN1_ENCODING *enc; | ||
| 153 | |||
| 154 | enc = asn1_get_enc_ptr(pval, it); | ||
| 155 | if (enc) { | ||
| 156 | free(enc->enc); | ||
| 157 | enc->enc = NULL; | ||
| 158 | enc->len = 0; | ||
| 159 | enc->modified = 1; | ||
| 160 | } | ||
| 161 | } | ||
| 162 | |||
| 163 | int | ||
| 164 | asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen, | ||
| 165 | const ASN1_ITEM *it) | ||
| 166 | { | ||
| 167 | ASN1_ENCODING *enc; | ||
| 168 | |||
| 169 | enc = asn1_get_enc_ptr(pval, it); | ||
| 170 | if (!enc) | ||
| 171 | return 1; | ||
| 172 | |||
| 173 | free(enc->enc); | ||
| 174 | enc->enc = malloc(inlen); | ||
| 175 | if (!enc->enc) | ||
| 176 | return 0; | ||
| 177 | memcpy(enc->enc, in, inlen); | ||
| 178 | enc->len = inlen; | ||
| 179 | enc->modified = 0; | ||
| 180 | |||
| 181 | return 1; | ||
| 182 | } | ||
| 183 | |||
| 184 | int | ||
| 185 | asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval, | ||
| 186 | const ASN1_ITEM *it) | ||
| 187 | { | ||
| 188 | ASN1_ENCODING *enc; | ||
| 189 | |||
| 190 | enc = asn1_get_enc_ptr(pval, it); | ||
| 191 | if (!enc || enc->modified) | ||
| 192 | return 0; | ||
| 193 | if (out) { | ||
| 194 | memcpy(*out, enc->enc, enc->len); | ||
| 195 | *out += enc->len; | ||
| 196 | } | ||
| 197 | if (len) | ||
| 198 | *len = enc->len; | ||
| 199 | return 1; | ||
| 200 | } | ||
| 201 | |||
| 202 | /* Given an ASN1_TEMPLATE get a pointer to a field */ | ||
| 203 | ASN1_VALUE ** | ||
| 204 | asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) | ||
| 205 | { | ||
| 206 | ASN1_VALUE **pvaltmp; | ||
| 207 | |||
| 208 | if (tt->flags & ASN1_TFLG_COMBINE) | ||
| 209 | return pval; | ||
| 210 | pvaltmp = offset2ptr(*pval, tt->offset); | ||
| 211 | /* NOTE for BOOLEAN types the field is just a plain | ||
| 212 | * int so we can't return int **, so settle for | ||
| 213 | * (int *). | ||
| 214 | */ | ||
| 215 | return pvaltmp; | ||
| 216 | } | ||
| 217 | |||
| 218 | /* Handle ANY DEFINED BY template, find the selector, look up | ||
| 219 | * the relevant ASN1_TEMPLATE in the table and return it. | ||
| 220 | */ | ||
| 221 | |||
| 222 | const ASN1_TEMPLATE * | ||
| 223 | asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt, int nullerr) | ||
| 224 | { | ||
| 225 | const ASN1_ADB *adb; | ||
| 226 | const ASN1_ADB_TABLE *atbl; | ||
| 227 | long selector; | ||
| 228 | ASN1_VALUE **sfld; | ||
| 229 | int i; | ||
| 230 | |||
| 231 | if (!(tt->flags & ASN1_TFLG_ADB_MASK)) | ||
| 232 | return tt; | ||
| 233 | |||
| 234 | /* Else ANY DEFINED BY ... get the table */ | ||
| 235 | adb = (const ASN1_ADB *)tt->item; | ||
| 236 | |||
| 237 | /* Get the selector field */ | ||
| 238 | sfld = offset2ptr(*pval, adb->offset); | ||
| 239 | |||
| 240 | /* Check if NULL */ | ||
| 241 | if (!sfld) { | ||
| 242 | if (!adb->null_tt) | ||
| 243 | goto err; | ||
| 244 | return adb->null_tt; | ||
| 245 | } | ||
| 246 | |||
| 247 | /* Convert type to a long: | ||
| 248 | * NB: don't check for NID_undef here because it | ||
| 249 | * might be a legitimate value in the table | ||
| 250 | */ | ||
| 251 | if (tt->flags & ASN1_TFLG_ADB_OID) | ||
| 252 | selector = OBJ_obj2nid((ASN1_OBJECT *)*sfld); | ||
| 253 | else | ||
| 254 | selector = ASN1_INTEGER_get((ASN1_INTEGER *)*sfld); | ||
| 255 | |||
| 256 | /* Try to find matching entry in table | ||
| 257 | * Maybe should check application types first to | ||
| 258 | * allow application override? Might also be useful | ||
| 259 | * to have a flag which indicates table is sorted and | ||
| 260 | * we can do a binary search. For now stick to a | ||
| 261 | * linear search. | ||
| 262 | */ | ||
| 263 | |||
| 264 | for (atbl = adb->tbl, i = 0; i < adb->tblcount; i++, atbl++) | ||
| 265 | if (atbl->value == selector) | ||
| 266 | return &atbl->tt; | ||
| 267 | |||
| 268 | /* FIXME: need to search application table too */ | ||
| 269 | |||
| 270 | /* No match, return default type */ | ||
| 271 | if (!adb->default_tt) | ||
| 272 | goto err; | ||
| 273 | return adb->default_tt; | ||
| 274 | |||
| 275 | err: | ||
| 276 | /* FIXME: should log the value or OID of unsupported type */ | ||
| 277 | if (nullerr) | ||
| 278 | ASN1err(ASN1_F_ASN1_DO_ADB, | ||
| 279 | ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE); | ||
| 280 | return NULL; | ||
| 281 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_algor.c b/src/lib/libcrypto/asn1/x_algor.c deleted file mode 100644 index 27405a2bfb..0000000000 --- a/src/lib/libcrypto/asn1/x_algor.c +++ /dev/null | |||
| @@ -1,222 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_algor.c,v 1.21 2015/07/24 15:09:52 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000 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 | #include <stddef.h> | ||
| 60 | #include <openssl/x509.h> | ||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/asn1t.h> | ||
| 63 | |||
| 64 | static const ASN1_TEMPLATE X509_ALGOR_seq_tt[] = { | ||
| 65 | { | ||
| 66 | .offset = offsetof(X509_ALGOR, algorithm), | ||
| 67 | .field_name = "algorithm", | ||
| 68 | .item = &ASN1_OBJECT_it, | ||
| 69 | }, | ||
| 70 | { | ||
| 71 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 72 | .offset = offsetof(X509_ALGOR, parameter), | ||
| 73 | .field_name = "parameter", | ||
| 74 | .item = &ASN1_ANY_it, | ||
| 75 | }, | ||
| 76 | }; | ||
| 77 | |||
| 78 | const ASN1_ITEM X509_ALGOR_it = { | ||
| 79 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 80 | .utype = V_ASN1_SEQUENCE, | ||
| 81 | .templates = X509_ALGOR_seq_tt, | ||
| 82 | .tcount = sizeof(X509_ALGOR_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 83 | .size = sizeof(X509_ALGOR), | ||
| 84 | .sname = "X509_ALGOR", | ||
| 85 | }; | ||
| 86 | |||
| 87 | static const ASN1_TEMPLATE X509_ALGORS_item_tt = { | ||
| 88 | .flags = ASN1_TFLG_SEQUENCE_OF, | ||
| 89 | .tag = 0, | ||
| 90 | .offset = 0, | ||
| 91 | .field_name = "algorithms", | ||
| 92 | .item = &X509_ALGOR_it, | ||
| 93 | }; | ||
| 94 | |||
| 95 | const ASN1_ITEM X509_ALGORS_it = { | ||
| 96 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 97 | .utype = -1, | ||
| 98 | .templates = &X509_ALGORS_item_tt, | ||
| 99 | .tcount = 0, | ||
| 100 | .funcs = NULL, | ||
| 101 | .size = 0, | ||
| 102 | .sname = "X509_ALGORS", | ||
| 103 | }; | ||
| 104 | |||
| 105 | |||
| 106 | X509_ALGOR * | ||
| 107 | d2i_X509_ALGOR(X509_ALGOR **a, const unsigned char **in, long len) | ||
| 108 | { | ||
| 109 | return (X509_ALGOR *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 110 | &X509_ALGOR_it); | ||
| 111 | } | ||
| 112 | |||
| 113 | int | ||
| 114 | i2d_X509_ALGOR(X509_ALGOR *a, unsigned char **out) | ||
| 115 | { | ||
| 116 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGOR_it); | ||
| 117 | } | ||
| 118 | |||
| 119 | X509_ALGOR * | ||
| 120 | X509_ALGOR_new(void) | ||
| 121 | { | ||
| 122 | return (X509_ALGOR *)ASN1_item_new(&X509_ALGOR_it); | ||
| 123 | } | ||
| 124 | |||
| 125 | void | ||
| 126 | X509_ALGOR_free(X509_ALGOR *a) | ||
| 127 | { | ||
| 128 | ASN1_item_free((ASN1_VALUE *)a, &X509_ALGOR_it); | ||
| 129 | } | ||
| 130 | |||
| 131 | X509_ALGORS * | ||
| 132 | d2i_X509_ALGORS(X509_ALGORS **a, const unsigned char **in, long len) | ||
| 133 | { | ||
| 134 | return (X509_ALGORS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 135 | &X509_ALGORS_it); | ||
| 136 | } | ||
| 137 | |||
| 138 | int | ||
| 139 | i2d_X509_ALGORS(X509_ALGORS *a, unsigned char **out) | ||
| 140 | { | ||
| 141 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ALGORS_it); | ||
| 142 | } | ||
| 143 | |||
| 144 | X509_ALGOR * | ||
| 145 | X509_ALGOR_dup(X509_ALGOR *x) | ||
| 146 | { | ||
| 147 | return ASN1_item_dup(&X509_ALGOR_it, x); | ||
| 148 | } | ||
| 149 | |||
| 150 | int | ||
| 151 | X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, void *pval) | ||
| 152 | { | ||
| 153 | if (!alg) | ||
| 154 | return 0; | ||
| 155 | if (ptype != V_ASN1_UNDEF) { | ||
| 156 | if (alg->parameter == NULL) | ||
| 157 | alg->parameter = ASN1_TYPE_new(); | ||
| 158 | if (alg->parameter == NULL) | ||
| 159 | return 0; | ||
| 160 | } | ||
| 161 | if (alg) { | ||
| 162 | if (alg->algorithm) | ||
| 163 | ASN1_OBJECT_free(alg->algorithm); | ||
| 164 | alg->algorithm = aobj; | ||
| 165 | } | ||
| 166 | if (ptype == 0) | ||
| 167 | return 1; | ||
| 168 | if (ptype == V_ASN1_UNDEF) { | ||
| 169 | if (alg->parameter) { | ||
| 170 | ASN1_TYPE_free(alg->parameter); | ||
| 171 | alg->parameter = NULL; | ||
| 172 | } | ||
| 173 | } else | ||
| 174 | ASN1_TYPE_set(alg->parameter, ptype, pval); | ||
| 175 | return 1; | ||
| 176 | } | ||
| 177 | |||
| 178 | void | ||
| 179 | X509_ALGOR_get0(ASN1_OBJECT **paobj, int *pptype, void **ppval, | ||
| 180 | X509_ALGOR *algor) | ||
| 181 | { | ||
| 182 | if (paobj) | ||
| 183 | *paobj = algor->algorithm; | ||
| 184 | if (pptype) { | ||
| 185 | if (algor->parameter == NULL) { | ||
| 186 | *pptype = V_ASN1_UNDEF; | ||
| 187 | return; | ||
| 188 | } else | ||
| 189 | *pptype = algor->parameter->type; | ||
| 190 | if (ppval) | ||
| 191 | *ppval = algor->parameter->value.ptr; | ||
| 192 | } | ||
| 193 | } | ||
| 194 | |||
| 195 | /* Set up an X509_ALGOR DigestAlgorithmIdentifier from an EVP_MD */ | ||
| 196 | |||
| 197 | void | ||
| 198 | X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md) | ||
| 199 | { | ||
| 200 | int param_type; | ||
| 201 | |||
| 202 | if (md->flags & EVP_MD_FLAG_DIGALGID_ABSENT) | ||
| 203 | param_type = V_ASN1_UNDEF; | ||
| 204 | else | ||
| 205 | param_type = V_ASN1_NULL; | ||
| 206 | |||
| 207 | X509_ALGOR_set0(alg, OBJ_nid2obj(EVP_MD_type(md)), param_type, NULL); | ||
| 208 | } | ||
| 209 | |||
| 210 | /* Returns 0 if they are equal, != 0 otherwise. */ | ||
| 211 | int | ||
| 212 | X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b) | ||
| 213 | { | ||
| 214 | int rv = OBJ_cmp(a->algorithm, b->algorithm); | ||
| 215 | if (!rv) { | ||
| 216 | if (!a->parameter && !b->parameter) | ||
| 217 | rv = 0; | ||
| 218 | else | ||
| 219 | rv = ASN1_TYPE_cmp(a->parameter, b->parameter); | ||
| 220 | } | ||
| 221 | return(rv); | ||
| 222 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_attrib.c b/src/lib/libcrypto/asn1/x_attrib.c deleted file mode 100644 index bb74a1b6c7..0000000000 --- a/src/lib/libcrypto/asn1/x_attrib.c +++ /dev/null | |||
| @@ -1,198 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_attrib.c,v 1.13 2015/02/14 14:56:45 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/objects.h> | ||
| 63 | #include <openssl/x509.h> | ||
| 64 | |||
| 65 | /* X509_ATTRIBUTE: this has the following form: | ||
| 66 | * | ||
| 67 | * typedef struct x509_attributes_st | ||
| 68 | * { | ||
| 69 | * ASN1_OBJECT *object; | ||
| 70 | * int single; | ||
| 71 | * union { | ||
| 72 | * char *ptr; | ||
| 73 | * STACK_OF(ASN1_TYPE) *set; | ||
| 74 | * ASN1_TYPE *single; | ||
| 75 | * } value; | ||
| 76 | * } X509_ATTRIBUTE; | ||
| 77 | * | ||
| 78 | * this needs some extra thought because the CHOICE type is | ||
| 79 | * merged with the main structure and because the value can | ||
| 80 | * be anything at all we *must* try the SET OF first because | ||
| 81 | * the ASN1_ANY type will swallow anything including the whole | ||
| 82 | * SET OF structure. | ||
| 83 | */ | ||
| 84 | |||
| 85 | static const ASN1_TEMPLATE X509_ATTRIBUTE_SET_ch_tt[] = { | ||
| 86 | { | ||
| 87 | .flags = ASN1_TFLG_SET_OF, | ||
| 88 | .tag = 0, | ||
| 89 | .offset = offsetof(X509_ATTRIBUTE, value.set), | ||
| 90 | .field_name = "value.set", | ||
| 91 | .item = &ASN1_ANY_it, | ||
| 92 | }, | ||
| 93 | { | ||
| 94 | .flags = 0, | ||
| 95 | .tag = 0, | ||
| 96 | .offset = offsetof(X509_ATTRIBUTE, value.single), | ||
| 97 | .field_name = "value.single", | ||
| 98 | .item = &ASN1_ANY_it, | ||
| 99 | }, | ||
| 100 | }; | ||
| 101 | |||
| 102 | const ASN1_ITEM X509_ATTRIBUTE_SET_it = { | ||
| 103 | .itype = ASN1_ITYPE_CHOICE, | ||
| 104 | .utype = offsetof(X509_ATTRIBUTE, single), | ||
| 105 | .templates = X509_ATTRIBUTE_SET_ch_tt, | ||
| 106 | .tcount = sizeof(X509_ATTRIBUTE_SET_ch_tt) / sizeof(ASN1_TEMPLATE), | ||
| 107 | .funcs = NULL, | ||
| 108 | .size = sizeof(X509_ATTRIBUTE), | ||
| 109 | .sname = "X509_ATTRIBUTE", | ||
| 110 | }; | ||
| 111 | |||
| 112 | static const ASN1_TEMPLATE X509_ATTRIBUTE_seq_tt[] = { | ||
| 113 | { | ||
| 114 | .flags = 0, | ||
| 115 | .tag = 0, | ||
| 116 | .offset = offsetof(X509_ATTRIBUTE, object), | ||
| 117 | .field_name = "object", | ||
| 118 | .item = &ASN1_OBJECT_it, | ||
| 119 | }, | ||
| 120 | /* CHOICE type merged with parent */ | ||
| 121 | { | ||
| 122 | .flags = 0 | ASN1_TFLG_COMBINE, | ||
| 123 | .tag = 0, | ||
| 124 | .offset = 0, | ||
| 125 | .field_name = NULL, | ||
| 126 | .item = &X509_ATTRIBUTE_SET_it, | ||
| 127 | }, | ||
| 128 | }; | ||
| 129 | |||
| 130 | const ASN1_ITEM X509_ATTRIBUTE_it = { | ||
| 131 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 132 | .utype = V_ASN1_SEQUENCE, | ||
| 133 | .templates = X509_ATTRIBUTE_seq_tt, | ||
| 134 | .tcount = sizeof(X509_ATTRIBUTE_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 135 | .funcs = NULL, | ||
| 136 | .size = sizeof(X509_ATTRIBUTE), | ||
| 137 | .sname = "X509_ATTRIBUTE", | ||
| 138 | }; | ||
| 139 | |||
| 140 | |||
| 141 | X509_ATTRIBUTE * | ||
| 142 | d2i_X509_ATTRIBUTE(X509_ATTRIBUTE **a, const unsigned char **in, long len) | ||
| 143 | { | ||
| 144 | return (X509_ATTRIBUTE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 145 | &X509_ATTRIBUTE_it); | ||
| 146 | } | ||
| 147 | |||
| 148 | int | ||
| 149 | i2d_X509_ATTRIBUTE(X509_ATTRIBUTE *a, unsigned char **out) | ||
| 150 | { | ||
| 151 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_ATTRIBUTE_it); | ||
| 152 | } | ||
| 153 | |||
| 154 | X509_ATTRIBUTE * | ||
| 155 | X509_ATTRIBUTE_new(void) | ||
| 156 | { | ||
| 157 | return (X509_ATTRIBUTE *)ASN1_item_new(&X509_ATTRIBUTE_it); | ||
| 158 | } | ||
| 159 | |||
| 160 | void | ||
| 161 | X509_ATTRIBUTE_free(X509_ATTRIBUTE *a) | ||
| 162 | { | ||
| 163 | ASN1_item_free((ASN1_VALUE *)a, &X509_ATTRIBUTE_it); | ||
| 164 | } | ||
| 165 | |||
| 166 | X509_ATTRIBUTE * | ||
| 167 | X509_ATTRIBUTE_dup(X509_ATTRIBUTE *x) | ||
| 168 | { | ||
| 169 | return ASN1_item_dup(&X509_ATTRIBUTE_it, x); | ||
| 170 | } | ||
| 171 | |||
| 172 | X509_ATTRIBUTE * | ||
| 173 | X509_ATTRIBUTE_create(int nid, int atrtype, void *value) | ||
| 174 | { | ||
| 175 | X509_ATTRIBUTE *ret = NULL; | ||
| 176 | ASN1_TYPE *val = NULL; | ||
| 177 | |||
| 178 | if ((ret = X509_ATTRIBUTE_new()) == NULL) | ||
| 179 | return (NULL); | ||
| 180 | ret->object = OBJ_nid2obj(nid); | ||
| 181 | ret->single = 0; | ||
| 182 | if ((ret->value.set = sk_ASN1_TYPE_new_null()) == NULL) | ||
| 183 | goto err; | ||
| 184 | if ((val = ASN1_TYPE_new()) == NULL) | ||
| 185 | goto err; | ||
| 186 | if (!sk_ASN1_TYPE_push(ret->value.set, val)) | ||
| 187 | goto err; | ||
| 188 | |||
| 189 | ASN1_TYPE_set(val, atrtype, value); | ||
| 190 | return (ret); | ||
| 191 | |||
| 192 | err: | ||
| 193 | if (ret != NULL) | ||
| 194 | X509_ATTRIBUTE_free(ret); | ||
| 195 | if (val != NULL) | ||
| 196 | ASN1_TYPE_free(val); | ||
| 197 | return (NULL); | ||
| 198 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_bignum.c b/src/lib/libcrypto/asn1/x_bignum.c deleted file mode 100644 index 73f0f73c1c..0000000000 --- a/src/lib/libcrypto/asn1/x_bignum.c +++ /dev/null | |||
| @@ -1,167 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_bignum.c,v 1.8 2015/07/25 17:07:17 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000 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 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/bn.h> | ||
| 63 | |||
| 64 | /* | ||
| 65 | * Custom primitive type for BIGNUM handling. This reads in an ASN1_INTEGER as a | ||
| 66 | * BIGNUM directly. Currently it ignores the sign which isn't a problem since | ||
| 67 | * all BIGNUMs used are non negative and anything that looks negative is | ||
| 68 | * normally due to an encoding error. | ||
| 69 | */ | ||
| 70 | |||
| 71 | static int bn_new(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 72 | static void bn_free(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 73 | |||
| 74 | static int bn_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, | ||
| 75 | const ASN1_ITEM *it); | ||
| 76 | static int bn_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, | ||
| 77 | int utype, char *free_cont, const ASN1_ITEM *it); | ||
| 78 | |||
| 79 | static ASN1_PRIMITIVE_FUNCS bignum_pf = { | ||
| 80 | NULL, | ||
| 81 | 0, | ||
| 82 | bn_new, | ||
| 83 | bn_free, | ||
| 84 | 0, | ||
| 85 | bn_c2i, | ||
| 86 | bn_i2c | ||
| 87 | }; | ||
| 88 | |||
| 89 | const ASN1_ITEM BIGNUM_it = { | ||
| 90 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 91 | .utype = V_ASN1_INTEGER, | ||
| 92 | .templates = NULL, | ||
| 93 | .tcount = 0, | ||
| 94 | .funcs = &bignum_pf, | ||
| 95 | .size = 0, | ||
| 96 | .sname = "BIGNUM", | ||
| 97 | }; | ||
| 98 | |||
| 99 | const ASN1_ITEM CBIGNUM_it = { | ||
| 100 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 101 | .utype = V_ASN1_INTEGER, | ||
| 102 | .templates = NULL, | ||
| 103 | .tcount = 0, | ||
| 104 | .funcs = &bignum_pf, | ||
| 105 | .size = 0, | ||
| 106 | .sname = "BIGNUM", | ||
| 107 | }; | ||
| 108 | |||
| 109 | static int | ||
| 110 | bn_new(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 111 | { | ||
| 112 | *pval = (ASN1_VALUE *)BN_new(); | ||
| 113 | if (*pval) | ||
| 114 | return 1; | ||
| 115 | else | ||
| 116 | return 0; | ||
| 117 | } | ||
| 118 | |||
| 119 | static void | ||
| 120 | bn_free(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 121 | { | ||
| 122 | if (*pval == NULL) | ||
| 123 | return; | ||
| 124 | BN_clear_free((BIGNUM *)*pval); | ||
| 125 | *pval = NULL; | ||
| 126 | } | ||
| 127 | |||
| 128 | static int | ||
| 129 | bn_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it) | ||
| 130 | { | ||
| 131 | BIGNUM *bn; | ||
| 132 | int pad, len; | ||
| 133 | |||
| 134 | if (*pval == NULL) | ||
| 135 | return -1; | ||
| 136 | bn = (BIGNUM *)*pval; | ||
| 137 | /* If MSB set in an octet we need a padding byte */ | ||
| 138 | if (BN_num_bits(bn) & 0x7) | ||
| 139 | pad = 0; | ||
| 140 | else | ||
| 141 | pad = 1; | ||
| 142 | if (cont) { | ||
| 143 | if (pad) | ||
| 144 | *cont++ = 0; | ||
| 145 | len = BN_bn2bin(bn, cont); | ||
| 146 | } else | ||
| 147 | len = BN_num_bytes(bn); | ||
| 148 | return pad + len; | ||
| 149 | } | ||
| 150 | |||
| 151 | static int | ||
| 152 | bn_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, | ||
| 153 | char *free_cont, const ASN1_ITEM *it) | ||
| 154 | { | ||
| 155 | BIGNUM *bn; | ||
| 156 | |||
| 157 | if (*pval == NULL) { | ||
| 158 | if (bn_new(pval, it) == 0) | ||
| 159 | return 0; | ||
| 160 | } | ||
| 161 | bn = (BIGNUM *)*pval; | ||
| 162 | if (!BN_bin2bn(cont, len, bn)) { | ||
| 163 | bn_free(pval, it); | ||
| 164 | return 0; | ||
| 165 | } | ||
| 166 | return 1; | ||
| 167 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_crl.c b/src/lib/libcrypto/asn1/x_crl.c deleted file mode 100644 index 6062587ed4..0000000000 --- a/src/lib/libcrypto/asn1/x_crl.c +++ /dev/null | |||
| @@ -1,687 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_crl.c,v 1.25 2015/07/20 15:29:13 miod Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1t.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | #include <openssl/x509v3.h> | ||
| 67 | |||
| 68 | #include "asn1_locl.h" | ||
| 69 | |||
| 70 | static int X509_REVOKED_cmp(const X509_REVOKED * const *a, | ||
| 71 | const X509_REVOKED * const *b); | ||
| 72 | static void setup_idp(X509_CRL *crl, ISSUING_DIST_POINT *idp); | ||
| 73 | |||
| 74 | static const ASN1_TEMPLATE X509_REVOKED_seq_tt[] = { | ||
| 75 | { | ||
| 76 | .offset = offsetof(X509_REVOKED, serialNumber), | ||
| 77 | .field_name = "serialNumber", | ||
| 78 | .item = &ASN1_INTEGER_it, | ||
| 79 | }, | ||
| 80 | { | ||
| 81 | .offset = offsetof(X509_REVOKED, revocationDate), | ||
| 82 | .field_name = "revocationDate", | ||
| 83 | .item = &ASN1_TIME_it, | ||
| 84 | }, | ||
| 85 | { | ||
| 86 | .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL, | ||
| 87 | .offset = offsetof(X509_REVOKED, extensions), | ||
| 88 | .field_name = "extensions", | ||
| 89 | .item = &X509_EXTENSION_it, | ||
| 90 | }, | ||
| 91 | }; | ||
| 92 | |||
| 93 | const ASN1_ITEM X509_REVOKED_it = { | ||
| 94 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 95 | .utype = V_ASN1_SEQUENCE, | ||
| 96 | .templates = X509_REVOKED_seq_tt, | ||
| 97 | .tcount = sizeof(X509_REVOKED_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 98 | .size = sizeof(X509_REVOKED), | ||
| 99 | .sname = "X509_REVOKED", | ||
| 100 | }; | ||
| 101 | |||
| 102 | static int def_crl_verify(X509_CRL *crl, EVP_PKEY *r); | ||
| 103 | static int def_crl_lookup(X509_CRL *crl, X509_REVOKED **ret, | ||
| 104 | ASN1_INTEGER *serial, X509_NAME *issuer); | ||
| 105 | |||
| 106 | static X509_CRL_METHOD int_crl_meth = { | ||
| 107 | .crl_lookup = def_crl_lookup, | ||
| 108 | .crl_verify = def_crl_verify | ||
| 109 | }; | ||
| 110 | |||
| 111 | static const X509_CRL_METHOD *default_crl_method = &int_crl_meth; | ||
| 112 | |||
| 113 | /* The X509_CRL_INFO structure needs a bit of customisation. | ||
| 114 | * Since we cache the original encoding the signature wont be affected by | ||
| 115 | * reordering of the revoked field. | ||
| 116 | */ | ||
| 117 | static int | ||
| 118 | crl_inf_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) | ||
| 119 | { | ||
| 120 | X509_CRL_INFO *a = (X509_CRL_INFO *)*pval; | ||
| 121 | |||
| 122 | if (!a || !a->revoked) | ||
| 123 | return 1; | ||
| 124 | switch (operation) { | ||
| 125 | /* Just set cmp function here. We don't sort because that | ||
| 126 | * would affect the output of X509_CRL_print(). | ||
| 127 | */ | ||
| 128 | case ASN1_OP_D2I_POST: | ||
| 129 | (void)sk_X509_REVOKED_set_cmp_func(a->revoked, X509_REVOKED_cmp); | ||
| 130 | break; | ||
| 131 | } | ||
| 132 | return 1; | ||
| 133 | } | ||
| 134 | |||
| 135 | |||
| 136 | static const ASN1_AUX X509_CRL_INFO_aux = { | ||
| 137 | .flags = ASN1_AFLG_ENCODING, | ||
| 138 | .asn1_cb = crl_inf_cb, | ||
| 139 | .enc_offset = offsetof(X509_CRL_INFO, enc), | ||
| 140 | }; | ||
| 141 | static const ASN1_TEMPLATE X509_CRL_INFO_seq_tt[] = { | ||
| 142 | { | ||
| 143 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 144 | .offset = offsetof(X509_CRL_INFO, version), | ||
| 145 | .field_name = "version", | ||
| 146 | .item = &ASN1_INTEGER_it, | ||
| 147 | }, | ||
| 148 | { | ||
| 149 | .offset = offsetof(X509_CRL_INFO, sig_alg), | ||
| 150 | .field_name = "sig_alg", | ||
| 151 | .item = &X509_ALGOR_it, | ||
| 152 | }, | ||
| 153 | { | ||
| 154 | .offset = offsetof(X509_CRL_INFO, issuer), | ||
| 155 | .field_name = "issuer", | ||
| 156 | .item = &X509_NAME_it, | ||
| 157 | }, | ||
| 158 | { | ||
| 159 | .offset = offsetof(X509_CRL_INFO, lastUpdate), | ||
| 160 | .field_name = "lastUpdate", | ||
| 161 | .item = &ASN1_TIME_it, | ||
| 162 | }, | ||
| 163 | { | ||
| 164 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 165 | .offset = offsetof(X509_CRL_INFO, nextUpdate), | ||
| 166 | .field_name = "nextUpdate", | ||
| 167 | .item = &ASN1_TIME_it, | ||
| 168 | }, | ||
| 169 | { | ||
| 170 | .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL, | ||
| 171 | .offset = offsetof(X509_CRL_INFO, revoked), | ||
| 172 | .field_name = "revoked", | ||
| 173 | .item = &X509_REVOKED_it, | ||
| 174 | }, | ||
| 175 | { | ||
| 176 | .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL, | ||
| 177 | .offset = offsetof(X509_CRL_INFO, extensions), | ||
| 178 | .field_name = "extensions", | ||
| 179 | .item = &X509_EXTENSION_it, | ||
| 180 | }, | ||
| 181 | }; | ||
| 182 | |||
| 183 | const ASN1_ITEM X509_CRL_INFO_it = { | ||
| 184 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 185 | .utype = V_ASN1_SEQUENCE, | ||
| 186 | .templates = X509_CRL_INFO_seq_tt, | ||
| 187 | .tcount = sizeof(X509_CRL_INFO_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 188 | .funcs = &X509_CRL_INFO_aux, | ||
| 189 | .size = sizeof(X509_CRL_INFO), | ||
| 190 | .sname = "X509_CRL_INFO", | ||
| 191 | }; | ||
| 192 | |||
| 193 | /* Set CRL entry issuer according to CRL certificate issuer extension. | ||
| 194 | * Check for unhandled critical CRL entry extensions. | ||
| 195 | */ | ||
| 196 | |||
| 197 | static int | ||
| 198 | crl_set_issuers(X509_CRL *crl) | ||
| 199 | { | ||
| 200 | int i, j; | ||
| 201 | GENERAL_NAMES *gens, *gtmp; | ||
| 202 | STACK_OF(X509_REVOKED) *revoked; | ||
| 203 | |||
| 204 | revoked = X509_CRL_get_REVOKED(crl); | ||
| 205 | |||
| 206 | gens = NULL; | ||
| 207 | for (i = 0; i < sk_X509_REVOKED_num(revoked); i++) { | ||
| 208 | X509_REVOKED *rev = sk_X509_REVOKED_value(revoked, i); | ||
| 209 | STACK_OF(X509_EXTENSION) *exts; | ||
| 210 | ASN1_ENUMERATED *reason; | ||
| 211 | X509_EXTENSION *ext; | ||
| 212 | gtmp = X509_REVOKED_get_ext_d2i(rev, NID_certificate_issuer, | ||
| 213 | &j, NULL); | ||
| 214 | if (!gtmp && (j != -1)) { | ||
| 215 | crl->flags |= EXFLAG_INVALID; | ||
| 216 | return 1; | ||
| 217 | } | ||
| 218 | |||
| 219 | if (gtmp) { | ||
| 220 | gens = gtmp; | ||
| 221 | if (!crl->issuers) { | ||
| 222 | crl->issuers = sk_GENERAL_NAMES_new_null(); | ||
| 223 | if (!crl->issuers) | ||
| 224 | return 0; | ||
| 225 | } | ||
| 226 | if (!sk_GENERAL_NAMES_push(crl->issuers, gtmp)) | ||
| 227 | return 0; | ||
| 228 | } | ||
| 229 | rev->issuer = gens; | ||
| 230 | |||
| 231 | reason = X509_REVOKED_get_ext_d2i(rev, NID_crl_reason, | ||
| 232 | &j, NULL); | ||
| 233 | if (!reason && (j != -1)) { | ||
| 234 | crl->flags |= EXFLAG_INVALID; | ||
| 235 | return 1; | ||
| 236 | } | ||
| 237 | |||
| 238 | if (reason) { | ||
| 239 | rev->reason = ASN1_ENUMERATED_get(reason); | ||
| 240 | ASN1_ENUMERATED_free(reason); | ||
| 241 | } else | ||
| 242 | rev->reason = CRL_REASON_NONE; | ||
| 243 | |||
| 244 | /* Check for critical CRL entry extensions */ | ||
| 245 | |||
| 246 | exts = rev->extensions; | ||
| 247 | |||
| 248 | for (j = 0; j < sk_X509_EXTENSION_num(exts); j++) { | ||
| 249 | ext = sk_X509_EXTENSION_value(exts, j); | ||
| 250 | if (ext->critical > 0) { | ||
| 251 | if (OBJ_obj2nid(ext->object) == | ||
| 252 | NID_certificate_issuer) | ||
| 253 | continue; | ||
| 254 | crl->flags |= EXFLAG_CRITICAL; | ||
| 255 | break; | ||
| 256 | } | ||
| 257 | } | ||
| 258 | } | ||
| 259 | |||
| 260 | return 1; | ||
| 261 | } | ||
| 262 | |||
| 263 | /* The X509_CRL structure needs a bit of customisation. Cache some extensions | ||
| 264 | * and hash of the whole CRL. | ||
| 265 | */ | ||
| 266 | static int | ||
| 267 | crl_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) | ||
| 268 | { | ||
| 269 | X509_CRL *crl = (X509_CRL *)*pval; | ||
| 270 | STACK_OF(X509_EXTENSION) *exts; | ||
| 271 | X509_EXTENSION *ext; | ||
| 272 | int idx; | ||
| 273 | int rc = 1; | ||
| 274 | |||
| 275 | switch (operation) { | ||
| 276 | case ASN1_OP_NEW_POST: | ||
| 277 | crl->idp = NULL; | ||
| 278 | crl->akid = NULL; | ||
| 279 | crl->flags = 0; | ||
| 280 | crl->idp_flags = 0; | ||
| 281 | crl->idp_reasons = CRLDP_ALL_REASONS; | ||
| 282 | crl->meth = default_crl_method; | ||
| 283 | crl->meth_data = NULL; | ||
| 284 | crl->issuers = NULL; | ||
| 285 | crl->crl_number = NULL; | ||
| 286 | crl->base_crl_number = NULL; | ||
| 287 | break; | ||
| 288 | |||
| 289 | case ASN1_OP_D2I_POST: | ||
| 290 | #ifndef OPENSSL_NO_SHA | ||
| 291 | X509_CRL_digest(crl, EVP_sha1(), crl->sha1_hash, NULL); | ||
| 292 | #endif | ||
| 293 | crl->idp = X509_CRL_get_ext_d2i(crl, | ||
| 294 | NID_issuing_distribution_point, NULL, NULL); | ||
| 295 | if (crl->idp) | ||
| 296 | setup_idp(crl, crl->idp); | ||
| 297 | |||
| 298 | crl->akid = X509_CRL_get_ext_d2i(crl, | ||
| 299 | NID_authority_key_identifier, NULL, NULL); | ||
| 300 | |||
| 301 | crl->crl_number = X509_CRL_get_ext_d2i(crl, | ||
| 302 | NID_crl_number, NULL, NULL); | ||
| 303 | |||
| 304 | crl->base_crl_number = X509_CRL_get_ext_d2i(crl, | ||
| 305 | NID_delta_crl, NULL, NULL); | ||
| 306 | /* Delta CRLs must have CRL number */ | ||
| 307 | if (crl->base_crl_number && !crl->crl_number) | ||
| 308 | crl->flags |= EXFLAG_INVALID; | ||
| 309 | |||
| 310 | /* See if we have any unhandled critical CRL extensions and | ||
| 311 | * indicate this in a flag. We only currently handle IDP, | ||
| 312 | * AKID and deltas, so anything else critical sets the flag. | ||
| 313 | * | ||
| 314 | * This code accesses the X509_CRL structure directly: | ||
| 315 | * applications shouldn't do this. | ||
| 316 | */ | ||
| 317 | |||
| 318 | exts = crl->crl->extensions; | ||
| 319 | |||
| 320 | for (idx = 0; idx < sk_X509_EXTENSION_num(exts); idx++) { | ||
| 321 | int nid; | ||
| 322 | ext = sk_X509_EXTENSION_value(exts, idx); | ||
| 323 | nid = OBJ_obj2nid(ext->object); | ||
| 324 | if (nid == NID_freshest_crl) | ||
| 325 | crl->flags |= EXFLAG_FRESHEST; | ||
| 326 | if (ext->critical > 0) { | ||
| 327 | /* We handle IDP, AKID and deltas */ | ||
| 328 | if (nid == NID_issuing_distribution_point || | ||
| 329 | nid == NID_authority_key_identifier || | ||
| 330 | nid == NID_delta_crl) | ||
| 331 | break; | ||
| 332 | crl->flags |= EXFLAG_CRITICAL; | ||
| 333 | break; | ||
| 334 | } | ||
| 335 | } | ||
| 336 | |||
| 337 | if (!crl_set_issuers(crl)) | ||
| 338 | return 0; | ||
| 339 | |||
| 340 | if (crl->meth->crl_init) { | ||
| 341 | if (crl->meth->crl_init(crl) == 0) | ||
| 342 | return 0; | ||
| 343 | } | ||
| 344 | break; | ||
| 345 | |||
| 346 | case ASN1_OP_FREE_POST: | ||
| 347 | if (crl->meth->crl_free) { | ||
| 348 | if (!crl->meth->crl_free(crl)) | ||
| 349 | rc = 0; | ||
| 350 | } | ||
| 351 | if (crl->akid) | ||
| 352 | AUTHORITY_KEYID_free(crl->akid); | ||
| 353 | if (crl->idp) | ||
| 354 | ISSUING_DIST_POINT_free(crl->idp); | ||
| 355 | ASN1_INTEGER_free(crl->crl_number); | ||
| 356 | ASN1_INTEGER_free(crl->base_crl_number); | ||
| 357 | sk_GENERAL_NAMES_pop_free(crl->issuers, GENERAL_NAMES_free); | ||
| 358 | break; | ||
| 359 | } | ||
| 360 | return rc; | ||
| 361 | } | ||
| 362 | |||
| 363 | /* Convert IDP into a more convenient form */ | ||
| 364 | |||
| 365 | static void | ||
| 366 | setup_idp(X509_CRL *crl, ISSUING_DIST_POINT *idp) | ||
| 367 | { | ||
| 368 | int idp_only = 0; | ||
| 369 | |||
| 370 | /* Set various flags according to IDP */ | ||
| 371 | crl->idp_flags |= IDP_PRESENT; | ||
| 372 | if (idp->onlyuser > 0) { | ||
| 373 | idp_only++; | ||
| 374 | crl->idp_flags |= IDP_ONLYUSER; | ||
| 375 | } | ||
| 376 | if (idp->onlyCA > 0) { | ||
| 377 | idp_only++; | ||
| 378 | crl->idp_flags |= IDP_ONLYCA; | ||
| 379 | } | ||
| 380 | if (idp->onlyattr > 0) { | ||
| 381 | idp_only++; | ||
| 382 | crl->idp_flags |= IDP_ONLYATTR; | ||
| 383 | } | ||
| 384 | |||
| 385 | if (idp_only > 1) | ||
| 386 | crl->idp_flags |= IDP_INVALID; | ||
| 387 | |||
| 388 | if (idp->indirectCRL > 0) | ||
| 389 | crl->idp_flags |= IDP_INDIRECT; | ||
| 390 | |||
| 391 | if (idp->onlysomereasons) { | ||
| 392 | crl->idp_flags |= IDP_REASONS; | ||
| 393 | if (idp->onlysomereasons->length > 0) | ||
| 394 | crl->idp_reasons = idp->onlysomereasons->data[0]; | ||
| 395 | if (idp->onlysomereasons->length > 1) | ||
| 396 | crl->idp_reasons |= | ||
| 397 | (idp->onlysomereasons->data[1] << 8); | ||
| 398 | crl->idp_reasons &= CRLDP_ALL_REASONS; | ||
| 399 | } | ||
| 400 | |||
| 401 | DIST_POINT_set_dpname(idp->distpoint, X509_CRL_get_issuer(crl)); | ||
| 402 | } | ||
| 403 | |||
| 404 | static const ASN1_AUX X509_CRL_aux = { | ||
| 405 | .app_data = NULL, | ||
| 406 | .flags = ASN1_AFLG_REFCOUNT, | ||
| 407 | .ref_offset = offsetof(X509_CRL, references), | ||
| 408 | .ref_lock = CRYPTO_LOCK_X509_CRL, | ||
| 409 | .asn1_cb = crl_cb, | ||
| 410 | }; | ||
| 411 | static const ASN1_TEMPLATE X509_CRL_seq_tt[] = { | ||
| 412 | { | ||
| 413 | .offset = offsetof(X509_CRL, crl), | ||
| 414 | .field_name = "crl", | ||
| 415 | .item = &X509_CRL_INFO_it, | ||
| 416 | }, | ||
| 417 | { | ||
| 418 | .offset = offsetof(X509_CRL, sig_alg), | ||
| 419 | .field_name = "sig_alg", | ||
| 420 | .item = &X509_ALGOR_it, | ||
| 421 | }, | ||
| 422 | { | ||
| 423 | .offset = offsetof(X509_CRL, signature), | ||
| 424 | .field_name = "signature", | ||
| 425 | .item = &ASN1_BIT_STRING_it, | ||
| 426 | }, | ||
| 427 | }; | ||
| 428 | |||
| 429 | const ASN1_ITEM X509_CRL_it = { | ||
| 430 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 431 | .utype = V_ASN1_SEQUENCE, | ||
| 432 | .templates = X509_CRL_seq_tt, | ||
| 433 | .tcount = sizeof(X509_CRL_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 434 | .funcs = &X509_CRL_aux, | ||
| 435 | .size = sizeof(X509_CRL), | ||
| 436 | .sname = "X509_CRL", | ||
| 437 | }; | ||
| 438 | |||
| 439 | |||
| 440 | X509_REVOKED * | ||
| 441 | d2i_X509_REVOKED(X509_REVOKED **a, const unsigned char **in, long len) | ||
| 442 | { | ||
| 443 | return (X509_REVOKED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 444 | &X509_REVOKED_it); | ||
| 445 | } | ||
| 446 | |||
| 447 | int | ||
| 448 | i2d_X509_REVOKED(X509_REVOKED *a, unsigned char **out) | ||
| 449 | { | ||
| 450 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REVOKED_it); | ||
| 451 | } | ||
| 452 | |||
| 453 | X509_REVOKED * | ||
| 454 | X509_REVOKED_new(void) | ||
| 455 | { | ||
| 456 | return (X509_REVOKED *)ASN1_item_new(&X509_REVOKED_it); | ||
| 457 | } | ||
| 458 | |||
| 459 | void | ||
| 460 | X509_REVOKED_free(X509_REVOKED *a) | ||
| 461 | { | ||
| 462 | ASN1_item_free((ASN1_VALUE *)a, &X509_REVOKED_it); | ||
| 463 | } | ||
| 464 | |||
| 465 | X509_CRL_INFO * | ||
| 466 | d2i_X509_CRL_INFO(X509_CRL_INFO **a, const unsigned char **in, long len) | ||
| 467 | { | ||
| 468 | return (X509_CRL_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 469 | &X509_CRL_INFO_it); | ||
| 470 | } | ||
| 471 | |||
| 472 | int | ||
| 473 | i2d_X509_CRL_INFO(X509_CRL_INFO *a, unsigned char **out) | ||
| 474 | { | ||
| 475 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_INFO_it); | ||
| 476 | } | ||
| 477 | |||
| 478 | X509_CRL_INFO * | ||
| 479 | X509_CRL_INFO_new(void) | ||
| 480 | { | ||
| 481 | return (X509_CRL_INFO *)ASN1_item_new(&X509_CRL_INFO_it); | ||
| 482 | } | ||
| 483 | |||
| 484 | void | ||
| 485 | X509_CRL_INFO_free(X509_CRL_INFO *a) | ||
| 486 | { | ||
| 487 | ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_INFO_it); | ||
| 488 | } | ||
| 489 | |||
| 490 | X509_CRL * | ||
| 491 | d2i_X509_CRL(X509_CRL **a, const unsigned char **in, long len) | ||
| 492 | { | ||
| 493 | return (X509_CRL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 494 | &X509_CRL_it); | ||
| 495 | } | ||
| 496 | |||
| 497 | int | ||
| 498 | i2d_X509_CRL(X509_CRL *a, unsigned char **out) | ||
| 499 | { | ||
| 500 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CRL_it); | ||
| 501 | } | ||
| 502 | |||
| 503 | X509_CRL * | ||
| 504 | X509_CRL_new(void) | ||
| 505 | { | ||
| 506 | return (X509_CRL *)ASN1_item_new(&X509_CRL_it); | ||
| 507 | } | ||
| 508 | |||
| 509 | void | ||
| 510 | X509_CRL_free(X509_CRL *a) | ||
| 511 | { | ||
| 512 | ASN1_item_free((ASN1_VALUE *)a, &X509_CRL_it); | ||
| 513 | } | ||
| 514 | |||
| 515 | X509_CRL * | ||
| 516 | X509_CRL_dup(X509_CRL *x) | ||
| 517 | { | ||
| 518 | return ASN1_item_dup(&X509_CRL_it, x); | ||
| 519 | } | ||
| 520 | |||
| 521 | static int | ||
| 522 | X509_REVOKED_cmp(const X509_REVOKED * const *a, const X509_REVOKED * const *b) | ||
| 523 | { | ||
| 524 | return(ASN1_STRING_cmp( | ||
| 525 | (ASN1_STRING *)(*a)->serialNumber, | ||
| 526 | (ASN1_STRING *)(*b)->serialNumber)); | ||
| 527 | } | ||
| 528 | |||
| 529 | int | ||
| 530 | X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev) | ||
| 531 | { | ||
| 532 | X509_CRL_INFO *inf; | ||
| 533 | |||
| 534 | inf = crl->crl; | ||
| 535 | if (!inf->revoked) | ||
| 536 | inf->revoked = sk_X509_REVOKED_new(X509_REVOKED_cmp); | ||
| 537 | if (!inf->revoked || !sk_X509_REVOKED_push(inf->revoked, rev)) { | ||
| 538 | ASN1err(ASN1_F_X509_CRL_ADD0_REVOKED, ERR_R_MALLOC_FAILURE); | ||
| 539 | return 0; | ||
| 540 | } | ||
| 541 | inf->enc.modified = 1; | ||
| 542 | return 1; | ||
| 543 | } | ||
| 544 | |||
| 545 | int | ||
| 546 | X509_CRL_verify(X509_CRL *crl, EVP_PKEY *r) | ||
| 547 | { | ||
| 548 | if (crl->meth->crl_verify) | ||
| 549 | return crl->meth->crl_verify(crl, r); | ||
| 550 | return 0; | ||
| 551 | } | ||
| 552 | |||
| 553 | int | ||
| 554 | X509_CRL_get0_by_serial(X509_CRL *crl, X509_REVOKED **ret, | ||
| 555 | ASN1_INTEGER *serial) | ||
| 556 | { | ||
| 557 | if (crl->meth->crl_lookup) | ||
| 558 | return crl->meth->crl_lookup(crl, ret, serial, NULL); | ||
| 559 | return 0; | ||
| 560 | } | ||
| 561 | |||
| 562 | int | ||
| 563 | X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x) | ||
| 564 | { | ||
| 565 | if (crl->meth->crl_lookup) | ||
| 566 | return crl->meth->crl_lookup(crl, ret, | ||
| 567 | X509_get_serialNumber(x), X509_get_issuer_name(x)); | ||
| 568 | return 0; | ||
| 569 | } | ||
| 570 | |||
| 571 | static int | ||
| 572 | def_crl_verify(X509_CRL *crl, EVP_PKEY *r) | ||
| 573 | { | ||
| 574 | return(ASN1_item_verify(ASN1_ITEM_rptr(X509_CRL_INFO), | ||
| 575 | crl->sig_alg, crl->signature, crl->crl, r)); | ||
| 576 | } | ||
| 577 | |||
| 578 | static int | ||
| 579 | crl_revoked_issuer_match(X509_CRL *crl, X509_NAME *nm, X509_REVOKED *rev) | ||
| 580 | { | ||
| 581 | int i; | ||
| 582 | |||
| 583 | if (!rev->issuer) { | ||
| 584 | if (!nm) | ||
| 585 | return 1; | ||
| 586 | if (!X509_NAME_cmp(nm, X509_CRL_get_issuer(crl))) | ||
| 587 | return 1; | ||
| 588 | return 0; | ||
| 589 | } | ||
| 590 | |||
| 591 | if (!nm) | ||
| 592 | nm = X509_CRL_get_issuer(crl); | ||
| 593 | |||
| 594 | for (i = 0; i < sk_GENERAL_NAME_num(rev->issuer); i++) { | ||
| 595 | GENERAL_NAME *gen = sk_GENERAL_NAME_value(rev->issuer, i); | ||
| 596 | if (gen->type != GEN_DIRNAME) | ||
| 597 | continue; | ||
| 598 | if (!X509_NAME_cmp(nm, gen->d.directoryName)) | ||
| 599 | return 1; | ||
| 600 | } | ||
| 601 | return 0; | ||
| 602 | |||
| 603 | } | ||
| 604 | |||
| 605 | static int | ||
| 606 | def_crl_lookup(X509_CRL *crl, X509_REVOKED **ret, ASN1_INTEGER *serial, | ||
| 607 | X509_NAME *issuer) | ||
| 608 | { | ||
| 609 | X509_REVOKED rtmp, *rev; | ||
| 610 | int idx; | ||
| 611 | |||
| 612 | rtmp.serialNumber = serial; | ||
| 613 | /* Sort revoked into serial number order if not already sorted. | ||
| 614 | * Do this under a lock to avoid race condition. | ||
| 615 | */ | ||
| 616 | if (!sk_X509_REVOKED_is_sorted(crl->crl->revoked)) { | ||
| 617 | CRYPTO_w_lock(CRYPTO_LOCK_X509_CRL); | ||
| 618 | sk_X509_REVOKED_sort(crl->crl->revoked); | ||
| 619 | CRYPTO_w_unlock(CRYPTO_LOCK_X509_CRL); | ||
| 620 | } | ||
| 621 | idx = sk_X509_REVOKED_find(crl->crl->revoked, &rtmp); | ||
| 622 | if (idx < 0) | ||
| 623 | return 0; | ||
| 624 | /* Need to look for matching name */ | ||
| 625 | for (; idx < sk_X509_REVOKED_num(crl->crl->revoked); idx++) { | ||
| 626 | rev = sk_X509_REVOKED_value(crl->crl->revoked, idx); | ||
| 627 | if (ASN1_INTEGER_cmp(rev->serialNumber, serial)) | ||
| 628 | return 0; | ||
| 629 | if (crl_revoked_issuer_match(crl, issuer, rev)) { | ||
| 630 | if (ret) | ||
| 631 | *ret = rev; | ||
| 632 | if (rev->reason == CRL_REASON_REMOVE_FROM_CRL) | ||
| 633 | return 2; | ||
| 634 | return 1; | ||
| 635 | } | ||
| 636 | } | ||
| 637 | return 0; | ||
| 638 | } | ||
| 639 | |||
| 640 | void | ||
| 641 | X509_CRL_set_default_method(const X509_CRL_METHOD *meth) | ||
| 642 | { | ||
| 643 | if (meth == NULL) | ||
| 644 | default_crl_method = &int_crl_meth; | ||
| 645 | else | ||
| 646 | default_crl_method = meth; | ||
| 647 | } | ||
| 648 | |||
| 649 | X509_CRL_METHOD * | ||
| 650 | X509_CRL_METHOD_new(int (*crl_init)(X509_CRL *crl), | ||
| 651 | int (*crl_free)(X509_CRL *crl), | ||
| 652 | int (*crl_lookup)(X509_CRL *crl, X509_REVOKED **ret, | ||
| 653 | ASN1_INTEGER *ser, X509_NAME *issuer), | ||
| 654 | int (*crl_verify)(X509_CRL *crl, EVP_PKEY *pk)) | ||
| 655 | { | ||
| 656 | X509_CRL_METHOD *m; | ||
| 657 | |||
| 658 | m = malloc(sizeof(X509_CRL_METHOD)); | ||
| 659 | if (!m) | ||
| 660 | return NULL; | ||
| 661 | m->crl_init = crl_init; | ||
| 662 | m->crl_free = crl_free; | ||
| 663 | m->crl_lookup = crl_lookup; | ||
| 664 | m->crl_verify = crl_verify; | ||
| 665 | m->flags = X509_CRL_METHOD_DYNAMIC; | ||
| 666 | return m; | ||
| 667 | } | ||
| 668 | |||
| 669 | void | ||
| 670 | X509_CRL_METHOD_free(X509_CRL_METHOD *m) | ||
| 671 | { | ||
| 672 | if (!(m->flags & X509_CRL_METHOD_DYNAMIC)) | ||
| 673 | return; | ||
| 674 | free(m); | ||
| 675 | } | ||
| 676 | |||
| 677 | void | ||
| 678 | X509_CRL_set_meth_data(X509_CRL *crl, void *dat) | ||
| 679 | { | ||
| 680 | crl->meth_data = dat; | ||
| 681 | } | ||
| 682 | |||
| 683 | void * | ||
| 684 | X509_CRL_get_meth_data(X509_CRL *crl) | ||
| 685 | { | ||
| 686 | return crl->meth_data; | ||
| 687 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_exten.c b/src/lib/libcrypto/asn1/x_exten.c deleted file mode 100644 index bb3dffc821..0000000000 --- a/src/lib/libcrypto/asn1/x_exten.c +++ /dev/null | |||
| @@ -1,153 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_exten.c,v 1.16 2015/07/24 15:09:52 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000 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 | #include <stddef.h> | ||
| 60 | #include <openssl/x509.h> | ||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/asn1t.h> | ||
| 63 | |||
| 64 | static const ASN1_TEMPLATE X509_EXTENSION_seq_tt[] = { | ||
| 65 | { | ||
| 66 | .offset = offsetof(X509_EXTENSION, object), | ||
| 67 | .field_name = "object", | ||
| 68 | .item = &ASN1_OBJECT_it, | ||
| 69 | }, | ||
| 70 | { | ||
| 71 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 72 | .offset = offsetof(X509_EXTENSION, critical), | ||
| 73 | .field_name = "critical", | ||
| 74 | .item = &ASN1_BOOLEAN_it, | ||
| 75 | }, | ||
| 76 | { | ||
| 77 | .offset = offsetof(X509_EXTENSION, value), | ||
| 78 | .field_name = "value", | ||
| 79 | .item = &ASN1_OCTET_STRING_it, | ||
| 80 | }, | ||
| 81 | }; | ||
| 82 | |||
| 83 | const ASN1_ITEM X509_EXTENSION_it = { | ||
| 84 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 85 | .utype = V_ASN1_SEQUENCE, | ||
| 86 | .templates = X509_EXTENSION_seq_tt, | ||
| 87 | .tcount = sizeof(X509_EXTENSION_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 88 | .size = sizeof(X509_EXTENSION), | ||
| 89 | .sname = "X509_EXTENSION", | ||
| 90 | }; | ||
| 91 | |||
| 92 | static const ASN1_TEMPLATE X509_EXTENSIONS_item_tt = { | ||
| 93 | .flags = ASN1_TFLG_SEQUENCE_OF, | ||
| 94 | .tag = 0, | ||
| 95 | .offset = 0, | ||
| 96 | .field_name = "Extension", | ||
| 97 | .item = &X509_EXTENSION_it, | ||
| 98 | }; | ||
| 99 | |||
| 100 | const ASN1_ITEM X509_EXTENSIONS_it = { | ||
| 101 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 102 | .utype = -1, | ||
| 103 | .templates = &X509_EXTENSIONS_item_tt, | ||
| 104 | .tcount = 0, | ||
| 105 | .funcs = NULL, | ||
| 106 | .size = 0, | ||
| 107 | .sname = "X509_EXTENSIONS", | ||
| 108 | }; | ||
| 109 | |||
| 110 | |||
| 111 | X509_EXTENSION * | ||
| 112 | d2i_X509_EXTENSION(X509_EXTENSION **a, const unsigned char **in, long len) | ||
| 113 | { | ||
| 114 | return (X509_EXTENSION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 115 | &X509_EXTENSION_it); | ||
| 116 | } | ||
| 117 | |||
| 118 | int | ||
| 119 | i2d_X509_EXTENSION(X509_EXTENSION *a, unsigned char **out) | ||
| 120 | { | ||
| 121 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_EXTENSION_it); | ||
| 122 | } | ||
| 123 | |||
| 124 | X509_EXTENSION * | ||
| 125 | X509_EXTENSION_new(void) | ||
| 126 | { | ||
| 127 | return (X509_EXTENSION *)ASN1_item_new(&X509_EXTENSION_it); | ||
| 128 | } | ||
| 129 | |||
| 130 | void | ||
| 131 | X509_EXTENSION_free(X509_EXTENSION *a) | ||
| 132 | { | ||
| 133 | ASN1_item_free((ASN1_VALUE *)a, &X509_EXTENSION_it); | ||
| 134 | } | ||
| 135 | |||
| 136 | X509_EXTENSIONS * | ||
| 137 | d2i_X509_EXTENSIONS(X509_EXTENSIONS **a, const unsigned char **in, long len) | ||
| 138 | { | ||
| 139 | return (X509_EXTENSIONS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 140 | &X509_EXTENSIONS_it); | ||
| 141 | } | ||
| 142 | |||
| 143 | int | ||
| 144 | i2d_X509_EXTENSIONS(X509_EXTENSIONS *a, unsigned char **out) | ||
| 145 | { | ||
| 146 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_EXTENSIONS_it); | ||
| 147 | } | ||
| 148 | |||
| 149 | X509_EXTENSION * | ||
| 150 | X509_EXTENSION_dup(X509_EXTENSION *x) | ||
| 151 | { | ||
| 152 | return ASN1_item_dup(&X509_EXTENSION_it, x); | ||
| 153 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_info.c b/src/lib/libcrypto/asn1/x_info.c deleted file mode 100644 index 466deaf6ce..0000000000 --- a/src/lib/libcrypto/asn1/x_info.c +++ /dev/null | |||
| @@ -1,108 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_info.c,v 1.15 2015/02/10 11:22:21 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/err.h> | ||
| 63 | #include <openssl/evp.h> | ||
| 64 | #include <openssl/x509.h> | ||
| 65 | |||
| 66 | X509_INFO * | ||
| 67 | X509_INFO_new(void) | ||
| 68 | { | ||
| 69 | X509_INFO *ret = NULL; | ||
| 70 | |||
| 71 | ret = malloc(sizeof(X509_INFO)); | ||
| 72 | if (ret == NULL) { | ||
| 73 | ASN1err(ASN1_F_X509_INFO_NEW, ERR_R_MALLOC_FAILURE); | ||
| 74 | return (NULL); | ||
| 75 | } | ||
| 76 | |||
| 77 | ret->enc_cipher.cipher = NULL; | ||
| 78 | ret->enc_len = 0; | ||
| 79 | ret->enc_data = NULL; | ||
| 80 | |||
| 81 | ret->references = 1; | ||
| 82 | ret->x509 = NULL; | ||
| 83 | ret->crl = NULL; | ||
| 84 | ret->x_pkey = NULL; | ||
| 85 | return (ret); | ||
| 86 | } | ||
| 87 | |||
| 88 | void | ||
| 89 | X509_INFO_free(X509_INFO *x) | ||
| 90 | { | ||
| 91 | int i; | ||
| 92 | |||
| 93 | if (x == NULL) | ||
| 94 | return; | ||
| 95 | |||
| 96 | i = CRYPTO_add(&x->references, -1, CRYPTO_LOCK_X509_INFO); | ||
| 97 | if (i > 0) | ||
| 98 | return; | ||
| 99 | |||
| 100 | if (x->x509 != NULL) | ||
| 101 | X509_free(x->x509); | ||
| 102 | if (x->crl != NULL) | ||
| 103 | X509_CRL_free(x->crl); | ||
| 104 | if (x->x_pkey != NULL) | ||
| 105 | X509_PKEY_free(x->x_pkey); | ||
| 106 | free(x->enc_data); | ||
| 107 | free(x); | ||
| 108 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_long.c b/src/lib/libcrypto/asn1/x_long.c deleted file mode 100644 index 90a41129bc..0000000000 --- a/src/lib/libcrypto/asn1/x_long.c +++ /dev/null | |||
| @@ -1,210 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_long.c,v 1.10 2015/07/25 17:07:17 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2000. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2000 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 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/asn1t.h> | ||
| 63 | #include <openssl/bn.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | |||
| 66 | /* Custom primitive type for long handling. This converts between an ASN1_INTEGER | ||
| 67 | * and a long directly. | ||
| 68 | */ | ||
| 69 | |||
| 70 | |||
| 71 | static int long_new(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 72 | static void long_free(ASN1_VALUE **pval, const ASN1_ITEM *it); | ||
| 73 | |||
| 74 | static int long_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, const ASN1_ITEM *it); | ||
| 75 | static int long_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, char *free_cont, const ASN1_ITEM *it); | ||
| 76 | static int long_print(BIO *out, ASN1_VALUE **pval, const ASN1_ITEM *it, int indent, const ASN1_PCTX *pctx); | ||
| 77 | |||
| 78 | static ASN1_PRIMITIVE_FUNCS long_pf = { | ||
| 79 | NULL, 0, | ||
| 80 | long_new, | ||
| 81 | long_free, | ||
| 82 | long_free, /* Clear should set to initial value */ | ||
| 83 | long_c2i, | ||
| 84 | long_i2c, | ||
| 85 | long_print | ||
| 86 | }; | ||
| 87 | |||
| 88 | const ASN1_ITEM LONG_it = { | ||
| 89 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 90 | .utype = V_ASN1_INTEGER, | ||
| 91 | .templates = NULL, | ||
| 92 | .tcount = 0, | ||
| 93 | .funcs = &long_pf, | ||
| 94 | .size = ASN1_LONG_UNDEF, | ||
| 95 | .sname = "LONG", | ||
| 96 | }; | ||
| 97 | |||
| 98 | const ASN1_ITEM ZLONG_it = { | ||
| 99 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 100 | .utype = V_ASN1_INTEGER, | ||
| 101 | .templates = NULL, | ||
| 102 | .tcount = 0, | ||
| 103 | .funcs = &long_pf, | ||
| 104 | .size = 0, | ||
| 105 | .sname = "ZLONG", | ||
| 106 | }; | ||
| 107 | |||
| 108 | static int | ||
| 109 | long_new(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 110 | { | ||
| 111 | *(long *)pval = it->size; | ||
| 112 | return 1; | ||
| 113 | } | ||
| 114 | |||
| 115 | static void | ||
| 116 | long_free(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 117 | { | ||
| 118 | *(long *)pval = it->size; | ||
| 119 | } | ||
| 120 | |||
| 121 | static int | ||
| 122 | long_i2c(ASN1_VALUE **pval, unsigned char *cont, int *putype, | ||
| 123 | const ASN1_ITEM *it) | ||
| 124 | { | ||
| 125 | long ltmp; | ||
| 126 | unsigned long utmp; | ||
| 127 | int clen, pad, i; | ||
| 128 | /* this exists to bypass broken gcc optimization */ | ||
| 129 | char *cp = (char *)pval; | ||
| 130 | |||
| 131 | /* use memcpy, because we may not be long aligned */ | ||
| 132 | memcpy(<mp, cp, sizeof(long)); | ||
| 133 | |||
| 134 | if (ltmp == it->size) | ||
| 135 | return -1; | ||
| 136 | /* Convert the long to positive: we subtract one if negative so | ||
| 137 | * we can cleanly handle the padding if only the MSB of the leading | ||
| 138 | * octet is set. | ||
| 139 | */ | ||
| 140 | if (ltmp < 0) | ||
| 141 | utmp = -ltmp - 1; | ||
| 142 | else | ||
| 143 | utmp = ltmp; | ||
| 144 | clen = BN_num_bits_word(utmp); | ||
| 145 | /* If MSB of leading octet set we need to pad */ | ||
| 146 | if (!(clen & 0x7)) | ||
| 147 | pad = 1; | ||
| 148 | else | ||
| 149 | pad = 0; | ||
| 150 | |||
| 151 | /* Convert number of bits to number of octets */ | ||
| 152 | clen = (clen + 7) >> 3; | ||
| 153 | |||
| 154 | if (cont) { | ||
| 155 | if (pad) | ||
| 156 | *cont++ = (ltmp < 0) ? 0xff : 0; | ||
| 157 | for (i = clen - 1; i >= 0; i--) { | ||
| 158 | cont[i] = (unsigned char)(utmp & 0xff); | ||
| 159 | if (ltmp < 0) | ||
| 160 | cont[i] ^= 0xff; | ||
| 161 | utmp >>= 8; | ||
| 162 | } | ||
| 163 | } | ||
| 164 | return clen + pad; | ||
| 165 | } | ||
| 166 | |||
| 167 | static int | ||
| 168 | long_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len, int utype, | ||
| 169 | char *free_cont, const ASN1_ITEM *it) | ||
| 170 | { | ||
| 171 | int neg, i; | ||
| 172 | long ltmp; | ||
| 173 | unsigned long utmp = 0; | ||
| 174 | char *cp = (char *)pval; | ||
| 175 | if (len > (int)sizeof(long)) { | ||
| 176 | ASN1err(ASN1_F_LONG_C2I, ASN1_R_INTEGER_TOO_LARGE_FOR_LONG); | ||
| 177 | return 0; | ||
| 178 | } | ||
| 179 | /* Is it negative? */ | ||
| 180 | if (len && (cont[0] & 0x80)) | ||
| 181 | neg = 1; | ||
| 182 | else | ||
| 183 | neg = 0; | ||
| 184 | utmp = 0; | ||
| 185 | for (i = 0; i < len; i++) { | ||
| 186 | utmp <<= 8; | ||
| 187 | if (neg) | ||
| 188 | utmp |= cont[i] ^ 0xff; | ||
| 189 | else | ||
| 190 | utmp |= cont[i]; | ||
| 191 | } | ||
| 192 | ltmp = (long)utmp; | ||
| 193 | if (neg) { | ||
| 194 | ltmp++; | ||
| 195 | ltmp = -ltmp; | ||
| 196 | } | ||
| 197 | if (ltmp == it->size) { | ||
| 198 | ASN1err(ASN1_F_LONG_C2I, ASN1_R_INTEGER_TOO_LARGE_FOR_LONG); | ||
| 199 | return 0; | ||
| 200 | } | ||
| 201 | memcpy(cp, <mp, sizeof(long)); | ||
| 202 | return 1; | ||
| 203 | } | ||
| 204 | |||
| 205 | static int | ||
| 206 | long_print(BIO *out, ASN1_VALUE **pval, const ASN1_ITEM *it, int indent, | ||
| 207 | const ASN1_PCTX *pctx) | ||
| 208 | { | ||
| 209 | return BIO_printf(out, "%ld\n", *(long *)pval); | ||
| 210 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_name.c b/src/lib/libcrypto/asn1/x_name.c deleted file mode 100644 index be936318d8..0000000000 --- a/src/lib/libcrypto/asn1/x_name.c +++ /dev/null | |||
| @@ -1,642 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_name.c,v 1.31 2015/07/24 15:09:52 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <ctype.h> | ||
| 60 | #include <stdio.h> | ||
| 61 | #include <string.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1t.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | |||
| 67 | #include "asn1_locl.h" | ||
| 68 | |||
| 69 | typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY; | ||
| 70 | DECLARE_STACK_OF(STACK_OF_X509_NAME_ENTRY) | ||
| 71 | |||
| 72 | static int x509_name_ex_d2i(ASN1_VALUE **val, const unsigned char **in, | ||
| 73 | long len, const ASN1_ITEM *it, int tag, int aclass, char opt, | ||
| 74 | ASN1_TLC *ctx); | ||
| 75 | |||
| 76 | static int x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out, | ||
| 77 | const ASN1_ITEM *it, int tag, int aclass); | ||
| 78 | static int x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it); | ||
| 79 | static void x509_name_ex_free(ASN1_VALUE **val, const ASN1_ITEM *it); | ||
| 80 | |||
| 81 | static int x509_name_encode(X509_NAME *a); | ||
| 82 | static int x509_name_canon(X509_NAME *a); | ||
| 83 | static int asn1_string_canon(ASN1_STRING *out, ASN1_STRING *in); | ||
| 84 | static int i2d_name_canon(STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname, | ||
| 85 | unsigned char **in); | ||
| 86 | |||
| 87 | static int x509_name_ex_print(BIO *out, ASN1_VALUE **pval, int indent, | ||
| 88 | const char *fname, const ASN1_PCTX *pctx); | ||
| 89 | |||
| 90 | static const ASN1_TEMPLATE X509_NAME_ENTRY_seq_tt[] = { | ||
| 91 | { | ||
| 92 | .offset = offsetof(X509_NAME_ENTRY, object), | ||
| 93 | .field_name = "object", | ||
| 94 | .item = &ASN1_OBJECT_it, | ||
| 95 | }, | ||
| 96 | { | ||
| 97 | .offset = offsetof(X509_NAME_ENTRY, value), | ||
| 98 | .field_name = "value", | ||
| 99 | .item = &ASN1_PRINTABLE_it, | ||
| 100 | }, | ||
| 101 | }; | ||
| 102 | |||
| 103 | const ASN1_ITEM X509_NAME_ENTRY_it = { | ||
| 104 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 105 | .utype = V_ASN1_SEQUENCE, | ||
| 106 | .templates = X509_NAME_ENTRY_seq_tt, | ||
| 107 | .tcount = sizeof(X509_NAME_ENTRY_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 108 | .size = sizeof(X509_NAME_ENTRY), | ||
| 109 | .sname = "X509_NAME_ENTRY", | ||
| 110 | }; | ||
| 111 | |||
| 112 | |||
| 113 | X509_NAME_ENTRY * | ||
| 114 | d2i_X509_NAME_ENTRY(X509_NAME_ENTRY **a, const unsigned char **in, long len) | ||
| 115 | { | ||
| 116 | return (X509_NAME_ENTRY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 117 | &X509_NAME_ENTRY_it); | ||
| 118 | } | ||
| 119 | |||
| 120 | int | ||
| 121 | i2d_X509_NAME_ENTRY(X509_NAME_ENTRY *a, unsigned char **out) | ||
| 122 | { | ||
| 123 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_NAME_ENTRY_it); | ||
| 124 | } | ||
| 125 | |||
| 126 | X509_NAME_ENTRY * | ||
| 127 | X509_NAME_ENTRY_new(void) | ||
| 128 | { | ||
| 129 | return (X509_NAME_ENTRY *)ASN1_item_new(&X509_NAME_ENTRY_it); | ||
| 130 | } | ||
| 131 | |||
| 132 | void | ||
| 133 | X509_NAME_ENTRY_free(X509_NAME_ENTRY *a) | ||
| 134 | { | ||
| 135 | ASN1_item_free((ASN1_VALUE *)a, &X509_NAME_ENTRY_it); | ||
| 136 | } | ||
| 137 | |||
| 138 | X509_NAME_ENTRY * | ||
| 139 | X509_NAME_ENTRY_dup(X509_NAME_ENTRY *x) | ||
| 140 | { | ||
| 141 | return ASN1_item_dup(&X509_NAME_ENTRY_it, x); | ||
| 142 | } | ||
| 143 | |||
| 144 | /* For the "Name" type we need a SEQUENCE OF { SET OF X509_NAME_ENTRY } | ||
| 145 | * so declare two template wrappers for this | ||
| 146 | */ | ||
| 147 | |||
| 148 | static const ASN1_TEMPLATE X509_NAME_ENTRIES_item_tt = { | ||
| 149 | .flags = ASN1_TFLG_SET_OF, | ||
| 150 | .tag = 0, | ||
| 151 | .offset = 0, | ||
| 152 | .field_name = "RDNS", | ||
| 153 | .item = &X509_NAME_ENTRY_it, | ||
| 154 | }; | ||
| 155 | |||
| 156 | const ASN1_ITEM X509_NAME_ENTRIES_it = { | ||
| 157 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 158 | .utype = -1, | ||
| 159 | .templates = &X509_NAME_ENTRIES_item_tt, | ||
| 160 | .tcount = 0, | ||
| 161 | .funcs = NULL, | ||
| 162 | .size = 0, | ||
| 163 | .sname = "X509_NAME_ENTRIES", | ||
| 164 | }; | ||
| 165 | |||
| 166 | static const ASN1_TEMPLATE X509_NAME_INTERNAL_item_tt = { | ||
| 167 | .flags = ASN1_TFLG_SEQUENCE_OF, | ||
| 168 | .tag = 0, | ||
| 169 | .offset = 0, | ||
| 170 | .field_name = "Name", | ||
| 171 | .item = &X509_NAME_ENTRIES_it, | ||
| 172 | }; | ||
| 173 | |||
| 174 | const ASN1_ITEM X509_NAME_INTERNAL_it = { | ||
| 175 | .itype = ASN1_ITYPE_PRIMITIVE, | ||
| 176 | .utype = -1, | ||
| 177 | .templates = &X509_NAME_INTERNAL_item_tt, | ||
| 178 | .tcount = 0, | ||
| 179 | .funcs = NULL, | ||
| 180 | .size = 0, | ||
| 181 | .sname = "X509_NAME_INTERNAL", | ||
| 182 | }; | ||
| 183 | |||
| 184 | /* Normally that's where it would end: we'd have two nested STACK structures | ||
| 185 | * representing the ASN1. Unfortunately X509_NAME uses a completely different | ||
| 186 | * form and caches encodings so we have to process the internal form and convert | ||
| 187 | * to the external form. | ||
| 188 | */ | ||
| 189 | |||
| 190 | const ASN1_EXTERN_FUNCS x509_name_ff = { | ||
| 191 | NULL, | ||
| 192 | x509_name_ex_new, | ||
| 193 | x509_name_ex_free, | ||
| 194 | 0, /* Default clear behaviour is OK */ | ||
| 195 | x509_name_ex_d2i, | ||
| 196 | x509_name_ex_i2d, | ||
| 197 | x509_name_ex_print | ||
| 198 | }; | ||
| 199 | |||
| 200 | const ASN1_ITEM X509_NAME_it = { | ||
| 201 | .itype = ASN1_ITYPE_EXTERN, | ||
| 202 | .utype = V_ASN1_SEQUENCE, | ||
| 203 | .templates = NULL, | ||
| 204 | .tcount = 0, | ||
| 205 | .funcs = &x509_name_ff, | ||
| 206 | .size = 0, | ||
| 207 | .sname = "X509_NAME", | ||
| 208 | }; | ||
| 209 | |||
| 210 | X509_NAME * | ||
| 211 | d2i_X509_NAME(X509_NAME **a, const unsigned char **in, long len) | ||
| 212 | { | ||
| 213 | return (X509_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 214 | &X509_NAME_it); | ||
| 215 | } | ||
| 216 | |||
| 217 | int | ||
| 218 | i2d_X509_NAME(X509_NAME *a, unsigned char **out) | ||
| 219 | { | ||
| 220 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_NAME_it); | ||
| 221 | } | ||
| 222 | |||
| 223 | X509_NAME * | ||
| 224 | X509_NAME_new(void) | ||
| 225 | { | ||
| 226 | return (X509_NAME *)ASN1_item_new(&X509_NAME_it); | ||
| 227 | } | ||
| 228 | |||
| 229 | void | ||
| 230 | X509_NAME_free(X509_NAME *a) | ||
| 231 | { | ||
| 232 | ASN1_item_free((ASN1_VALUE *)a, &X509_NAME_it); | ||
| 233 | } | ||
| 234 | |||
| 235 | X509_NAME * | ||
| 236 | X509_NAME_dup(X509_NAME *x) | ||
| 237 | { | ||
| 238 | return ASN1_item_dup(&X509_NAME_it, x); | ||
| 239 | } | ||
| 240 | |||
| 241 | static int | ||
| 242 | x509_name_ex_new(ASN1_VALUE **val, const ASN1_ITEM *it) | ||
| 243 | { | ||
| 244 | X509_NAME *ret = NULL; | ||
| 245 | |||
| 246 | ret = malloc(sizeof(X509_NAME)); | ||
| 247 | if (!ret) | ||
| 248 | goto memerr; | ||
| 249 | if ((ret->entries = sk_X509_NAME_ENTRY_new_null()) == NULL) | ||
| 250 | goto memerr; | ||
| 251 | if ((ret->bytes = BUF_MEM_new()) == NULL) | ||
| 252 | goto memerr; | ||
| 253 | ret->canon_enc = NULL; | ||
| 254 | ret->canon_enclen = 0; | ||
| 255 | ret->modified = 1; | ||
| 256 | *val = (ASN1_VALUE *)ret; | ||
| 257 | return 1; | ||
| 258 | |||
| 259 | memerr: | ||
| 260 | ASN1err(ASN1_F_X509_NAME_EX_NEW, ERR_R_MALLOC_FAILURE); | ||
| 261 | if (ret) { | ||
| 262 | if (ret->entries) | ||
| 263 | sk_X509_NAME_ENTRY_free(ret->entries); | ||
| 264 | free(ret); | ||
| 265 | } | ||
| 266 | return 0; | ||
| 267 | } | ||
| 268 | |||
| 269 | static void | ||
| 270 | x509_name_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) | ||
| 271 | { | ||
| 272 | X509_NAME *a; | ||
| 273 | |||
| 274 | if (!pval || !*pval) | ||
| 275 | return; | ||
| 276 | a = (X509_NAME *)*pval; | ||
| 277 | |||
| 278 | BUF_MEM_free(a->bytes); | ||
| 279 | sk_X509_NAME_ENTRY_pop_free(a->entries, X509_NAME_ENTRY_free); | ||
| 280 | free(a->canon_enc); | ||
| 281 | free(a); | ||
| 282 | *pval = NULL; | ||
| 283 | } | ||
| 284 | |||
| 285 | static int | ||
| 286 | x509_name_ex_d2i(ASN1_VALUE **val, const unsigned char **in, long len, | ||
| 287 | const ASN1_ITEM *it, int tag, int aclass, char opt, ASN1_TLC *ctx) | ||
| 288 | { | ||
| 289 | const unsigned char *p = *in, *q; | ||
| 290 | union { | ||
| 291 | STACK_OF(STACK_OF_X509_NAME_ENTRY) *s; | ||
| 292 | ASN1_VALUE *a; | ||
| 293 | } intname = {NULL}; | ||
| 294 | union { | ||
| 295 | X509_NAME *x; | ||
| 296 | ASN1_VALUE *a; | ||
| 297 | } nm = {NULL}; | ||
| 298 | int i, j, ret; | ||
| 299 | STACK_OF(X509_NAME_ENTRY) *entries; | ||
| 300 | X509_NAME_ENTRY *entry; | ||
| 301 | q = p; | ||
| 302 | |||
| 303 | /* Get internal representation of Name */ | ||
| 304 | ret = ASN1_item_ex_d2i(&intname.a, &p, len, | ||
| 305 | ASN1_ITEM_rptr(X509_NAME_INTERNAL), tag, aclass, opt, ctx); | ||
| 306 | |||
| 307 | if (ret <= 0) | ||
| 308 | return ret; | ||
| 309 | |||
| 310 | if (*val) | ||
| 311 | x509_name_ex_free(val, NULL); | ||
| 312 | if (!x509_name_ex_new(&nm.a, NULL)) | ||
| 313 | goto err; | ||
| 314 | /* We've decoded it: now cache encoding */ | ||
| 315 | if (!BUF_MEM_grow(nm.x->bytes, p - q)) | ||
| 316 | goto err; | ||
| 317 | memcpy(nm.x->bytes->data, q, p - q); | ||
| 318 | |||
| 319 | /* Convert internal representation to X509_NAME structure */ | ||
| 320 | for (i = 0; i < sk_STACK_OF_X509_NAME_ENTRY_num(intname.s); i++) { | ||
| 321 | entries = sk_STACK_OF_X509_NAME_ENTRY_value(intname.s, i); | ||
| 322 | for (j = 0; j < sk_X509_NAME_ENTRY_num(entries); j++) { | ||
| 323 | entry = sk_X509_NAME_ENTRY_value(entries, j); | ||
| 324 | entry->set = i; | ||
| 325 | if (!sk_X509_NAME_ENTRY_push(nm.x->entries, entry)) | ||
| 326 | goto err; | ||
| 327 | } | ||
| 328 | sk_X509_NAME_ENTRY_free(entries); | ||
| 329 | } | ||
| 330 | sk_STACK_OF_X509_NAME_ENTRY_free(intname.s); | ||
| 331 | ret = x509_name_canon(nm.x); | ||
| 332 | if (!ret) | ||
| 333 | goto err; | ||
| 334 | nm.x->modified = 0; | ||
| 335 | *val = nm.a; | ||
| 336 | *in = p; | ||
| 337 | return ret; | ||
| 338 | |||
| 339 | err: | ||
| 340 | if (nm.x != NULL) | ||
| 341 | X509_NAME_free(nm.x); | ||
| 342 | ASN1err(ASN1_F_X509_NAME_EX_D2I, ERR_R_NESTED_ASN1_ERROR); | ||
| 343 | return 0; | ||
| 344 | } | ||
| 345 | |||
| 346 | static int | ||
| 347 | x509_name_ex_i2d(ASN1_VALUE **val, unsigned char **out, const ASN1_ITEM *it, | ||
| 348 | int tag, int aclass) | ||
| 349 | { | ||
| 350 | int ret; | ||
| 351 | X509_NAME *a = (X509_NAME *)*val; | ||
| 352 | |||
| 353 | if (a->modified) { | ||
| 354 | ret = x509_name_encode(a); | ||
| 355 | if (ret < 0) | ||
| 356 | return ret; | ||
| 357 | ret = x509_name_canon(a); | ||
| 358 | if (ret < 0) | ||
| 359 | return ret; | ||
| 360 | } | ||
| 361 | ret = a->bytes->length; | ||
| 362 | if (out != NULL) { | ||
| 363 | memcpy(*out, a->bytes->data, ret); | ||
| 364 | *out += ret; | ||
| 365 | } | ||
| 366 | return ret; | ||
| 367 | } | ||
| 368 | |||
| 369 | static void | ||
| 370 | local_sk_X509_NAME_ENTRY_free(STACK_OF(X509_NAME_ENTRY) *ne) | ||
| 371 | { | ||
| 372 | sk_X509_NAME_ENTRY_free(ne); | ||
| 373 | } | ||
| 374 | |||
| 375 | static void | ||
| 376 | local_sk_X509_NAME_ENTRY_pop_free(STACK_OF(X509_NAME_ENTRY) *ne) | ||
| 377 | { | ||
| 378 | sk_X509_NAME_ENTRY_pop_free(ne, X509_NAME_ENTRY_free); | ||
| 379 | } | ||
| 380 | |||
| 381 | static int | ||
| 382 | x509_name_encode(X509_NAME *a) | ||
| 383 | { | ||
| 384 | union { | ||
| 385 | STACK_OF(STACK_OF_X509_NAME_ENTRY) *s; | ||
| 386 | ASN1_VALUE *a; | ||
| 387 | } intname = {NULL}; | ||
| 388 | int len; | ||
| 389 | unsigned char *p; | ||
| 390 | STACK_OF(X509_NAME_ENTRY) *entries = NULL; | ||
| 391 | X509_NAME_ENTRY *entry; | ||
| 392 | int i, set = -1; | ||
| 393 | |||
| 394 | intname.s = sk_STACK_OF_X509_NAME_ENTRY_new_null(); | ||
| 395 | if (!intname.s) | ||
| 396 | goto memerr; | ||
| 397 | for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) { | ||
| 398 | entry = sk_X509_NAME_ENTRY_value(a->entries, i); | ||
| 399 | if (entry->set != set) { | ||
| 400 | entries = sk_X509_NAME_ENTRY_new_null(); | ||
| 401 | if (!entries) | ||
| 402 | goto memerr; | ||
| 403 | if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname.s, | ||
| 404 | entries)) | ||
| 405 | goto memerr; | ||
| 406 | set = entry->set; | ||
| 407 | } | ||
| 408 | if (entries == NULL /* if entry->set is bogusly -1 */ || | ||
| 409 | !sk_X509_NAME_ENTRY_push(entries, entry)) | ||
| 410 | goto memerr; | ||
| 411 | } | ||
| 412 | len = ASN1_item_ex_i2d(&intname.a, NULL, | ||
| 413 | ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1); | ||
| 414 | if (!BUF_MEM_grow(a->bytes, len)) | ||
| 415 | goto memerr; | ||
| 416 | p = (unsigned char *)a->bytes->data; | ||
| 417 | ASN1_item_ex_i2d(&intname.a, &p, ASN1_ITEM_rptr(X509_NAME_INTERNAL), | ||
| 418 | -1, -1); | ||
| 419 | sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s, | ||
| 420 | local_sk_X509_NAME_ENTRY_free); | ||
| 421 | a->modified = 0; | ||
| 422 | return len; | ||
| 423 | |||
| 424 | memerr: | ||
| 425 | sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s, | ||
| 426 | local_sk_X509_NAME_ENTRY_free); | ||
| 427 | ASN1err(ASN1_F_X509_NAME_ENCODE, ERR_R_MALLOC_FAILURE); | ||
| 428 | return -1; | ||
| 429 | } | ||
| 430 | |||
| 431 | static int | ||
| 432 | x509_name_ex_print(BIO *out, ASN1_VALUE **pval, int indent, const char *fname, | ||
| 433 | const ASN1_PCTX *pctx) | ||
| 434 | { | ||
| 435 | if (X509_NAME_print_ex(out, (X509_NAME *)*pval, indent, | ||
| 436 | pctx->nm_flags) <= 0) | ||
| 437 | return 0; | ||
| 438 | return 2; | ||
| 439 | } | ||
| 440 | |||
| 441 | /* This function generates the canonical encoding of the Name structure. | ||
| 442 | * In it all strings are converted to UTF8, leading, trailing and | ||
| 443 | * multiple spaces collapsed, converted to lower case and the leading | ||
| 444 | * SEQUENCE header removed. | ||
| 445 | * | ||
| 446 | * In future we could also normalize the UTF8 too. | ||
| 447 | * | ||
| 448 | * By doing this comparison of Name structures can be rapidly | ||
| 449 | * performed by just using memcmp() of the canonical encoding. | ||
| 450 | * By omitting the leading SEQUENCE name constraints of type | ||
| 451 | * dirName can also be checked with a simple memcmp(). | ||
| 452 | */ | ||
| 453 | |||
| 454 | static int | ||
| 455 | x509_name_canon(X509_NAME *a) | ||
| 456 | { | ||
| 457 | unsigned char *p; | ||
| 458 | STACK_OF(STACK_OF_X509_NAME_ENTRY) *intname = NULL; | ||
| 459 | STACK_OF(X509_NAME_ENTRY) *entries = NULL; | ||
| 460 | X509_NAME_ENTRY *entry, *tmpentry = NULL; | ||
| 461 | int i, len, set = -1, ret = 0; | ||
| 462 | |||
| 463 | if (a->canon_enc) { | ||
| 464 | free(a->canon_enc); | ||
| 465 | a->canon_enc = NULL; | ||
| 466 | } | ||
| 467 | /* Special case: empty X509_NAME => null encoding */ | ||
| 468 | if (sk_X509_NAME_ENTRY_num(a->entries) == 0) { | ||
| 469 | a->canon_enclen = 0; | ||
| 470 | return 1; | ||
| 471 | } | ||
| 472 | intname = sk_STACK_OF_X509_NAME_ENTRY_new_null(); | ||
| 473 | if (!intname) | ||
| 474 | goto err; | ||
| 475 | for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) { | ||
| 476 | entry = sk_X509_NAME_ENTRY_value(a->entries, i); | ||
| 477 | if (entry->set != set) { | ||
| 478 | entries = sk_X509_NAME_ENTRY_new_null(); | ||
| 479 | if (!entries) | ||
| 480 | goto err; | ||
| 481 | if (sk_STACK_OF_X509_NAME_ENTRY_push(intname, | ||
| 482 | entries) == 0) { | ||
| 483 | sk_X509_NAME_ENTRY_free(entries); | ||
| 484 | goto err; | ||
| 485 | } | ||
| 486 | set = entry->set; | ||
| 487 | } | ||
| 488 | tmpentry = X509_NAME_ENTRY_new(); | ||
| 489 | if (tmpentry == NULL) | ||
| 490 | goto err; | ||
| 491 | tmpentry->object = OBJ_dup(entry->object); | ||
| 492 | if (tmpentry->object == NULL) | ||
| 493 | goto err; | ||
| 494 | if (!asn1_string_canon(tmpentry->value, entry->value)) | ||
| 495 | goto err; | ||
| 496 | if (entries == NULL /* if entry->set is bogusly -1 */ || | ||
| 497 | !sk_X509_NAME_ENTRY_push(entries, tmpentry)) | ||
| 498 | goto err; | ||
| 499 | tmpentry = NULL; | ||
| 500 | } | ||
| 501 | |||
| 502 | /* Finally generate encoding */ | ||
| 503 | len = i2d_name_canon(intname, NULL); | ||
| 504 | if (len < 0) | ||
| 505 | goto err; | ||
| 506 | p = malloc(len); | ||
| 507 | if (p == NULL) | ||
| 508 | goto err; | ||
| 509 | a->canon_enc = p; | ||
| 510 | a->canon_enclen = len; | ||
| 511 | i2d_name_canon(intname, &p); | ||
| 512 | ret = 1; | ||
| 513 | |||
| 514 | err: | ||
| 515 | if (tmpentry) | ||
| 516 | X509_NAME_ENTRY_free(tmpentry); | ||
| 517 | if (intname) | ||
| 518 | sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname, | ||
| 519 | local_sk_X509_NAME_ENTRY_pop_free); | ||
| 520 | return ret; | ||
| 521 | } | ||
| 522 | |||
| 523 | /* Bitmap of all the types of string that will be canonicalized. */ | ||
| 524 | |||
| 525 | #define ASN1_MASK_CANON \ | ||
| 526 | (B_ASN1_UTF8STRING | B_ASN1_BMPSTRING | B_ASN1_UNIVERSALSTRING \ | ||
| 527 | | B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_IA5STRING \ | ||
| 528 | | B_ASN1_VISIBLESTRING) | ||
| 529 | |||
| 530 | |||
| 531 | static int | ||
| 532 | asn1_string_canon(ASN1_STRING *out, ASN1_STRING *in) | ||
| 533 | { | ||
| 534 | unsigned char *to, *from; | ||
| 535 | int len, i; | ||
| 536 | |||
| 537 | /* If type not in bitmask just copy string across */ | ||
| 538 | if (!(ASN1_tag2bit(in->type) & ASN1_MASK_CANON)) { | ||
| 539 | if (!ASN1_STRING_copy(out, in)) | ||
| 540 | return 0; | ||
| 541 | return 1; | ||
| 542 | } | ||
| 543 | |||
| 544 | out->type = V_ASN1_UTF8STRING; | ||
| 545 | out->length = ASN1_STRING_to_UTF8(&out->data, in); | ||
| 546 | if (out->length == -1) | ||
| 547 | return 0; | ||
| 548 | |||
| 549 | to = out->data; | ||
| 550 | from = to; | ||
| 551 | |||
| 552 | len = out->length; | ||
| 553 | |||
| 554 | /* Convert string in place to canonical form. | ||
| 555 | * Ultimately we may need to handle a wider range of characters | ||
| 556 | * but for now ignore anything with MSB set and rely on the | ||
| 557 | * isspace() and tolower() functions. | ||
| 558 | */ | ||
| 559 | |||
| 560 | /* Ignore leading spaces */ | ||
| 561 | while ((len > 0) && !(*from & 0x80) && isspace(*from)) { | ||
| 562 | from++; | ||
| 563 | len--; | ||
| 564 | } | ||
| 565 | |||
| 566 | to = from + len - 1; | ||
| 567 | |||
| 568 | /* Ignore trailing spaces */ | ||
| 569 | while ((len > 0) && !(*to & 0x80) && isspace(*to)) { | ||
| 570 | to--; | ||
| 571 | len--; | ||
| 572 | } | ||
| 573 | |||
| 574 | to = out->data; | ||
| 575 | |||
| 576 | i = 0; | ||
| 577 | while (i < len) { | ||
| 578 | /* If MSB set just copy across */ | ||
| 579 | if (*from & 0x80) { | ||
| 580 | *to++ = *from++; | ||
| 581 | i++; | ||
| 582 | } | ||
| 583 | /* Collapse multiple spaces */ | ||
| 584 | else if (isspace(*from)) { | ||
| 585 | /* Copy one space across */ | ||
| 586 | *to++ = ' '; | ||
| 587 | /* Ignore subsequent spaces. Note: don't need to | ||
| 588 | * check len here because we know the last | ||
| 589 | * character is a non-space so we can't overflow. | ||
| 590 | */ | ||
| 591 | do { | ||
| 592 | from++; | ||
| 593 | i++; | ||
| 594 | } while (!(*from & 0x80) && isspace(*from)); | ||
| 595 | } else { | ||
| 596 | *to++ = tolower(*from); | ||
| 597 | from++; | ||
| 598 | i++; | ||
| 599 | } | ||
| 600 | } | ||
| 601 | |||
| 602 | out->length = to - out->data; | ||
| 603 | |||
| 604 | return 1; | ||
| 605 | } | ||
| 606 | |||
| 607 | static int | ||
| 608 | i2d_name_canon(STACK_OF(STACK_OF_X509_NAME_ENTRY) *_intname, unsigned char **in) | ||
| 609 | { | ||
| 610 | int i, len, ltmp; | ||
| 611 | ASN1_VALUE *v; | ||
| 612 | STACK_OF(ASN1_VALUE) *intname = (STACK_OF(ASN1_VALUE) *)_intname; | ||
| 613 | |||
| 614 | len = 0; | ||
| 615 | for (i = 0; i < sk_ASN1_VALUE_num(intname); i++) { | ||
| 616 | v = sk_ASN1_VALUE_value(intname, i); | ||
| 617 | ltmp = ASN1_item_ex_i2d(&v, in, | ||
| 618 | ASN1_ITEM_rptr(X509_NAME_ENTRIES), -1, -1); | ||
| 619 | if (ltmp < 0) | ||
| 620 | return ltmp; | ||
| 621 | len += ltmp; | ||
| 622 | } | ||
| 623 | return len; | ||
| 624 | } | ||
| 625 | |||
| 626 | int | ||
| 627 | X509_NAME_set(X509_NAME **xn, X509_NAME *name) | ||
| 628 | { | ||
| 629 | X509_NAME *in; | ||
| 630 | |||
| 631 | if (!xn || !name) | ||
| 632 | return (0); | ||
| 633 | |||
| 634 | if (*xn != name) { | ||
| 635 | in = X509_NAME_dup(name); | ||
| 636 | if (in != NULL) { | ||
| 637 | X509_NAME_free(*xn); | ||
| 638 | *xn = in; | ||
| 639 | } | ||
| 640 | } | ||
| 641 | return (*xn != NULL); | ||
| 642 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_nx509.c b/src/lib/libcrypto/asn1/x_nx509.c deleted file mode 100644 index 7e18be8c79..0000000000 --- a/src/lib/libcrypto/asn1/x_nx509.c +++ /dev/null | |||
| @@ -1,113 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_nx509.c,v 1.6 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL | ||
| 3 | * project 2005. | ||
| 4 | */ | ||
| 5 | /* ==================================================================== | ||
| 6 | * Copyright (c) 2005 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 | #include <stddef.h> | ||
| 60 | #include <openssl/x509.h> | ||
| 61 | #include <openssl/asn1.h> | ||
| 62 | #include <openssl/asn1t.h> | ||
| 63 | |||
| 64 | /* Old netscape certificate wrapper format */ | ||
| 65 | |||
| 66 | static const ASN1_TEMPLATE NETSCAPE_X509_seq_tt[] = { | ||
| 67 | { | ||
| 68 | .offset = offsetof(NETSCAPE_X509, header), | ||
| 69 | .field_name = "header", | ||
| 70 | .item = &ASN1_OCTET_STRING_it, | ||
| 71 | }, | ||
| 72 | { | ||
| 73 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 74 | .offset = offsetof(NETSCAPE_X509, cert), | ||
| 75 | .field_name = "cert", | ||
| 76 | .item = &X509_it, | ||
| 77 | }, | ||
| 78 | }; | ||
| 79 | |||
| 80 | const ASN1_ITEM NETSCAPE_X509_it = { | ||
| 81 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 82 | .utype = V_ASN1_SEQUENCE, | ||
| 83 | .templates = NETSCAPE_X509_seq_tt, | ||
| 84 | .tcount = sizeof(NETSCAPE_X509_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 85 | .size = sizeof(NETSCAPE_X509), | ||
| 86 | .sname = "NETSCAPE_X509", | ||
| 87 | }; | ||
| 88 | |||
| 89 | |||
| 90 | NETSCAPE_X509 * | ||
| 91 | d2i_NETSCAPE_X509(NETSCAPE_X509 **a, const unsigned char **in, long len) | ||
| 92 | { | ||
| 93 | return (NETSCAPE_X509 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 94 | &NETSCAPE_X509_it); | ||
| 95 | } | ||
| 96 | |||
| 97 | int | ||
| 98 | i2d_NETSCAPE_X509(NETSCAPE_X509 *a, unsigned char **out) | ||
| 99 | { | ||
| 100 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_X509_it); | ||
| 101 | } | ||
| 102 | |||
| 103 | NETSCAPE_X509 * | ||
| 104 | NETSCAPE_X509_new(void) | ||
| 105 | { | ||
| 106 | return (NETSCAPE_X509 *)ASN1_item_new(&NETSCAPE_X509_it); | ||
| 107 | } | ||
| 108 | |||
| 109 | void | ||
| 110 | NETSCAPE_X509_free(NETSCAPE_X509 *a) | ||
| 111 | { | ||
| 112 | ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_X509_it); | ||
| 113 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_pkey.c b/src/lib/libcrypto/asn1/x_pkey.c deleted file mode 100644 index 28e79858b5..0000000000 --- a/src/lib/libcrypto/asn1/x_pkey.c +++ /dev/null | |||
| @@ -1,121 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_pkey.c,v 1.18 2015/07/27 12:53:56 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | #include <string.h> | ||
| 61 | |||
| 62 | #include <openssl/err.h> | ||
| 63 | #include <openssl/evp.h> | ||
| 64 | #include <openssl/objects.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | |||
| 67 | X509_PKEY * | ||
| 68 | X509_PKEY_new(void) | ||
| 69 | { | ||
| 70 | X509_PKEY *ret = NULL; | ||
| 71 | |||
| 72 | if ((ret = malloc(sizeof(X509_PKEY))) == NULL) { | ||
| 73 | ASN1err(ASN1_F_X509_PKEY_NEW, ERR_R_MALLOC_FAILURE); | ||
| 74 | goto err; | ||
| 75 | } | ||
| 76 | ret->version = 0; | ||
| 77 | if ((ret->enc_algor = X509_ALGOR_new()) == NULL) { | ||
| 78 | ASN1err(ASN1_F_X509_PKEY_NEW, ERR_R_MALLOC_FAILURE); | ||
| 79 | goto err; | ||
| 80 | } | ||
| 81 | if ((ret->enc_pkey = M_ASN1_OCTET_STRING_new()) == NULL) { | ||
| 82 | ASN1err(ASN1_F_X509_PKEY_NEW, ERR_R_MALLOC_FAILURE); | ||
| 83 | goto err; | ||
| 84 | } | ||
| 85 | ret->dec_pkey = NULL; | ||
| 86 | ret->key_length = 0; | ||
| 87 | ret->key_data = NULL; | ||
| 88 | ret->key_free = 0; | ||
| 89 | ret->cipher.cipher = NULL; | ||
| 90 | memset(ret->cipher.iv, 0, EVP_MAX_IV_LENGTH); | ||
| 91 | ret->references = 1; | ||
| 92 | return (ret); | ||
| 93 | |||
| 94 | err: | ||
| 95 | if (ret) { | ||
| 96 | X509_ALGOR_free(ret->enc_algor); | ||
| 97 | free(ret); | ||
| 98 | } | ||
| 99 | return NULL; | ||
| 100 | } | ||
| 101 | |||
| 102 | void | ||
| 103 | X509_PKEY_free(X509_PKEY *x) | ||
| 104 | { | ||
| 105 | int i; | ||
| 106 | |||
| 107 | if (x == NULL) | ||
| 108 | return; | ||
| 109 | |||
| 110 | i = CRYPTO_add(&x->references, -1, CRYPTO_LOCK_X509_PKEY); | ||
| 111 | if (i > 0) | ||
| 112 | return; | ||
| 113 | |||
| 114 | if (x->enc_algor != NULL) | ||
| 115 | X509_ALGOR_free(x->enc_algor); | ||
| 116 | M_ASN1_OCTET_STRING_free(x->enc_pkey); | ||
| 117 | EVP_PKEY_free(x->dec_pkey); | ||
| 118 | if ((x->key_data != NULL) && (x->key_free)) | ||
| 119 | free(x->key_data); | ||
| 120 | free(x); | ||
| 121 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_pubkey.c b/src/lib/libcrypto/asn1/x_pubkey.c deleted file mode 100644 index 3bdbb5a536..0000000000 --- a/src/lib/libcrypto/asn1/x_pubkey.c +++ /dev/null | |||
| @@ -1,430 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_pubkey.c,v 1.25 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1t.h> | ||
| 64 | #include <openssl/err.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | |||
| 67 | #ifndef OPENSSL_NO_DSA | ||
| 68 | #include <openssl/dsa.h> | ||
| 69 | #endif | ||
| 70 | #ifndef OPENSSL_NO_RSA | ||
| 71 | #include <openssl/rsa.h> | ||
| 72 | #endif | ||
| 73 | |||
| 74 | #include "asn1_locl.h" | ||
| 75 | |||
| 76 | /* Minor tweak to operation: free up EVP_PKEY */ | ||
| 77 | static int | ||
| 78 | pubkey_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) | ||
| 79 | { | ||
| 80 | if (operation == ASN1_OP_FREE_POST) { | ||
| 81 | X509_PUBKEY *pubkey = (X509_PUBKEY *)*pval; | ||
| 82 | EVP_PKEY_free(pubkey->pkey); | ||
| 83 | } | ||
| 84 | return 1; | ||
| 85 | } | ||
| 86 | |||
| 87 | static const ASN1_AUX X509_PUBKEY_aux = { | ||
| 88 | .asn1_cb = pubkey_cb, | ||
| 89 | }; | ||
| 90 | static const ASN1_TEMPLATE X509_PUBKEY_seq_tt[] = { | ||
| 91 | { | ||
| 92 | .offset = offsetof(X509_PUBKEY, algor), | ||
| 93 | .field_name = "algor", | ||
| 94 | .item = &X509_ALGOR_it, | ||
| 95 | }, | ||
| 96 | { | ||
| 97 | .offset = offsetof(X509_PUBKEY, public_key), | ||
| 98 | .field_name = "public_key", | ||
| 99 | .item = &ASN1_BIT_STRING_it, | ||
| 100 | }, | ||
| 101 | }; | ||
| 102 | |||
| 103 | const ASN1_ITEM X509_PUBKEY_it = { | ||
| 104 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 105 | .utype = V_ASN1_SEQUENCE, | ||
| 106 | .templates = X509_PUBKEY_seq_tt, | ||
| 107 | .tcount = sizeof(X509_PUBKEY_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 108 | .funcs = &X509_PUBKEY_aux, | ||
| 109 | .size = sizeof(X509_PUBKEY), | ||
| 110 | .sname = "X509_PUBKEY", | ||
| 111 | }; | ||
| 112 | |||
| 113 | |||
| 114 | X509_PUBKEY * | ||
| 115 | d2i_X509_PUBKEY(X509_PUBKEY **a, const unsigned char **in, long len) | ||
| 116 | { | ||
| 117 | return (X509_PUBKEY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 118 | &X509_PUBKEY_it); | ||
| 119 | } | ||
| 120 | |||
| 121 | int | ||
| 122 | i2d_X509_PUBKEY(X509_PUBKEY *a, unsigned char **out) | ||
| 123 | { | ||
| 124 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_PUBKEY_it); | ||
| 125 | } | ||
| 126 | |||
| 127 | X509_PUBKEY * | ||
| 128 | X509_PUBKEY_new(void) | ||
| 129 | { | ||
| 130 | return (X509_PUBKEY *)ASN1_item_new(&X509_PUBKEY_it); | ||
| 131 | } | ||
| 132 | |||
| 133 | void | ||
| 134 | X509_PUBKEY_free(X509_PUBKEY *a) | ||
| 135 | { | ||
| 136 | ASN1_item_free((ASN1_VALUE *)a, &X509_PUBKEY_it); | ||
| 137 | } | ||
| 138 | |||
| 139 | int | ||
| 140 | X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey) | ||
| 141 | { | ||
| 142 | X509_PUBKEY *pk = NULL; | ||
| 143 | |||
| 144 | if (x == NULL) | ||
| 145 | return (0); | ||
| 146 | if ((pk = X509_PUBKEY_new()) == NULL) | ||
| 147 | goto error; | ||
| 148 | |||
| 149 | if (pkey->ameth) { | ||
| 150 | if (pkey->ameth->pub_encode) { | ||
| 151 | if (!pkey->ameth->pub_encode(pk, pkey)) { | ||
| 152 | X509err(X509_F_X509_PUBKEY_SET, | ||
| 153 | X509_R_PUBLIC_KEY_ENCODE_ERROR); | ||
| 154 | goto error; | ||
| 155 | } | ||
| 156 | } else { | ||
| 157 | X509err(X509_F_X509_PUBKEY_SET, | ||
| 158 | X509_R_METHOD_NOT_SUPPORTED); | ||
| 159 | goto error; | ||
| 160 | } | ||
| 161 | } else { | ||
| 162 | X509err(X509_F_X509_PUBKEY_SET, X509_R_UNSUPPORTED_ALGORITHM); | ||
| 163 | goto error; | ||
| 164 | } | ||
| 165 | |||
| 166 | if (*x != NULL) | ||
| 167 | X509_PUBKEY_free(*x); | ||
| 168 | |||
| 169 | *x = pk; | ||
| 170 | |||
| 171 | return 1; | ||
| 172 | |||
| 173 | error: | ||
| 174 | if (pk != NULL) | ||
| 175 | X509_PUBKEY_free(pk); | ||
| 176 | return 0; | ||
| 177 | } | ||
| 178 | |||
| 179 | EVP_PKEY * | ||
| 180 | X509_PUBKEY_get(X509_PUBKEY *key) | ||
| 181 | { | ||
| 182 | EVP_PKEY *ret = NULL; | ||
| 183 | |||
| 184 | if (key == NULL) | ||
| 185 | goto error; | ||
| 186 | |||
| 187 | if (key->pkey != NULL) { | ||
| 188 | CRYPTO_add(&key->pkey->references, 1, CRYPTO_LOCK_EVP_PKEY); | ||
| 189 | return key->pkey; | ||
| 190 | } | ||
| 191 | |||
| 192 | if (key->public_key == NULL) | ||
| 193 | goto error; | ||
| 194 | |||
| 195 | if ((ret = EVP_PKEY_new()) == NULL) { | ||
| 196 | X509err(X509_F_X509_PUBKEY_GET, ERR_R_MALLOC_FAILURE); | ||
| 197 | goto error; | ||
| 198 | } | ||
| 199 | |||
| 200 | if (!EVP_PKEY_set_type(ret, OBJ_obj2nid(key->algor->algorithm))) { | ||
| 201 | X509err(X509_F_X509_PUBKEY_GET, X509_R_UNSUPPORTED_ALGORITHM); | ||
| 202 | goto error; | ||
| 203 | } | ||
| 204 | |||
| 205 | if (ret->ameth->pub_decode) { | ||
| 206 | if (!ret->ameth->pub_decode(ret, key)) { | ||
| 207 | X509err(X509_F_X509_PUBKEY_GET, | ||
| 208 | X509_R_PUBLIC_KEY_DECODE_ERROR); | ||
| 209 | goto error; | ||
| 210 | } | ||
| 211 | } else { | ||
| 212 | X509err(X509_F_X509_PUBKEY_GET, X509_R_METHOD_NOT_SUPPORTED); | ||
| 213 | goto error; | ||
| 214 | } | ||
| 215 | |||
| 216 | /* Check to see if another thread set key->pkey first */ | ||
| 217 | CRYPTO_w_lock(CRYPTO_LOCK_EVP_PKEY); | ||
| 218 | if (key->pkey) { | ||
| 219 | CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY); | ||
| 220 | EVP_PKEY_free(ret); | ||
| 221 | ret = key->pkey; | ||
| 222 | } else { | ||
| 223 | key->pkey = ret; | ||
| 224 | CRYPTO_w_unlock(CRYPTO_LOCK_EVP_PKEY); | ||
| 225 | } | ||
| 226 | CRYPTO_add(&ret->references, 1, CRYPTO_LOCK_EVP_PKEY); | ||
| 227 | |||
| 228 | return ret; | ||
| 229 | |||
| 230 | error: | ||
| 231 | EVP_PKEY_free(ret); | ||
| 232 | return (NULL); | ||
| 233 | } | ||
| 234 | |||
| 235 | /* Now two pseudo ASN1 routines that take an EVP_PKEY structure | ||
| 236 | * and encode or decode as X509_PUBKEY | ||
| 237 | */ | ||
| 238 | |||
| 239 | EVP_PKEY * | ||
| 240 | d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp, long length) | ||
| 241 | { | ||
| 242 | X509_PUBKEY *xpk; | ||
| 243 | EVP_PKEY *pktmp; | ||
| 244 | xpk = d2i_X509_PUBKEY(NULL, pp, length); | ||
| 245 | if (!xpk) | ||
| 246 | return NULL; | ||
| 247 | pktmp = X509_PUBKEY_get(xpk); | ||
| 248 | X509_PUBKEY_free(xpk); | ||
| 249 | if (!pktmp) | ||
| 250 | return NULL; | ||
| 251 | if (a) { | ||
| 252 | EVP_PKEY_free(*a); | ||
| 253 | *a = pktmp; | ||
| 254 | } | ||
| 255 | return pktmp; | ||
| 256 | } | ||
| 257 | |||
| 258 | int | ||
| 259 | i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp) | ||
| 260 | { | ||
| 261 | X509_PUBKEY *xpk = NULL; | ||
| 262 | int ret; | ||
| 263 | if (!a) | ||
| 264 | return 0; | ||
| 265 | if (!X509_PUBKEY_set(&xpk, a)) | ||
| 266 | return 0; | ||
| 267 | ret = i2d_X509_PUBKEY(xpk, pp); | ||
| 268 | X509_PUBKEY_free(xpk); | ||
| 269 | return ret; | ||
| 270 | } | ||
| 271 | |||
| 272 | /* The following are equivalents but which return RSA and DSA | ||
| 273 | * keys | ||
| 274 | */ | ||
| 275 | #ifndef OPENSSL_NO_RSA | ||
| 276 | RSA * | ||
| 277 | d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp, long length) | ||
| 278 | { | ||
| 279 | EVP_PKEY *pkey; | ||
| 280 | RSA *key; | ||
| 281 | const unsigned char *q; | ||
| 282 | q = *pp; | ||
| 283 | pkey = d2i_PUBKEY(NULL, &q, length); | ||
| 284 | if (!pkey) | ||
| 285 | return NULL; | ||
| 286 | key = EVP_PKEY_get1_RSA(pkey); | ||
| 287 | EVP_PKEY_free(pkey); | ||
| 288 | if (!key) | ||
| 289 | return NULL; | ||
| 290 | *pp = q; | ||
| 291 | if (a) { | ||
| 292 | RSA_free(*a); | ||
| 293 | *a = key; | ||
| 294 | } | ||
| 295 | return key; | ||
| 296 | } | ||
| 297 | |||
| 298 | int | ||
| 299 | i2d_RSA_PUBKEY(RSA *a, unsigned char **pp) | ||
| 300 | { | ||
| 301 | EVP_PKEY *pktmp; | ||
| 302 | int ret; | ||
| 303 | if (!a) | ||
| 304 | return 0; | ||
| 305 | pktmp = EVP_PKEY_new(); | ||
| 306 | if (!pktmp) { | ||
| 307 | ASN1err(ASN1_F_I2D_RSA_PUBKEY, ERR_R_MALLOC_FAILURE); | ||
| 308 | return 0; | ||
| 309 | } | ||
| 310 | EVP_PKEY_set1_RSA(pktmp, a); | ||
| 311 | ret = i2d_PUBKEY(pktmp, pp); | ||
| 312 | EVP_PKEY_free(pktmp); | ||
| 313 | return ret; | ||
| 314 | } | ||
| 315 | #endif | ||
| 316 | |||
| 317 | #ifndef OPENSSL_NO_DSA | ||
| 318 | DSA * | ||
| 319 | d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length) | ||
| 320 | { | ||
| 321 | EVP_PKEY *pkey; | ||
| 322 | DSA *key; | ||
| 323 | const unsigned char *q; | ||
| 324 | q = *pp; | ||
| 325 | pkey = d2i_PUBKEY(NULL, &q, length); | ||
| 326 | if (!pkey) | ||
| 327 | return NULL; | ||
| 328 | key = EVP_PKEY_get1_DSA(pkey); | ||
| 329 | EVP_PKEY_free(pkey); | ||
| 330 | if (!key) | ||
| 331 | return NULL; | ||
| 332 | *pp = q; | ||
| 333 | if (a) { | ||
| 334 | DSA_free(*a); | ||
| 335 | *a = key; | ||
| 336 | } | ||
| 337 | return key; | ||
| 338 | } | ||
| 339 | |||
| 340 | int | ||
| 341 | i2d_DSA_PUBKEY(DSA *a, unsigned char **pp) | ||
| 342 | { | ||
| 343 | EVP_PKEY *pktmp; | ||
| 344 | int ret; | ||
| 345 | if (!a) | ||
| 346 | return 0; | ||
| 347 | pktmp = EVP_PKEY_new(); | ||
| 348 | if (!pktmp) { | ||
| 349 | ASN1err(ASN1_F_I2D_DSA_PUBKEY, ERR_R_MALLOC_FAILURE); | ||
| 350 | return 0; | ||
| 351 | } | ||
| 352 | EVP_PKEY_set1_DSA(pktmp, a); | ||
| 353 | ret = i2d_PUBKEY(pktmp, pp); | ||
| 354 | EVP_PKEY_free(pktmp); | ||
| 355 | return ret; | ||
| 356 | } | ||
| 357 | #endif | ||
| 358 | |||
| 359 | #ifndef OPENSSL_NO_EC | ||
| 360 | EC_KEY * | ||
| 361 | d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length) | ||
| 362 | { | ||
| 363 | EVP_PKEY *pkey; | ||
| 364 | EC_KEY *key; | ||
| 365 | const unsigned char *q; | ||
| 366 | q = *pp; | ||
| 367 | pkey = d2i_PUBKEY(NULL, &q, length); | ||
| 368 | if (!pkey) | ||
| 369 | return (NULL); | ||
| 370 | key = EVP_PKEY_get1_EC_KEY(pkey); | ||
| 371 | EVP_PKEY_free(pkey); | ||
| 372 | if (!key) | ||
| 373 | return (NULL); | ||
| 374 | *pp = q; | ||
| 375 | if (a) { | ||
| 376 | EC_KEY_free(*a); | ||
| 377 | *a = key; | ||
| 378 | } | ||
| 379 | return (key); | ||
| 380 | } | ||
| 381 | |||
| 382 | int | ||
| 383 | i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp) | ||
| 384 | { | ||
| 385 | EVP_PKEY *pktmp; | ||
| 386 | int ret; | ||
| 387 | if (!a) | ||
| 388 | return (0); | ||
| 389 | if ((pktmp = EVP_PKEY_new()) == NULL) { | ||
| 390 | ASN1err(ASN1_F_I2D_EC_PUBKEY, ERR_R_MALLOC_FAILURE); | ||
| 391 | return (0); | ||
| 392 | } | ||
| 393 | EVP_PKEY_set1_EC_KEY(pktmp, a); | ||
| 394 | ret = i2d_PUBKEY(pktmp, pp); | ||
| 395 | EVP_PKEY_free(pktmp); | ||
| 396 | return (ret); | ||
| 397 | } | ||
| 398 | #endif | ||
| 399 | |||
| 400 | int | ||
| 401 | X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj, int ptype, | ||
| 402 | void *pval, unsigned char *penc, int penclen) | ||
| 403 | { | ||
| 404 | if (!X509_ALGOR_set0(pub->algor, aobj, ptype, pval)) | ||
| 405 | return 0; | ||
| 406 | if (penc) { | ||
| 407 | free(pub->public_key->data); | ||
| 408 | pub->public_key->data = penc; | ||
| 409 | pub->public_key->length = penclen; | ||
| 410 | /* Set number of unused bits to zero */ | ||
| 411 | pub->public_key->flags&= ~(ASN1_STRING_FLAG_BITS_LEFT|0x07); | ||
| 412 | pub->public_key->flags |= ASN1_STRING_FLAG_BITS_LEFT; | ||
| 413 | } | ||
| 414 | return 1; | ||
| 415 | } | ||
| 416 | |||
| 417 | int | ||
| 418 | X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, const unsigned char **pk, | ||
| 419 | int *ppklen, X509_ALGOR **pa, X509_PUBKEY *pub) | ||
| 420 | { | ||
| 421 | if (ppkalg) | ||
| 422 | *ppkalg = pub->algor->algorithm; | ||
| 423 | if (pk) { | ||
| 424 | *pk = pub->public_key->data; | ||
| 425 | *ppklen = pub->public_key->length; | ||
| 426 | } | ||
| 427 | if (pa) | ||
| 428 | *pa = pub->algor; | ||
| 429 | return 1; | ||
| 430 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_req.c b/src/lib/libcrypto/asn1/x_req.c deleted file mode 100644 index 5ffa11e2dd..0000000000 --- a/src/lib/libcrypto/asn1/x_req.c +++ /dev/null | |||
| @@ -1,227 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_req.c,v 1.15 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/x509.h> | ||
| 63 | |||
| 64 | /* X509_REQ_INFO is handled in an unusual way to get round | ||
| 65 | * invalid encodings. Some broken certificate requests don't | ||
| 66 | * encode the attributes field if it is empty. This is in | ||
| 67 | * violation of PKCS#10 but we need to tolerate it. We do | ||
| 68 | * this by making the attributes field OPTIONAL then using | ||
| 69 | * the callback to initialise it to an empty STACK. | ||
| 70 | * | ||
| 71 | * This means that the field will be correctly encoded unless | ||
| 72 | * we NULL out the field. | ||
| 73 | * | ||
| 74 | * As a result we no longer need the req_kludge field because | ||
| 75 | * the information is now contained in the attributes field: | ||
| 76 | * 1. If it is NULL then it's the invalid omission. | ||
| 77 | * 2. If it is empty it is the correct encoding. | ||
| 78 | * 3. If it is not empty then some attributes are present. | ||
| 79 | * | ||
| 80 | */ | ||
| 81 | |||
| 82 | static int | ||
| 83 | rinf_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) | ||
| 84 | { | ||
| 85 | X509_REQ_INFO *rinf = (X509_REQ_INFO *)*pval; | ||
| 86 | |||
| 87 | if (operation == ASN1_OP_NEW_POST) { | ||
| 88 | rinf->attributes = sk_X509_ATTRIBUTE_new_null(); | ||
| 89 | if (!rinf->attributes) | ||
| 90 | return 0; | ||
| 91 | } | ||
| 92 | return 1; | ||
| 93 | } | ||
| 94 | |||
| 95 | static const ASN1_AUX X509_REQ_INFO_aux = { | ||
| 96 | .flags = ASN1_AFLG_ENCODING, | ||
| 97 | .asn1_cb = rinf_cb, | ||
| 98 | .enc_offset = offsetof(X509_REQ_INFO, enc), | ||
| 99 | }; | ||
| 100 | static const ASN1_TEMPLATE X509_REQ_INFO_seq_tt[] = { | ||
| 101 | { | ||
| 102 | .offset = offsetof(X509_REQ_INFO, version), | ||
| 103 | .field_name = "version", | ||
| 104 | .item = &ASN1_INTEGER_it, | ||
| 105 | }, | ||
| 106 | { | ||
| 107 | .offset = offsetof(X509_REQ_INFO, subject), | ||
| 108 | .field_name = "subject", | ||
| 109 | .item = &X509_NAME_it, | ||
| 110 | }, | ||
| 111 | { | ||
| 112 | .offset = offsetof(X509_REQ_INFO, pubkey), | ||
| 113 | .field_name = "pubkey", | ||
| 114 | .item = &X509_PUBKEY_it, | ||
| 115 | }, | ||
| 116 | /* This isn't really OPTIONAL but it gets round invalid | ||
| 117 | * encodings | ||
| 118 | */ | ||
| 119 | { | ||
| 120 | .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SET_OF | ASN1_TFLG_OPTIONAL, | ||
| 121 | .offset = offsetof(X509_REQ_INFO, attributes), | ||
| 122 | .field_name = "attributes", | ||
| 123 | .item = &X509_ATTRIBUTE_it, | ||
| 124 | }, | ||
| 125 | }; | ||
| 126 | |||
| 127 | const ASN1_ITEM X509_REQ_INFO_it = { | ||
| 128 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 129 | .utype = V_ASN1_SEQUENCE, | ||
| 130 | .templates = X509_REQ_INFO_seq_tt, | ||
| 131 | .tcount = sizeof(X509_REQ_INFO_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 132 | .funcs = &X509_REQ_INFO_aux, | ||
| 133 | .size = sizeof(X509_REQ_INFO), | ||
| 134 | .sname = "X509_REQ_INFO", | ||
| 135 | }; | ||
| 136 | |||
| 137 | |||
| 138 | X509_REQ_INFO * | ||
| 139 | d2i_X509_REQ_INFO(X509_REQ_INFO **a, const unsigned char **in, long len) | ||
| 140 | { | ||
| 141 | return (X509_REQ_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 142 | &X509_REQ_INFO_it); | ||
| 143 | } | ||
| 144 | |||
| 145 | int | ||
| 146 | i2d_X509_REQ_INFO(X509_REQ_INFO *a, unsigned char **out) | ||
| 147 | { | ||
| 148 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REQ_INFO_it); | ||
| 149 | } | ||
| 150 | |||
| 151 | X509_REQ_INFO * | ||
| 152 | X509_REQ_INFO_new(void) | ||
| 153 | { | ||
| 154 | return (X509_REQ_INFO *)ASN1_item_new(&X509_REQ_INFO_it); | ||
| 155 | } | ||
| 156 | |||
| 157 | void | ||
| 158 | X509_REQ_INFO_free(X509_REQ_INFO *a) | ||
| 159 | { | ||
| 160 | ASN1_item_free((ASN1_VALUE *)a, &X509_REQ_INFO_it); | ||
| 161 | } | ||
| 162 | |||
| 163 | static const ASN1_AUX X509_REQ_aux = { | ||
| 164 | .app_data = NULL, | ||
| 165 | .flags = ASN1_AFLG_REFCOUNT, | ||
| 166 | .ref_offset = offsetof(X509_REQ, references), | ||
| 167 | .ref_lock = CRYPTO_LOCK_X509_REQ, | ||
| 168 | }; | ||
| 169 | static const ASN1_TEMPLATE X509_REQ_seq_tt[] = { | ||
| 170 | { | ||
| 171 | .offset = offsetof(X509_REQ, req_info), | ||
| 172 | .field_name = "req_info", | ||
| 173 | .item = &X509_REQ_INFO_it, | ||
| 174 | }, | ||
| 175 | { | ||
| 176 | .offset = offsetof(X509_REQ, sig_alg), | ||
| 177 | .field_name = "sig_alg", | ||
| 178 | .item = &X509_ALGOR_it, | ||
| 179 | }, | ||
| 180 | { | ||
| 181 | .offset = offsetof(X509_REQ, signature), | ||
| 182 | .field_name = "signature", | ||
| 183 | .item = &ASN1_BIT_STRING_it, | ||
| 184 | }, | ||
| 185 | }; | ||
| 186 | |||
| 187 | const ASN1_ITEM X509_REQ_it = { | ||
| 188 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 189 | .utype = V_ASN1_SEQUENCE, | ||
| 190 | .templates = X509_REQ_seq_tt, | ||
| 191 | .tcount = sizeof(X509_REQ_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 192 | .funcs = &X509_REQ_aux, | ||
| 193 | .size = sizeof(X509_REQ), | ||
| 194 | .sname = "X509_REQ", | ||
| 195 | }; | ||
| 196 | |||
| 197 | |||
| 198 | X509_REQ * | ||
| 199 | d2i_X509_REQ(X509_REQ **a, const unsigned char **in, long len) | ||
| 200 | { | ||
| 201 | return (X509_REQ *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 202 | &X509_REQ_it); | ||
| 203 | } | ||
| 204 | |||
| 205 | int | ||
| 206 | i2d_X509_REQ(X509_REQ *a, unsigned char **out) | ||
| 207 | { | ||
| 208 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_REQ_it); | ||
| 209 | } | ||
| 210 | |||
| 211 | X509_REQ * | ||
| 212 | X509_REQ_new(void) | ||
| 213 | { | ||
| 214 | return (X509_REQ *)ASN1_item_new(&X509_REQ_it); | ||
| 215 | } | ||
| 216 | |||
| 217 | void | ||
| 218 | X509_REQ_free(X509_REQ *a) | ||
| 219 | { | ||
| 220 | ASN1_item_free((ASN1_VALUE *)a, &X509_REQ_it); | ||
| 221 | } | ||
| 222 | |||
| 223 | X509_REQ * | ||
| 224 | X509_REQ_dup(X509_REQ *x) | ||
| 225 | { | ||
| 226 | return ASN1_item_dup(&X509_REQ_it, x); | ||
| 227 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_sig.c b/src/lib/libcrypto/asn1/x_sig.c deleted file mode 100644 index 702bc40e55..0000000000 --- a/src/lib/libcrypto/asn1/x_sig.c +++ /dev/null | |||
| @@ -1,110 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_sig.c,v 1.11 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/x509.h> | ||
| 63 | |||
| 64 | static const ASN1_TEMPLATE X509_SIG_seq_tt[] = { | ||
| 65 | { | ||
| 66 | .offset = offsetof(X509_SIG, algor), | ||
| 67 | .field_name = "algor", | ||
| 68 | .item = &X509_ALGOR_it, | ||
| 69 | }, | ||
| 70 | { | ||
| 71 | .offset = offsetof(X509_SIG, digest), | ||
| 72 | .field_name = "digest", | ||
| 73 | .item = &ASN1_OCTET_STRING_it, | ||
| 74 | }, | ||
| 75 | }; | ||
| 76 | |||
| 77 | const ASN1_ITEM X509_SIG_it = { | ||
| 78 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 79 | .utype = V_ASN1_SEQUENCE, | ||
| 80 | .templates = X509_SIG_seq_tt, | ||
| 81 | .tcount = sizeof(X509_SIG_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 82 | .size = sizeof(X509_SIG), | ||
| 83 | .sname = "X509_SIG", | ||
| 84 | }; | ||
| 85 | |||
| 86 | |||
| 87 | X509_SIG * | ||
| 88 | d2i_X509_SIG(X509_SIG **a, const unsigned char **in, long len) | ||
| 89 | { | ||
| 90 | return (X509_SIG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 91 | &X509_SIG_it); | ||
| 92 | } | ||
| 93 | |||
| 94 | int | ||
| 95 | i2d_X509_SIG(X509_SIG *a, unsigned char **out) | ||
| 96 | { | ||
| 97 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_SIG_it); | ||
| 98 | } | ||
| 99 | |||
| 100 | X509_SIG * | ||
| 101 | X509_SIG_new(void) | ||
| 102 | { | ||
| 103 | return (X509_SIG *)ASN1_item_new(&X509_SIG_it); | ||
| 104 | } | ||
| 105 | |||
| 106 | void | ||
| 107 | X509_SIG_free(X509_SIG *a) | ||
| 108 | { | ||
| 109 | ASN1_item_free((ASN1_VALUE *)a, &X509_SIG_it); | ||
| 110 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_spki.c b/src/lib/libcrypto/asn1/x_spki.c deleted file mode 100644 index 2aa860feb9..0000000000 --- a/src/lib/libcrypto/asn1/x_spki.c +++ /dev/null | |||
| @@ -1,174 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_spki.c,v 1.11 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | /* This module was send to me my Pat Richards <patr@x509.com> who | ||
| 60 | * wrote it. It is under my Copyright with his permission | ||
| 61 | */ | ||
| 62 | |||
| 63 | #include <stdio.h> | ||
| 64 | |||
| 65 | #include <openssl/x509.h> | ||
| 66 | #include <openssl/asn1t.h> | ||
| 67 | |||
| 68 | static const ASN1_TEMPLATE NETSCAPE_SPKAC_seq_tt[] = { | ||
| 69 | { | ||
| 70 | .offset = offsetof(NETSCAPE_SPKAC, pubkey), | ||
| 71 | .field_name = "pubkey", | ||
| 72 | .item = &X509_PUBKEY_it, | ||
| 73 | }, | ||
| 74 | { | ||
| 75 | .offset = offsetof(NETSCAPE_SPKAC, challenge), | ||
| 76 | .field_name = "challenge", | ||
| 77 | .item = &ASN1_IA5STRING_it, | ||
| 78 | }, | ||
| 79 | }; | ||
| 80 | |||
| 81 | const ASN1_ITEM NETSCAPE_SPKAC_it = { | ||
| 82 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 83 | .utype = V_ASN1_SEQUENCE, | ||
| 84 | .templates = NETSCAPE_SPKAC_seq_tt, | ||
| 85 | .tcount = sizeof(NETSCAPE_SPKAC_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 86 | .size = sizeof(NETSCAPE_SPKAC), | ||
| 87 | .sname = "NETSCAPE_SPKAC", | ||
| 88 | }; | ||
| 89 | |||
| 90 | |||
| 91 | NETSCAPE_SPKAC * | ||
| 92 | d2i_NETSCAPE_SPKAC(NETSCAPE_SPKAC **a, const unsigned char **in, long len) | ||
| 93 | { | ||
| 94 | return (NETSCAPE_SPKAC *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 95 | &NETSCAPE_SPKAC_it); | ||
| 96 | } | ||
| 97 | |||
| 98 | int | ||
| 99 | i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC *a, unsigned char **out) | ||
| 100 | { | ||
| 101 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_SPKAC_it); | ||
| 102 | } | ||
| 103 | |||
| 104 | NETSCAPE_SPKAC * | ||
| 105 | NETSCAPE_SPKAC_new(void) | ||
| 106 | { | ||
| 107 | return (NETSCAPE_SPKAC *)ASN1_item_new(&NETSCAPE_SPKAC_it); | ||
| 108 | } | ||
| 109 | |||
| 110 | void | ||
| 111 | NETSCAPE_SPKAC_free(NETSCAPE_SPKAC *a) | ||
| 112 | { | ||
| 113 | ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_SPKAC_it); | ||
| 114 | } | ||
| 115 | |||
| 116 | static const ASN1_TEMPLATE NETSCAPE_SPKI_seq_tt[] = { | ||
| 117 | { | ||
| 118 | .flags = 0, | ||
| 119 | .tag = 0, | ||
| 120 | .offset = offsetof(NETSCAPE_SPKI, spkac), | ||
| 121 | .field_name = "spkac", | ||
| 122 | .item = &NETSCAPE_SPKAC_it, | ||
| 123 | }, | ||
| 124 | { | ||
| 125 | .flags = 0, | ||
| 126 | .tag = 0, | ||
| 127 | .offset = offsetof(NETSCAPE_SPKI, sig_algor), | ||
| 128 | .field_name = "sig_algor", | ||
| 129 | .item = &X509_ALGOR_it, | ||
| 130 | }, | ||
| 131 | { | ||
| 132 | .flags = 0, | ||
| 133 | .tag = 0, | ||
| 134 | .offset = offsetof(NETSCAPE_SPKI, signature), | ||
| 135 | .field_name = "signature", | ||
| 136 | .item = &ASN1_BIT_STRING_it, | ||
| 137 | }, | ||
| 138 | }; | ||
| 139 | |||
| 140 | const ASN1_ITEM NETSCAPE_SPKI_it = { | ||
| 141 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 142 | .utype = V_ASN1_SEQUENCE, | ||
| 143 | .templates = NETSCAPE_SPKI_seq_tt, | ||
| 144 | .tcount = sizeof(NETSCAPE_SPKI_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 145 | .funcs = NULL, | ||
| 146 | .size = sizeof(NETSCAPE_SPKI), | ||
| 147 | .sname = "NETSCAPE_SPKI", | ||
| 148 | }; | ||
| 149 | |||
| 150 | |||
| 151 | NETSCAPE_SPKI * | ||
| 152 | d2i_NETSCAPE_SPKI(NETSCAPE_SPKI **a, const unsigned char **in, long len) | ||
| 153 | { | ||
| 154 | return (NETSCAPE_SPKI *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 155 | &NETSCAPE_SPKI_it); | ||
| 156 | } | ||
| 157 | |||
| 158 | int | ||
| 159 | i2d_NETSCAPE_SPKI(NETSCAPE_SPKI *a, unsigned char **out) | ||
| 160 | { | ||
| 161 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &NETSCAPE_SPKI_it); | ||
| 162 | } | ||
| 163 | |||
| 164 | NETSCAPE_SPKI * | ||
| 165 | NETSCAPE_SPKI_new(void) | ||
| 166 | { | ||
| 167 | return (NETSCAPE_SPKI *)ASN1_item_new(&NETSCAPE_SPKI_it); | ||
| 168 | } | ||
| 169 | |||
| 170 | void | ||
| 171 | NETSCAPE_SPKI_free(NETSCAPE_SPKI *a) | ||
| 172 | { | ||
| 173 | ASN1_item_free((ASN1_VALUE *)a, &NETSCAPE_SPKI_it); | ||
| 174 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_val.c b/src/lib/libcrypto/asn1/x_val.c deleted file mode 100644 index eb2ba783bb..0000000000 --- a/src/lib/libcrypto/asn1/x_val.c +++ /dev/null | |||
| @@ -1,110 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_val.c,v 1.11 2015/02/11 04:00:39 jsing Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/x509.h> | ||
| 63 | |||
| 64 | static const ASN1_TEMPLATE X509_VAL_seq_tt[] = { | ||
| 65 | { | ||
| 66 | .offset = offsetof(X509_VAL, notBefore), | ||
| 67 | .field_name = "notBefore", | ||
| 68 | .item = &ASN1_TIME_it, | ||
| 69 | }, | ||
| 70 | { | ||
| 71 | .offset = offsetof(X509_VAL, notAfter), | ||
| 72 | .field_name = "notAfter", | ||
| 73 | .item = &ASN1_TIME_it, | ||
| 74 | }, | ||
| 75 | }; | ||
| 76 | |||
| 77 | const ASN1_ITEM X509_VAL_it = { | ||
| 78 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 79 | .utype = V_ASN1_SEQUENCE, | ||
| 80 | .templates = X509_VAL_seq_tt, | ||
| 81 | .tcount = sizeof(X509_VAL_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 82 | .size = sizeof(X509_VAL), | ||
| 83 | .sname = "X509_VAL", | ||
| 84 | }; | ||
| 85 | |||
| 86 | |||
| 87 | X509_VAL * | ||
| 88 | d2i_X509_VAL(X509_VAL **a, const unsigned char **in, long len) | ||
| 89 | { | ||
| 90 | return (X509_VAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 91 | &X509_VAL_it); | ||
| 92 | } | ||
| 93 | |||
| 94 | int | ||
| 95 | i2d_X509_VAL(X509_VAL *a, unsigned char **out) | ||
| 96 | { | ||
| 97 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_VAL_it); | ||
| 98 | } | ||
| 99 | |||
| 100 | X509_VAL * | ||
| 101 | X509_VAL_new(void) | ||
| 102 | { | ||
| 103 | return (X509_VAL *)ASN1_item_new(&X509_VAL_it); | ||
| 104 | } | ||
| 105 | |||
| 106 | void | ||
| 107 | X509_VAL_free(X509_VAL *a) | ||
| 108 | { | ||
| 109 | ASN1_item_free((ASN1_VALUE *)a, &X509_VAL_it); | ||
| 110 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_x509.c b/src/lib/libcrypto/asn1/x_x509.c deleted file mode 100644 index 168c2c0fcd..0000000000 --- a/src/lib/libcrypto/asn1/x_x509.c +++ /dev/null | |||
| @@ -1,346 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_x509.c,v 1.24 2015/03/19 14:00:22 tedu Exp $ */ | ||
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | ||
| 3 | * All rights reserved. | ||
| 4 | * | ||
| 5 | * This package is an SSL implementation written | ||
| 6 | * by Eric Young (eay@cryptsoft.com). | ||
| 7 | * The implementation was written so as to conform with Netscapes SSL. | ||
| 8 | * | ||
| 9 | * This library is free for commercial and non-commercial use as long as | ||
| 10 | * the following conditions are aheared to. The following conditions | ||
| 11 | * apply to all code found in this distribution, be it the RC4, RSA, | ||
| 12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation | ||
| 13 | * included with this distribution is covered by the same copyright terms | ||
| 14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). | ||
| 15 | * | ||
| 16 | * Copyright remains Eric Young's, and as such any Copyright notices in | ||
| 17 | * the code are not to be removed. | ||
| 18 | * If this package is used in a product, Eric Young should be given attribution | ||
| 19 | * as the author of the parts of the library used. | ||
| 20 | * This can be in the form of a textual message at program startup or | ||
| 21 | * in documentation (online or textual) provided with the package. | ||
| 22 | * | ||
| 23 | * Redistribution and use in source and binary forms, with or without | ||
| 24 | * modification, are permitted provided that the following conditions | ||
| 25 | * are met: | ||
| 26 | * 1. Redistributions of source code must retain the copyright | ||
| 27 | * notice, this list of conditions and the following disclaimer. | ||
| 28 | * 2. Redistributions in binary form must reproduce the above copyright | ||
| 29 | * notice, this list of conditions and the following disclaimer in the | ||
| 30 | * documentation and/or other materials provided with the distribution. | ||
| 31 | * 3. All advertising materials mentioning features or use of this software | ||
| 32 | * must display the following acknowledgement: | ||
| 33 | * "This product includes cryptographic software written by | ||
| 34 | * Eric Young (eay@cryptsoft.com)" | ||
| 35 | * The word 'cryptographic' can be left out if the rouines from the library | ||
| 36 | * being used are not cryptographic related :-). | ||
| 37 | * 4. If you include any Windows specific code (or a derivative thereof) from | ||
| 38 | * the apps directory (application code) you must include an acknowledgement: | ||
| 39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" | ||
| 40 | * | ||
| 41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND | ||
| 42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
| 43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
| 44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE | ||
| 45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
| 46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
| 47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
| 48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
| 49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
| 50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
| 51 | * SUCH DAMAGE. | ||
| 52 | * | ||
| 53 | * The licence and distribution terms for any publically available version or | ||
| 54 | * derivative of this code cannot be changed. i.e. this code cannot simply be | ||
| 55 | * copied and put under another distribution licence | ||
| 56 | * [including the GNU Public Licence.] | ||
| 57 | */ | ||
| 58 | |||
| 59 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/opensslconf.h> | ||
| 62 | |||
| 63 | #include <openssl/asn1t.h> | ||
| 64 | #include <openssl/evp.h> | ||
| 65 | #include <openssl/x509.h> | ||
| 66 | #include <openssl/x509v3.h> | ||
| 67 | |||
| 68 | static const ASN1_AUX X509_CINF_aux = { | ||
| 69 | .flags = ASN1_AFLG_ENCODING, | ||
| 70 | .enc_offset = offsetof(X509_CINF, enc), | ||
| 71 | }; | ||
| 72 | static const ASN1_TEMPLATE X509_CINF_seq_tt[] = { | ||
| 73 | { | ||
| 74 | .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL, | ||
| 75 | .offset = offsetof(X509_CINF, version), | ||
| 76 | .field_name = "version", | ||
| 77 | .item = &ASN1_INTEGER_it, | ||
| 78 | }, | ||
| 79 | { | ||
| 80 | .offset = offsetof(X509_CINF, serialNumber), | ||
| 81 | .field_name = "serialNumber", | ||
| 82 | .item = &ASN1_INTEGER_it, | ||
| 83 | }, | ||
| 84 | { | ||
| 85 | .offset = offsetof(X509_CINF, signature), | ||
| 86 | .field_name = "signature", | ||
| 87 | .item = &X509_ALGOR_it, | ||
| 88 | }, | ||
| 89 | { | ||
| 90 | .offset = offsetof(X509_CINF, issuer), | ||
| 91 | .field_name = "issuer", | ||
| 92 | .item = &X509_NAME_it, | ||
| 93 | }, | ||
| 94 | { | ||
| 95 | .offset = offsetof(X509_CINF, validity), | ||
| 96 | .field_name = "validity", | ||
| 97 | .item = &X509_VAL_it, | ||
| 98 | }, | ||
| 99 | { | ||
| 100 | .offset = offsetof(X509_CINF, subject), | ||
| 101 | .field_name = "subject", | ||
| 102 | .item = &X509_NAME_it, | ||
| 103 | }, | ||
| 104 | { | ||
| 105 | .offset = offsetof(X509_CINF, key), | ||
| 106 | .field_name = "key", | ||
| 107 | .item = &X509_PUBKEY_it, | ||
| 108 | }, | ||
| 109 | { | ||
| 110 | .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL, | ||
| 111 | .tag = 1, | ||
| 112 | .offset = offsetof(X509_CINF, issuerUID), | ||
| 113 | .field_name = "issuerUID", | ||
| 114 | .item = &ASN1_BIT_STRING_it, | ||
| 115 | }, | ||
| 116 | { | ||
| 117 | .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_OPTIONAL, | ||
| 118 | .tag = 2, | ||
| 119 | .offset = offsetof(X509_CINF, subjectUID), | ||
| 120 | .field_name = "subjectUID", | ||
| 121 | .item = &ASN1_BIT_STRING_it, | ||
| 122 | }, | ||
| 123 | { | ||
| 124 | .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_SEQUENCE_OF | | ||
| 125 | ASN1_TFLG_OPTIONAL, | ||
| 126 | .tag = 3, | ||
| 127 | .offset = offsetof(X509_CINF, extensions), | ||
| 128 | .field_name = "extensions", | ||
| 129 | .item = &X509_EXTENSION_it, | ||
| 130 | }, | ||
| 131 | }; | ||
| 132 | |||
| 133 | const ASN1_ITEM X509_CINF_it = { | ||
| 134 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 135 | .utype = V_ASN1_SEQUENCE, | ||
| 136 | .templates = X509_CINF_seq_tt, | ||
| 137 | .tcount = sizeof(X509_CINF_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 138 | .funcs = &X509_CINF_aux, | ||
| 139 | .size = sizeof(X509_CINF), | ||
| 140 | .sname = "X509_CINF", | ||
| 141 | }; | ||
| 142 | |||
| 143 | |||
| 144 | X509_CINF * | ||
| 145 | d2i_X509_CINF(X509_CINF **a, const unsigned char **in, long len) | ||
| 146 | { | ||
| 147 | return (X509_CINF *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 148 | &X509_CINF_it); | ||
| 149 | } | ||
| 150 | |||
| 151 | int | ||
| 152 | i2d_X509_CINF(X509_CINF *a, unsigned char **out) | ||
| 153 | { | ||
| 154 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CINF_it); | ||
| 155 | } | ||
| 156 | |||
| 157 | X509_CINF * | ||
| 158 | X509_CINF_new(void) | ||
| 159 | { | ||
| 160 | return (X509_CINF *)ASN1_item_new(&X509_CINF_it); | ||
| 161 | } | ||
| 162 | |||
| 163 | void | ||
| 164 | X509_CINF_free(X509_CINF *a) | ||
| 165 | { | ||
| 166 | ASN1_item_free((ASN1_VALUE *)a, &X509_CINF_it); | ||
| 167 | } | ||
| 168 | /* X509 top level structure needs a bit of customisation */ | ||
| 169 | |||
| 170 | extern void policy_cache_free(X509_POLICY_CACHE *cache); | ||
| 171 | |||
| 172 | static int | ||
| 173 | x509_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it, void *exarg) | ||
| 174 | { | ||
| 175 | X509 *ret = (X509 *)*pval; | ||
| 176 | |||
| 177 | switch (operation) { | ||
| 178 | |||
| 179 | case ASN1_OP_NEW_POST: | ||
| 180 | ret->valid = 0; | ||
| 181 | ret->name = NULL; | ||
| 182 | ret->ex_flags = 0; | ||
| 183 | ret->ex_pathlen = -1; | ||
| 184 | ret->skid = NULL; | ||
| 185 | ret->akid = NULL; | ||
| 186 | ret->aux = NULL; | ||
| 187 | ret->crldp = NULL; | ||
| 188 | CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509, ret, &ret->ex_data); | ||
| 189 | break; | ||
| 190 | |||
| 191 | case ASN1_OP_D2I_POST: | ||
| 192 | free(ret->name); | ||
| 193 | ret->name = X509_NAME_oneline(ret->cert_info->subject, NULL, 0); | ||
| 194 | break; | ||
| 195 | |||
| 196 | case ASN1_OP_FREE_POST: | ||
| 197 | CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509, ret, &ret->ex_data); | ||
| 198 | X509_CERT_AUX_free(ret->aux); | ||
| 199 | ASN1_OCTET_STRING_free(ret->skid); | ||
| 200 | AUTHORITY_KEYID_free(ret->akid); | ||
| 201 | CRL_DIST_POINTS_free(ret->crldp); | ||
| 202 | policy_cache_free(ret->policy_cache); | ||
| 203 | GENERAL_NAMES_free(ret->altname); | ||
| 204 | NAME_CONSTRAINTS_free(ret->nc); | ||
| 205 | free(ret->name); | ||
| 206 | ret->name = NULL; | ||
| 207 | break; | ||
| 208 | } | ||
| 209 | |||
| 210 | return 1; | ||
| 211 | } | ||
| 212 | |||
| 213 | static const ASN1_AUX X509_aux = { | ||
| 214 | .app_data = NULL, | ||
| 215 | .flags = ASN1_AFLG_REFCOUNT, | ||
| 216 | .ref_offset = offsetof(X509, references), | ||
| 217 | .ref_lock = CRYPTO_LOCK_X509, | ||
| 218 | .asn1_cb = x509_cb, | ||
| 219 | }; | ||
| 220 | static const ASN1_TEMPLATE X509_seq_tt[] = { | ||
| 221 | { | ||
| 222 | .offset = offsetof(X509, cert_info), | ||
| 223 | .field_name = "cert_info", | ||
| 224 | .item = &X509_CINF_it, | ||
| 225 | }, | ||
| 226 | { | ||
| 227 | .offset = offsetof(X509, sig_alg), | ||
| 228 | .field_name = "sig_alg", | ||
| 229 | .item = &X509_ALGOR_it, | ||
| 230 | }, | ||
| 231 | { | ||
| 232 | .offset = offsetof(X509, signature), | ||
| 233 | .field_name = "signature", | ||
| 234 | .item = &ASN1_BIT_STRING_it, | ||
| 235 | }, | ||
| 236 | }; | ||
| 237 | |||
| 238 | const ASN1_ITEM X509_it = { | ||
| 239 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 240 | .utype = V_ASN1_SEQUENCE, | ||
| 241 | .templates = X509_seq_tt, | ||
| 242 | .tcount = sizeof(X509_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 243 | .funcs = &X509_aux, | ||
| 244 | .size = sizeof(X509), | ||
| 245 | .sname = "X509", | ||
| 246 | }; | ||
| 247 | |||
| 248 | |||
| 249 | X509 * | ||
| 250 | d2i_X509(X509 **a, const unsigned char **in, long len) | ||
| 251 | { | ||
| 252 | return (X509 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 253 | &X509_it); | ||
| 254 | } | ||
| 255 | |||
| 256 | int | ||
| 257 | i2d_X509(X509 *a, unsigned char **out) | ||
| 258 | { | ||
| 259 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_it); | ||
| 260 | } | ||
| 261 | |||
| 262 | X509 * | ||
| 263 | X509_new(void) | ||
| 264 | { | ||
| 265 | return (X509 *)ASN1_item_new(&X509_it); | ||
| 266 | } | ||
| 267 | |||
| 268 | void | ||
| 269 | X509_free(X509 *a) | ||
| 270 | { | ||
| 271 | ASN1_item_free((ASN1_VALUE *)a, &X509_it); | ||
| 272 | } | ||
| 273 | |||
| 274 | X509 * | ||
| 275 | X509_dup(X509 *x) | ||
| 276 | { | ||
| 277 | return ASN1_item_dup(&X509_it, x); | ||
| 278 | } | ||
| 279 | |||
| 280 | int | ||
| 281 | X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, | ||
| 282 | CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func) | ||
| 283 | { | ||
| 284 | return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, argl, argp, | ||
| 285 | new_func, dup_func, free_func); | ||
| 286 | } | ||
| 287 | |||
| 288 | int | ||
| 289 | X509_set_ex_data(X509 *r, int idx, void *arg) | ||
| 290 | { | ||
| 291 | return (CRYPTO_set_ex_data(&r->ex_data, idx, arg)); | ||
| 292 | } | ||
| 293 | |||
| 294 | void * | ||
| 295 | X509_get_ex_data(X509 *r, int idx) | ||
| 296 | { | ||
| 297 | return (CRYPTO_get_ex_data(&r->ex_data, idx)); | ||
| 298 | } | ||
| 299 | |||
| 300 | /* X509_AUX ASN1 routines. X509_AUX is the name given to | ||
| 301 | * a certificate with extra info tagged on the end. Since these | ||
| 302 | * functions set how a certificate is trusted they should only | ||
| 303 | * be used when the certificate comes from a reliable source | ||
| 304 | * such as local storage. | ||
| 305 | * | ||
| 306 | */ | ||
| 307 | |||
| 308 | X509 * | ||
| 309 | d2i_X509_AUX(X509 **a, const unsigned char **pp, long length) | ||
| 310 | { | ||
| 311 | const unsigned char *q; | ||
| 312 | X509 *ret; | ||
| 313 | |||
| 314 | /* Save start position */ | ||
| 315 | q = *pp; | ||
| 316 | ret = d2i_X509(NULL, pp, length); | ||
| 317 | /* If certificate unreadable then forget it */ | ||
| 318 | if (!ret) | ||
| 319 | return NULL; | ||
| 320 | /* update length */ | ||
| 321 | length -= *pp - q; | ||
| 322 | if (length > 0) { | ||
| 323 | if (!d2i_X509_CERT_AUX(&ret->aux, pp, length)) | ||
| 324 | goto err; | ||
| 325 | } | ||
| 326 | if (a != NULL) { | ||
| 327 | X509_free(*a); | ||
| 328 | *a = ret; | ||
| 329 | } | ||
| 330 | return ret; | ||
| 331 | |||
| 332 | err: | ||
| 333 | X509_free(ret); | ||
| 334 | return NULL; | ||
| 335 | } | ||
| 336 | |||
| 337 | int | ||
| 338 | i2d_X509_AUX(X509 *a, unsigned char **pp) | ||
| 339 | { | ||
| 340 | int length; | ||
| 341 | |||
| 342 | length = i2d_X509(a, pp); | ||
| 343 | if (a) | ||
| 344 | length += i2d_X509_CERT_AUX(a->aux, pp); | ||
| 345 | return length; | ||
| 346 | } | ||
diff --git a/src/lib/libcrypto/asn1/x_x509a.c b/src/lib/libcrypto/asn1/x_x509a.c deleted file mode 100644 index 29817915b6..0000000000 --- a/src/lib/libcrypto/asn1/x_x509a.c +++ /dev/null | |||
| @@ -1,325 +0,0 @@ | |||
| 1 | /* $OpenBSD: x_x509a.c,v 1.14 2015/02/14 15:28:39 miod Exp $ */ | ||
| 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 | #include <stdio.h> | ||
| 60 | |||
| 61 | #include <openssl/asn1t.h> | ||
| 62 | #include <openssl/evp.h> | ||
| 63 | #include <openssl/x509.h> | ||
| 64 | |||
| 65 | /* X509_CERT_AUX routines. These are used to encode additional | ||
| 66 | * user modifiable data about a certificate. This data is | ||
| 67 | * appended to the X509 encoding when the *_X509_AUX routines | ||
| 68 | * are used. This means that the "traditional" X509 routines | ||
| 69 | * will simply ignore the extra data. | ||
| 70 | */ | ||
| 71 | |||
| 72 | static X509_CERT_AUX *aux_get(X509 *x); | ||
| 73 | |||
| 74 | static const ASN1_TEMPLATE X509_CERT_AUX_seq_tt[] = { | ||
| 75 | { | ||
| 76 | .flags = ASN1_TFLG_SEQUENCE_OF | ASN1_TFLG_OPTIONAL, | ||
| 77 | .offset = offsetof(X509_CERT_AUX, trust), | ||
| 78 | .field_name = "trust", | ||
| 79 | .item = &ASN1_OBJECT_it, | ||
| 80 | }, | ||
| 81 | { | ||
| 82 | .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | | ||
| 83 | ASN1_TFLG_OPTIONAL, | ||
| 84 | .tag = 0, | ||
| 85 | .offset = offsetof(X509_CERT_AUX, reject), | ||
| 86 | .field_name = "reject", | ||
| 87 | .item = &ASN1_OBJECT_it, | ||
| 88 | }, | ||
| 89 | { | ||
| 90 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 91 | .offset = offsetof(X509_CERT_AUX, alias), | ||
| 92 | .field_name = "alias", | ||
| 93 | .item = &ASN1_UTF8STRING_it, | ||
| 94 | }, | ||
| 95 | { | ||
| 96 | .flags = ASN1_TFLG_OPTIONAL, | ||
| 97 | .offset = offsetof(X509_CERT_AUX, keyid), | ||
| 98 | .field_name = "keyid", | ||
| 99 | .item = &ASN1_OCTET_STRING_it, | ||
| 100 | }, | ||
| 101 | { | ||
| 102 | .flags = ASN1_TFLG_IMPLICIT | ASN1_TFLG_SEQUENCE_OF | | ||
| 103 | ASN1_TFLG_OPTIONAL, | ||
| 104 | .tag = 1, | ||
| 105 | .offset = offsetof(X509_CERT_AUX, other), | ||
| 106 | .field_name = "other", | ||
| 107 | .item = &X509_ALGOR_it, | ||
| 108 | }, | ||
| 109 | }; | ||
| 110 | |||
| 111 | const ASN1_ITEM X509_CERT_AUX_it = { | ||
| 112 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 113 | .utype = V_ASN1_SEQUENCE, | ||
| 114 | .templates = X509_CERT_AUX_seq_tt, | ||
| 115 | .tcount = sizeof(X509_CERT_AUX_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 116 | .size = sizeof(X509_CERT_AUX), | ||
| 117 | .sname = "X509_CERT_AUX", | ||
| 118 | }; | ||
| 119 | |||
| 120 | |||
| 121 | X509_CERT_AUX * | ||
| 122 | d2i_X509_CERT_AUX(X509_CERT_AUX **a, const unsigned char **in, long len) | ||
| 123 | { | ||
| 124 | return (X509_CERT_AUX *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 125 | &X509_CERT_AUX_it); | ||
| 126 | } | ||
| 127 | |||
| 128 | int | ||
| 129 | i2d_X509_CERT_AUX(X509_CERT_AUX *a, unsigned char **out) | ||
| 130 | { | ||
| 131 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CERT_AUX_it); | ||
| 132 | } | ||
| 133 | |||
| 134 | X509_CERT_AUX * | ||
| 135 | X509_CERT_AUX_new(void) | ||
| 136 | { | ||
| 137 | return (X509_CERT_AUX *)ASN1_item_new(&X509_CERT_AUX_it); | ||
| 138 | } | ||
| 139 | |||
| 140 | void | ||
| 141 | X509_CERT_AUX_free(X509_CERT_AUX *a) | ||
| 142 | { | ||
| 143 | ASN1_item_free((ASN1_VALUE *)a, &X509_CERT_AUX_it); | ||
| 144 | } | ||
| 145 | |||
| 146 | static X509_CERT_AUX * | ||
| 147 | aux_get(X509 *x) | ||
| 148 | { | ||
| 149 | if (!x) | ||
| 150 | return NULL; | ||
| 151 | if (!x->aux && !(x->aux = X509_CERT_AUX_new())) | ||
| 152 | return NULL; | ||
| 153 | return x->aux; | ||
| 154 | } | ||
| 155 | |||
| 156 | int | ||
| 157 | X509_alias_set1(X509 *x, unsigned char *name, int len) | ||
| 158 | { | ||
| 159 | X509_CERT_AUX *aux; | ||
| 160 | if (!name) { | ||
| 161 | if (!x || !x->aux || !x->aux->alias) | ||
| 162 | return 1; | ||
| 163 | ASN1_UTF8STRING_free(x->aux->alias); | ||
| 164 | x->aux->alias = NULL; | ||
| 165 | return 1; | ||
| 166 | } | ||
| 167 | if (!(aux = aux_get(x))) | ||
| 168 | return 0; | ||
| 169 | if (!aux->alias && !(aux->alias = ASN1_UTF8STRING_new())) | ||
| 170 | return 0; | ||
| 171 | return ASN1_STRING_set(aux->alias, name, len); | ||
| 172 | } | ||
| 173 | |||
| 174 | int | ||
| 175 | X509_keyid_set1(X509 *x, unsigned char *id, int len) | ||
| 176 | { | ||
| 177 | X509_CERT_AUX *aux; | ||
| 178 | if (!id) { | ||
| 179 | if (!x || !x->aux || !x->aux->keyid) | ||
| 180 | return 1; | ||
| 181 | ASN1_OCTET_STRING_free(x->aux->keyid); | ||
| 182 | x->aux->keyid = NULL; | ||
| 183 | return 1; | ||
| 184 | } | ||
| 185 | if (!(aux = aux_get(x))) | ||
| 186 | return 0; | ||
| 187 | if (!aux->keyid && !(aux->keyid = ASN1_OCTET_STRING_new())) | ||
| 188 | return 0; | ||
| 189 | return ASN1_STRING_set(aux->keyid, id, len); | ||
| 190 | } | ||
| 191 | |||
| 192 | unsigned char * | ||
| 193 | X509_alias_get0(X509 *x, int *len) | ||
| 194 | { | ||
| 195 | if (!x->aux || !x->aux->alias) | ||
| 196 | return NULL; | ||
| 197 | if (len) | ||
| 198 | *len = x->aux->alias->length; | ||
| 199 | return x->aux->alias->data; | ||
| 200 | } | ||
| 201 | |||
| 202 | unsigned char * | ||
| 203 | X509_keyid_get0(X509 *x, int *len) | ||
| 204 | { | ||
| 205 | if (!x->aux || !x->aux->keyid) | ||
| 206 | return NULL; | ||
| 207 | if (len) | ||
| 208 | *len = x->aux->keyid->length; | ||
| 209 | return x->aux->keyid->data; | ||
| 210 | } | ||
| 211 | |||
| 212 | int | ||
| 213 | X509_add1_trust_object(X509 *x, ASN1_OBJECT *obj) | ||
| 214 | { | ||
| 215 | X509_CERT_AUX *aux; | ||
| 216 | ASN1_OBJECT *objtmp; | ||
| 217 | int rc; | ||
| 218 | |||
| 219 | if (!(objtmp = OBJ_dup(obj))) | ||
| 220 | return 0; | ||
| 221 | if (!(aux = aux_get(x))) | ||
| 222 | goto err; | ||
| 223 | if (!aux->trust && !(aux->trust = sk_ASN1_OBJECT_new_null())) | ||
| 224 | goto err; | ||
| 225 | rc = sk_ASN1_OBJECT_push(aux->trust, objtmp); | ||
| 226 | if (rc != 0) | ||
| 227 | return rc; | ||
| 228 | |||
| 229 | err: | ||
| 230 | ASN1_OBJECT_free(objtmp); | ||
| 231 | return 0; | ||
| 232 | } | ||
| 233 | |||
| 234 | int | ||
| 235 | X509_add1_reject_object(X509 *x, ASN1_OBJECT *obj) | ||
| 236 | { | ||
| 237 | X509_CERT_AUX *aux; | ||
| 238 | ASN1_OBJECT *objtmp; | ||
| 239 | int rc; | ||
| 240 | |||
| 241 | if (!(objtmp = OBJ_dup(obj))) | ||
| 242 | return 0; | ||
| 243 | if (!(aux = aux_get(x))) | ||
| 244 | goto err; | ||
| 245 | if (!aux->reject && !(aux->reject = sk_ASN1_OBJECT_new_null())) | ||
| 246 | goto err; | ||
| 247 | rc = sk_ASN1_OBJECT_push(aux->reject, objtmp); | ||
| 248 | if (rc != 0) | ||
| 249 | return rc; | ||
| 250 | |||
| 251 | err: | ||
| 252 | ASN1_OBJECT_free(objtmp); | ||
| 253 | return 0; | ||
| 254 | } | ||
| 255 | |||
| 256 | void | ||
| 257 | X509_trust_clear(X509 *x) | ||
| 258 | { | ||
| 259 | if (x->aux && x->aux->trust) { | ||
| 260 | sk_ASN1_OBJECT_pop_free(x->aux->trust, ASN1_OBJECT_free); | ||
| 261 | x->aux->trust = NULL; | ||
| 262 | } | ||
| 263 | } | ||
| 264 | |||
| 265 | void | ||
| 266 | X509_reject_clear(X509 *x) | ||
| 267 | { | ||
| 268 | if (x->aux && x->aux->reject) { | ||
| 269 | sk_ASN1_OBJECT_pop_free(x->aux->reject, ASN1_OBJECT_free); | ||
| 270 | x->aux->reject = NULL; | ||
| 271 | } | ||
| 272 | } | ||
| 273 | |||
| 274 | static const ASN1_TEMPLATE X509_CERT_PAIR_seq_tt[] = { | ||
| 275 | { | ||
| 276 | .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL, | ||
| 277 | .tag = 0, | ||
| 278 | .offset = offsetof(X509_CERT_PAIR, forward), | ||
| 279 | .field_name = "forward", | ||
| 280 | .item = &X509_it, | ||
| 281 | }, | ||
| 282 | { | ||
| 283 | .flags = ASN1_TFLG_EXPLICIT | ASN1_TFLG_OPTIONAL, | ||
| 284 | .tag = 1, | ||
| 285 | .offset = offsetof(X509_CERT_PAIR, reverse), | ||
| 286 | .field_name = "reverse", | ||
| 287 | .item = &X509_it, | ||
| 288 | }, | ||
| 289 | }; | ||
| 290 | |||
| 291 | const ASN1_ITEM X509_CERT_PAIR_it = { | ||
| 292 | .itype = ASN1_ITYPE_SEQUENCE, | ||
| 293 | .utype = V_ASN1_SEQUENCE, | ||
| 294 | .templates = X509_CERT_PAIR_seq_tt, | ||
| 295 | .tcount = sizeof(X509_CERT_PAIR_seq_tt) / sizeof(ASN1_TEMPLATE), | ||
| 296 | .funcs = NULL, | ||
| 297 | .size = sizeof(X509_CERT_PAIR), | ||
| 298 | .sname = "X509_CERT_PAIR", | ||
| 299 | }; | ||
| 300 | |||
| 301 | |||
| 302 | X509_CERT_PAIR * | ||
| 303 | d2i_X509_CERT_PAIR(X509_CERT_PAIR **a, const unsigned char **in, long len) | ||
| 304 | { | ||
| 305 | return (X509_CERT_PAIR *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, | ||
| 306 | &X509_CERT_PAIR_it); | ||
| 307 | } | ||
| 308 | |||
| 309 | int | ||
| 310 | i2d_X509_CERT_PAIR(X509_CERT_PAIR *a, unsigned char **out) | ||
| 311 | { | ||
| 312 | return ASN1_item_i2d((ASN1_VALUE *)a, out, &X509_CERT_PAIR_it); | ||
| 313 | } | ||
| 314 | |||
| 315 | X509_CERT_PAIR * | ||
| 316 | X509_CERT_PAIR_new(void) | ||
| 317 | { | ||
| 318 | return (X509_CERT_PAIR *)ASN1_item_new(&X509_CERT_PAIR_it); | ||
| 319 | } | ||
| 320 | |||
| 321 | void | ||
| 322 | X509_CERT_PAIR_free(X509_CERT_PAIR *a) | ||
| 323 | { | ||
| 324 | ASN1_item_free((ASN1_VALUE *)a, &X509_CERT_PAIR_it); | ||
| 325 | } | ||
