1 /** 2 * \file asn1.h 3 * 4 * \brief Generic ASN.1 parsing 5 */ 6 /* 7 * Copyright The Mbed TLS Contributors 8 * SPDX-License-Identifier: Apache-2.0 9 * 10 * Licensed under the Apache License, Version 2.0 (the "License"); you may 11 * not use this file except in compliance with the License. 12 * You may obtain a copy of the License at 13 * 14 * http://www.apache.org/licenses/LICENSE-2.0 15 * 16 * Unless required by applicable law or agreed to in writing, software 17 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 18 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 19 * See the License for the specific language governing permissions and 20 * limitations under the License. 21 */ 22 #ifndef MBEDTLS_ASN1_H 23 #define MBEDTLS_ASN1_H 24 #include "mbedtls/private_access.h" 25 26 #include "mbedtls/build_info.h" 27 #include "mbedtls/platform_util.h" 28 29 #include <stddef.h> 30 31 #if defined(MBEDTLS_BIGNUM_C) 32 #include "mbedtls/bignum.h" 33 #endif 34 35 /** 36 * \addtogroup asn1_module 37 * \{ 38 */ 39 40 /** 41 * \name ASN1 Error codes 42 * These error codes are combined with other error codes for 43 * higher error granularity. 44 * e.g. X.509 and PKCS #7 error codes 45 * ASN1 is a standard to specify data structures. 46 * \{ 47 */ 48 /** Out of data when parsing an ASN1 data structure. */ 49 #define MBEDTLS_ERR_ASN1_OUT_OF_DATA -0x0060 50 /** ASN1 tag was of an unexpected value. */ 51 #define MBEDTLS_ERR_ASN1_UNEXPECTED_TAG -0x0062 52 /** Error when trying to determine the length or invalid length. */ 53 #define MBEDTLS_ERR_ASN1_INVALID_LENGTH -0x0064 54 /** Actual length differs from expected length. */ 55 #define MBEDTLS_ERR_ASN1_LENGTH_MISMATCH -0x0066 56 /** Data is invalid. */ 57 #define MBEDTLS_ERR_ASN1_INVALID_DATA -0x0068 58 /** Memory allocation failed */ 59 #define MBEDTLS_ERR_ASN1_ALLOC_FAILED -0x006A 60 /** Buffer too small when writing ASN.1 data structure. */ 61 #define MBEDTLS_ERR_ASN1_BUF_TOO_SMALL -0x006C 62 63 /** \} name ASN1 Error codes */ 64 65 /** 66 * \name DER constants 67 * These constants comply with the DER encoded ASN.1 type tags. 68 * DER encoding uses hexadecimal representation. 69 * An example DER sequence is:\n 70 * - 0x02 -- tag indicating INTEGER 71 * - 0x01 -- length in octets 72 * - 0x05 -- value 73 * Such sequences are typically read into \c ::mbedtls_x509_buf. 74 * \{ 75 */ 76 #define MBEDTLS_ASN1_BOOLEAN 0x01 77 #define MBEDTLS_ASN1_INTEGER 0x02 78 #define MBEDTLS_ASN1_BIT_STRING 0x03 79 #define MBEDTLS_ASN1_OCTET_STRING 0x04 80 #define MBEDTLS_ASN1_NULL 0x05 81 #define MBEDTLS_ASN1_OID 0x06 82 #define MBEDTLS_ASN1_ENUMERATED 0x0A 83 #define MBEDTLS_ASN1_UTF8_STRING 0x0C 84 #define MBEDTLS_ASN1_SEQUENCE 0x10 85 #define MBEDTLS_ASN1_SET 0x11 86 #define MBEDTLS_ASN1_PRINTABLE_STRING 0x13 87 #define MBEDTLS_ASN1_T61_STRING 0x14 88 #define MBEDTLS_ASN1_IA5_STRING 0x16 89 #define MBEDTLS_ASN1_UTC_TIME 0x17 90 #define MBEDTLS_ASN1_GENERALIZED_TIME 0x18 91 #define MBEDTLS_ASN1_UNIVERSAL_STRING 0x1C 92 #define MBEDTLS_ASN1_BMP_STRING 0x1E 93 #define MBEDTLS_ASN1_PRIMITIVE 0x00 94 #define MBEDTLS_ASN1_CONSTRUCTED 0x20 95 #define MBEDTLS_ASN1_CONTEXT_SPECIFIC 0x80 96 97 /* Slightly smaller way to check if tag is a string tag 98 * compared to canonical implementation. */ 99 #define MBEDTLS_ASN1_IS_STRING_TAG( tag ) \ 100 ( ( tag ) < 32u && ( \ 101 ( ( 1u << ( tag ) ) & ( ( 1u << MBEDTLS_ASN1_BMP_STRING ) | \ 102 ( 1u << MBEDTLS_ASN1_UTF8_STRING ) | \ 103 ( 1u << MBEDTLS_ASN1_T61_STRING ) | \ 104 ( 1u << MBEDTLS_ASN1_IA5_STRING ) | \ 105 ( 1u << MBEDTLS_ASN1_UNIVERSAL_STRING ) | \ 106 ( 1u << MBEDTLS_ASN1_PRINTABLE_STRING ) | \ 107 ( 1u << MBEDTLS_ASN1_BIT_STRING ) ) ) != 0 ) ) 108 109 /* 110 * Bit masks for each of the components of an ASN.1 tag as specified in 111 * ITU X.690 (08/2015), section 8.1 "General rules for encoding", 112 * paragraph 8.1.2.2: 113 * 114 * Bit 8 7 6 5 1 115 * +-------+-----+------------+ 116 * | Class | P/C | Tag number | 117 * +-------+-----+------------+ 118 */ 119 #define MBEDTLS_ASN1_TAG_CLASS_MASK 0xC0 120 #define MBEDTLS_ASN1_TAG_PC_MASK 0x20 121 #define MBEDTLS_ASN1_TAG_VALUE_MASK 0x1F 122 123 /** \} name DER constants */ 124 125 /** Returns the size of the binary string, without the trailing \\0 */ 126 #define MBEDTLS_OID_SIZE(x) (sizeof(x) - 1) 127 128 /** 129 * Compares an mbedtls_asn1_buf structure to a reference OID. 130 * 131 * Only works for 'defined' oid_str values (MBEDTLS_OID_HMAC_SHA1), you cannot use a 132 * 'unsigned char *oid' here! 133 */ 134 #define MBEDTLS_OID_CMP(oid_str, oid_buf) \ 135 ( ( MBEDTLS_OID_SIZE(oid_str) != (oid_buf)->len ) || \ 136 memcmp( (oid_str), (oid_buf)->p, (oid_buf)->len) != 0 ) 137 138 #define MBEDTLS_OID_CMP_RAW(oid_str, oid_buf, oid_buf_len) \ 139 ( ( MBEDTLS_OID_SIZE(oid_str) != (oid_buf_len) ) || \ 140 memcmp( (oid_str), (oid_buf), (oid_buf_len) ) != 0 ) 141 142 #ifdef __cplusplus 143 extern "C" { 144 #endif 145 146 /** 147 * \name Functions to parse ASN.1 data structures 148 * \{ 149 */ 150 151 /** 152 * Type-length-value structure that allows for ASN1 using DER. 153 */ 154 typedef struct mbedtls_asn1_buf 155 { 156 int tag; /**< ASN1 type, e.g. MBEDTLS_ASN1_UTF8_STRING. */ 157 size_t len; /**< ASN1 length, in octets. */ 158 unsigned char *p; /**< ASN1 data, e.g. in ASCII. */ 159 } 160 mbedtls_asn1_buf; 161 162 /** 163 * Container for ASN1 bit strings. 164 */ 165 typedef struct mbedtls_asn1_bitstring 166 { 167 size_t len; /**< ASN1 length, in octets. */ 168 unsigned char unused_bits; /**< Number of unused bits at the end of the string */ 169 unsigned char *p; /**< Raw ASN1 data for the bit string */ 170 } 171 mbedtls_asn1_bitstring; 172 173 /** 174 * Container for a sequence of ASN.1 items 175 */ 176 typedef struct mbedtls_asn1_sequence 177 { 178 mbedtls_asn1_buf buf; /**< Buffer containing the given ASN.1 item. */ 179 180 /** The next entry in the sequence. 181 * 182 * The details of memory management for sequences are not documented and 183 * may change in future versions. Set this field to \p NULL when 184 * initializing a structure, and do not modify it except via Mbed TLS 185 * library functions. 186 */ 187 struct mbedtls_asn1_sequence *next; 188 } 189 mbedtls_asn1_sequence; 190 191 /** 192 * Container for a sequence or list of 'named' ASN.1 data items 193 */ 194 typedef struct mbedtls_asn1_named_data 195 { 196 mbedtls_asn1_buf oid; /**< The object identifier. */ 197 mbedtls_asn1_buf val; /**< The named value. */ 198 199 /** The next entry in the sequence. 200 * 201 * The details of memory management for named data sequences are not 202 * documented and may change in future versions. Set this field to \p NULL 203 * when initializing a structure, and do not modify it except via Mbed TLS 204 * library functions. 205 */ 206 struct mbedtls_asn1_named_data *next; 207 208 /** Merge next item into the current one? 209 * 210 * This field exists for the sake of Mbed TLS's X.509 certificate parsing 211 * code and may change in future versions of the library. 212 */ 213 unsigned char MBEDTLS_PRIVATE(next_merged); 214 } 215 mbedtls_asn1_named_data; 216 217 /** 218 * \brief Get the length of an ASN.1 element. 219 * Updates the pointer to immediately behind the length. 220 * 221 * \param p On entry, \c *p points to the first byte of the length, 222 * i.e. immediately after the tag. 223 * On successful completion, \c *p points to the first byte 224 * after the length, i.e. the first byte of the content. 225 * On error, the value of \c *p is undefined. 226 * \param end End of data. 227 * \param len On successful completion, \c *len contains the length 228 * read from the ASN.1 input. 229 * 230 * \return 0 if successful. 231 * \return #MBEDTLS_ERR_ASN1_OUT_OF_DATA if the ASN.1 element 232 * would end beyond \p end. 233 * \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the length is unparsable. 234 */ 235 int mbedtls_asn1_get_len( unsigned char **p, 236 const unsigned char *end, 237 size_t *len ); 238 239 /** 240 * \brief Get the tag and length of the element. 241 * Check for the requested tag. 242 * Updates the pointer to immediately behind the tag and length. 243 * 244 * \param p On entry, \c *p points to the start of the ASN.1 element. 245 * On successful completion, \c *p points to the first byte 246 * after the length, i.e. the first byte of the content. 247 * On error, the value of \c *p is undefined. 248 * \param end End of data. 249 * \param len On successful completion, \c *len contains the length 250 * read from the ASN.1 input. 251 * \param tag The expected tag. 252 * 253 * \return 0 if successful. 254 * \return #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the data does not start 255 * with the requested tag. 256 * \return #MBEDTLS_ERR_ASN1_OUT_OF_DATA if the ASN.1 element 257 * would end beyond \p end. 258 * \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the length is unparsable. 259 */ 260 int mbedtls_asn1_get_tag( unsigned char **p, 261 const unsigned char *end, 262 size_t *len, int tag ); 263 264 /** 265 * \brief Retrieve a boolean ASN.1 tag and its value. 266 * Updates the pointer to immediately behind the full tag. 267 * 268 * \param p On entry, \c *p points to the start of the ASN.1 element. 269 * On successful completion, \c *p points to the first byte 270 * beyond the ASN.1 element. 271 * On error, the value of \c *p is undefined. 272 * \param end End of data. 273 * \param val On success, the parsed value (\c 0 or \c 1). 274 * 275 * \return 0 if successful. 276 * \return An ASN.1 error code if the input does not start with 277 * a valid ASN.1 BOOLEAN. 278 */ 279 int mbedtls_asn1_get_bool( unsigned char **p, 280 const unsigned char *end, 281 int *val ); 282 283 /** 284 * \brief Retrieve an integer ASN.1 tag and its value. 285 * Updates the pointer to immediately behind the full tag. 286 * 287 * \param p On entry, \c *p points to the start of the ASN.1 element. 288 * On successful completion, \c *p points to the first byte 289 * beyond the ASN.1 element. 290 * On error, the value of \c *p is undefined. 291 * \param end End of data. 292 * \param val On success, the parsed value. 293 * 294 * \return 0 if successful. 295 * \return An ASN.1 error code if the input does not start with 296 * a valid ASN.1 INTEGER. 297 * \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does 298 * not fit in an \c int. 299 */ 300 int mbedtls_asn1_get_int( unsigned char **p, 301 const unsigned char *end, 302 int *val ); 303 304 /** 305 * \brief Retrieve an enumerated ASN.1 tag and its value. 306 * Updates the pointer to immediately behind the full tag. 307 * 308 * \param p On entry, \c *p points to the start of the ASN.1 element. 309 * On successful completion, \c *p points to the first byte 310 * beyond the ASN.1 element. 311 * On error, the value of \c *p is undefined. 312 * \param end End of data. 313 * \param val On success, the parsed value. 314 * 315 * \return 0 if successful. 316 * \return An ASN.1 error code if the input does not start with 317 * a valid ASN.1 ENUMERATED. 318 * \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does 319 * not fit in an \c int. 320 */ 321 int mbedtls_asn1_get_enum( unsigned char **p, 322 const unsigned char *end, 323 int *val ); 324 325 /** 326 * \brief Retrieve a bitstring ASN.1 tag and its value. 327 * Updates the pointer to immediately behind the full tag. 328 * 329 * \param p On entry, \c *p points to the start of the ASN.1 element. 330 * On successful completion, \c *p is equal to \p end. 331 * On error, the value of \c *p is undefined. 332 * \param end End of data. 333 * \param bs On success, ::mbedtls_asn1_bitstring information about 334 * the parsed value. 335 * 336 * \return 0 if successful. 337 * \return #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input contains 338 * extra data after a valid BIT STRING. 339 * \return An ASN.1 error code if the input does not start with 340 * a valid ASN.1 BIT STRING. 341 */ 342 int mbedtls_asn1_get_bitstring( unsigned char **p, const unsigned char *end, 343 mbedtls_asn1_bitstring *bs ); 344 345 /** 346 * \brief Retrieve a bitstring ASN.1 tag without unused bits and its 347 * value. 348 * Updates the pointer to the beginning of the bit/octet string. 349 * 350 * \param p On entry, \c *p points to the start of the ASN.1 element. 351 * On successful completion, \c *p points to the first byte 352 * of the content of the BIT STRING. 353 * On error, the value of \c *p is undefined. 354 * \param end End of data. 355 * \param len On success, \c *len is the length of the content in bytes. 356 * 357 * \return 0 if successful. 358 * \return #MBEDTLS_ERR_ASN1_INVALID_DATA if the input starts with 359 * a valid BIT STRING with a nonzero number of unused bits. 360 * \return An ASN.1 error code if the input does not start with 361 * a valid ASN.1 BIT STRING. 362 */ 363 int mbedtls_asn1_get_bitstring_null( unsigned char **p, 364 const unsigned char *end, 365 size_t *len ); 366 367 /** 368 * \brief Parses and splits an ASN.1 "SEQUENCE OF <tag>". 369 * Updates the pointer to immediately behind the full sequence tag. 370 * 371 * This function allocates memory for the sequence elements. You can free 372 * the allocated memory with mbedtls_asn1_sequence_free(). 373 * 374 * \note On error, this function may return a partial list in \p cur. 375 * You must set `cur->next = NULL` before calling this function! 376 * Otherwise it is impossible to distinguish a previously non-null 377 * pointer from a pointer to an object allocated by this function. 378 * 379 * \note If the sequence is empty, this function does not modify 380 * \c *cur. If the sequence is valid and non-empty, this 381 * function sets `cur->buf.tag` to \p tag. This allows 382 * callers to distinguish between an empty sequence and 383 * a one-element sequence. 384 * 385 * \param p On entry, \c *p points to the start of the ASN.1 element. 386 * On successful completion, \c *p is equal to \p end. 387 * On error, the value of \c *p is undefined. 388 * \param end End of data. 389 * \param cur A ::mbedtls_asn1_sequence which this function fills. 390 * When this function returns, \c *cur is the head of a linked 391 * list. Each node in this list is allocated with 392 * mbedtls_calloc() apart from \p cur itself, and should 393 * therefore be freed with mbedtls_free(). 394 * The list describes the content of the sequence. 395 * The head of the list (i.e. \c *cur itself) describes the 396 * first element, `*cur->next` describes the second element, etc. 397 * For each element, `buf.tag == tag`, `buf.len` is the length 398 * of the content of the content of the element, and `buf.p` 399 * points to the first byte of the content (i.e. immediately 400 * past the length of the element). 401 * Note that list elements may be allocated even on error. 402 * \param tag Each element of the sequence must have this tag. 403 * 404 * \return 0 if successful. 405 * \return #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input contains 406 * extra data after a valid SEQUENCE OF \p tag. 407 * \return #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the input starts with 408 * an ASN.1 SEQUENCE in which an element has a tag that 409 * is different from \p tag. 410 * \return #MBEDTLS_ERR_ASN1_ALLOC_FAILED if a memory allocation failed. 411 * \return An ASN.1 error code if the input does not start with 412 * a valid ASN.1 SEQUENCE. 413 */ 414 int mbedtls_asn1_get_sequence_of( unsigned char **p, 415 const unsigned char *end, 416 mbedtls_asn1_sequence *cur, 417 int tag ); 418 /** 419 * \brief Free a heap-allocated linked list presentation of 420 * an ASN.1 sequence, including the first element. 421 * 422 * There are two common ways to manage the memory used for the representation 423 * of a parsed ASN.1 sequence: 424 * - Allocate a head node `mbedtls_asn1_sequence *head` with mbedtls_calloc(). 425 * Pass this node as the `cur` argument to mbedtls_asn1_get_sequence_of(). 426 * When you have finished processing the sequence, 427 * call mbedtls_asn1_sequence_free() on `head`. 428 * - Allocate a head node `mbedtls_asn1_sequence *head` in any manner, 429 * for example on the stack. Make sure that `head->next == NULL`. 430 * Pass `head` as the `cur` argument to mbedtls_asn1_get_sequence_of(). 431 * When you have finished processing the sequence, 432 * call mbedtls_asn1_sequence_free() on `head->cur`, 433 * then free `head` itself in the appropriate manner. 434 * 435 * \param seq The address of the first sequence component. This may 436 * be \c NULL, in which case this functions returns 437 * immediately. 438 */ 439 void mbedtls_asn1_sequence_free( mbedtls_asn1_sequence *seq ); 440 441 /** 442 * \brief Traverse an ASN.1 SEQUENCE container and 443 * call a callback for each entry. 444 * 445 * This function checks that the input is a SEQUENCE of elements that 446 * each have a "must" tag, and calls a callback function on the elements 447 * that have a "may" tag. 448 * 449 * For example, to validate that the input is a SEQUENCE of `tag1` and call 450 * `cb` on each element, use 451 * ``` 452 * mbedtls_asn1_traverse_sequence_of(&p, end, 0xff, tag1, 0, 0, cb, ctx); 453 * ``` 454 * 455 * To validate that the input is a SEQUENCE of ANY and call `cb` on 456 * each element, use 457 * ``` 458 * mbedtls_asn1_traverse_sequence_of(&p, end, 0, 0, 0, 0, cb, ctx); 459 * ``` 460 * 461 * To validate that the input is a SEQUENCE of CHOICE {NULL, OCTET STRING} 462 * and call `cb` on each element that is an OCTET STRING, use 463 * ``` 464 * mbedtls_asn1_traverse_sequence_of(&p, end, 0xfe, 0x04, 0xff, 0x04, cb, ctx); 465 * ``` 466 * 467 * The callback is called on the elements with a "may" tag from left to 468 * right. If the input is not a valid SEQUENCE of elements with a "must" tag, 469 * the callback is called on the elements up to the leftmost point where 470 * the input is invalid. 471 * 472 * \warning This function is still experimental and may change 473 * at any time. 474 * 475 * \param p The address of the pointer to the beginning of 476 * the ASN.1 SEQUENCE header. This is updated to 477 * point to the end of the ASN.1 SEQUENCE container 478 * on a successful invocation. 479 * \param end The end of the ASN.1 SEQUENCE container. 480 * \param tag_must_mask A mask to be applied to the ASN.1 tags found within 481 * the SEQUENCE before comparing to \p tag_must_value. 482 * \param tag_must_val The required value of each ASN.1 tag found in the 483 * SEQUENCE, after masking with \p tag_must_mask. 484 * Mismatching tags lead to an error. 485 * For example, a value of \c 0 for both \p tag_must_mask 486 * and \p tag_must_val means that every tag is allowed, 487 * while a value of \c 0xFF for \p tag_must_mask means 488 * that \p tag_must_val is the only allowed tag. 489 * \param tag_may_mask A mask to be applied to the ASN.1 tags found within 490 * the SEQUENCE before comparing to \p tag_may_value. 491 * \param tag_may_val The desired value of each ASN.1 tag found in the 492 * SEQUENCE, after masking with \p tag_may_mask. 493 * Mismatching tags will be silently ignored. 494 * For example, a value of \c 0 for \p tag_may_mask and 495 * \p tag_may_val means that any tag will be considered, 496 * while a value of \c 0xFF for \p tag_may_mask means 497 * that all tags with value different from \p tag_may_val 498 * will be ignored. 499 * \param cb The callback to trigger for each component 500 * in the ASN.1 SEQUENCE that matches \p tag_may_val. 501 * The callback function is called with the following 502 * parameters: 503 * - \p ctx. 504 * - The tag of the current element. 505 * - A pointer to the start of the current element's 506 * content inside the input. 507 * - The length of the content of the current element. 508 * If the callback returns a non-zero value, 509 * the function stops immediately, 510 * forwarding the callback's return value. 511 * \param ctx The context to be passed to the callback \p cb. 512 * 513 * \return \c 0 if successful the entire ASN.1 SEQUENCE 514 * was traversed without parsing or callback errors. 515 * \return #MBEDTLS_ERR_ASN1_LENGTH_MISMATCH if the input 516 * contains extra data after a valid SEQUENCE 517 * of elements with an accepted tag. 518 * \return #MBEDTLS_ERR_ASN1_UNEXPECTED_TAG if the input starts 519 * with an ASN.1 SEQUENCE in which an element has a tag 520 * that is not accepted. 521 * \return An ASN.1 error code if the input does not start with 522 * a valid ASN.1 SEQUENCE. 523 * \return A non-zero error code forwarded from the callback 524 * \p cb in case the latter returns a non-zero value. 525 */ 526 int mbedtls_asn1_traverse_sequence_of( 527 unsigned char **p, 528 const unsigned char *end, 529 unsigned char tag_must_mask, unsigned char tag_must_val, 530 unsigned char tag_may_mask, unsigned char tag_may_val, 531 int (*cb)( void *ctx, int tag, 532 unsigned char* start, size_t len ), 533 void *ctx ); 534 535 #if defined(MBEDTLS_BIGNUM_C) 536 /** 537 * \brief Retrieve an integer ASN.1 tag and its value. 538 * Updates the pointer to immediately behind the full tag. 539 * 540 * \param p On entry, \c *p points to the start of the ASN.1 element. 541 * On successful completion, \c *p points to the first byte 542 * beyond the ASN.1 element. 543 * On error, the value of \c *p is undefined. 544 * \param end End of data. 545 * \param X On success, the parsed value. 546 * 547 * \return 0 if successful. 548 * \return An ASN.1 error code if the input does not start with 549 * a valid ASN.1 INTEGER. 550 * \return #MBEDTLS_ERR_ASN1_INVALID_LENGTH if the parsed value does 551 * not fit in an \c int. 552 * \return An MPI error code if the parsed value is too large. 553 */ 554 int mbedtls_asn1_get_mpi( unsigned char **p, 555 const unsigned char *end, 556 mbedtls_mpi *X ); 557 #endif /* MBEDTLS_BIGNUM_C */ 558 559 /** 560 * \brief Retrieve an AlgorithmIdentifier ASN.1 sequence. 561 * Updates the pointer to immediately behind the full 562 * AlgorithmIdentifier. 563 * 564 * \param p On entry, \c *p points to the start of the ASN.1 element. 565 * On successful completion, \c *p points to the first byte 566 * beyond the AlgorithmIdentifier element. 567 * On error, the value of \c *p is undefined. 568 * \param end End of data. 569 * \param alg The buffer to receive the OID. 570 * \param params The buffer to receive the parameters. 571 * This is zeroized if there are no parameters. 572 * 573 * \return 0 if successful or a specific ASN.1 or MPI error code. 574 */ 575 int mbedtls_asn1_get_alg( unsigned char **p, 576 const unsigned char *end, 577 mbedtls_asn1_buf *alg, mbedtls_asn1_buf *params ); 578 579 /** 580 * \brief Retrieve an AlgorithmIdentifier ASN.1 sequence with NULL or no 581 * params. 582 * Updates the pointer to immediately behind the full 583 * AlgorithmIdentifier. 584 * 585 * \param p On entry, \c *p points to the start of the ASN.1 element. 586 * On successful completion, \c *p points to the first byte 587 * beyond the AlgorithmIdentifier element. 588 * On error, the value of \c *p is undefined. 589 * \param end End of data. 590 * \param alg The buffer to receive the OID. 591 * 592 * \return 0 if successful or a specific ASN.1 or MPI error code. 593 */ 594 int mbedtls_asn1_get_alg_null( unsigned char **p, 595 const unsigned char *end, 596 mbedtls_asn1_buf *alg ); 597 598 /** 599 * \brief Find a specific named_data entry in a sequence or list based on 600 * the OID. 601 * 602 * \param list The list to seek through 603 * \param oid The OID to look for 604 * \param len Size of the OID 605 * 606 * \return NULL if not found, or a pointer to the existing entry. 607 */ 608 const mbedtls_asn1_named_data *mbedtls_asn1_find_named_data( const mbedtls_asn1_named_data *list, 609 const char *oid, size_t len ); 610 611 #if !defined(MBEDTLS_DEPRECATED_REMOVED) 612 /** 613 * \brief Free a mbedtls_asn1_named_data entry 614 * 615 * \deprecated This function is deprecated and will be removed in a 616 * future version of the library. 617 * Please use mbedtls_asn1_free_named_data_list() 618 * or mbedtls_asn1_free_named_data_list_shallow(). 619 * 620 * \param entry The named data entry to free. 621 * This function calls mbedtls_free() on 622 * `entry->oid.p` and `entry->val.p`. 623 */ 624 void MBEDTLS_DEPRECATED mbedtls_asn1_free_named_data( mbedtls_asn1_named_data *entry ); 625 #endif /* MBEDTLS_DEPRECATED_REMOVED */ 626 627 /** 628 * \brief Free all entries in a mbedtls_asn1_named_data list. 629 * 630 * \param head Pointer to the head of the list of named data entries to free. 631 * This function calls mbedtls_free() on 632 * `entry->oid.p` and `entry->val.p` and then on `entry` 633 * for each list entry, and sets \c *head to \c NULL. 634 */ 635 void mbedtls_asn1_free_named_data_list( mbedtls_asn1_named_data **head ); 636 637 /** 638 * \brief Free all shallow entries in a mbedtls_asn1_named_data list, 639 * but do not free internal pointer targets. 640 * 641 * \param name Head of the list of named data entries to free. 642 * This function calls mbedtls_free() on each list element. 643 */ 644 void mbedtls_asn1_free_named_data_list_shallow( mbedtls_asn1_named_data *name ); 645 646 /** \} name Functions to parse ASN.1 data structures */ 647 /** \} addtogroup asn1_module */ 648 649 #ifdef __cplusplus 650 } 651 #endif 652 653 #endif /* asn1.h */ 654
