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