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