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